trimEn now takes vector

slsDetectorSoftware/include/multiSlsDetector.h

@@ -1355,16 +1355,15 @@ class multiSlsDetector : public virtual slsDetectorDefs {
      * @param detPos -1 for all detectors in  list or specific detector position
      * @returns number of trim energies
      */
-    int setTrimEn(int nen, int *en = nullptr, int detPos = -1);
+    int setTrimEn(std::vector<int> energies, int detPos = -1);
 
     /**
      * Returns the number of trim energies and their value  (Eiger)
      *
-     * @param en array of energies
      * @param detPos -1 for all detectors in  list or specific detector position
-     * @returns number of trim energies
+     * @returns vector of trim energies
      */
-    int getTrimEn(int *en = nullptr, int detPos = -1);
+    std::vector<int> getTrimEn(int detPos = -1);
 
     /**
      * Pulse Pixel (Eiger)
@@ -1953,6 +1952,8 @@ class multiSlsDetector : public virtual slsDetectorDefs {
      */
     void processData();
 
+    void addSlsDetector(std::unique_ptr<slsDetector> det);
+
   private:
     /**
      * Initialize (open/create) shared memory for the sharedMultiDetector
@@ -1992,11 +1993,13 @@ class multiSlsDetector : public virtual slsDetectorDefs {
      */
     void addSlsDetector(const std::string &hostname);
 
+    
+
         /**
          * add gap pixels to the image (only for Eiger in 4 bit mode)
          * @param image pointer to image without gap pixels
-     * @param gpImage poiner to image with gap pixels, if NULL, allocated inside
-     * function
+         * @param gpImage poiner to image with gap pixels, if NULL, allocated
+         * inside function
          * @returns number of data bytes of image with gap pixels
          */
         int processImageWithGapPixels(char *image, char *&gpImage);

slsDetectorSoftware/include/slsDetector.h

@@ -1208,18 +1208,17 @@ class slsDetector : public virtual slsDetectorDefs{
 	 * Sets the number of trim energies and their value  (Eiger)
 	 * \sa sharedSlsDetector
 	 * @param nen number of energies
-	 * @param en array of energies
+	 * @param vector os trimmed energies
 	 * @returns number of trim energies
 	 */
-    int setTrimEn(int nen, int *en = nullptr);
+    int setTrimEn(std::vector<int> energies={});
 
     /**
-	 * Returns the number of trim energies and their value  (Eiger)
+     * Returns a vector with the trimmed energies  (Eiger)
      * \sa sharedSlsDetector
-	 * @param en array of energies
-	 * @returns number of trim energies
+     * @returns vector with the trimmed energies
      */
-    int getTrimEn(int *en = nullptr);
+    std::vector<int> getTrimEn();
 
     /**
 	 * Pulse Pixel (Eiger)

slsDetectorSoftware/src/multiSlsDetector.cpp

@@ -426,6 +426,15 @@ void multiSlsDetector::addSlsDetector(const std::string &hostname) {
     detectors[pos]->setOnline(true);
 }
 
+void multiSlsDetector::addSlsDetector(std::unique_ptr<slsDetector> det){
+    detectors.push_back(std::move(det));
+    multi_shm()->numberOfDetectors = detectors.size();
+    multi_shm()->dataBytes += detectors.back()->getDataBytes();
+    multi_shm()->dataBytesInclGapPixels +=
+        detectors.back()->getDataBytesInclGapPixels();
+    multi_shm()->numberOfChannels += detectors.back()->getTotalNumberOfChannels();
+}
+
 slsDetectorDefs::detectorType multiSlsDetector::getDetectorTypeAsEnum(int detPos) {
     // single
     if (detPos >= 0) {
@@ -2524,25 +2533,19 @@ int multiSlsDetector::enableGapPixels(int val, int detPos) {
     return ret;
 }
 
-int multiSlsDetector::setTrimEn(int ne, int *ene, int detPos) {
-    // single
+int multiSlsDetector::setTrimEn(std::vector<int> energies, int detPos) {
     if (detPos >= 0) {
-        return detectors[detPos]->setTrimEn(ne, ene);
+        return detectors[detPos]->setTrimEn(energies);
     }
-
-    // multi
-    auto r = serialCall(&slsDetector::setTrimEn, ne, ene);
+    auto r = parallelCall(&slsDetector::setTrimEn, energies);
     return sls::minusOneIfDifferent(r);
 }
 
-int multiSlsDetector::getTrimEn(int *ene, int detPos) {
-    // single
+std::vector<int> multiSlsDetector::getTrimEn(int detPos) {
     if (detPos >= 0) {
-        return detectors[detPos]->getTrimEn(ene);
+        return detectors[detPos]->getTrimEn();
     }
-
-    // multi
-    auto r = serialCall(&slsDetector::getTrimEn, ene);
+    auto r = parallelCall(&slsDetector::getTrimEn);
     return sls::minusOneIfDifferent(r);
 }
 

slsDetectorSoftware/src/slsDetector.cpp

@@ -3125,23 +3125,28 @@ int slsDetector::enableGapPixels(int val) {
     return detector_shm()->gappixels;
 }
 
-int slsDetector::setTrimEn(int nen, int *en) {
-    if (en) {
-        for (int ien = 0; ien < nen; ++ien) {
-            detector_shm()->trimEnergies[ien] = en[ien];
+int slsDetector::setTrimEn(std::vector<int> energies) {
+    if (energies.size()>MAX_TRIMEN){
+        std::ostringstream os;
+        os << "Size of trim energies: " << energies.size() << " exceeds what can "
+        << "be stored in shared memory: " << MAX_TRIMEN << "\n";
+        throw RuntimeError(os.str());
     }
-        detector_shm()->nTrimEn = nen;
+
+    for (int i = 0; i != energies.size(); ++i) {
+        detector_shm()->trimEnergies[i] = energies[i];
     }
+    detector_shm()->nTrimEn = energies.size();
     return (detector_shm()->nTrimEn);
 }
 
-int slsDetector::getTrimEn(int *en) {
-    if (en) {
-        for (int ien = 0; ien < detector_shm()->nTrimEn; ++ien) {
-            en[ien] = detector_shm()->trimEnergies[ien];
+std::vector<int> slsDetector::getTrimEn() {
+    std::vector<int> energies;
+    energies.reserve(detector_shm()->nTrimEn);
+    for (int i = 0; i != detector_shm()->nTrimEn; ++i) {
+        energies.push_back(detector_shm()->trimEnergies[i]);
     }
-    }
-    return (detector_shm()->nTrimEn);
+    return energies;
 }
 
 int slsDetector::pulsePixel(int n, int x, int y) {

slsDetectorSoftware/src/slsDetectorCommand.cpp

@@ -2505,41 +2505,24 @@ std::string slsDetectorCommand::helpSettingsDir(int action) {
 }
 
 std::string slsDetectorCommand::cmdTrimEn(int narg, char *args[], int action, int detPos) {
-    int ival;
-    int ip;
-
-    char answer[1000];
-
+    std::vector<int> energies;
     if (action == HELP_ACTION) 
         return helpTrimEn(action);
 
     if (action == PUT_ACTION) {
-        if (sscanf(args[1], "%d", &ival)) {
-            int pos[ival];
-            for (ip = 0; ip < ival; ++ip) {
-                if ((2 + ip) < narg) {
-                    if (sscanf(args[2 + ip], "%d", pos + ip)) {
-                    } else
-                        break;
+        energies.reserve(narg-1);
+        for(int i=1; i!=narg; ++i){
+            energies.push_back(std::stoi(args[i]));
         }
+        myDet->setTrimEn(energies, detPos);
+        energies.clear();
     }
-            myDet->setTrimEn(ip, pos, detPos);
+    energies = myDet->getTrimEn(detPos);
+    std::ostringstream os;
+    for(const auto& en : energies){
+        os << en << ' ';
     }
-    }
-    int npos = myDet->getTrimEn(nullptr, detPos);
-    if (npos != -1) {
-        sprintf(answer, "%d", npos);
-        int opos[npos];
-        npos = myDet->getTrimEn(opos, detPos);
-        if (npos != -1) {
-            for (int ip = 0; ip < npos; ++ip) {
-                sprintf(answer, "%s %d", answer, opos[ip]);
-            }
-        }
-    }
-    if (npos == -1)
-        sprintf(answer, "%d", -1);
-    return std::string(answer);
+    return os.str();
 }
 
 std::string slsDetectorCommand::helpTrimEn(int action) {

slsDetectorSoftware/tests/CMakeLists.txt

@@ -1 +1,5 @@
-target_sources(tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test-SharedMemory.cpp)
+target_sources(tests PRIVATE 
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-SharedMemory.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-slsDetector.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-multiSlsDetector.cpp
+)

slsDetectorSoftware/tests/test-multiSlsDetector.cpp

@@ -0,0 +1,63 @@
+
+#include "catch.hpp"
+#include "container_utils.h"
+#include "multiSlsDetector.h"
+#include "slsDetector.h"
+#include "string_utils.h"
+
+#include <iostream>
+
+using namespace sls;
+
+SCENARIO("Multi detector operation", "[detector]") {
+
+    multiSlsDetector::freeSharedMemory(0, -1);
+
+    GIVEN("An empty multi detector") {
+        multiSlsDetector m(0);
+        THEN("the size is zero") {
+            CHECK(m.getNumberOfDetectors() == 0);
+            CHECK(m.getDataBytes() == 0);
+            CHECK(m.getTotalNumberOfChannels() == 0);
+        }
+
+        WHEN("we add a detector") {
+            m.addSlsDetector(sls::make_unique<slsDetector>(
+                slsDetectorDefs::detectorType::EIGER, 0, 0));
+            THEN("the size and number of detector changes") {
+                CHECK(m.getNumberOfDetectors() == 1);
+                CHECK(m.getTotalNumberOfChannels() == 256 * 1024);
+            }
+
+            WHEN("we add another detector") {
+                m.addSlsDetector(sls::make_unique<slsDetector>(
+                    slsDetectorDefs::detectorType::EIGER, 0, 1));
+                THEN("the size and number of detector changes") {
+                    CHECK(m.getNumberOfDetectors() == 2);
+                    CHECK(m.getTotalNumberOfChannels() == 2 * 256 * 1024);
+                }
+
+                WHEN("We set the trimen") {
+                    std::vector<int> energies{5000, 6000, 7000, 8000, 9000};
+                    m.setTrimEn(energies);
+                    THEN("we read back the same values") {
+                        CHECK(m.getTrimEn() == energies);
+                    }
+                }
+                WHEN("We set the trimen to different values") {
+                    std::vector<int> en0{5000, 6000, 7000, 8000, 9000};
+                    std::vector<int> en1{6000, 7000, 8000, 9000};
+                    m.setTrimEn(en0, 0);
+                    m.setTrimEn(en1, 1);
+                    THEN("we read back the same values") {
+                        CHECK(m.getTrimEn(0) == en0);
+                        CHECK(m.getTrimEn(1) == en1);
+                        CHECK(m.getTrimEn() == std::vector<int>{-1});
+                    }
+                }
+            }
+        }
+
+        m.freeSharedMemory();
+    }
+}

slsDetectorSoftware/tests/test-slsDetector.cpp

@@ -0,0 +1,49 @@
+
+#include "catch.hpp"
+#include "container_utils.h"
+#include "slsDetector.h"
+#include "string_utils.h"
+
+#include <iostream>
+
+using namespace sls;
+
+TEST_CASE("Set and get trimen", "[detector]") {
+    // Free shared memory to be sure that we start in a clean state
+    slsDetector::freeSharedMemory(0, 0);
+
+    // Create a detector and check that the type is set correctly
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0);
+    CHECK(d.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER);
+
+    // At the beginning there should be no trimen set
+    auto res = d.getTrimEn();
+    CHECK(res.size() == 0);
+
+    std::vector<int> energies{5200, 6400, 8500, 9900, 12000};
+    d.setTrimEn(energies);
+    auto res2 = d.getTrimEn();
+
+    // Check that the size and every element matches what we set
+    CHECK(res2.size() == energies.size());
+    for (size_t i = 0; i != res2.size(); ++i)
+        CHECK(res2[i] == energies[i]);
+
+    
+
+    // Setting trimen with too many vales throws an exception and keeps the
+    // old values
+    std::vector<int> too_many(150, 1000);
+    CHECK_THROWS(d.setTrimEn(too_many));
+    auto res3 = d.getTrimEn();
+    CHECK(res3.size() == energies.size());
+    for (size_t i = 0; i != res3.size(); ++i)
+        CHECK(res3[i] == energies[i]);
+
+    // Setting trimen without arguments resets to zero
+    d.setTrimEn();
+    CHECK(d.getTrimEn().size() == 0);
+
+    // Clean up before next test
+    d.freeSharedMemory();
+}

slsReceiverSoftware/tests/test.cpp

@@ -1,3 +0,0 @@
-// tests-main.cpp
-#define CATCH_CONFIG_MAIN
-#include "catch.hpp"

slsSupportLib/include/container_utils.h

@@ -2,17 +2,15 @@
 #define CONTAINER_UTILS_H
 
 #include <algorithm>
+#include <memory>
 #include <numeric>
+#include <sstream>
 #include <string>
 #include <type_traits>
 #include <vector>
-#include <sstream>
-#include <memory>
 
 namespace sls {
 
-
-
 // C++11 make_unique implementation for exception safety
 // already available as std::make_unique in C++14
 template <typename T, typename... Args>
@@ -23,16 +21,12 @@ make_unique(Args &&... args) {
 
 template <typename T>
 typename std::enable_if<std::is_array<T>::value, std::unique_ptr<T>>::type
-make_unique(std::size_t n)
-{
+make_unique(std::size_t n) {
     typedef typename std::remove_extent<T>::type RT;
     return std::unique_ptr<T>(new RT[n]);
 }
 
-
-template <typename T>
-bool allEqual(const std::vector<T>& container)
-{
+template <typename T> bool allEqual(const std::vector<T> &container) {
     if (container.empty())
         return false;
     const auto &first = container[0];
@@ -42,8 +36,7 @@ bool allEqual(const std::vector<T>& container)
 
 template <typename T>
 typename std::enable_if<std::is_arithmetic<T>::value, bool>::type
-allEqualWithTol(const std::vector<T>& container, const T tol)
-{
+allEqualWithTol(const std::vector<T> &container, const T tol) {
     if (container.empty())
         return false;
 
@@ -55,8 +48,7 @@ allEqualWithTol(const std::vector<T>& container, const T tol)
 }
 
 template <typename T>
-bool allEqualTo(const std::vector<T>& container, const T value)
-{
+bool allEqualTo(const std::vector<T> &container, const T value) {
     if (container.empty())
         return false;
 
@@ -66,8 +58,7 @@ bool allEqualTo(const std::vector<T>& container, const T value)
 
 template <typename T>
 bool allEqualToWithTol(const std::vector<T> &container, const T value,
-    const T tol)
-{
+                       const T tol) {
     if (container.empty())
         return false;
 
@@ -78,39 +69,40 @@ bool allEqualToWithTol(const std::vector<T>& container, const T value,
 }
 
 template <typename T>
-bool anyEqualTo(const std::vector<T>& container, const T value)
-{
+bool anyEqualTo(const std::vector<T> &container, const T value) {
     return std::any_of(container.cbegin(), container.cend(),
                        [value](const T &element) { return element == value; });
 }
 
 template <typename T>
 bool anyEqualToWithTol(const std::vector<T> &container, const T value,
-    const T tol)
-{
+                       const T tol) {
     return std::any_of(container.cbegin(), container.cend(),
-        [value, tol](const T& element) { return (std::abs(element - value) < tol); });
+                       [value, tol](const T &element) {
+                           return (std::abs(element - value) < tol);
+                       });
 }
 
 template <typename T>
 typename std::enable_if<std::is_arithmetic<T>::value, T>::type
-sum(const std::vector<T>& container)
-{
+sum(const std::vector<T> &container) {
     return std::accumulate(container.cbegin(), container.cend(), T{0});
 }
 
-template <typename T>
-T minusOneIfDifferent(const std::vector<T>& container)
-{
-    if (allEqual(container)) {
+template <typename T> T minusOneIfDifferent(const std::vector<T> &container) {
+    if (allEqual(container))
         return container.front();
-    } else {
     return static_cast<T>(-1);
 }
+
+template <typename T>
+std::vector<T>
+minusOneIfDifferent(const std::vector<std::vector<T>> &container) {
+    if (allEqual(container))
+        return container.front();
+    return std::vector<T>{-1};
 }
 
-
-
 } // namespace sls
 
 #endif // CONTAINER_UTILS_H

slsSupportLib/src/string_utils.cpp

@@ -47,17 +47,8 @@ std::string concatenateIfDifferent(const std::vector<T> &container) {
     }
 }
 
+
 template std::string concatenateIfDifferent(const std::vector<IpAddr> &);
 template std::string concatenateIfDifferent(const std::vector<MacAddr> &);
 
-std::string stringIpToHex(const std::string &ip) {
-    std::istringstream iss(ip);
-    std::ostringstream oss;
-    std::string item;
-    while (std::getline(iss, item, '.')) {
-        oss << std::setw(2) << std::setfill('0') << std::hex << std::stoi(item);
-    }
-    return oss.str();
-}
-
 }; // namespace sls

slsSupportLib/tests/test-container_utils.cpp

@@ -4,16 +4,9 @@
 #include <string>
 #include <vector>
 
-using sls::allEqual;
-using sls::allEqualTo;
-using sls::anyEqualTo;
-using sls::allEqualToWithTol;
-using sls::allEqualWithTol;
-using sls::anyEqualToWithTol;
+using namespace sls;
 
-using sls::sum;
-
-TEST_CASE("Equality of an empty vector") {
+TEST_CASE("Equality of an empty vector", "[support]") {
     std::vector<int> v;
     REQUIRE(v.empty());
     REQUIRE_FALSE(allEqual(v));
@@ -23,7 +16,7 @@ TEST_CASE("Equality of an empty vector") {
     REQUIRE_FALSE(anyEqualToWithTol(v, 5, 1));
 }
 
-TEST_CASE("Equality of a vector with one element") {
+TEST_CASE("Equality of a vector with one element", "[support]") {
     std::vector<int> v{5};
     REQUIRE(v.size() == 1);
     REQUIRE(allEqual(v));
@@ -34,7 +27,7 @@ TEST_CASE("Equality of a vector with one element") {
     REQUIRE(anyEqualToWithTol(v, 5, 1));
 }
 
-TEST_CASE("A larger vector of the same elements") {
+TEST_CASE("A larger vector of the same elements", "[support]") {
     std::vector<int> v(101, 5);
     REQUIRE(v.size() == 101);
     REQUIRE(allEqual(v));
@@ -42,8 +35,8 @@ TEST_CASE("A larger vector of the same elements") {
     REQUIRE(allEqualTo(v, 5));
     REQUIRE(anyEqualTo(v, 5));
 
-  SECTION(
-      "Push back another element to create a vector where not all are equal") {
+    SECTION("Push back another element to create a vector where not all are "
+            "equal") {
         v.push_back(7);
         REQUIRE(v.size() == 102);
         REQUIRE_FALSE(allEqual(v));
@@ -59,7 +52,7 @@ TEST_CASE("A larger vector of the same elements") {
     }
 }
 
-TEST_CASE("A vector of double with different values") {
+TEST_CASE("A vector of double with different values", "[support]") {
     std::vector<double> v{1.2, 2., 4.2, 4, 1.1};
 
     REQUIRE(allEqual(v) == false);
@@ -67,17 +60,17 @@ TEST_CASE("A vector of double with different values") {
     REQUIRE(allEqualWithTol(v, 3.2));
 }
 
-TEST_CASE("Sum of empty vector") {
+TEST_CASE("Sum of empty vector", "[support]") {
     std::vector<float> v;
     REQUIRE(sls::sum(v) == Approx(0));
 }
 
-TEST_CASE("Sum of vector") {
+TEST_CASE("Sum of vector", "[support]") {
     std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
     REQUIRE(sls::sum(v) == Approx(12.53));
 }
 
-TEST_CASE("Minus one if different") {
+TEST_CASE("Minus one if different", "[support]") {
     std::vector<double> v;
     REQUIRE(v.empty());
     double d = -1;
@@ -96,7 +89,7 @@ TEST_CASE("Minus one if different") {
     }
 }
 
-TEST_CASE("minus one does not have side effects"){
+TEST_CASE("minus one does not have side effects", "[support]") {
     std::vector<int> v{1, 1, 1};
     int i = sls::minusOneIfDifferent(v);
     REQUIRE(i == 1);
@@ -104,3 +97,18 @@ TEST_CASE("minus one does not have side effects"){
     REQUIRE(v[0] == 1);
 }
 
+TEST_CASE("Compare a vector containing two vectors", "[support]") {
+
+    std::vector<std::vector<int>> a{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 4, 5}};
+    std::vector<std::vector<int>> b{{0, 1, 2, 3, 4, 5}, {0, 1, 2, 3, 3, 5}};
+    std::vector<std::vector<int>> c{{0, 1, 2, 3, 4}, {0, 1, 2, 3, 3, 5}};
+    std::vector<std::vector<int>> d{
+        {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}, {0, 1, 2, 3, 4}};
+    std::vector<int> e{0, 1, 2, 3, 4, 5};
+
+    CHECK(minusOneIfDifferent(a) == a[0]);
+    CHECK(minusOneIfDifferent(a) == e);
+    CHECK(minusOneIfDifferent(b) == std::vector<int>{-1});
+    CHECK(minusOneIfDifferent(c) == std::vector<int>{-1});
+    CHECK(minusOneIfDifferent(d) == d[2]);
+}

slsSupportLib/tests/test-string_utils.cpp

@@ -90,11 +90,6 @@ TEST_CASE("concatenate non empty strings with one element"){
   REQUIRE(ret=="hej+");
 }
 
-TEST_CASE("Convert ip address"){
-  std::string address = "101.255.103.1";
-  REQUIRE(sls::stringIpToHex(address) == "65ff6701");
-
-}
 
 TEST_CASE("Remove char from string"){
   char str[] = "sometest"; 

slsSupportLib/tests/test.cpp

@@ -1,3 +0,0 @@
-// tests-main.cpp
-#define CATCH_CONFIG_MAIN
-#include "catch.hpp"