Setting dac names for CTB (C++ and Python) (#413)

# Setting DAC names for CTB
* Introduced new shared memory for CTB only
* Prepared for additional functionality 
* Works from C++ and Python

Co-authored-by: Dhanya Thattil <dhanya.thattil@psi.ch>

slsDetectorSoftware/CMakeLists.txt

@@ -7,6 +7,7 @@ set(SOURCES
     src/CmdProxy.cpp
     src/CmdParser.cpp
     src/Pattern.cpp
+    src/CtbConfig.cpp
 )
 
 add_library(slsDetectorObject OBJECT

slsDetectorSoftware/include/sls/Detector.h

@@ -1613,6 +1613,14 @@ class Detector {
 
     /** [CTB] Default is enabled. */
     void setLEDEnable(bool enable, Positions pos = {});
+
+
+    void setDacNames(const std::vector<std::string> names);
+
+    std::vector<std::string> getDacNames() const;
+
+    defs::dacIndex getDacIndex(const std::string& name);
+    std::string getDacName(defs::dacIndex i);
     ///@}
 
     /** @name Pattern */

slsDetectorSoftware/src/CmdProxy.cpp

@@ -1056,11 +1056,10 @@ std::string CmdProxy::TemperatureValues(int action) {
 std::string CmdProxy::Dac(int action) {
     std::ostringstream os;
     os << cmd << ' ';
-
+    auto type = det->getDetectorType().squash();
     // dac indices only for ctb
     if (args.size() > 0 && action != defs::HELP_ACTION) {
-        if (is_int(args[0]) &&
-            det->getDetectorType().squash() != defs::CHIPTESTBOARD) {
+        if (is_int(args[0]) && type != defs::CHIPTESTBOARD) {
             throw sls::RuntimeError(
                 "Dac indices can only be used for chip test board. Use daclist "
                 "to get list of dac names for current detector.");
@@ -1077,7 +1076,14 @@ std::string CmdProxy::Dac(int action) {
         if (args.empty())
             WrongNumberOfParameters(1); // This prints slightly wrong
 
-        defs::dacIndex dacIndex = StringTo<defs::dacIndex>(args[0]);
+        defs::dacIndex dacIndex{};
+        //TODO! Remove if
+        if (type == defs::CHIPTESTBOARD && !is_int(args[0])) {
+            dacIndex = det->getDacIndex(args[0]);
+        } else {
+            dacIndex = StringTo<defs::dacIndex>(args[0]);
+        }
+
         bool mV = false;
 
         if (args.size() == 2) {
@@ -1095,7 +1101,11 @@ std::string CmdProxy::Dac(int action) {
         if (args.empty())
             WrongNumberOfParameters(1); // This prints slightly wrong
 
-        defs::dacIndex dacIndex = StringTo<defs::dacIndex>(args[0]);
+        defs::dacIndex dacIndex{};
+        if (type == defs::CHIPTESTBOARD && !is_int(args[0]))
+            dacIndex = det->getDacIndex(args[0]);
+        else
+            dacIndex = StringTo<defs::dacIndex>(args[0]);
         bool mV = false;
         if (args.size() == 3) {
             if ((args[2] != "mv") && (args[2] != "mV")) {
@@ -1115,6 +1125,38 @@ std::string CmdProxy::Dac(int action) {
     return os.str();
 }
 
+std::string CmdProxy::DacList(const int action) {
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == slsDetectorDefs::HELP_ACTION) {
+        os << "\n\t[dacname1 dacname2 .. dacname18] \n\t\t[ChipTestBoard] Set "
+              "the list of dac names for this detector.\n\t\t[All] Gets the "
+              "list "
+              "of "
+              "dac names for every dac for this detector."
+           << '\n';
+    } else if (action == slsDetectorDefs::GET_ACTION) {
+        if (!args.empty()) {
+            WrongNumberOfParameters(0);
+        }
+        auto t = det->getDacNames();
+        os << sls::ToString(t) << '\n';
+    } else if (action == slsDetectorDefs::PUT_ACTION) {
+        if (det->getDetectorType().squash() != defs::CHIPTESTBOARD) {
+            throw sls::RuntimeError("This detector already has fixed dac "
+                                    "names. Cannot change them.");
+        }
+        if (args.size() != 18) {
+            WrongNumberOfParameters(18);
+        }
+        det->setDacNames(args);
+        os << ToString(args) << '\n';
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 std::string CmdProxy::DacValues(int action) {
     std::ostringstream os;
     os << cmd << ' ';
@@ -1134,13 +1176,15 @@ std::string CmdProxy::DacValues(int action) {
             WrongNumberOfParameters(1);
         }
         auto t = det->getDacList();
+        auto names = det->getDacNames();
+        auto name_it = names.begin();
         os << '[';
         auto it = t.cbegin();
-        os << ToString(*it) << ' ';
+        os << ToString(*name_it++) << ' ';
         os << OutString(det->getDAC(*it++, mv, std::vector<int>{det_id}))
            << (!args.empty() ? " mV" : "");
         while (it != t.cend()) {
-            os << ", " << ToString(*it) << ' ';
+            os << ", " << ToString(*name_it++) << ' ';
             os << OutString(det->getDAC(*it++, mv, std::vector<int>{det_id}))
                << (!args.empty() ? " mV" : "");
         }

slsDetectorSoftware/src/CmdProxy.h

@@ -837,7 +837,7 @@ class CmdProxy {
 
         /* dacs */
         {"dac", &CmdProxy::Dac},
-        {"daclist", &CmdProxy::daclist},
+        {"daclist", &CmdProxy::DacList},
         {"dacvalues", &CmdProxy::DacValues},
         {"resetdacs", &CmdProxy::ResetDacs},
         {"defaultdac", &CmdProxy::DefaultDac},
@@ -1124,6 +1124,7 @@ class CmdProxy {
     std::string TemperatureValues(int action);
     /* dacs */
     std::string Dac(int action);
+    std::string DacList(int action);
     std::string DacValues(int action);
     std::string ResetDacs(int action);
     std::string DefaultDac(int action);
@@ -1465,10 +1466,6 @@ class CmdProxy {
 
     /* dacs */
 
-    GET_COMMAND_NOID(
-        daclist, getDacList,
-        "\n\tGets the list of commands for every dac for this detector.");
-
     /* on chip dacs */
     INTEGER_USER_IND_COMMAND(
         vchip_comp_fe, getOnChipDAC, setOnChipDAC, StringTo<int>,

slsDetectorSoftware/src/CtbConfig.cpp

@@ -0,0 +1,72 @@
+
+#include "CtbConfig.h"
+#include "SharedMemory.h"
+#include "sls/ToString.h"
+#include "sls/string_utils.h"
+
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+
+namespace sls {
+
+CtbConfig::CtbConfig(){
+    for (size_t i=0; i!=num_dacs; ++i){
+        setDacName(i, "dac"+ToString(i));
+    }
+}
+
+void CtbConfig::check_index(size_t i) const {
+    if (!(i < num_dacs)) {
+        std::ostringstream oss;
+        oss << "DAC index is too large needs to be below " << num_dacs;
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::check_size(const std::string &name) const {
+   
+    if (name.empty())
+        throw RuntimeError("Name needs to be at least one character");
+
+     // dacname_length -1 to account for \0 termination
+    if (!(name.size() < (name_length - 1))) {
+        std::ostringstream oss;
+        oss << "Length of name needs to be less than " << name_length - 1
+            << " chars";
+        throw RuntimeError(oss.str());
+    }
+}
+
+void CtbConfig::setDacName(size_t index, const std::string &name) {
+
+    check_index(index);
+    check_size(name);
+
+    char *dst = &dacnames[index * name_length];
+    memset(dst, '\0', name_length);
+    memcpy(dst, &name[0], name.size());
+}
+
+void CtbConfig::setDacNames(const std::vector<std::string>& names){
+    for (size_t i = 0; i!=num_dacs; ++i){
+        setDacName(i, names[i]);
+    }
+}
+
+std::string CtbConfig::getDacName(size_t index) const {
+    return dacnames + index * name_length;
+}
+
+std::vector<std::string> CtbConfig::getDacNames() const {
+    std::vector<std::string> names;
+    for (size_t i = 0; i != num_dacs; ++i)
+        names.push_back(getDacName(i));
+    return names;
+}
+
+const char* CtbConfig::shm_tag(){
+    return shm_tag_;
+}
+
+} // namespace sls

slsDetectorSoftware/src/CtbConfig.h

@@ -0,0 +1,31 @@
+#pragma once
+#include <string>
+#include <vector>
+namespace sls {
+
+
+class CtbConfig {
+    static constexpr size_t name_length = 20;
+    static constexpr size_t num_dacs = 18;
+    static constexpr const char* shm_tag_ = "ctbdacs";
+    char dacnames[name_length * num_dacs]{};
+
+    void check_index(size_t i) const;
+    void check_size(const std::string &name) const;
+
+  public:
+    CtbConfig();
+    CtbConfig(const CtbConfig&) = default;
+    CtbConfig(CtbConfig&&) = default;
+    CtbConfig& operator=(const CtbConfig&) = default;
+    ~CtbConfig() = default;
+
+    void setDacNames(const std::vector<std::string> &names);
+    void setDacName(size_t index, const std::string &name);
+    std::string getDacName(size_t index) const;
+    std::vector<std::string> getDacNames() const;
+    static const char* shm_tag();
+};
+
+
+} // namespace sls

slsDetectorSoftware/src/Detector.cpp

@@ -7,6 +7,7 @@
 #include "CmdProxy.h"
 #include "DetectorImpl.h"
 #include "Module.h"
+#include "CtbConfig.h"
 #include "sls/Pattern.h"
 #include "sls/container_utils.h"
 #include "sls/file_utils.h"
@@ -21,6 +22,7 @@
 namespace sls {
 
 void freeSharedMemory(int detectorIndex, int moduleIndex) {
+
     // single module
     if (moduleIndex >= 0) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, moduleIndex);
@@ -44,6 +46,11 @@ void freeSharedMemory(int detectorIndex, int moduleIndex) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, i);
         moduleShm.RemoveSharedMemory();
     }
+
+    // Ctb configuration
+    SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
+    if (ctbShm.IsExisting())
+        ctbShm.RemoveSharedMemory();
 }
 
 using defs = slsDetectorDefs;
@@ -2067,6 +2074,42 @@ void Detector::setLEDEnable(bool enable, Positions pos) {
     pimpl->Parallel(&Module::setLEDEnable, pos, enable);
 }
 
+void Detector::setDacNames(const std::vector<std::string> names) {
+    if (getDetectorType().squash() != defs::CHIPTESTBOARD)
+        throw RuntimeError("Named dacs only for CTB");
+    pimpl->setCtbDacNames(names);
+}
+
+std::vector<std::string> Detector::getDacNames() const {
+    std::vector<std::string> names;
+    auto type = getDetectorType().squash();
+    if (type == defs::CHIPTESTBOARD)
+        return pimpl->getCtbDacNames();
+
+    for (const auto &index : getDacList())
+        names.push_back(ToString(index));
+    return names;
+}
+
+defs::dacIndex Detector::getDacIndex(const std::string &name) {
+    auto type = getDetectorType().squash();
+    if (type == defs::CHIPTESTBOARD) {
+        auto names = getDacNames();
+        auto it = std::find(names.begin(), names.end(), name);
+        if (it == names.end())
+            throw RuntimeError("Dacname not found");
+        return static_cast<defs::dacIndex>(it - names.begin());
+    }
+    return StringTo<defs::dacIndex>(name);
+}
+
+std::string Detector::getDacName(defs::dacIndex i) {
+    auto type = getDetectorType().squash();
+    if (type == defs::CHIPTESTBOARD)
+        return pimpl->getCtbDacName(i);
+    return ToString(i);
+}
+
 // Pattern
 
 void Detector::setPattern(const std::string &fname, Positions pos) {

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -32,7 +32,8 @@
 namespace sls {
 
 DetectorImpl::DetectorImpl(int detector_index, bool verify, bool update)
-    : detectorIndex(detector_index), shm(detector_index, -1) {
+    : detectorIndex(detector_index), shm(detector_index, -1),
+      ctb_shm(detector_index, -1, CtbConfig::shm_tag()) {
     setupDetector(verify, update);
 }
 
@@ -44,6 +45,9 @@ void DetectorImpl::setupDetector(bool verify, bool update) {
     if (update) {
         updateUserdetails();
     }
+
+    if (ctb_shm.IsExisting())
+        ctb_shm.OpenSharedMemory();
 }
 
 void DetectorImpl::setAcquiringFlag(bool flag) { shm()->acquiringFlag = flag; }
@@ -74,6 +78,10 @@ void DetectorImpl::freeSharedMemory(int detectorIndex, int detPos) {
         SharedMemory<sharedModule> moduleShm(detectorIndex, i);
         moduleShm.RemoveSharedMemory();
     }
+
+    SharedMemory<CtbConfig> ctbShm(detectorIndex, -1, CtbConfig::shm_tag());
+    if (ctbShm.IsExisting())
+        ctbShm.RemoveSharedMemory();
 }
 
 void DetectorImpl::freeSharedMemory() {
@@ -86,6 +94,9 @@ void DetectorImpl::freeSharedMemory() {
     // clear detector shm
     shm.RemoveSharedMemory();
     client_downstream = false;
+
+    if (ctb_shm.IsExisting())
+        ctb_shm.RemoveSharedMemory();
 }
 
 std::string DetectorImpl::getUserDetails() {
@@ -144,6 +155,8 @@ void DetectorImpl::initSharedMemory(bool verify) {
             throw SharedMemoryError("Shared memory version mismatch!");
         }
     }
+
+    // std::cout <<
 }
 
 void DetectorImpl::initializeDetectorStructure() {
@@ -245,6 +258,16 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
         addModule(hostname);
     }
     updateDetectorSize();
+
+    // Here we know the detector type and can add ctb shared memory
+    // if needed, CTB dac names are only on detector level
+
+    if (shm()->detType == defs::CHIPTESTBOARD) {
+        if (ctb_shm.IsExisting())
+            ctb_shm.OpenSharedMemory();
+        else
+            ctb_shm.CreateSharedMemory();
+    }
 }
 
 void DetectorImpl::addModule(const std::string &hostname) {
@@ -1379,4 +1402,16 @@ void DetectorImpl::setDefaultDac(defs::dacIndex index, int defaultValue,
     Parallel(&Module::setDefaultDac, pos, index, defaultValue, sett);
 }
 
+std::vector<std::string> DetectorImpl::getCtbDacNames() const {
+    return ctb_shm()->getDacNames();
+}
+
+void DetectorImpl::setCtbDacNames(const std::vector<std::string> &names) {
+    ctb_shm()->setDacNames(names);
+}
+
+std::string DetectorImpl::getCtbDacName(defs::dacIndex i) const {
+    return ctb_shm()->getDacName(static_cast<int>(i));
+}
+
 } // namespace sls

slsDetectorSoftware/src/DetectorImpl.h

@@ -7,6 +7,8 @@
 #include "sls/logger.h"
 #include "sls/sls_detector_defs.h"
 
+
+#include "CtbConfig.h"
 class ZmqSocket;
 class detectorData;
 
@@ -298,6 +300,11 @@ class DetectorImpl : public virtual slsDetectorDefs {
     void setDefaultDac(defs::dacIndex index, int defaultValue,
                        defs::detectorSettings sett, Positions pos);
 
+
+    std::vector<std::string> getCtbDacNames() const;
+    std::string getCtbDacName(defs::dacIndex i) const;
+    void setCtbDacNames(const std::vector<std::string>& names);
+
   private:
     /**
      * Creates/open shared memory, initializes detector structure and members
@@ -381,6 +388,7 @@ class DetectorImpl : public virtual slsDetectorDefs {
 
     const int detectorIndex{0};
     sls::SharedMemory<sharedDetector> shm{0, -1};
+    sls::SharedMemory<CtbConfig> ctb_shm{0, -1, "a"};
     std::vector<std::unique_ptr<sls::Module>> modules;
 
     /** data streaming (down stream) enabled in client (zmq sckets created) */

slsDetectorSoftware/src/SharedMemory.h

@@ -19,7 +19,6 @@
 #include <fcntl.h> // O_CREAT, O_TRUNC..
 #include <iostream>
 #include <sstream>
-// #include <stdio.h>    // printf
 #include <sys/mman.h> // shared memory
 #include <sys/stat.h> // fstat
 #include <unistd.h>
@@ -36,11 +35,9 @@ namespace sls {
 template <typename T> class SharedMemory {
 
   public:
-    /**
-     * moduleid of -1 creates a detector only shared memory
-     */
-    SharedMemory(int detectorId, int moduleIndex) {
-        name = ConstructSharedMemoryName(detectorId, moduleIndex);
+    //moduleid of -1 creates a detector only shared memory
+    SharedMemory(int detectorId, int moduleIndex, const std::string& tag = "") {
+        name = ConstructSharedMemoryName(detectorId, moduleIndex, tag);
     }
 
     /**
@@ -103,11 +100,7 @@ template <typename T> class SharedMemory {
         return ret;
     }
 
-    /**
-     * Get shared memory name
-     */
     std::string GetName() const { return name; }
-
     size_t size() const { return shmSize; }
 
     /**
@@ -133,8 +126,10 @@ template <typename T> class SharedMemory {
             RemoveSharedMemory();
             throw SharedMemoryError(msg);
         }
+        // int *pInt = new (buf) int(3);
 
         shared_struct = MapSharedMemory();
+        new (shared_struct) T{}; // is this ok? 
         LOG(logINFO) << "Shared memory created " << name;
     }
 
@@ -211,7 +206,7 @@ template <typename T> class SharedMemory {
      * @param moduleIndex module id, -1 if a detector shared memory
      * @returns shared memory name
      */
-    std::string ConstructSharedMemoryName(int detectorId, int moduleIndex) {
+    std::string ConstructSharedMemoryName(int detectorId, int moduleIndex, const std::string& tag) {
 
         // using environment path
         std::string sEnvPath;
@@ -222,8 +217,12 @@ template <typename T> class SharedMemory {
         }
 
         std::stringstream ss;
-        if (moduleIndex < 0)
+        if (moduleIndex < 0){
             ss << SHM_DETECTOR_PREFIX << detectorId << sEnvPath;
+            if (!tag.empty())
+                ss << "_" << tag;
+        }
+            
         else
             ss << SHM_DETECTOR_PREFIX << detectorId << SHM_MODULE_PREFIX
                << moduleIndex << sEnvPath;
@@ -293,15 +292,10 @@ template <typename T> class SharedMemory {
         return 0;
     }
 
-    /** Shared memory name */
+
     std::string name;
-
-    /** File descriptor */
     int fd{-1};
-
-    /** shm size */
     size_t shmSize{0};
-
     T *shared_struct{nullptr};
 };
 

slsDetectorSoftware/tests/CMakeLists.txt

@@ -18,6 +18,7 @@ target_sources(tests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/test-CmdParser.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test-Module.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/test-Pattern.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-CtbConfig.cpp
 )
 
 target_include_directories(tests PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>")

slsDetectorSoftware/tests/test-CmdProxy.cpp

@@ -590,13 +590,13 @@ TEST_CASE("master", "[.cmd]") {
             }
             {
                 std::ostringstream oss1;
-                proxy.Call("master", {"0"}, 0, PUT, oss3);
-                REQUIRE(oss3.str() == "master 0\n");
+                proxy.Call("master", {"0"}, 0, PUT, oss1);
+                REQUIRE(oss1.str() == "master 0\n");
             }
             {
                 std::ostringstream oss1;
-                proxy.Call("master", {"1"}, 0, PUT, oss3);
-                REQUIRE(oss3.str() == "master 1\n");
+                proxy.Call("master", {"1"}, 0, PUT, oss1);
+                REQUIRE(oss1.str() == "master 1\n");
             }
             REQUIRE_THROWS(proxy.Call("master", {"1"}, -1, PUT));
             // set all to slaves, and then master

slsDetectorSoftware/tests/test-CtbConfig.cpp

@@ -0,0 +1,59 @@
+#include "catch.hpp"
+#include <string>
+
+#include <stdlib.h>
+
+#include "SharedMemory.h"
+#include "CtbConfig.h"
+using namespace sls;
+#include <fstream>
+
+
+TEST_CASE("Default construction"){
+    static_assert(sizeof(CtbConfig) == 360); // 18*20 
+
+    CtbConfig c;
+    auto names = c.getDacNames();
+    REQUIRE(names.size() == 18);
+    REQUIRE(names[0] == "dac0");
+    REQUIRE(names[1] == "dac1");
+    REQUIRE(names[2] == "dac2");
+    REQUIRE(names[3] == "dac3");
+}
+
+TEST_CASE("Set and get a single dac name"){
+    CtbConfig c;
+    c.setDacName(3, "vrf");
+    auto names = c.getDacNames();
+
+    REQUIRE(c.getDacName(3) == "vrf");
+    REQUIRE(names[3] == "vrf");
+}
+
+TEST_CASE("Set a name that is too large throws"){
+    CtbConfig c;
+    REQUIRE_THROWS(c.setDacName(3, "somestringthatisreallytolongforadatac"));
+}
+
+TEST_CASE("Length of dac name cannot be 0"){
+    CtbConfig c;
+    REQUIRE_THROWS(c.setDacName(1, ""));
+}
+
+TEST_CASE("Copy a CTB config"){
+    CtbConfig c1;
+    c1.setDacName(5, "somename");
+
+    auto c2 = c1;
+    //change the name on the first object 
+    //to detecto shallow copy
+    c1.setDacName(5, "someothername");
+    REQUIRE(c2.getDacName(5) == "somename");
+}
+
+TEST_CASE("Move CtbConfig "){
+    CtbConfig c1;
+    c1.setDacName(3, "yetanothername");
+    CtbConfig c2(std::move(c1));
+    REQUIRE(c2.getDacName(3) == "yetanothername");
+}

slsDetectorSoftware/tests/test-SharedMemory.cpp

@@ -134,3 +134,31 @@ TEST_CASE("Create several shared memories", "[detector]") {
         CHECK(v[i].IsExisting() == false);
     }
 }
+
+TEST_CASE("Create create a shared memory with a tag"){
+    SharedMemory<int> shm(0, -1, "ctbdacs");
+    REQUIRE(shm.GetName() == "/slsDetectorPackage_detector_0_ctbdacs");
+
+}
+
+TEST_CASE("Create create a shared memory with a tag when SLSDETNAME is set"){
+
+    // if SLSDETNAME is already set we unset it but
+    // save the value
+    std::string old_slsdetname;
+    if (getenv(SHM_ENV_NAME))
+        old_slsdetname = getenv(SHM_ENV_NAME);
+    unsetenv(SHM_ENV_NAME);
+    setenv(SHM_ENV_NAME, "myprefix", 1);
+
+    SharedMemory<int> shm(0, -1, "ctbdacs");
+    REQUIRE(shm.GetName() == "/slsDetectorPackage_detector_0_myprefix_ctbdacs");
+
+    // Clean up after us
+    if (old_slsdetname.empty())
+        unsetenv(SHM_ENV_NAME);
+    else
+        setenv(SHM_ENV_NAME, old_slsdetname.c_str(), 1);
+
+}
+