Merge pull request #340 from slsdetectorgroup/eiger2udp

Eiger2udp

RELEASE.txt

@@ -21,6 +21,9 @@ This document describes the differences between v6.1.0 and v6.0.0.
 
 - Fixed minor warnings (will fix commandline print of excess packets for missing packets)
 - ctb slow adcs and any other adcs (other than temp) goes to the control Server
+- number of udp interfaces is 2 for Eiger (CHANGE IN API??)
+- added module id for virtual servers into the udp header
+- refactoring (rxr)
 - fixed patsetbit and patsetmask for moench
 - changed default vref of adc9257 to 2V for moench (from 1.33V)
 

slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c

@@ -1492,6 +1492,8 @@ enum timingMode getTiming() {
 
 /* configure mac */
 
+int getNumberofUDPInterfaces() { return 1; }
+
 void calcChecksum(udp_header *udp) {
     int count = IP_HEADER_SIZE;
     long int sum = 0;

slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c

@@ -88,6 +88,7 @@ int eiger_virtual_read_n_rows = 256;
 int eiger_virtual_interrupt_subframe = 0;
 int eiger_virtual_left_datastream = 1;
 int eiger_virtual_right_datastream = 1;
+int eiger_virtual_module_id = 0;
 #endif
 int defaultDacValues[NDAC] = DEFAULT_DAC_VALS;
 
@@ -304,10 +305,9 @@ u_int32_t getDetectorIP() {
 void initControlServer() {
     LOG(logINFOBLUE, ("Configuring Control server\n"));
     if (!updateFlag && initError == OK) {
-#ifndef VIRTUAL
         int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
-#else
+#ifdef VIRTUAL
-        getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
+        eiger_virtual_module_id = modid;
 #endif
         if (initError == FAIL) {
             return;
@@ -1500,6 +1500,7 @@ enum timingMode getTiming() {
 }
 
 /* configure mac */
+int getNumberofUDPInterfaces() { return 2; }
 
 int getNumberofDestinations(int *retval) {
 #ifdef VIRTUAL
@@ -2407,6 +2408,7 @@ void *start_timer(void *arg) {
                 header->version = SLS_DETECTOR_HEADER_VERSION;
                 header->frameNumber = frameNr + iframes;
                 header->packetNumber = i;
+                header->modId = eiger_virtual_module_id;
                 header->row = row;
                 header->column = colLeft;
 
@@ -2417,6 +2419,7 @@ void *start_timer(void *arg) {
                 header->version = SLS_DETECTOR_HEADER_VERSION;
                 header->frameNumber = frameNr + iframes;
                 header->packetNumber = i;
+                header->modId = eiger_virtual_module_id;
                 header->row = row;
                 header->column = colRight;
                 if (eiger_virtual_quad_mode) {

slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c

@@ -41,6 +41,7 @@ char initErrorMessage[MAX_STR_LENGTH];
 #ifdef VIRTUAL
 pthread_t pthread_virtual_tid;
 int64_t virtual_currentFrameNumber = 2;
+int virtual_moduleid = 0;
 #endif
 
 enum detectorSettings thisSettings = UNINITIALIZED;
@@ -101,8 +102,9 @@ void basictests() {
     }
     // does check only if flag is 0 (by default), set by command line
     if ((!debugflag) && (!updateFlag) &&
-        ((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) || (checkType() == FAIL) ||
+        ((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) ||
-         (testFpga() == FAIL) || (testBus() == FAIL))) {
+         (checkType() == FAIL) || (testFpga() == FAIL) ||
+         (testBus() == FAIL))) {
         sprintf(initErrorMessage,
                 "Could not pass basic tests of FPGA and bus. Dangerous to "
                 "continue. (Firmware version:0x%llx) \n",
@@ -480,6 +482,9 @@ void setupDetector() {
 
     // set module id in register
     int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
+#ifdef VIRTUAL
+    virtual_moduleid = modid;
+#endif
     if (initError == FAIL) {
         return;
     }
@@ -2083,40 +2088,56 @@ int setReadoutSpeed(int val) {
     case G2_108MHZ:
         LOG(logINFOBLUE, ("Setting readout speed to 108 MHz\n"));
         if (setClockDivider(READOUT_C0, SPEED_108_CLKDIV_0) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set readout clk 0 to %d\n", SPEED_108_CLKDIV_0));
+            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
+                           "set readout clk 0 to %d\n",
+                           SPEED_108_CLKDIV_0));
             return FAIL;
         }
         if (setClockDivider(READOUT_C1, SPEED_108_CLKDIV_1) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set readout clk 1 to %d\n", SPEED_108_CLKDIV_1));
+            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
+                           "set readout clk 1 to %d\n",
+                           SPEED_108_CLKDIV_1));
             return FAIL;
         }
         if (setPhase(READOUT_C1, SPEED_108_CLKPHASE_DEG_1, 1) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set clk phase 1 %d deg\n", SPEED_108_CLKPHASE_DEG_1));
+            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
+                           "set clk phase 1 %d deg\n",
+                           SPEED_108_CLKPHASE_DEG_1));
             return FAIL;
         }
         setDBITPipeline(SPEED_144_DBIT_PIPELINE);
         if (getDBITPipeline() != SPEED_144_DBIT_PIPELINE) {
-            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set dbitpipeline to %d \n", SPEED_144_DBIT_PIPELINE));
+            LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
+                           "set dbitpipeline to %d \n",
+                           SPEED_144_DBIT_PIPELINE));
             return FAIL;
         }
         break;
     case G2_144MHZ:
         LOG(logINFOBLUE, ("Setting readout speed to 144 MHz\n"));
         if (setClockDivider(READOUT_C0, SPEED_144_CLKDIV_0) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set readout clk 0 to %d\n", SPEED_144_CLKDIV_0));
+            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
+                           "set readout clk 0 to %d\n",
+                           SPEED_144_CLKDIV_0));
             return FAIL;
         }
         if (setClockDivider(READOUT_C1, SPEED_144_CLKDIV_1) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set readout clk 1 to %d\n", SPEED_144_CLKDIV_1));
+            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
+                           "set readout clk 1 to %d\n",
+                           SPEED_144_CLKDIV_1));
             return FAIL;
         }
         if (setPhase(READOUT_C1, SPEED_144_CLKPHASE_DEG_1, 1) == FAIL) {
-            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set clk phase 1 %d deg\n", SPEED_144_CLKPHASE_DEG_1));
+            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
+                           "set clk phase 1 %d deg\n",
+                           SPEED_144_CLKPHASE_DEG_1));
             return FAIL;
         }
         setDBITPipeline(SPEED_144_DBIT_PIPELINE);
         if (getDBITPipeline() != SPEED_144_DBIT_PIPELINE) {
-            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set dbitpipeline to %d \n", SPEED_144_DBIT_PIPELINE));
+            LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
+                           "set dbitpipeline to %d \n",
+                           SPEED_144_DBIT_PIPELINE));
             return FAIL;
         }
         break;
@@ -3005,7 +3026,7 @@ void *start_timer(void *arg) {
             header->version = SLS_DETECTOR_HEADER_VERSION - 1;
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = 0;
-            header->modId = 0;
+            header->modId = virtual_moduleid;
             header->row = detPos[X];
             header->column = detPos[Y];
             // fill data

slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c

@@ -1299,6 +1299,8 @@ int getExtSignal(int signalIndex) {
 
 /* configure mac */
 
+int getNumberofUDPInterfaces() { return 1; }
+
 void calcChecksum(mac_conf *mac, int sourceip, int destip) {
     mac->ip.ip_ver = 0x4;
     mac->ip.ip_ihl = 0x5;

slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c

@@ -1157,6 +1157,8 @@ enum timingMode getTiming() {
 
 /* configure mac */
 
+int getNumberofUDPInterfaces() { return 1; }
+
 void calcChecksum(udp_header *udp) {
     int count = IP_HEADER_SIZE;
     long int sum = 0;

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c

@@ -42,6 +42,7 @@ char initErrorMessage[MAX_STR_LENGTH];
 #ifdef VIRTUAL
 pthread_t pthread_virtual_tid;
 int64_t virtual_currentFrameNumber = 2;
+int virtual_moduleid = 0;
 #endif
 
 enum detectorSettings thisSettings = UNINITIALIZED;
@@ -448,6 +449,9 @@ void setupDetector() {
 
     // set module id in register
     int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
+#ifdef VIRTUAL
+    virtual_moduleid = modid;
+#endif
     if (initError == FAIL) {
         return;
     }
@@ -1719,6 +1723,8 @@ int getExtSignal(int signalIndex) {
     }
 }
 
+int getNumberofUDPInterfaces() { return 1; }
+
 int configureMAC() {
 
     uint32_t srcip = udpDetails[0].srcip;
@@ -2280,7 +2286,7 @@ void *start_timer(void *arg) {
             header->version = SLS_DETECTOR_HEADER_VERSION - 1;
             header->frameNumber = virtual_currentFrameNumber;
             header->packetNumber = i;
-            header->modId = 0;
+            header->modId = virtual_moduleid;
             header->row = detPos[X];
             header->column = detPos[Y];
 

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -387,8 +387,8 @@ void calcChecksum(mac_conf *mac, int sourceip, int destip);
 #endif
 #if defined(JUNGFRAUD) || defined(GOTTHARD2D)
 void setNumberofUDPInterfaces(int val);
-int getNumberofUDPInterfaces();
 #endif
+int getNumberofUDPInterfaces();
 
 #if defined(JUNGFRAUD) || defined(EIGERD)
 int getNumberofDestinations(int *retval);

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -4725,19 +4725,22 @@ void calculate_and_set_position() {
         LOG(logERROR, (mess));
         return;
     }
-    int maxy = maxydet;
+
-    // position does not change for gotthard2 (2 interfaces)
+    // calculating new position
-#ifdef JUNGFRAUD
+    int modulePorts[2] = {1, 1};
-    maxy *= getNumberofUDPInterfaces();
+    // position does change for eiger and jungfrau (2 interfaces)
+#if defined(EIGERD)
+    modulePorts[1] = getNumberofUDPInterfaces(); // horz
+#elif defined(JUNGFRAUD)
+    modulePorts[0] = getNumberofUDPInterfaces(); // vert
 #endif
+    int maxy = maxydet * modulePorts[0];
     int pos[2] = {0, 0};
     // row
     pos[0] = (detectorId % maxy);
     // col for horiz. udp ports
-    pos[1] = (detectorId / maxy);
+    pos[1] = (detectorId / maxy) * modulePorts[1];
-#ifdef EIGERD
+
-    pos[1] *= 2;
-#endif
     LOG(logDEBUG, ("Setting Positions (%d,%d)\n", pos[0], pos[1]));
     if (setDetectorPosition(pos) == FAIL) {
         ret = FAIL;
@@ -5320,7 +5323,16 @@ int set_num_interfaces(int file_des) {
     LOG(logINFO, ("Setting number of interfaces: %d\n", arg));
 
 #if !defined(JUNGFRAUD) && !defined(GOTTHARD2D)
-    functionNotImplemented();
+    // fixed number of udp interfaces
+    int num_interfaces = getNumberofUDPInterfaces();
+    if (arg != num_interfaces) {
+        ret = FAIL;
+        sprintf(mess,
+                "Could not set number of interfaces. Invalid value: %d. Must "
+                "be %d\n",
+                arg, num_interfaces);
+        LOG(logERROR, (mess));
+    }
 #else
     // only set
     if (Server_VerifyLock() == OK) {
@@ -5380,12 +5392,9 @@ int get_num_interfaces(int file_des) {
     int retval = -1;
     LOG(logDEBUG1, ("Getting number of udp interfaces\n"));
 
-#if !defined(JUNGFRAUD) && !defined(GOTTHARD2D)
-    retval = 1;
-#else
     // get only
     retval = getNumberofUDPInterfaces();
-#endif
+
     LOG(logDEBUG1, ("Number of udp interfaces retval: %u\n", retval));
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
@@ -6883,11 +6892,7 @@ int get_receiver_parameters(int file_des) {
 
     // sending real detector parameters
     // udp interfaces
-#if defined(JUNGFRAUD) || defined(GOTTHARD2D)
     i32 = getNumberofUDPInterfaces();
-#else
-    i32 = 1;
-#endif
     n += sendData(file_des, &i32, sizeof(i32), INT32);
     if (n < 0)
         return printSocketReadError();

slsDetectorSoftware/src/Detector.cpp

@@ -2306,20 +2306,8 @@ Result<uint64_t> Detector::getRxCurrentFrameIndex(Positions pos) const {
 }
 
 std::vector<int> Detector::getPortNumbers(int start_port) {
-    int num_sockets_per_detector = 1;
+    int num_sockets_per_detector = pimpl->getNumberofUDPInterfaces({}).tsquash(
-    switch (getDetectorType().squash()) {
+        "Number of UDP Interfaces is not consistent among modules");
-    case defs::EIGER:
-        num_sockets_per_detector *= 2;
-        break;
-    case defs::JUNGFRAU:
-    case defs::GOTTHARD2:
-        if (pimpl->getNumberofUDPInterfaces({}).squash() == 2) {
-            num_sockets_per_detector *= 2;
-        }
-        break;
-    default:
-        break;
-    }
     std::vector<int> res;
     res.reserve(size());
     for (int idet = 0; idet < size(); ++idet) {

slsDetectorSoftware/src/DetectorImpl.cpp

@@ -245,6 +245,15 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
         addModule(hostname);
     }
     updateDetectorSize();
+
+    // update zmq port (especially for eiger)
+    int numInterfaces = modules[0]->getNumberofUDPInterfaces();
+    if (numInterfaces == 2) {
+        for (size_t i = 0; i < modules.size(); ++i) {
+            modules[i]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
+                                               i * numInterfaces);
+        }
+    }
 }
 
 void DetectorImpl::addModule(const std::string &hostname) {
@@ -402,27 +411,21 @@ int DetectorImpl::createReceivingDataSockets() {
     }
     LOG(logINFO) << "Going to create data sockets";
 
-    size_t numSockets = modules.size();
+    size_t numUDPInterfaces =
-    size_t numSocketsPerModule = 1;
+        Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash(1);
-    if (shm()->detType == EIGER) {
+    // gotthard2 second interface is only for veto debugging (not in gui)
-        numSocketsPerModule = 2;
+    if (shm()->detType == GOTTHARD2) {
+        numUDPInterfaces = 1;
     }
-    // gotthard2 second interface is only for veto debugging
+    size_t numSockets = modules.size() * numUDPInterfaces;
-    else if (shm()->detType != GOTTHARD2) {
-        if (Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash() ==
-            2) {
-            numSocketsPerModule = 2;
-        }
-    }
-    numSockets *= numSocketsPerModule;
 
     for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
         uint32_t portnum =
-            (modules[iSocket / numSocketsPerModule]->getClientStreamingPort());
+            (modules[iSocket / numUDPInterfaces]->getClientStreamingPort());
-        portnum += (iSocket % numSocketsPerModule);
+        portnum += (iSocket % numUDPInterfaces);
         try {
-            zmqSocket.push_back(sls::make_unique<ZmqSocket>(
+            zmqSocket.push_back(
-                modules[iSocket / numSocketsPerModule]
+                sls::make_unique<ZmqSocket>(modules[iSocket / numUDPInterfaces]
                                                 ->getClientStreamingIP()
                                                 .str()
                                                 .c_str(),
@@ -460,13 +463,9 @@ void DetectorImpl::readFrameFromReceiver() {
     int nDetPixelsX = 0;
     int nDetPixelsY = 0;
     bool quadEnable = false;
+    // to flip image
     bool eiger = false;
-    bool numInterfaces = 1;
+
-    // gotthard2 second interface is veto debugging
-    if (shm()->detType != GOTTHARD2) {
-        numInterfaces = Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
-                            .squash(); // cannot pick up from zmq
-    }
     std::vector<bool> runningList(zmqSocket.size());
     std::vector<bool> connectList(zmqSocket.size());
     numZmqRunning = 0;
@@ -542,10 +541,9 @@ void DetectorImpl::readFrameFromReceiver() {
                         // shape
                         nPixelsX = zHeader.npixelsx;
                         nPixelsY = zHeader.npixelsy;
-                        // module shape
+                        // module shape (port)
                         nX = zHeader.ndetx;
                         nY = zHeader.ndety;
-                        nY *= numInterfaces;
                         nDetPixelsX = nX * nPixelsX;
                         nDetPixelsY = nY * nPixelsY;
                         // det type

slsDetectorSoftware/src/Module.cpp

@@ -3130,8 +3130,8 @@ void Module::initializeModuleStructure(detectorType type) {
     sls::strcpy_safe(shm()->rxHostname, "none");
     shm()->rxTCPPort = DEFAULT_PORTNO + 2;
     shm()->useReceiverFlag = false;
-    shm()->zmqport = DEFAULT_ZMQ_CL_PORTNO +
+    shm()->zmqport =
-                     (moduleIndex * ((shm()->detType == EIGER) ? 2 : 1));
+        DEFAULT_ZMQ_CL_PORTNO + moduleIndex * shm()->numUDPInterfaces;
     shm()->zmqip = IpAddr{};
     shm()->numUDPInterfaces = 1;
     shm()->stoppedFlag = false;

slsReceiverSoftware/src/ClientInterface.cpp

@@ -317,10 +317,7 @@ int ClientInterface::setup_receiver(Interface &socket) {
 
     // basic setup
     setDetectorType(arg.detType);
-    {
+    impl()->setDetectorSize(arg.numberOfModule);
-        int msize[2] = {arg.numberOfModule.x, arg.numberOfModule.y};
-        impl()->setDetectorSize(msize);
-    }
     impl()->setModulePositionId(arg.moduleIndex);
     impl()->setDetectorHostname(arg.hostname);
 

slsReceiverSoftware/src/DataStreamer.cpp

@@ -17,11 +17,12 @@
 const std::string DataStreamer::TypeName = "DataStreamer";
 
 DataStreamer::DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi,
-                           bool fr, int *nm, bool *qe, uint64_t *tot)
+                           bool fr, slsDetectorDefs::xy nm, bool *qe,
+                           uint64_t *tot)
     : ThreadObject(ind, TypeName), fifo(f), dynamicRange(dr), roi(r),
       fileIndex(fi), flipRows(fr), quadEnable(qe), totalNumFrames(tot) {
-    numMods[0] = nm[0];
+    numMods.x = nm.x;
-    numMods[1] = nm[1];
+    numMods.y = nm.y;
 
     LOG(logDEBUG) << "DataStreamer " << ind << " created";
 }
@@ -62,9 +63,9 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, char *buf) {
 
 void DataStreamer::SetGeneralData(GeneralData *g) { generalData = g; }
 
-void DataStreamer::SetNumberofModules(int *nm) {
+void DataStreamer::SetNumberofModules(xy nm) {
-    numMods[0] = nm[0];
+    numMods.x = nm.x;
-    numMods[1] = nm[1];
+    numMods.y = nm.y;
 }
 
 void DataStreamer::SetFlipRows(bool fd) { flipRows = fd; }
@@ -219,8 +220,8 @@ int DataStreamer::SendHeader(sls_receiver_header *rheader, uint32_t size,
 
     zHeader.dynamicRange = *dynamicRange;
     zHeader.fileIndex = *fileIndex;
-    zHeader.ndetx = numMods[0];
+    zHeader.ndetx = numMods.x;
-    zHeader.ndety = numMods[1];
+    zHeader.ndety = numMods.y;
     zHeader.npixelsx = nx;
     zHeader.npixelsy = ny;
     zHeader.imageSize = size;

slsReceiverSoftware/src/DataStreamer.h

@@ -33,12 +33,12 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
      * @param r roi
      * @param fi pointer to file index
      * @param fr flip rows
-     * @param nm pointer to number of modules in each dimension
+     * @param nm number of modules in each dimension
      * @param qe pointer to quad Enable
      * @param tot pointer to total number of frames
      */
     DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi, bool fr,
-                 int *nm, bool *qe, uint64_t *tot);
+                 xy nm, bool *qe, uint64_t *tot);
 
     /**
      * Destructor
@@ -65,9 +65,9 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
 
     /**
      * Set number of detectors
-     * @param nm number of modules in both dimensions
+     * @param nm number of modules/ports  in both dimensions
      */
-    void SetNumberofModules(int *nm);
+    void SetNumberofModules(xy nm);
 
     /**
      * Set Flipped rows
@@ -196,7 +196,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
     char *completeBuffer{nullptr};
 
     /** Number of Modules in X and Y dimension */
-    int numMods[2];
+    xy numMods{1, 1};
 
     /** Quad Enable */
     bool *quadEnable;

slsReceiverSoftware/src/GeneralData.h

@@ -38,7 +38,7 @@ class GeneralData {
     /** Header size of data saved into fifo buffer at a time*/
     uint32_t fifoBufferHeaderSize{0};
     uint32_t defaultFifoDepth{0};
-    uint32_t threadsPerReceiver{1};
+    uint32_t numUDPInterfaces{1};
     uint32_t headerPacketSize{0};
     /** Streaming (for ROI - mainly short Gotthard)  */
     uint32_t nPixelsXComplete{0};
@@ -54,10 +54,27 @@ class GeneralData {
     uint32_t vetoImageSize{0};
     uint32_t vetoHsize{0};
     uint32_t maxRowsPerReadout{0};
+    uint32_t dynamicRange{16};
+    bool tengigaEnable{false};
+    uint32_t nAnalogSamples{0};
+    uint32_t nDigitalSamples{0};
+    slsDetectorDefs::readoutMode readoutType{slsDetectorDefs::ANALOG_ONLY};
+    uint32_t adcEnableMaskOneGiga{BIT32_MASK};
+    uint32_t adcEnableMaskTenGiga{BIT32_MASK};
+    slsDetectorDefs::ROI roi{};
 
     GeneralData(){};
     virtual ~GeneralData(){};
 
+    // Returns the pixel depth in byte, 4 bits being 0.5 byte
+    float GetPixelDepth() { return float(dynamicRange) / 8; }
+
+    void ThrowGenericError(std::string msg) const {
+        throw sls::RuntimeError(
+            msg + std::string("SetROI is a generic function that should be "
+                              "overloaded by a derived class"));
+    }
+
     /**
      * Get Header Infomation (frame number, packet number)
      * @param index thread index for debugging purposes
@@ -78,94 +95,61 @@ class GeneralData {
         bunchId = -1;
     }
 
-    /**
-     * Set ROI
-     * @param i ROI
-     */
     virtual void SetROI(slsDetectorDefs::ROI i) {
-        LOG(logERROR) << "SetROI is a generic function that should be "
+        ThrowGenericError("SetROI");
-                         "overloaded by a derived class";
     };
 
-    /**
+    /**@returns adc configured */
-     * Get Adc configured
-     * @param index thread index for debugging purposes
-     * @param i
-     * @returns adc configured
-     */
     virtual int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
-        LOG(logERROR) << "GetAdcConfigured is a generic function that should "
+        ThrowGenericError("GetAdcConfigured");
-                         "be overloaded by a derived class";
         return 0;
     };
 
-    /**
+    virtual void SetDynamicRange(int dr) {
-     * Setting dynamic range changes member variables
+        ThrowGenericError("SetDynamicRange");
-     * @param dr dynamic range
-     * @param tgEnable true if 10GbE is enabled, else false
-     */
-    virtual void SetDynamicRange(int dr, bool tgEnable) {
-        LOG(logERROR) << "SetDynamicRange is a generic function that should be "
-                         "overloaded by a derived class";
     };
 
-    /**
+    virtual void SetTenGigaEnable(bool tgEnable) {
-     * Setting ten giga enable changes member variables
+        ThrowGenericError("SetTenGigaEnable");
-     * @param tgEnable true if 10GbE is enabled, else false
-     * @param dr dynamic range
-     */
-    virtual void SetTenGigaEnable(bool tgEnable, int dr) {
-        LOG(logERROR) << "SetTenGigaEnable is a generic function that should "
-                         "be overloaded by a derived class";
     };
 
-    /**
-     * Set odd starting packet (gotthard)
-     * @param index thread index for debugging purposes
-     * @param packetData pointer to data
-     * @returns true or false for odd starting packet number
-     */
     virtual bool SetOddStartingPacket(int index, char *packetData) {
-        LOG(logERROR) << "SetOddStartingPacket is a generic function that "
+        ThrowGenericError("SetOddStartingPacket");
-                         "should be overloaded by a derived class";
         return false;
     };
 
-    /**
+    virtual void SetNumberofInterfaces(const int n) {
-     * Set databytes (ctb, moench)
+        ThrowGenericError("SetNumberofInterfaces");
-     * @param a adc enable mask
+    };
-     * @param as analog number of samples
+
-     * @param ds digital number of samples
+    virtual void SetNumberofCounters(const int n) {
-     * @param t tengiga enable
+        ThrowGenericError("SetNumberofCounters");
-     * @param f readout flags
+    };
-     * @returns analog data bytes
+
-     */
+    virtual int GetNumberOfAnalogDatabytes() {
-    virtual int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t,
+        ThrowGenericError("GetNumberOfAnalogDatabytes");
-                             slsDetectorDefs::readoutMode f) {
-        LOG(logERROR) << "setImageSize is a generic function that should be "
-                         "overloaded by a derived class";
         return 0;
     };
 
-    /**
+    virtual void SetNumberOfAnalogSamples(int n) {
-     * set number of interfaces (jungfrau)
+        ThrowGenericError("SetNumberOfAnalogSamples");
-     * @param n number of interfaces
+    };
-     */
-    virtual void SetNumberofInterfaces(const int n) {
-        LOG(logERROR) << "SetNumberofInterfaces is a generic function that "
-                         "should be overloaded by a derived class";
-    }
 
-    /**
+    virtual void SetNumberOfDigitalSamples(int n) {
-     * set number of counters (mythen3)
+        ThrowGenericError("SetNumberOfDigitalSamples");
-     * @param n number of counters
+    };
-     * @param dr dynamic range
+
-     * @param tgEnable ten giga enable
+    virtual void SetOneGigaAdcEnableMask(int n) {
-     */
+        ThrowGenericError("SetOneGigaAdcEnableMask");
-    virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) {
+    };
-        LOG(logERROR) << "SetNumberofCounters is a generic function that "
+
-                         "should be overloaded by a derived class";
+    virtual void SetTenGigaAdcEnableMask(int n) {
-    }
+        ThrowGenericError("SetTenGigaAdcEnableMask");
+    };
+
+    virtual void SetReadoutMode(slsDetectorDefs::readoutMode r) {
+        ThrowGenericError("SetReadoutMode");
+    };
 };
 
 class GotthardData : public GeneralData {
@@ -175,23 +159,14 @@ class GotthardData : public GeneralData {
     const int nChipsPerAdc = 2;
 
   public:
-    /** Constructor */
     GotthardData() {
         myDetectorType = slsDetectorDefs::GOTTHARD;
-        nPixelsX = 1280;
         nPixelsY = 1;
-        headerSizeinPacket = 4;
+        headerSizeinPacket = 6;
-        dataSize = 1280;
-        packetSize = GOTTHARD_PACKET_SIZE;
-        packetsPerFrame = 2;
-        imageSize = dataSize * packetsPerFrame;
-        frameIndexMask = 0xFFFFFFFE;
-        frameIndexOffset = 1;
-        packetIndexMask = 1;
         maxFramesPerFile = MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
-        defaultFifoDepth = 50000;
+        UpdateImageSize();
     };
 
     /**
@@ -219,56 +194,7 @@ class GotthardData : public GeneralData {
         bunchId = -1;
     }
 
-    /**
+    /** @returns adc configured */
-     * Set ROI
-     * @param i ROI
-     */
-    void SetROI(slsDetectorDefs::ROI i) {
-        // all adcs
-        if (i.xmin == -1) {
-            nPixelsX = 1280;
-            dataSize = 1280;
-            packetSize = GOTTHARD_PACKET_SIZE;
-            packetsPerFrame = 2;
-            imageSize = dataSize * packetsPerFrame;
-            frameIndexMask = 0xFFFFFFFE;
-            frameIndexOffset = 1;
-            packetIndexMask = 1;
-            maxFramesPerFile = MAX_FRAMES_PER_FILE;
-            fifoBufferHeaderSize = FIFO_HEADER_NUMBYTES +
-                                   sizeof(slsDetectorDefs::sls_receiver_header);
-            defaultFifoDepth = 50000;
-            nPixelsXComplete = 0;
-            nPixelsYComplete = 0;
-            imageSizeComplete = 0;
-        }
-
-        // single adc
-        else {
-            nPixelsX = 256;
-            dataSize = 512;
-            packetSize = 518;
-            packetsPerFrame = 1;
-            imageSize = dataSize * packetsPerFrame;
-            frameIndexMask = 0xFFFFFFFF;
-            frameIndexOffset = 0;
-            packetIndexMask = 0;
-            maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
-            fifoBufferHeaderSize = FIFO_HEADER_NUMBYTES +
-                                   sizeof(slsDetectorDefs::sls_receiver_header);
-            defaultFifoDepth = 75000;
-            nPixelsXComplete = 1280;
-            nPixelsYComplete = 1;
-            imageSizeComplete = 1280 * 2;
-        }
-    };
-
-    /**
-     * Get Adc configured
-     * @param index thread index for debugging purposes
-     * @param i ROI
-     * @returns adc configured
-     */
     int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
         int adc = -1;
         // single adc
@@ -320,99 +246,114 @@ class GotthardData : public GeneralData {
         }
         return oddStartingPacket;
     };
+
+    void SetROI(slsDetectorDefs::ROI i) {
+        roi = i;
+        UpdateImageSize();
+    };
+
+  private:
+    void UpdateImageSize() {
+
+        // all adcs
+        if (roi.xmin == -1) {
+            nPixelsX = 1280;
+            dataSize = 1280;
+            packetsPerFrame = 2;
+            frameIndexMask = 0xFFFFFFFE;
+            frameIndexOffset = 1;
+            packetIndexMask = 1;
+            maxFramesPerFile = MAX_FRAMES_PER_FILE;
+            nPixelsXComplete = 0;
+            nPixelsYComplete = 0;
+            imageSizeComplete = 0;
+            defaultFifoDepth = 50000;
+        } else {
+            nPixelsX = 256;
+            dataSize = 512;
+            packetsPerFrame = 1;
+            frameIndexMask = 0xFFFFFFFF;
+            frameIndexOffset = 0;
+            packetIndexMask = 0;
+            maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
+            nPixelsXComplete = 1280;
+            nPixelsYComplete = 1;
+            imageSizeComplete = 1280 * 2;
+            defaultFifoDepth = 75000;
+        }
+        imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
+        packetSize = headerSizeinPacket + dataSize;
+        packetsPerFrame = imageSize / dataSize;
+    };
 };
 
 class EigerData : public GeneralData {
 
   public:
-    /** Constructor */
     EigerData() {
         myDetectorType = slsDetectorDefs::EIGER;
-        nPixelsX = (256 * 2);
-        nPixelsY = 256;
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
-        dataSize = 1024;
-        packetSize = headerSizeinPacket + dataSize;
-        packetsPerFrame = 256;
-        imageSize = dataSize * packetsPerFrame;
         maxFramesPerFile = EIGER_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
-        defaultFifoDepth = 1000;
+        numUDPInterfaces = 2;
-        threadsPerReceiver = 2;
         headerPacketSize = 40;
         standardheader = true;
         maxRowsPerReadout = 256;
+        UpdateImageSize();
     };
 
-    /**
+    void SetDynamicRange(int dr) {
-     * Setting dynamic range changes member variables
+        dynamicRange = dr;
-     * @param dr dynamic range
+        UpdateImageSize();
-     * @param tgEnable true if 10GbE is enabled, else false
-     */
-    void SetDynamicRange(int dr, bool tgEnable) {
-        packetsPerFrame = (tgEnable ? 4 : 16) * dr;
-        imageSize = dataSize * packetsPerFrame;
-        defaultFifoDepth = (dr == 32 ? 100 : 1000);
     }
 
-    /**
+    void SetTenGigaEnable(bool tgEnable) {
-     * Setting ten giga enable changes member variables
+        tengigaEnable = tgEnable;
-     * @param tgEnable true if 10GbE is enabled, else false
+        UpdateImageSize();
-     * @param dr dynamic range
+    };
-     */
+
-    void SetTenGigaEnable(bool tgEnable, int dr) {
+  private:
-        dataSize = (tgEnable ? 4096 : 1024);
+    void UpdateImageSize() {
+        nPixelsX = (256 * 4) / numUDPInterfaces;
+        nPixelsY = 256;
+        dataSize = (tengigaEnable ? 4096 : 1024);
         packetSize = headerSizeinPacket + dataSize;
-        packetsPerFrame = (tgEnable ? 4 : 16) * dr;
+        imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
-        imageSize = dataSize * packetsPerFrame;
+        packetsPerFrame = imageSize / dataSize;
+        defaultFifoDepth = (dynamicRange == 32 ? 100 : 1000);
     };
 };
 
 class JungfrauData : public GeneralData {
 
   public:
-    /** Constructor */
     JungfrauData() {
         myDetectorType = slsDetectorDefs::JUNGFRAU;
-        nPixelsX = (256 * 4);
-        nPixelsY = 512;
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
         dataSize = 8192;
         packetSize = headerSizeinPacket + dataSize;
-        packetsPerFrame = 128;
-        imageSize = dataSize * packetsPerFrame;
         maxFramesPerFile = JFRAU_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
         defaultFifoDepth = 2500;
         standardheader = true;
-        defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
         maxRowsPerReadout = 512;
+        UpdateImageSize();
     };
 
-    /**
-     * set number of interfaces (jungfrau)
-     * @param n number of interfaces
-     */
     void SetNumberofInterfaces(const int n) {
-        // 2 interfaces
+        numUDPInterfaces = n;
-        if (n == 2) {
+        UpdateImageSize();
-            nPixelsY = 256;
+    };
-            packetsPerFrame = 64;
-            imageSize = dataSize * packetsPerFrame;
-            threadsPerReceiver = 2;
-            defaultUdpSocketBufferSize = (500 * 1024 * 1024);
 
-        }
+  private:
-        // 1 interface
+    void UpdateImageSize() {
-        else {
+        nPixelsX = (256 * 4);
-            nPixelsY = 512;
+        nPixelsY = (256 * 2) / numUDPInterfaces;
-            packetsPerFrame = 128;
+        imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
-            imageSize = dataSize * packetsPerFrame;
+        packetsPerFrame = imageSize / dataSize;
-            threadsPerReceiver = 1;
+        defaultUdpSocketBufferSize = (1000 * 1024 * 1024) / numUDPInterfaces;
-            defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
-        }
     };
 };
 
@@ -422,39 +363,46 @@ class Mythen3Data : public GeneralData {
     const int NCHAN = 1280;
 
   public:
-    /** Constructor */
     Mythen3Data() {
         myDetectorType = slsDetectorDefs::MYTHEN3;
         ncounters = 3;
-        nPixelsX = (NCHAN * ncounters); // max 1280 channels x 3 counters
         nPixelsY = 1;
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
-        dataSize = 7680;
-        packetSize = headerSizeinPacket + dataSize;
-        packetsPerFrame = 2;
-        imageSize = dataSize * packetsPerFrame;
         maxFramesPerFile = MYTHEN3_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
         defaultFifoDepth = 50000;
         standardheader = true;
         defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
+        dynamicRange = 32;
+        tengigaEnable = true;
+        UpdateImageSize();
     };
 
-    /**
+    void SetDynamicRange(int dr) {
-     * set number of counters (mythen3)
+        dynamicRange = dr;
-     * @param n number of counters
+        UpdateImageSize();
-     * @param dr dynamic range
+    };
-     * @param tgEnable ten giga enable
+
-     */
+    void SetTenGigaEnable(bool tg) {
-    virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) {
+        tengigaEnable = tg;
+        UpdateImageSize();
+    };
+
+    virtual void SetNumberofCounters(const int n) {
         ncounters = n;
-        nPixelsX = NCHAN * ncounters;
+        UpdateImageSize();
+    };
+
+  private:
+    void UpdateImageSize() {
+        nPixelsX = (NCHAN * ncounters); // max 1280 channels x 3 counters
         LOG(logINFO) << "nPixelsX: " << nPixelsX;
-        imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00);
+        imageSize = nPixelsX * nPixelsY * GetPixelDepth();
+
         // 10g
-        if (tgEnable) {
+        if (tengigaEnable) {
-            if (dr == 32 && n > 1) {
+            if (dynamicRange == 32 && ncounters > 1) {
                 packetsPerFrame = 2;
             } else {
                 packetsPerFrame = 1;
@@ -463,7 +411,7 @@ class Mythen3Data : public GeneralData {
         }
         // 1g
         else {
-            if (n == 3) {
+            if (ncounters == 3) {
                 dataSize = 768;
             } else {
                 dataSize = 1280;
@@ -479,41 +427,25 @@ class Mythen3Data : public GeneralData {
 
 class Gotthard2Data : public GeneralData {
   public:
-    /** Constructor */
     Gotthard2Data() {
         myDetectorType = slsDetectorDefs::GOTTHARD2;
         nPixelsX = 128 * 10;
         nPixelsY = 1;
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
         dataSize = 2560; // 1280 channels * 2 bytes
-        packetSize = headerSizeinPacket + dataSize;
-        packetsPerFrame = 1;
-        imageSize = dataSize * packetsPerFrame;
         maxFramesPerFile = GOTTHARD2_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
         defaultFifoDepth = 50000;
         standardheader = true;
-        defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
         vetoDataSize = 160;
-        vetoImageSize = vetoDataSize * packetsPerFrame;
         vetoHsize = 16;
-        vetoPacketSize = vetoHsize + vetoDataSize;
+        UpdateImageSize();
     };
 
-    /**
-     * set number of interfaces
-     * @param n number of interfaces
-     */
     void SetNumberofInterfaces(const int n) {
-        // 2 interfaces (+veto)
+        numUDPInterfaces = n;
-        if (n == 2) {
+        UpdateImageSize();
-            threadsPerReceiver = 2;
-        }
-        // 1 interface (data only)
-        else {
-            threadsPerReceiver = 1;
-        }
     };
 
     /**
@@ -532,134 +464,158 @@ class Gotthard2Data : public GeneralData {
         bunchId = *reinterpret_cast<uint64_t *>(packetData + 8);
         packetNumber = 0;
     };
+
+  private:
+    void UpdateImageSize() {
+        packetSize = headerSizeinPacket + dataSize;
+        imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
+        packetsPerFrame = imageSize / dataSize;
+        vetoPacketSize = vetoHsize + vetoDataSize;
+        vetoImageSize = vetoDataSize * packetsPerFrame;
+        defaultUdpSocketBufferSize = (1000 * 1024 * 1024) / numUDPInterfaces;
+    };
 };
 
 class ChipTestBoardData : public GeneralData {
   private:
-    /** Number of digital channels */
     const int NCHAN_DIGITAL = 64;
-    /** Number of bytes per analog channel */
     const int NUM_BYTES_PER_ANALOG_CHANNEL = 2;
+    int nAnalogBytes = 0;
 
   public:
     /** Constructor */
     ChipTestBoardData() {
         myDetectorType = slsDetectorDefs::CHIPTESTBOARD;
-        nPixelsX = 36; // total number of channels
         nPixelsY = 1; // number of samples
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
-        dataSize = UDP_PACKET_DATA_BYTES;
-        packetSize = headerSizeinPacket + dataSize;
-        // packetsPerFrame 	= 1;
-        imageSize = nPixelsX * nPixelsY * 2;
         frameIndexMask = 0xFFFFFF; // 10g
         frameIndexOffset = 8;      // 10g
         packetIndexMask = 0xFF;    // 10g
-        packetsPerFrame =
-            ceil((double)imageSize / (double)UDP_PACKET_DATA_BYTES);
         maxFramesPerFile = CTB_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
         defaultFifoDepth = 2500;
         standardheader = true;
+        UpdateImageSize();
     };
 
-    /**
+  public:
-     * Set databytes
+    int GetNumberOfAnalogDatabytes() { return nAnalogBytes; };
-     * @param a adc enable mask
+
-     * @param as analog number of samples
+    void SetNumberOfAnalogSamples(int n) {
-     * @param ds digital number of samples
+        nAnalogSamples = n;
-     * @param t tengiga enable
+        UpdateImageSize();
-     * @param f readout flags
+    };
-     * @returns analog data bytes
+
-     */
+    void SetNumberOfDigitalSamples(int n) {
-    int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t,
+        nDigitalSamples = n;
-                     slsDetectorDefs::readoutMode f) {
+        UpdateImageSize();
-        int nachans = 0, ndchans = 0;
+    };
-        int adatabytes = 0, ddatabytes = 0;
+
+    void SetOneGigaAdcEnableMask(int n) {
+        adcEnableMaskOneGiga = n;
+        UpdateImageSize();
+    };
+
+    void SetTenGigaAdcEnableMask(int n) {
+        adcEnableMaskTenGiga = n;
+        UpdateImageSize();
+    };
+
+    void SetReadoutMode(slsDetectorDefs::readoutMode r) {
+        readoutType = r;
+        UpdateImageSize();
+    };
+
+    void SetTenGigaEnable(bool tg) {
+        tengigaEnable = tg;
+        UpdateImageSize();
+    };
+
+  private:
+    void UpdateImageSize() {
+        nAnalogBytes = 0;
+        int nDigitalBytes = 0;
+        int nAnalogChans = 0, nDigitalChans = 0;
 
         // analog channels (normal, analog/digital readout)
-        if (f == slsDetectorDefs::ANALOG_ONLY ||
+        if (readoutType == slsDetectorDefs::ANALOG_ONLY ||
-            f == slsDetectorDefs::ANALOG_AND_DIGITAL) {
+            readoutType == slsDetectorDefs::ANALOG_AND_DIGITAL) {
-            nachans = __builtin_popcount(a);
+            uint32_t adcEnableMask =
+                (tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga);
+            nAnalogChans = __builtin_popcount(adcEnableMask);
 
-            adatabytes = nachans * NUM_BYTES_PER_ANALOG_CHANNEL * as;
+            nAnalogBytes =
-            LOG(logDEBUG1) << " Number of Analog Channels:" << nachans
+                nAnalogChans * NUM_BYTES_PER_ANALOG_CHANNEL * nAnalogSamples;
-                           << " Databytes: " << adatabytes;
+            LOG(logDEBUG1) << " Number of Analog Channels:" << nAnalogChans
+                           << " Databytes: " << nAnalogBytes;
         }
         // digital channels
-        if (f == slsDetectorDefs::DIGITAL_ONLY ||
+        if (readoutType == slsDetectorDefs::DIGITAL_ONLY ||
-            f == slsDetectorDefs::ANALOG_AND_DIGITAL) {
+            readoutType == slsDetectorDefs::ANALOG_AND_DIGITAL) {
-            ndchans = NCHAN_DIGITAL;
+            nDigitalChans = NCHAN_DIGITAL;
-            ddatabytes = (sizeof(uint64_t) * ds);
+            nDigitalBytes = (sizeof(uint64_t) * nDigitalSamples);
-            LOG(logDEBUG1) << "Number of Digital Channels:" << ndchans
+            LOG(logDEBUG1) << "Number of Digital Channels:" << nDigitalChans
-                           << " Databytes: " << ddatabytes;
+                           << " Databytes: " << nDigitalBytes;
-        }
-        LOG(logDEBUG1) << "Total Number of Channels:" << nachans + ndchans
-                       << " Databytes: " << adatabytes + ddatabytes;
-
-        nPixelsX = nachans + ndchans;
-        nPixelsY = 1;
-
-        // 10G
-        if (t) {
-            dataSize = 8144;
-        }
-        // 1g udp (via fifo readout)
-        else {
-            dataSize = UDP_PACKET_DATA_BYTES;
         }
 
+        nPixelsX = nAnalogChans + nDigitalChans;
+        dataSize = tengigaEnable ? 8144 : UDP_PACKET_DATA_BYTES;
         packetSize = headerSizeinPacket + dataSize;
-        imageSize = adatabytes + ddatabytes;
+        imageSize = nAnalogBytes + nDigitalBytes;
         packetsPerFrame = ceil((double)imageSize / (double)dataSize);
 
-        return adatabytes;
+        LOG(logDEBUG1) << "Total Number of Channels:" << nPixelsX
-    }
+                       << " Databytes: " << imageSize;
+    };
 };
 
 class MoenchData : public GeneralData {
 
   private:
-    /** Number of bytes per analog channel */
     const int NUM_BYTES_PER_ANALOG_CHANNEL = 2;
 
   public:
-    /** Constructor */
     MoenchData() {
         myDetectorType = slsDetectorDefs::MOENCH;
-        nPixelsX = 32; // total number of channels
-        nPixelsY = 1;  // number of samples
         headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
-        dataSize = UDP_PACKET_DATA_BYTES;
-        packetSize = headerSizeinPacket + dataSize;
-        // packetsPerFrame 		= 1;
-        imageSize = nPixelsX * nPixelsY * 2;
-        packetsPerFrame =
-            ceil((double)imageSize / (double)UDP_PACKET_DATA_BYTES);
         frameIndexMask = 0xFFFFFF;
         maxFramesPerFile = MOENCH_MAX_FRAMES_PER_FILE;
         fifoBufferHeaderSize =
             FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
         defaultFifoDepth = 2500;
         standardheader = true;
+        UpdateImageSize();
     };
 
-    /**
+    void SetNumberOfAnalogSamples(int n) {
-     * Set databytes
+        nAnalogSamples = n;
-     * @param a adc enable mask
+        UpdateImageSize();
-     * @param as analog number of samples
+    };
-     * @param ds digital number of samples
+
-     * @param t tengiga enable
+    void SetOneGigaAdcEnableMask(int n) {
-     * @param f readout flags
+        adcEnableMaskOneGiga = n;
-     * @returns analog data bytes
+        UpdateImageSize();
-     */
+    };
-    int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t,
+
-                     slsDetectorDefs::readoutMode f) {
+    void SetTenGigaAdcEnableMask(int n) {
+        adcEnableMaskTenGiga = n;
+        UpdateImageSize();
+    };
+
+    void SetTenGigaEnable(bool tg) {
+        tengigaEnable = tg;
+        UpdateImageSize();
+    };
+
+  private:
+    void UpdateImageSize() {
+        uint32_t adcEnableMask =
+            (tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga);
 
         // count number of channels in x, each adc has 25 channels each
-        int nchanTop = __builtin_popcount(a & 0xF0F0F0F0) * 25;
+        int nchanTop = __builtin_popcount(adcEnableMask & 0xF0F0F0F0) * 25;
-        int nchanBot = __builtin_popcount(a & 0x0F0F0F0F) * 25;
+        int nchanBot = __builtin_popcount(adcEnableMask & 0x0F0F0F0F) * 25;
         nPixelsX = nchanTop > 0 ? nchanTop : nchanBot;
 
         // if both top and bottom adcs enabled, rows = 2
@@ -667,25 +623,15 @@ class MoenchData : public GeneralData {
         if (nchanTop > 0 && nchanBot > 0) {
             nrows = 2;
         }
-        nPixelsY = as / 25 * nrows;
+        nPixelsY = nAnalogSamples / 25 * nrows;
         LOG(logINFO) << "Number of Pixels: [" << nPixelsX << ", " << nPixelsY
                      << "]";
 
-        // 10G
+        dataSize = tengigaEnable ? 8144 : UDP_PACKET_DATA_BYTES;
-        if (t) {
-            dataSize = 8144;
-        }
-        // 1g udp (via fifo readout)
-        else {
-            dataSize = UDP_PACKET_DATA_BYTES;
-        }
-
-        imageSize = nPixelsX * nPixelsY * NUM_BYTES_PER_ANALOG_CHANNEL;
         packetSize = headerSizeinPacket + dataSize;
+        imageSize = nPixelsX * nPixelsY * NUM_BYTES_PER_ANALOG_CHANNEL;
         packetsPerFrame = ceil((double)imageSize / (double)dataSize);
 
         LOG(logDEBUG) << "Databytes: " << imageSize;
-
+    };
-        return imageSize;
-    }
 };

slsReceiverSoftware/src/Implementation.cpp

@@ -64,7 +64,7 @@ void Implementation::SetThreadPriorities() {
 
 void Implementation::SetupFifoStructure() {
     fifo.clear();
-    for (int i = 0; i < numThreads; ++i) {
+    for (int i = 0; i < numUDPInterfaces; ++i) {
         uint32_t datasize = generalData->imageSize;
         // veto data size
         if (detType == GOTTHARD2 && i != 0) {
@@ -97,7 +97,7 @@ void Implementation::SetupFifoStructure() {
                             (double)(1024 * 1024)
                      << " MB";
     }
-    LOG(logINFO) << numThreads << " Fifo structure(s) reconstructed";
+    LOG(logINFO) << numUDPInterfaces << " Fifo structure(s) reconstructed";
 }
 
 /**************************************************
@@ -152,7 +152,7 @@ void Implementation::setDetectorType(const detectorType d) {
     default:
         break;
     }
-    numThreads = generalData->threadsPerReceiver;
+    numUDPInterfaces = generalData->numUDPInterfaces;
     fifoDepth = generalData->defaultFifoDepth;
     udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
     framesPerFile = generalData->maxFramesPerFile;
@@ -161,7 +161,7 @@ void Implementation::setDetectorType(const detectorType d) {
     SetupFifoStructure();
 
     // create threads
-    for (int i = 0; i < numThreads; ++i) {
+    for (int i = 0; i < numUDPInterfaces; ++i) {
 
         try {
             auto fifo_ptr = fifo[i].get();
@@ -170,6 +170,10 @@ void Implementation::setDetectorType(const detectorType d) {
                 &udpSocketBufferSize, &actualUDPSocketBufferSize,
                 &framesPerFile, &frameDiscardMode, &activated,
                 &detectorDataStream[i], &silentMode));
+            int ctbAnalogDataBytes = 0;
+            if (detType == CHIPTESTBOARD) {
+                ctbAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
+            }
             dataProcessor.push_back(sls::make_unique<DataProcessor>(
                 i, detType, fifo_ptr, &activated, &dataStreamEnable,
                 &streamingFrequency, &streamingTimerInMs, &streamingStartFnum,
@@ -194,35 +198,35 @@ void Implementation::setDetectorType(const detectorType d) {
     LOG(logDEBUG) << " Detector type set to " << sls::ToString(d);
 }
 
-int *Implementation::getDetectorSize() const { return (int *)numMods; }
+slsDetectorDefs::xy Implementation::getDetectorSize() const {
-
+    return numModules;
-void Implementation::setDetectorSize(const int *size) {
-    std::string log_message = "Detector Size (ports): (";
-    for (int i = 0; i < MAX_DIMENSIONS; ++i) {
-        // x dir (colums) each udp port
-        if (detType == EIGER && i == X)
-            numMods[i] = size[i] * 2;
-        // y dir (rows) each udp port
-        else if (numUDPInterfaces == 2 && i == Y)
-            numMods[i] = size[i] * 2;
-        else
-            numMods[i] = size[i];
-        log_message += std::to_string(numMods[i]);
-        if (i < MAX_DIMENSIONS - 1)
-            log_message += ", ";
 }
-    log_message += ")";
 
-    int nm[2] = {numMods[0], numMods[1]};
+slsDetectorDefs::xy Implementation::GetPortGeometry() {
+    xy portGeometry{1, 1};
+    if (detType == EIGER)
+        portGeometry.x = numUDPInterfaces;
+    else // (jungfrau and gotthard2)
+        portGeometry.y = numUDPInterfaces;
+    return portGeometry;
+}
+
+void Implementation::setDetectorSize(const slsDetectorDefs::xy size) {
+    xy portGeometry = GetPortGeometry();
+
+    std::string log_message = "Detector Size (ports): (";
+    numModules.x = portGeometry.x * size.x;
+    numModules.y = portGeometry.y * size.y;
+    xy nm{numModules.x, numModules.y};
     if (quadEnable) {
-        nm[0] = 1;
+        nm.x = 1;
-        nm[1] = 2;
+        nm.y = 2;
     }
     for (const auto &it : dataStreamer) {
         it->SetNumberofModules(nm);
     }
 
-    LOG(logINFO) << log_message;
+    LOG(logINFO) << "Detector Size (ports): " << sls::ToString(numModules);
 }
 
 int Implementation::getModulePositionId() const { return modulePos; }
@@ -232,19 +236,18 @@ void Implementation::setModulePositionId(const int id) {
     LOG(logINFO) << "Module Position Id:" << modulePos;
 
     // update zmq port
-    streamingPort =
+    xy portGeometry = GetPortGeometry();
-        DEFAULT_ZMQ_RX_PORTNO + (modulePos * (detType == EIGER ? 2 : 1));
+    streamingPort = DEFAULT_ZMQ_RX_PORTNO + modulePos * portGeometry.x;
 
     for (const auto &it : dataProcessor)
         it->SetupFileWriter(fileWriteEnable, masterFileWriteEnable,
                             fileFormatType, modulePos, &hdf5Lib);
-    assert(numMods[1] != 0);
+    assert(numModules.y != 0);
     for (unsigned int i = 0; i < listener.size(); ++i) {
         uint16_t row = 0, col = 0;
-        row =
+        row = (modulePos % numModules.y) * portGeometry.y;
-            (modulePos % numMods[1]) * ((numUDPInterfaces == 2) ? 2 : 1); // row
+        col = (modulePos / numModules.y) * portGeometry.x + i;
-        col = (modulePos / numMods[1]) * ((detType == EIGER) ? 2 : 1) +
+
-              i; // col for horiz. udp ports
         listener[i]->SetHardCodedPosition(row, col);
     }
 }
@@ -308,7 +311,7 @@ std::array<pid_t, NUM_RX_THREAD_IDS> Implementation::getThreadIds() const {
     } else {
         retval[id++] = 0;
     }
-    if (numThreads == 2) {
+    if (numUDPInterfaces == 2) {
         retval[id++] = listener[1]->GetThreadId();
         retval[id++] = dataProcessor[1]->GetThreadId();
         if (dataStreamEnable) {
@@ -474,8 +477,8 @@ double Implementation::getProgress() const {
 }
 
 std::vector<int64_t> Implementation::getNumMissingPackets() const {
-    std::vector<int64_t> mp(numThreads);
+    std::vector<int64_t> mp(numUDPInterfaces);
-    for (int i = 0; i < numThreads; ++i) {
+    for (int i = 0; i < numUDPInterfaces; ++i) {
         int np = generalData->packetsPerFrame;
         uint64_t totnp = np;
         // ReadNRows
@@ -562,11 +565,12 @@ void Implementation::stopReceiver() {
         if (modulePos == 0) {
             // more than 1 file, create virtual file
             if (dataProcessor[0]->GetFilesInAcquisition() > 1 ||
-                (numMods[X] * numMods[Y]) > 1) {
+                (numModules.x * numModules.y) > 1) {
                 dataProcessor[0]->CreateVirtualFile(
                     filePath, fileName, fileIndex, overwriteEnable, silentMode,
-                    modulePos, numThreads, framesPerFile, numberOfTotalFrames,
+                    modulePos, numUDPInterfaces, framesPerFile,
-                    dynamicRange, numMods[X], numMods[Y], &hdf5Lib);
+                    numberOfTotalFrames, dynamicRange, numModules.x,
+                    numModules.y, &hdf5Lib);
             }
             // link file in master
             dataProcessor[0]->LinkDataInMasterFile(silentMode);
@@ -598,7 +602,7 @@ void Implementation::stopReceiver() {
         auto mp = getNumMissingPackets();
         // print summary
         uint64_t tot = 0;
-        for (int i = 0; i < numThreads; i++) {
+        for (int i = 0; i < numUDPInterfaces; i++) {
             int nf = dataProcessor[i]->GetNumCompleteFramesCaught();
             tot += nf;
             std::string mpMessage = std::to_string(mp[i]);
@@ -629,7 +633,7 @@ void Implementation::stopReceiver() {
         // callback
         if (acquisitionFinishedCallBack) {
             try {
-                acquisitionFinishedCallBack((tot / numThreads),
+                acquisitionFinishedCallBack((tot / numUDPInterfaces),
                                             pAcquisitionFinished);
             } catch (const std::exception &e) {
                 // change status
@@ -810,7 +814,7 @@ void Implementation::SetupWriter() {
         for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
             dataProcessor[i]->CreateFirstFiles(
                 masterAttributes.get(), filePath, fileName, fileIndex,
-                overwriteEnable, silentMode, modulePos, numThreads,
+                overwriteEnable, silentMode, modulePos, numUDPInterfaces,
                 udpPortNum[i], framesPerFile, numberOfTotalFrames, dynamicRange,
                 detectorDataStream[i]);
         }
@@ -849,16 +853,19 @@ int Implementation::getNumberofUDPInterfaces() const {
     return numUDPInterfaces;
 }
 
+// not Eiger
 void Implementation::setNumberofUDPInterfaces(const int n) {
+    if (detType == EIGER) {
+        throw sls::RuntimeError(
+            "Cannot set number of UDP interfaces for Eiger");
+    }
 
     if (numUDPInterfaces != n) {
 
-        // reduce number of detectors in y dir (rows) if it had 2 interfaces
+        // reduce number of detectors to size with 1 interface
-        // before
+        xy portGeometry = GetPortGeometry();
-        if (numUDPInterfaces == 2)
+        numModules.x /= portGeometry.x;
-            numMods[Y] /= 2;
+        numModules.y /= portGeometry.y;
-
-        numUDPInterfaces = n;
 
         // clear all threads and fifos
         listener.clear();
@@ -868,14 +875,14 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
 
         // set local variables
         generalData->SetNumberofInterfaces(n);
-        numThreads = generalData->threadsPerReceiver;
+        numUDPInterfaces = n;
-        udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
 
         // fifo
+        udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
         SetupFifoStructure();
 
         // create threads
-        for (int i = 0; i < numThreads; ++i) {
+        for (int i = 0; i < numUDPInterfaces; ++i) {
             // listener and dataprocessor threads
             try {
                 auto fifo_ptr = fifo[i].get();
@@ -886,6 +893,11 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
                     &detectorDataStream[i], &silentMode));
                 listener[i]->SetGeneralData(generalData);
 
+                int ctbAnalogDataBytes = 0;
+                if (detType == CHIPTESTBOARD) {
+                    ctbAnalogDataBytes =
+                        generalData->GetNumberOfAnalogDatabytes();
+                }
                 dataProcessor.push_back(sls::make_unique<DataProcessor>(
                     i, detType, fifo_ptr, &activated, &dataStreamEnable,
                     &streamingFrequency, &streamingTimerInMs,
@@ -903,18 +915,18 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
             if (dataStreamEnable) {
                 try {
                     bool flip = flipRows;
-                    int nm[2] = {numMods[0], numMods[1]};
+                    xy nm{numModules.x, numModules.y};
                     if (quadEnable) {
                         flip = (i == 1 ? true : false);
-                        nm[0] = 1;
+                        nm.x = 1;
-                        nm[1] = 2;
+                        nm.y = 2;
                     }
                     dataStreamer.push_back(sls::make_unique<DataStreamer>(
                         i, fifo[i].get(), &dynamicRange, &roi, &fileIndex, flip,
-                        (int *)nm, &quadEnable, &numberOfTotalFrames));
+                        nm, &quadEnable, &numberOfTotalFrames));
                     dataStreamer[i]->SetGeneralData(generalData);
                     dataStreamer[i]->CreateZmqSockets(
-                        &numThreads, streamingPort, streamingSrcIP,
+                        &numUDPInterfaces, streamingPort, streamingSrcIP,
                         streamingHwm);
                     dataStreamer[i]->SetAdditionalJsonHeader(
                         additionalJsonHeader);
@@ -934,7 +946,7 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
         SetThreadPriorities();
 
         // update (from 1 to 2 interface) & also for printout
-        setDetectorSize(numMods);
+        setDetectorSize(numModules);
         // update row and column in dataprocessor
         setModulePositionId(modulePos);
 
@@ -994,7 +1006,8 @@ void Implementation::setUDPSocketBufferSize(const int s) {
     // testing default setup at startup, argument is 0 to use default values
     int size = (s == 0) ? udpSocketBufferSize : s;
     size_t listSize = listener.size();
-    if (detType == JUNGFRAU && (int)listSize != numUDPInterfaces) {
+    if ((detType == JUNGFRAU || detType == GOTTHARD2) &&
+        (int)listSize != numUDPInterfaces) {
         throw sls::RuntimeError(
             "Number of Interfaces " + std::to_string(numUDPInterfaces) +
             " do not match listener size " + std::to_string(listSize));
@@ -1029,21 +1042,21 @@ void Implementation::setDataStreamEnable(const bool enable) {
         dataStreamer.clear();
 
         if (enable) {
-            for (int i = 0; i < numThreads; ++i) {
+            for (int i = 0; i < numUDPInterfaces; ++i) {
                 try {
                     bool flip = flipRows;
-                    int nm[2] = {numMods[0], numMods[1]};
+                    xy nm{numModules.x, numModules.y};
                     if (quadEnable) {
                         flip = (i == 1 ? true : false);
-                        nm[0] = 1;
+                        nm.x = 1;
-                        nm[1] = 2;
+                        nm.y = 2;
                     }
                     dataStreamer.push_back(sls::make_unique<DataStreamer>(
                         i, fifo[i].get(), &dynamicRange, &roi, &fileIndex, flip,
-                        (int *)nm, &quadEnable, &numberOfTotalFrames));
+                        nm, &quadEnable, &numberOfTotalFrames));
                     dataStreamer[i]->SetGeneralData(generalData);
                     dataStreamer[i]->CreateZmqSockets(
-                        &numThreads, streamingPort, streamingSrcIP,
+                        &numUDPInterfaces, streamingPort, streamingSrcIP,
                         streamingHwm);
                     dataStreamer[i]->SetAdditionalJsonHeader(
                         additionalJsonHeader);
@@ -1348,11 +1361,7 @@ void Implementation::setNumberofAnalogSamples(const uint32_t i) {
     if (numberOfAnalogSamples != i) {
         numberOfAnalogSamples = i;
 
-        ctbAnalogDataBytes = generalData->setImageSize(
+        generalData->SetNumberOfAnalogSamples(i);
-            tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-            numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-            readoutType);
-
         SetupFifoStructure();
     }
     LOG(logINFO) << "Number of Analog Samples: " << numberOfAnalogSamples;
@@ -1367,11 +1376,7 @@ void Implementation::setNumberofDigitalSamples(const uint32_t i) {
     if (numberOfDigitalSamples != i) {
         numberOfDigitalSamples = i;
 
-        ctbAnalogDataBytes = generalData->setImageSize(
+        generalData->SetNumberOfDigitalSamples(i);
-            tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-            numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-            readoutType);
-
         SetupFifoStructure();
     }
     LOG(logINFO) << "Number of Digital Samples: " << numberOfDigitalSamples;
@@ -1389,8 +1394,7 @@ void Implementation::setCounterMask(const uint32_t i) {
                                     ". Expected 1-3.");
         }
         counterMask = i;
-        generalData->SetNumberofCounters(ncounters, dynamicRange,
+        generalData->SetNumberofCounters(ncounters);
-                                         tengigaEnable);
         SetupFifoStructure();
     }
     LOG(logINFO) << "Counter mask: " << sls::ToStringHex(counterMask);
@@ -1405,14 +1409,7 @@ void Implementation::setDynamicRange(const uint32_t i) {
         dynamicRange = i;
 
         if (detType == EIGER || detType == MYTHEN3) {
-
+            generalData->SetDynamicRange(i);
-            if (detType == EIGER) {
-                generalData->SetDynamicRange(i, tengigaEnable);
-            } else {
-                int ncounters = __builtin_popcount(counterMask);
-                generalData->SetNumberofCounters(ncounters, i, tengigaEnable);
-            }
-
             fifoDepth = generalData->defaultFifoDepth;
             SetupFifoStructure();
         }
@@ -1442,25 +1439,8 @@ bool Implementation::getTenGigaEnable() const { return tengigaEnable; }
 void Implementation::setTenGigaEnable(const bool b) {
     if (tengigaEnable != b) {
         tengigaEnable = b;
-        int ncounters = __builtin_popcount(counterMask);
+
-        // side effects
+        generalData->SetTenGigaEnable(b);
-        switch (detType) {
-        case EIGER:
-            generalData->SetTenGigaEnable(b, dynamicRange);
-            break;
-        case MYTHEN3:
-            generalData->SetNumberofCounters(ncounters, dynamicRange, b);
-            break;
-        case MOENCH:
-        case CHIPTESTBOARD:
-            ctbAnalogDataBytes = generalData->setImageSize(
-                tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-                numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-                readoutType);
-            break;
-        default:
-            break;
-        }
         SetupFifoStructure();
     }
     LOG(logINFO) << "Ten Giga: " << (tengigaEnable ? "enabled" : "disabled");
@@ -1494,14 +1474,15 @@ void Implementation::setQuad(const bool b) {
         quadEnable = b;
 
         if (!quadEnable) {
+            xy nm{numModules.x, numModules.y};
             for (const auto &it : dataStreamer) {
-                it->SetNumberofModules(numMods);
+                it->SetNumberofModules(nm);
                 it->SetFlipRows(flipRows);
             }
         } else {
-            int size[2] = {1, 2};
+            xy nm{1, 2};
             for (const auto &it : dataStreamer) {
-                it->SetNumberofModules(size);
+                it->SetNumberofModules(nm);
             }
             if (dataStreamer.size() == 2) {
                 dataStreamer[0]->SetFlipRows(false);
@@ -1563,11 +1544,7 @@ void Implementation::setReadoutMode(const readoutMode f) {
     if (readoutType != f) {
         readoutType = f;
 
-        // side effects
+        generalData->SetReadoutMode(f);
-        ctbAnalogDataBytes = generalData->setImageSize(
-            tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-            numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-            readoutType);
         SetupFifoStructure();
     }
     LOG(logINFO) << "Readout Mode: " << sls::ToString(f);
@@ -1581,11 +1558,8 @@ uint32_t Implementation::getADCEnableMask() const {
 void Implementation::setADCEnableMask(uint32_t mask) {
     if (adcEnableMaskOneGiga != mask) {
         adcEnableMaskOneGiga = mask;
-        ctbAnalogDataBytes = generalData->setImageSize(
-            tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-            numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-            readoutType);
 
+        generalData->SetOneGigaAdcEnableMask(mask);
         SetupFifoStructure();
     }
     LOG(logINFO) << "ADC Enable Mask for 1Gb mode: 0x" << std::hex
@@ -1601,11 +1575,7 @@ void Implementation::setTenGigaADCEnableMask(uint32_t mask) {
     if (adcEnableMaskTenGiga != mask) {
         adcEnableMaskTenGiga = mask;
 
-        ctbAnalogDataBytes = generalData->setImageSize(
+        generalData->SetTenGigaAdcEnableMask(mask);
-            tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
-            numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
-            readoutType);
-
         SetupFifoStructure();
     }
     LOG(logINFO) << "ADC Enable Mask for 10Gb mode: 0x" << std::hex

slsReceiverSoftware/src/Implementation.h

@@ -33,8 +33,8 @@ class Implementation : private virtual slsDetectorDefs {
      * ************************************************/
 
     void setDetectorType(const detectorType d);
-    int *getDetectorSize() const;
+    xy getDetectorSize() const;
-    void setDetectorSize(const int *size);
+    void setDetectorSize(const xy size);
     int getModulePositionId() const;
     void setModulePositionId(const int id);
     std::string getDetectorHostname() const;
@@ -266,6 +266,7 @@ class Implementation : private virtual slsDetectorDefs {
     void SetThreadPriorities();
     void SetupFifoStructure();
 
+    xy GetPortGeometry();
     void ResetParametersforNewAcquisition();
     void CreateUDPSockets();
     void SetupWriter();
@@ -278,9 +279,8 @@ class Implementation : private virtual slsDetectorDefs {
      * ************************************************/
 
     // config parameters
-    int numThreads{1};
     detectorType detType{GENERIC};
-    int numMods[MAX_DIMENSIONS] = {0, 0};
+    xy numModules{1, 1};
     int modulePos{0};
     std::string detHostname;
     bool silentMode{false};
@@ -361,7 +361,6 @@ class Implementation : private virtual slsDetectorDefs {
     uint32_t adcEnableMaskTenGiga{BIT32_MASK};
     std::vector<int> ctbDbitList;
     int ctbDbitOffset{0};
-    int ctbAnalogDataBytes{0};
 
     // callbacks
     int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,

slsSupportLib/include/sls/versionAPI.h

@@ -5,11 +5,11 @@
 #define APILIB 0x211125
 #define APIRECEIVER 0x211124
 #define APIGUI 0x211124
+
+#define APIEIGER 0x220124
 #define APICTB 0x220124
 #define APIGOTTHARD 0x220124
 #define APIGOTTHARD2 0x220124
 #define APIJUNGFRAU 0x220124
 #define APIMYTHEN3 0x220124
 #define APIMOENCH 0x220124
-
-#define APIEIGER 0x220124