minor fixes

Fixed build of the moenchZmqExecutables (#706 )
* changed to pure virtual methods for Clone and setClusterSize * added std:: * added moench to the github actions build
2025-06-14 13:57:13 +02:00 · 2023-03-31 09:40:03 +02:00 · 2023-03-29 15:01:22 +02:00 · 2023-03-28 16:27:01 +02:00 · 2023-03-28 15:22:36 +02:00 · 2023-03-22 14:25:02 +01:00
46 changed files with 1975 additions and 288 deletions
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@ -0,0 +1,38 @@
+name: CMake
+
+on: [push, pull_request]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Debug
+
+jobs:
+  build:
+    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
+    # You can convert this to a matrix build if you need cross-platform coverage.
+    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+    runs-on: ubuntu-latest
+    name: Configure and build using cmake
+    steps:
+      - uses: actions/checkout@v3
+      - uses: awalsh128/cache-apt-pkgs-action@latest
+        with:
+          packages: libzmq3-dev libhdf5-dev qtbase5-dev qt5-qmake libqt5svg5-dev
+          version: 1.0
+
+      - name: Configure CMake
+        # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+        # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+        run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DSLS_USE_TESTS=ON -DSLS_USE_HDF5=ON -DSLS_USE_GUI=ON -DSLS_USE_MOENCH=ON
+
+      - name: Build
+        # Build your program with the given configuration
+        run: cmake --build ${{github.workspace}}/build -j2 --config ${{env.BUILD_TYPE}}
+
+      - name: Test
+        working-directory: ${{github.workspace}}/build
+        # Execute tests defined by the CMake configuration.
+        # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+        run: ctest -C ${{env.BUILD_TYPE}} -j1
+
+
--- a/RELEASE.txt
+++ b/RELEASE.txt
@ -29,10 +29,13 @@ This document describes the differences between v7.x.x and v7.0.0


 - moench being made compatible with jungfrau 2.0 boards (jungfrau structure, away from ctb)
+- rx_hostname and port can be combo to one or to all, or vector or hostnames and ports. ignoring none or empty, then verifying no duplicates for the host port combo including from shared memory
+- same for hostname and port combo (for virtual servers)
 - eiger febl and febr in versions, ensure its the same as beb fw version
 - eiger hardware version fx30 and fx70 (versions command)
 - fixed rx_arping error
 - fix hdf5 compilation (detspec fields)
+- print server version atleast in exception msg when connecting to an older server, also able to add hostname to shm



--- a/slsDetectorCalibration/analogDetector.h
+++ b/slsDetectorCalibration/analogDetector.h
@ -220,7 +220,7 @@ template <class dataType> class analogDetector {
       clone. Must be virtual!
       \returns a clone of the original analog detector
     */
-    virtual analogDetector *Clone() { return new analogDetector(this); }
+    virtual analogDetector *Clone() = 0;

    /**
       Gives an id to the structure. For debugging purposes in case of
@ -298,8 +298,8 @@ template <class dataType> class analogDetector {
            if (gmap)
                delete[] gmap;
            gmap = new double[nnx * nny];
-            for (iy = 0; iy < nny; ++iy) {
-                for (ix = 0; ix < nnx; ++ix) {
+            for (iy = 0; iy < static_cast<int>(nny); ++iy) {
+                for (ix = 0; ix < static_cast<int>(nnx); ++ix) {
                    gmap[iy * nnx + ix] = gm[iy * nnx + ix];
                    // cout << gmap[iy*nnx+ix] << " " ;
                }
@ -1097,6 +1097,8 @@ template <class dataType> class analogDetector {
        return thr;
    };

+    virtual int setClusterSize(int n = -1) = 0;
+
    /**
       gets threshold value for conversion into number of photons
       \returns threshold value
--- a/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsData.h
+++ b/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsData.h
@ -2,7 +2,11 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #ifndef JUNGFRAULGADSTRIXELDATA_H
 #define JUNGFRAULGADSTRIXELDATA_H
+#ifdef CINT
+#include "sls/sls_detector_defs_CINT.h"
+#else
 #include "sls/sls_detector_defs.h"
+#endif
 #include "slsDetectorData.h"

 /*
@ -32,7 +36,7 @@ typedef struct {
    uint64_t bunchNumber; /**< is the frame number */
    uint64_t pre;         /**< something */

-} jf_header;
+} jf_header; //Aldo's header


 using namespace std;    
@ -41,7 +45,11 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
  private:
    int iframe;

+#ifdef ALDO //VH
+    using header = jf_header; //VH
+#else //VH
    using header = sls::defs::sls_receiver_header;
+#endif //VH
  public:
    /**
       Implements the slsReceiverData structure for the moench02 prototype read
@ -49,103 +57,137 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
       1286 large etc.) \param c crosstalk parameter for the output buffer

    */
+
+    int groupmap[512*5][1024/5];
+
+ 
    jungfrauLGADStrixelsData()
        : slsDetectorData<uint16_t>(1024/5, 512*5,
                                    512 * 1024 * 2 + sizeof(header)) {
-      cout << "aaa" << endl;
+      //      cout << "aaa" << endl;
+#ifdef ALDO //VH
+      cout<< "using reduced jf_header" << endl; //VH
+#endif //VH
        for (int ix = 0; ix < 1024/5; ix++) {
            for (int iy = 0; iy < 512*5; iy++) {
 	      dataMap[iy][ix] = sizeof(header);//+ ( 1024 * 5 + 300) * 2; //somewhere on the guardring of the LGAD
+	      groupmap[iy][ix]=-1;
 #ifdef HIGHZ
                dataMask[iy][ix] = 0x3fff;
 #endif
            }
        }
+        
 	int x0=256+10, x1=256+246;
 	int y0=10, y1=256-10;
 	int ix,iy;
 	int ox=0, oy=0, ooy=0;
-	ox=0;
+	ox=2;//0; //original value is 0
 	cout << "G0" << endl;

 	//chip1
+	/*
+	 * TL;DR comments: y0 is too high by 1, group 1 and group 2 are by one row too short
+	 * group34 by 2 rows, x is by one column too short
+	 * NOTE: If x0, x1, y0 are changed, likely also ox (and oy and ooy) will be affected!
+	 */

+	cout << "G0" << endl; //chip coordinates of chip1 group1: x=255+10 to x=255+246, y=10 to y=64
+	//9 pixels guard ring, bonding shift by one pixel in y, one square pixel in x on the left
+
+	int x0=256+10, x1=256+246; //excludes first column (in chip coordinates)
+	int y0=10, y1=256-10; //y1 does nothing
+	int ix,iy;
+	int ox=0, oy=0, ooy=0;
+	ox=0;
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0; ipy<y0+54; ipy++) {
-	    ix=(ipx-x0+ox)/3;
+	  for (int ipy=y0; ipy<y0+54; ipy++) { //y0+54 excludes the last row (in chip coordinates), should be y0+55 to include all rows
 	    iy=(ipx-x0+ox)%3+(ipy-y0+oy)*3+ooy;
+	    ix=(ipx-x0+ox)/3;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
-	    
+	    groupmap[iy][ix]=0;
 	    //  cout << ipx << " " << ipy << " " << ix << " " << iy << endl;
-
-
 	  }
 	}
-	cout << "G1" << endl;
+
+	cout << "G1" << endl; //chip coordinates of chip1 group2: x=255+12 to x=255+246, y=65 to y=128
+	//3 square pixels in x on the left
 	oy=-54;
 	ooy=54*3;
-	ox=3;
+	ox=2;//; //original value is 3
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0+54; ipy<y0+64+54; ipy++) {
+	  for (int ipy=y0+54; ipy<y0+64+54; ipy++) { //I think y0+54 catches the last row of group1! Should be y0+55 if we want to include all rows? And y0+55+64
 	    ix=(ipx-x0+ox)/5;
 	    iy=(ipx-x0+ox)%5+(ipy-y0+oy)*5+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
+	    groupmap[iy][ix]=1;
 	  }
 	}
 	
-	cout << "G2" << endl;
+	cout << "G2" << endl; //chip coordinates of chip1 group34: x=255+11 to x=255+246, y=129 to y=247
+	//2 square pixels on the left
 	oy=-54-64;
 	ooy=54*3+64*5;	
 	ox=3;
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0+64+54; ipy<y0+64*2+54*2; ipy++) {
+	  for (int ipy=y0+64+54; ipy<y0+64*2+54*2; ipy++) { //Same as above, I think it should be y0+55+64 and y0+55*2+64*2 to include all rows
 	    ix=(ipx-x0+ox)/4;
 	    iy=(ipx-x0+ox)%4+(ipy-y0+oy)*4+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
+	    groupmap[iy][ix]=2;
 	  }
 	}
 	
 	//chip 6
+	/*
+	 * TL;DR comments: y0 is too high by 3, group34 and group 1 are by one row too short
+	 * x is by two columns too short
+	 * NOTE: If x0, x1, y0 are changed, likely also ox (and oy and ooy) will be affected!
+	 */

+	cout << "G0" << endl; //chip coordinates of chip6 group34: x=255+256+9 to x=255+256+244, y=255+8 to y=255+126
+	//9 pixels guard ring, bonding shift by one pixel in -y, 2 square pixels in x on the right
 	x0=256*2+10;
 	y0=256+10;
 	x1=256*2+246;
 	ooy=256*5;
 	oy=0;
 	ox=1;
-	cout << "G0" << endl;
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0; ipy<y0+54+64; ipy++) {
+	  for (int ipy=y0; ipy<y0+54+64; ipy++) { //shifted by 3 rows because of y0, if y0 is corrected it should be y0+55+64 to include all rows
 	    ix=(ipx-x0+ox)/4;
 	    iy=(ipx-x0+ox)%4+(ipy-y0+oy)*4+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
-	    if (ipx==x0)
-	      cout << ipx << " " << ipy << " " << ix << " " << iy << endl;
-
-
+	    //if (ipx==x0)    cout << ipx << " " << ipy << " " << ix << " " << iy << endl;
+	    groupmap[iy][ix]=2;
 	  }
 	}
-	cout << "G1" << endl;
+
+	cout << "G1" << endl; //chip coordinates of chip6 group2: x=255+256+9 to x=255+256+243, y=255+127 to y=255+190
+	//3 square pixels in x on the right
 	oy=-54-64;
 	ooy+=(54+64)*4;
 	ox=1;
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0+54+64; ipy<y0+64*2+54; ipy++) {
+	  for (int ipy=y0+54+64; ipy<y0+64*2+54; ipy++) { //shifted by 3 rows because of y0, if y0 is corrected it should be y0+55+64 and y0+55+64*2 to include all rows
 	    ix=(ipx-x0+ox)/5;
 	    iy=(ipx-x0+ox)%5+(ipy-y0+oy)*5+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
+	    groupmap[iy][ix]=1;
 	  }
 	}
 	
-	cout << "G2" << endl;
+	cout << "G2" << endl; //chip coordinates of chip6 group1: x=255+256+9 to x=255+256+245, y=255+191 to y=255+245
+	//one square pixel in x on the right
 	oy=-54-64*2;
 	ooy+=64*5;	
 	ox=1;
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0+64*2+54; ipy<y0+64*2+54*2; ipy++) {
+	  for (int ipy=y0+64*2+54; ipy<y0+64*2+54*2; ipy++) { //shifted by 3 rows because of y0, if y0 is corrected it should be y0+55+64*2 and y0+55*2+64*2
 	    ix=(ipx-x0+ox)/3;
 	    iy=(ipx-x0+ox)%3+(ipy-y0+oy)*3+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
+	    groupmap[iy][ix]=0;
 	  }
 	}
 	
@ -206,7 +248,11 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {


    int getFrameNumber(char *buff) {
-        return ((header *)buff)->detHeader.frameNumber;
+#ifdef ALDO //VH
+      return ((header *)buff)->bunchNumber; //VH
+#else //VH
+      return ((header *)buff)->detHeader.frameNumber;
+#endif //VH
    };

    /**
@ -219,7 +265,11 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {

    */
    int getPacketNumber(char *buff) {
-        return ((header *)buff)->detHeader.packetNumber;
+#ifdef ALDO //VH
+      return -1; //VH //TODO: Keep in mind in case of bugs!
+#else //VH
+      return ((header *)buff)->detHeader.packetNumber;
+#endif //VH
    };

   
@ -265,8 +315,6 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
        return NULL;
    };

-    /*  /**
-
    /*    Loops over a memory slot until a complete frame is found (i.e. all */
    /*    packets 0 to nPackets, same frame number). purely virtual func \param */
    /*    data pointer to the memory to be analyzed \param ndata reference to the */
--- a/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsDataSingleChip.h
+++ b/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsDataSingleChip.h
@ -0,0 +1,305 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#ifndef JUNGFRAULGADSTRIXELSDATASINGLECHIP_H
+#define JUNGFRAULGADSTRIXELSDATASINGLECHIP_H
+#ifdef CINT
+#include "sls/sls_detector_defs_CINT.h"
+#else
+#include "sls/sls_detector_defs.h"
+#endif
+#include "slsDetectorData.h"
+
+/*
+/afs/psi.ch/project/mythen/Anna/slsDetectorPackageDeveloperMpc2011/slsDetectorCalibration/jungfrauExecutables 
+make -f Makefile.rawdataprocess jungfrauRawDataProcessStrx
+ ../dataStructures/jungfrauLGADStrixelsData.h
+*/
+//#define VERSION_V2
+/**
+    @short  structure for a Detector Packet or Image Header
+    @li frameNumber is the frame number
+    @li expLength is the subframe number (32 bit eiger) or real time exposure
+   time in 100ns (others)
+    @li packetNumber is the packet number
+    @li bunchId is the bunch id from beamline
+    @li timestamp is the time stamp with 10 MHz clock
+    @li modId is the unique module id (unique even for left, right, top, bottom)
+    @li xCoord is the x coordinate in the complete detector system
+    @li yCoord is the y coordinate in the complete detector system
+    @li zCoord is the z coordinate in the complete detector system
+    @li debug is for debugging purposes
+    @li roundRNumber is the round robin set number
+    @li detType is the detector type see :: detectorType
+    @li version is the version number of this structure format
+*/
+
+namespace strixelSingleChip {
+  constexpr int nc_chip = 256;
+  constexpr int nr_chip = 256;
+  constexpr int gr = 9;
+
+  //Group 1: 25um pitch, groups of 3, 1 column of square pixels
+  constexpr int g1_ncols{ (nc_chip-(2*gr)-1)/3 }; //79
+  constexpr int g1_nrows{ ( (nr_chip/4)-gr )*3 }; //165
+  
+  //Group 2: 15um pitch, groups of 5, 3 columns of square pixels
+  constexpr int g2_ncols{ (nc_chip-(2*gr)-3)/5 }; //47
+  constexpr int g2_nrows{ (nr_chip/4)*5 }; //320
+  
+  //Group 3: 18.75um pitch, groups of 4, 2 columns of square pixels (double the size of the other groups)
+  constexpr int g3_ncols{ (nc_chip-(2*gr)-2)/4 }; //59
+  constexpr int g3_nrows{ ( ((nr_chip/4)*2)-gr )*4 }; //476
+
+  constexpr int nc_strixel = 2*gr + 1 + g1_ncols; //group 1 is the "longest" group in x and has one extra square pixel
+  constexpr int nr_strixel = 2*gr + g1_nrows + g2_nrows + g3_nrows;
+}
+
+typedef struct {
+    uint64_t bunchNumber; /**< is the frame number */
+    uint64_t pre;         /**< something */
+
+} jf_header; //Aldo's header
+
+
+using namespace strixelSingleChip;    
+class jungfrauLGADStrixelsDataSingleChip : public slsDetectorData<uint16_t> {
+
+  private:
+    int iframe;
+    int mchip;
+
+    void remapGroup( const int group ) {
+      int ix, iy;
+      int x0, y0, x1, y1, shifty;
+      int multiplicator;
+
+      switch (group) {
+      default:
+      case 1:
+	multiplicator = 3;
+	break;
+      case 2:
+	multiplicator = 5;
+	break;
+      case 3:
+	multiplicator = 4;
+	break;
+      }
+
+      if ( mchip == 1 ) {
+	switch (group) {
+	default:
+	case 1:
+	  x0 = 10;
+	  x1 = 247;
+	  y0 = 10;
+	  y1 = 65;
+	  shifty = 0;
+	  break;
+	case 2:
+	  x0 = 12;
+	  x1 = 247;
+	  y0 = 65;
+	  y1 = 129;
+	  shifty = ( (nr_chip/4)-gr )*3;
+	  break;
+	case 3:
+	  x0 = 11;
+	  x1 = 247;
+	  y0 = 129;
+	  y1 = 248;
+	  shifty = ( (nr_chip/4)-gr )*3 + (nr_chip/4)*5;
+	  break;
+	}
+      }
+
+      if ( mchip == 6 ) {
+	switch (group) {
+	default:
+	case 1:
+	  x0 = 9;
+	  x1 = 246;
+	  y0 = 191;
+	  y1 = 246;
+	  shifty = ( (nr_chip/4)-gr+(nr_chip/4) )*4 + (nr_chip/4)*5;
+	  break;
+	case 2:
+	  x0 = 9;
+	  x1 = 244;
+	  y0 = 127;
+	  y1 = 191;
+	  shifty = ( (nr_chip/4)-gr+(nr_chip/4) )*4;
+	  break;
+	case 3:
+	  x0 = 9;
+	  x1 = 245;
+	  y0 = 8;
+	  y1 = 127;
+	  shifty = 0;
+	  break;
+	}
+      }
+     
+      //remapping loop
+      for ( int ipx=x0; ipx!=x1; ++ipx ) {
+	for ( int ipy=y0; ipy!=y1; ++ipy) {
+	  ix = (ipx-x0)/multiplicator;
+	  for ( int m=0; m!=multiplicator; ++m ) {
+	    if ( (ipx-x0)%multiplicator==m ) iy=(ipy-y0)*multiplicator + m + shifty;
+	  }
+	  dataMap[iy][ix] = sizeof(header) + (nc_chip * ipy + ipx) * 2;
+	}
+      } 
+
+    }
+
+  public:
+
+#ifdef ALDO //VH
+    using header = jf_header; //VH
+#else //VH
+    using header = sls::defs::sls_receiver_header;
+#endif //VH
+    
+    jungfrauLGADStrixelsDataSingleChip( const int chip )
+      : slsDetectorData<uint16_t>( /*nc_strixel*/nc_chip/3, /*nr_strixel*/ nr_chip*5,
+                                    nc_chip * nr_chip * 2 + sizeof(header) ) {
+      std::cout << "Jungfrau strixels single chip" << std::endl;
+#ifdef ALDO //VH
+      std::cout<< "using reduced jf_header" << std::endl; //VH
+#endif //VH
+
+      mchip = chip;
+      //Fill all strixels with dummy values
+      for (int ix = 0; ix != nc_strixel; ++ix) {
+	for (int iy = 0; iy != nr_strixel; ++iy) {
+	  dataMap[iy][ix] = sizeof(header);
+#ifdef HIGHZ
+	  dataMask[iy][ix] = 0x3fff;
+#endif
+	}
+      }
+
+      remapGroup(1);
+      remapGroup(2);
+      remapGroup(3);
+	
+      iframe = 0;
+      std::cout << "data struct created" << std::endl;
+    };
+
+    /**
+       Returns the value of the selected channel for the given dataset as
+       double. \param data pointer to the dataset (including headers etc) \param
+       ix pixel number in the x direction \param iy pixel number in the y
+       direction \returns data for the selected channel, with inversion if
+       required as double
+
+    */
+    virtual double getValue(char *data, int ix, int iy = 0) {
+
+        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
+        return val;
+    };
+
+    /**
+
+    Returns the frame number for the given dataset. Purely virtual func.
+    \param buff pointer to the dataset
+    \returns frame number
+
+    */
+
+
+    int getFrameNumber(char *buff) {
+#ifdef ALDO //VH
+      return ((header *)buff)->bunchNumber; //VH
+#else //VH
+      return ((header *)buff)->detHeader.frameNumber;
+#endif //VH
+    };
+
+    /**
+
+       Returns the packet number for the given dataset. purely virtual func
+       \param buff pointer to the dataset
+       \returns packet number number
+
+
+
+    */
+    int getPacketNumber(char *buff) {
+#ifdef ALDO //VH
+      //uint32_t fakePacketNumber = 1000;
+      //return fakePacketNumber; //VH //TODO: Keep in mind in case of bugs! //This is definitely bad!
+      return 1000;
+#else //VH
+      return ((header *)buff)->detHeader.packetNumber;
+#endif //VH
+    };
+
+   
+
+    char *readNextFrame(std::ifstream &filebin) {
+        int ff = -1, np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff) {
+        int np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np) {
+        char *data = new char[dataSize];
+        char *d = readNextFrame(filebin, ff, np, data);
+        if (d == NULL) {
+            delete[] data;
+            data = NULL;
+        }
+        return data;
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np,char *data) {
+        char *retval = 0;
+        int nd;
+        int fnum = -1;
+        np = 0;
+        int pn;
+
+        //  cout << dataSize << endl;
+        if (ff >= 0)
+            fnum = ff;
+
+        if (filebin.is_open()) {
+            if (filebin.read(data, dataSize)) {
+                ff = getFrameNumber(data);
+                np = getPacketNumber(data);
+                return data;
+            }
+        }
+        return NULL;
+    };
+
+    /*    Loops over a memory slot until a complete frame is found (i.e. all */
+    /*    packets 0 to nPackets, same frame number). purely virtual func \param */
+    /*    data pointer to the memory to be analyzed \param ndata reference to the */
+    /*    amount of data found for the frame, in case the frame is incomplete at */
+    /*    the end of the memory slot \param dsize size of the memory slot to be */
+    /*    analyzed \returns pointer to the beginning of the last good frame (might */
+    /*    be incomplete if ndata smaller than dataSize), or NULL if no frame is */
+    /*    found */
+
+    /* *\/ */
+    virtual char *findNextFrame(char *data, int &ndata, int dsize) {
+        if (dsize < dataSize)
+            ndata = dsize;
+        else
+            ndata = dataSize;
+        return data;
+    };
+
+    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+};
+
+#endif
--- a/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsData_new.h
+++ b/slsDetectorCalibration/dataStructures/jungfrauLGADStrixelsData_new.h
@ -0,0 +1,336 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#ifndef JUNGFRAULGADSTRIXELSDATA_H
+#define JUNGFRAULGADSTRIXELSDATA_H
+#ifdef CINT
+#include "sls/sls_detector_defs_CINT.h"
+#else
+#include "sls/sls_detector_defs.h"
+#endif
+#include "slsDetectorData.h"
+
+//#define VERSION_V2
+/**
+    @short  structure for a Detector Packet or Image Header
+    @li frameNumber is the frame number
+    @li expLength is the subframe number (32 bit eiger) or real time exposure
+   time in 100ns (others)
+    @li packetNumber is the packet number
+    @li bunchId is the bunch id from beamline
+    @li timestamp is the time stamp with 10 MHz clock
+    @li modId is the unique module id (unique even for left, right, top, bottom)
+    @li xCoord is the x coordinate in the complete detector system
+    @li yCoord is the y coordinate in the complete detector system
+    @li zCoord is the z coordinate in the complete detector system
+    @li debug is for debugging purposes
+    @li roundRNumber is the round robin set number
+    @li detType is the detector type see :: detectorType
+    @li version is the version number of this structure format
+*/
+
+namespace strixelSingleChip {
+  constexpr int nc_rawimg = 1024; //for full images  //256;
+  constexpr int nr_rawimg = 512; 
+  constexpr int nr_chip = 256;
+  constexpr int gr = 9;
+
+  //Group 1: 25um pitch, groups of 3, 1 column of square pixels
+  constexpr int g1_ncols{ (nc_rawimg-(2*gr)-1)/3 }; //79
+  constexpr int g1_nrows{ ( (nr_chip/4)-gr )*3 }; //165
+  
+  //Group 2: 15um pitch, groups of 5, 3 columns of square pixels
+  constexpr int g2_ncols{ (nc_rawimg-(2*gr)-3)/5 }; //47
+  constexpr int g2_nrows{ (nr_chip/4)*5 }; //320
+  
+  //Group 3: 18.75um pitch, groups of 4, 2 columns of square pixels (double the size of the other groups)
+  constexpr int g3_ncols{ (nc_rawimg-(2*gr)-2)/4 }; //59
+  constexpr int g3_nrows{ ( ((nr_chip/4)*2)-gr )*4 }; //476
+
+  constexpr int nc_strixel = 2*gr + 1 + g1_ncols; //group 1 is the "longest" group in x and has one extra square pixel
+  constexpr int nr_strixel = 2*gr + g1_nrows + g2_nrows + g3_nrows;
+
+
+
+}
+
+typedef struct {
+    uint64_t bunchNumber; /**< is the frame number */
+    uint64_t pre;         /**< something */
+
+} jf_header; //Aldo's header
+
+
+using namespace strixelSingleChip; 
+   
+class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
+
+  private:
+    int iframe;
+    int mchip;
+    int chip_x0;
+    int chip_y0;
+
+    void remapGroup( const int group ) {
+      int ix, iy=0;
+      int x0, y0, x1, y1, shifty;
+      int multiplicator;
+      int shiftx;
+      switch (group) {
+      default:
+      case 1:
+	multiplicator = 3;
+	break;
+      case 2:
+	multiplicator = 5;
+	break;
+      case 3:
+	multiplicator = 4;
+	break;
+      }
+
+       if ( mchip == 1 ) {
+        
+	chip_x0=256;
+	chip_y0=1;  //because of bump bonding issues(+1 row)  on M408 
+	
+	switch (group) {
+	default:
+	case 1:
+	  x0 = 10+chip_x0;  //9 gr + 1 sq pixel 
+	  x1 = 246+chip_x0;
+	  y0 = 9+chip_y0;
+	  y1 = 64+chip_y0;
+	  shifty = 0;
+	  break;
+	case 2:
+	  x0 = 12+chip_x0;
+	  x1 = 247+chip_x0;
+	  y0 = 64+chip_y0;
+	  y1 = 128+chip_y0;
+	  shifty = g1_nrows;
+	  break;
+	case 3:
+	  x0 = 11+chip_x0;
+	  x1 = 247+chip_x0;
+	  y0 = 128+chip_y0;
+	  y1 = 247+chip_y0;
+	  shifty = g2_nrows+g1_nrows;
+	  break;
+	}
+      }
+
+      if ( mchip == 6 ) {
+
+	chip_x0=512;
+	chip_y0=255;  //should be 256 but is 255 because of bump bonding issues (+1 row) on M408
+	
+	switch (group) {
+	default:
+	case 1:
+
+	  x0 = 9+chip_x0;  //9 gr sq pixel 
+	  x1 = 246+chip_x0;
+	  y0 = 192+chip_y0;
+	  y1 = 244+chip_y0;
+
+	  shifty = g1_nrows+2*g2_nrows+2*g3_nrows;
+	  break;
+
+	case 2:
+	  
+	  x0 = 9+chip_x0;
+	  x1 = 244+chip_x0;
+	  y0 = 128+chip_y0;
+	  y1 = 191+chip_y0;
+	  
+
+	  shifty = g1_nrows+g2_nrows+2*g3_nrows;;
+	  break;
+	case 3:
+
+	  x0 = 9+chip_x0;
+	  x1 = 244+chip_x0;
+	  y0 = 9+chip_y0;
+	  y1 = 127+chip_y0;
+	  shifty =g1_nrows+g2_nrows+g3_nrows;
+
+	  break;
+	}
+      }
+     
+      //remapping loop
+      for ( int ipy=y0; ipy<=y1;ipy++) {
+	for ( int ipx=x0; ipx<=x1; ipx++ ) {
+
+	  ix = int ((ipx-x0)/multiplicator);
+	  for ( int m=0; m<multiplicator;m++ ) {
+	    if ( (ipx-x0)%multiplicator==m ) iy=(ipy-y0)*multiplicator +m + shifty;
+	  
+
+	  }
+	  
+	  //	  if (iy< 40)	  cout << iy << "  " << ix <<endl;
+	  	  dataMap[iy][ix] = sizeof(header) + (nc_rawimg * ipy + ipx) * 2;
+	  	  groupmap[iy][ix]=group-1;
+	}
+      } 
+
+    }
+
+  public:
+
+    int groupmap[512*5][1024/3];
+
+    using header = sls::defs::sls_receiver_header;
+
+    
+    jungfrauLGADStrixelsData()
+      : slsDetectorData<uint16_t>( /*nc_strixel*/g1_ncols, /*nr_strixel*/ 2*g1_nrows+2*g2_nrows+2*g3_nrows,
+				   g1_ncols*  (2*g1_nrows+2*g2_nrows+2*g3_nrows) * 2 + sizeof(header) ) {
+      std::cout << "Jungfrau strixels 2X single chip with full module data " << std::endl;
+
+      
+
+      
+      //Fill all strixels with dummy values
+      for (int ix = 0; ix != g1_ncols; ++ix) {
+	for (int iy = 0; iy != 2*g1_nrows+2*g2_nrows+2*g3_nrows; ++iy) {
+	  dataMap[iy][ix] = sizeof(header);
+
+	}
+      }
+
+      cout << "sizeofheader = "<<sizeof(header)<<endl;
+std::cout << "Jungfrau strixels 2X single chip with full module data " << std::endl;
+
+      mchip = 1;
+      remapGroup(1);
+  
+
+      remapGroup(2);
+      remapGroup(3);
+
+      mchip = 6;
+      remapGroup(1);
+      remapGroup(2);
+      remapGroup(3);
+	
+      iframe = 0;
+      std::cout << "data struct created" << std::endl;
+    };
+
+    /**
+       Returns the value of the selected channel for the given dataset as
+       double. \param data pointer to the dataset (including headers etc) \param
+       ix pixel number in the x direction \param iy pixel number in the y
+       direction \returns data for the selected channel, with inversion if
+       required as double
+
+    */
+    virtual double getValue(char *data, int ix, int iy = 0) {
+
+        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
+        return val;
+    };
+
+    /**
+
+    Returns the frame number for the given dataset. Purely virtual func.
+    \param buff pointer to the dataset
+    \returns frame number
+
+    */
+
+
+    int getFrameNumber(char *buff) {
+#ifdef ALDO //VH
+      return ((header *)buff)->bunchNumber; //VH
+#else //VH
+      return ((header *)buff)->detHeader.frameNumber;
+#endif //VH
+    };
+
+    /**
+
+       Returns the packet number for the given dataset. purely virtual func
+       \param buff pointer to the dataset
+       \returns packet number number
+
+
+
+    */
+    int getPacketNumber(char *buff) {
+#ifdef ALDO //VH
+      //uint32_t fakePacketNumber = 1000;
+      //return fakePacketNumber; //VH //TODO: Keep in mind in case of bugs! //This is definitely bad!
+      return 1000;
+#else //VH
+      return ((header *)buff)->detHeader.packetNumber;
+#endif //VH
+    };
+
+   
+
+    char *readNextFrame(std::ifstream &filebin) {
+        int ff = -1, np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff) {
+        int np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np) {
+        char *data = new char[dataSize];
+        char *d = readNextFrame(filebin, ff, np, data);
+        if (d == NULL) {
+            delete[] data;
+            data = NULL;
+        }
+        return data;
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np,char *data) {
+        char *retval = 0;
+        int nd;
+        int fnum = -1;
+        np = 0;
+        int pn;
+
+        //  cout << dataSize << endl;
+        if (ff >= 0)
+            fnum = ff;
+
+        if (filebin.is_open()) {
+            if (filebin.read(data, dataSize)) {
+                ff = getFrameNumber(data);
+                np = getPacketNumber(data);
+                return data;
+            }
+        }
+        return NULL;
+    };
+
+    /*    Loops over a memory slot until a complete frame is found (i.e. all */
+    /*    packets 0 to nPackets, same frame number). purely virtual func \param */
+    /*    data pointer to the memory to be analyzed \param ndata reference to the */
+    /*    amount of data found for the frame, in case the frame is incomplete at */
+    /*    the end of the memory slot \param dsize size of the memory slot to be */
+    /*    analyzed \returns pointer to the beginning of the last good frame (might */
+    /*    be incomplete if ndata smaller than dataSize), or NULL if no frame is */
+    /*    found */
+
+    /* *\/ */
+    virtual char *findNextFrame(char *data, int &ndata, int dsize) {
+        if (dsize < dataSize)
+            ndata = dsize;
+        else
+            ndata = dataSize;
+        return data;
+    };
+
+    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+};
+
+#endif
--- a/slsDetectorCalibration/dataStructures/jungfrauStrixelsHalfModuleOldDesign.h
+++ b/slsDetectorCalibration/dataStructures/jungfrauStrixelsHalfModuleOldDesign.h
@ -0,0 +1,271 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#ifndef JUNGFRAUSTRIXELSHALFMODULEOLD_H
+#define JUNGFRAUSTRIXELSHALFMODULEOLD_H
+#ifdef CINT
+#include "sls/sls_detector_defs_CINT.h"
+#else
+#include "sls/sls_detector_defs.h"
+#endif
+#include "slsDetectorData.h"
+
+/*
+/afs/psi.ch/project/mythen/Anna/slsDetectorPackageDeveloperMpc2011/slsDetectorCalibration/jungfrauExecutables 
+make -f Makefile.rawdataprocess jungfrauRawDataProcessStrx
+ ../dataStructures/jungfrauLGADStrixelsData.h
+*/
+//#define VERSION_V2
+/**
+    @short  structure for a Detector Packet or Image Header
+    @li frameNumber is the frame number
+    @li expLength is the subframe number (32 bit eiger) or real time exposure
+   time in 100ns (others)
+    @li packetNumber is the packet number
+    @li bunchId is the bunch id from beamline
+    @li timestamp is the time stamp with 10 MHz clock
+    @li modId is the unique module id (unique even for left, right, top, bottom)
+    @li xCoord is the x coordinate in the complete detector system
+    @li yCoord is the y coordinate in the complete detector system
+    @li zCoord is the z coordinate in the complete detector system
+    @li debug is for debugging purposes
+    @li roundRNumber is the round robin set number
+    @li detType is the detector type see :: detectorType
+    @li version is the version number of this structure format
+*/
+
+namespace strixelsOldDesign {
+  constexpr int NC_STRIXEL = (1024*3);
+  constexpr int NR_TOTAL = (512/3);
+  constexpr int NR_STRIXEL = ( (256-4)/3 );
+}
+
+typedef struct {
+    uint64_t bunchNumber; /**< is the frame number */
+    uint64_t pre;         /**< something */
+
+} jf_header; //Aldo's header
+
+
+using namespace strixelsOldDesign;    
+class jungfrauStrixelsHalfModuleOldDesign : public slsDetectorData<uint16_t> {
+
+  private:
+    int iframe;
+
+#ifdef ALDO //VH
+    using header = jf_header; //VH
+#else //VH
+    using header = sls::defs::sls_receiver_header;
+#endif //VH
+  public:
+    /**
+       Implements the slsReceiverData structure for the moench02 prototype read
+       out by a module i.e. using the slsReceiver (160x160 pixels, 40 packets
+       1286 large etc.) \param c crosstalk parameter for the output buffer
+
+    */
+    jungfrauStrixelsHalfModuleOldDesign()
+      : slsDetectorData<uint16_t>( 1024*3, 512/3,
+                                    512 * 1024 * 2 + sizeof(header) ) {
+      std::cout << "Jungfrau strixels old design" << std::endl;
+#ifdef ALDO //VH
+      std::cout<< "using reduced jf_header" << std::endl; //VH
+#endif //VH
+      for (int ix = 0; ix != 1024*3; ++ix) {
+	for (int iy = 0; iy != 512/3; ++iy) {
+	  dataMap[iy][ix] = sizeof(header);//+ ( 1024 * 5 + 300) * 2; //somewhere on the guardring of the LGAD
+#ifdef HIGHZ
+	  dataMask[iy][ix] = 0x3fff;
+#endif
+	}
+      }
+
+      //remap
+      int ix, iy;
+      for (int ipx=0; ipx!=1024; ++ipx) {
+	for (int ipy=0; ipy!=256-4; ++ipy) {
+	  iy=ipy/3;
+	  /* //1
+	  if (ipy%3==0) ix=ipx*3+2;
+	  if (ipy%3==1) ix=ipx*3+1;
+	  if (ipy%3==2) ix=ipx*3;
+	  */
+	  /* //2
+	  if (ipy%3==2) ix=ipx*3+2;
+	  if (ipy%3==0) ix=ipx*3+1;
+	  if (ipy%3==1) ix=ipx*3;
+	  */
+	  /* //3
+	  if (ipy%3==1) ix=ipx*3+2;
+	  if (ipy%3==2) ix=ipx*3+1;
+	  if (ipy%3==0) ix=ipx*3;
+	  */
+	  //4 //This seems to be correct //corresponds to looking from the backside of the sensor
+	  if (ipy%3==0) ix=ipx*3;
+	  if (ipy%3==1) ix=ipx*3+1;
+	  if (ipy%3==2) ix=ipx*3+2;
+	  
+	  /* //5
+	  if (ipy%3==2) ix=ipx*3;
+	  if (ipy%3==0) ix=ipx*3+1;
+	  if (ipy%3==1) ix=ipx*3+2;
+	  */
+	  /* //6
+	  if (ipy%3==1) ix=ipx*3;
+	  if (ipy%3==2) ix=ipx*3+1;
+	  if (ipy%3==0) ix=ipx*3+2;
+	  */
+
+	  if ( ipx!=255 && ipx!=256 && ipx!=511 && ipx!=512 && ipx!=767 && ipx!=768 ) //avoid double pixels
+	    // ( !( ipx%256==0 || ipx%256==255 ) || ipx==0 || ipx==1023 )
+	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
+	  //  cout << ipx << " " << ipy << " " << ix << " " << iy << endl;
+	}
+      }
+	
+      iframe = 0;
+      std::cout << "data struct created" << std::endl;
+    };
+
+    /**
+       Returns the value of the selected channel for the given dataset as
+       double. \param data pointer to the dataset (including headers etc) \param
+       ix pixel number in the x direction \param iy pixel number in the y
+       direction \returns data for the selected channel, with inversion if
+       required as double
+
+    */
+    virtual double getValue(char *data, int ix, int iy = 0) {
+
+        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
+        return val;
+    };
+
+    /* virtual void calcGhost(char *data, int ix, int iy) { */
+    /*   double val=0; */
+    /*   ghost[iy][ix]=0; */
+
+    /* } */
+
+    /* virtual void calcGhost(char *data) { */
+    /*   for (int ix=0; ix<25; ix++){ */
+    /*     for (int iy=0; iy<200; iy++) { */
+    /* 	calcGhost(data, ix,iy); */
+    /*     }  */
+    /*   } */
+    /*   // cout << "*" << endl; */
+    /* } */
+
+    /* double getGhost(int ix, int iy) { */
+    /*   return 0; */
+    /* }; */
+
+    /**
+
+    Returns the frame number for the given dataset. Purely virtual func.
+    \param buff pointer to the dataset
+    \returns frame number
+
+ */
+
+    /* class jfrau_packet_header_t { */
+    /*  public: */
+    /* 	unsigned char reserved[4]; */
+    /* 	unsigned char packetNumber[1]; */
+    /* 	unsigned char frameNumber[3]; */
+    /* 	unsigned char bunchid[8]; */
+    /* }; */
+
+
+    int getFrameNumber(char *buff) {
+#ifdef ALDO //VH
+      return ((header *)buff)->bunchNumber; //VH
+#else //VH
+      return ((header *)buff)->detHeader.frameNumber;
+#endif //VH
+    };
+
+    /**
+
+       Returns the packet number for the given dataset. purely virtual func
+       \param buff pointer to the dataset
+       \returns packet number number
+
+
+
+    */
+    int getPacketNumber(char *buff) {
+#ifdef ALDO //VH
+      //uint32_t fakePacketNumber = 1000;
+      //return fakePacketNumber; //VH //TODO: Keep in mind in case of bugs! //This is definitely bad!
+      return 1000;
+#else //VH
+      return ((header *)buff)->detHeader.packetNumber;
+#endif //VH
+    };
+
+   
+
+    char *readNextFrame(std::ifstream &filebin) {
+        int ff = -1, np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff) {
+        int np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np) {
+        char *data = new char[dataSize];
+        char *d = readNextFrame(filebin, ff, np, data);
+        if (d == NULL) {
+            delete[] data;
+            data = NULL;
+        }
+        return data;
+    };
+
+    char *readNextFrame(std::ifstream &filebin, int &ff, int &np,char *data) {
+        char *retval = 0;
+        int nd;
+        int fnum = -1;
+        np = 0;
+        int pn;
+
+        //  cout << dataSize << endl;
+        if (ff >= 0)
+            fnum = ff;
+
+        if (filebin.is_open()) {
+            if (filebin.read(data, dataSize)) {
+                ff = getFrameNumber(data);
+                np = getPacketNumber(data);
+                return data;
+            }
+        }
+        return NULL;
+    };
+
+    /*    Loops over a memory slot until a complete frame is found (i.e. all */
+    /*    packets 0 to nPackets, same frame number). purely virtual func \param */
+    /*    data pointer to the memory to be analyzed \param ndata reference to the */
+    /*    amount of data found for the frame, in case the frame is incomplete at */
+    /*    the end of the memory slot \param dsize size of the memory slot to be */
+    /*    analyzed \returns pointer to the beginning of the last good frame (might */
+    /*    be incomplete if ndata smaller than dataSize), or NULL if no frame is */
+    /*    found */
+
+    /* *\/ */
+    virtual char *findNextFrame(char *data, int &ndata, int dsize) {
+        if (dsize < dataSize)
+            ndata = dsize;
+        else
+            ndata = dataSize;
+        return data;
+    };
+
+    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+};
+
+#endif
--- a/slsDetectorCalibration/dataStructures/moench04CtbZmq10GbData.h
+++ b/slsDetectorCalibration/dataStructures/moench04CtbZmq10GbData.h
@ -54,28 +54,28 @@ class moench04CtbZmq10GbData : public slsDetectorData<uint16_t> {
 #endif
 #endif

-      cout << "off is " << off << endl;
+    cout << "off is " << off << endl;
 	  
-	  if (off>0)
+	if (off>0)
 	    cout << "M04 RAW DATA NEW " << endl;
-	  else
+	else
 	    cout << "M04 ZMQ DATA NEW " << endl;
 	    
-            int adc_nr[32] = {9,  8,  11, 10, 13, 12, 15, 14, 1,  0,  3,
-                              2,  5,  4,  7,  6,  23, 22, 21, 20, 19, 18,
-                              17, 16, 31, 30, 29, 28, 27, 26, 25, 24};
+    int adc_nr[32] = {9,  8,  11, 10, 13, 12, 15, 14, 1,  0,  3,
+                        2,  5,  4,  7,  6,  23, 22, 21, 20, 19, 18,
+                        17, 16, 31, 30, 29, 28, 27, 26, 25, 24};

-           
+    

-            int row, col;
+    int row, col;

-            // int isample;
-            int iadc;
-            // int ix, iy;
+    // int isample;
+    int iadc;
+    // int ix, iy;

-            // int npackets=40;
-            int i;
-            // int adc4(0);
+    // int npackets=40;
+    int i;
+    // int adc4(0);

            for (int is = 0; is < aSamples; is++) {

--- a/slsDetectorCalibration/dataStructures/slsDetectorData.h
+++ b/slsDetectorCalibration/dataStructures/slsDetectorData.h
@ -12,8 +12,7 @@ template <class dataType> class slsDetectorData {
    const int nx;  /**< Number of pixels in the x direction */
    const int ny;  /**< Number of pixels in the y direction */
    int dataSize;  /**<size of the data constituting one frame */
-    int **dataMap; /**< Array of size nx*ny storing the pointers to the data in
-                      the dataset (as offset)*/
+ 
    dataType **dataMask; /**< Array of size nx*ny storing the polarity of the
                            data in the dataset (should be 0 if no inversion is
                            required, 0xffffffff is inversion is required) */
@ -25,6 +24,9 @@ template <class dataType> class slsDetectorData {
    int isOrdered;

  public:
+
+    int **dataMap; /**< Array of size nx*ny storing the pointers to the data in
+                      the dataset (as offset)*/
    /**
    General slsDetectors data structure. Works for data acquired using the
    slsDetectorReceiver. Can be generalized to other detectors (many virtual
@ -196,19 +198,18 @@ template <typename dataType> slsDetectorData<dataType>::~slsDetectorData() {
 template <typename dataType>
 void slsDetectorData<dataType>::setDataMap(int **dMap) {

-    int ip = 0;
-    int ix, iy;
+    // int ip = 0;
    if (dMap == NULL) {
-        for (iy = 0; iy < ny; iy++) {
-            for (ix = 0; ix < nx; ix++) {
+        for (int iy = 0; iy < ny; iy++) {
+            for (int ix = 0; ix < nx; ix++) {
                dataMap[iy][ix] = (iy * nx + ix) * sizeof(dataType);
            }
        }
    } else {
        // cout << "set dmap "<< dataMap << " " << dMap << endl;
-        for (iy = 0; iy < ny; iy++) {
+        for (int iy = 0; iy < ny; iy++) {
            // cout << iy << endl;
-            for (ix = 0; ix < nx; ix++) {
+            for (int ix = 0; ix < nx; ix++) {
                dataMap[iy][ix] = dMap[iy][ix];
                // cout << ix << " " << iy << endl;
                /*ip=dataMap[ix][iy]/sizeof(dataType);
@ -217,14 +218,15 @@ void slsDetectorData<dataType>::setDataMap(int **dMap) {
            }
        }
    }
-    for (iy = 0; iy < ny; iy++) {
-        for (ix = 0; ix < nx; ix++) {
+    /* //commented this part because it causes out-of-bound issues if nx or ny are larger than dataMap bounds (single-chip readout of strixel with groups of different pitches) VH 2023-02-24
+    for (int iy = 0; iy < ny; iy++) {
+        for (int ix = 0; ix < nx; ix++) {
            ip = dataMap[iy][ix] / sizeof(dataType);
            xmap[ip] = ix;
            ymap[ip] = iy;
        }
    }
-
+     */
    // cout << "nx:" <<nx << " ny:" << ny << endl;
 }

@ -290,7 +292,6 @@ template <typename dataType>
 dataType **slsDetectorData<dataType>::getData(char *ptr, int dsize) {
    int el = dsize / sizeof(dataType);
    // dataType **data;
-    int ix, iy;
    // data=new dataType*[ny];
    // for(int i = 0; i < ny; i++) {
    //   data[i]=new dataType[nx];
@ -300,6 +301,7 @@ dataType **slsDetectorData<dataType>::getData(char *ptr, int dsize) {
        dsize = dataSize;

    for (int ip = 0; ip < (el); ip++) {
+        int ix, iy;
        getPixel(ip, ix, iy);
        if (ix >= 0 && ix < nx && iy >= 0 && iy < ny) {
            // data[iy][ix]=getChannel(ptr,ix,iy);
--- a/slsDetectorCalibration/interpolations/eta2InterpolationBase.h
+++ b/slsDetectorCalibration/interpolations/eta2InterpolationBase.h
@ -23,7 +23,7 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
              /* if (etamin>=etamax) { */
              /*   etamin=-1; */
              /*   etamax=2;  */
-              /*   //  cout << ":" <<endl; */
+              /*   //  std::cout << ":" <<endl; */
              /* } */
              /* etastep=(etamax-etamin)/nbeta; */

@ -164,7 +164,7 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
            dY = -1.;
            break;
        default:
-            cout << "bad quadrant" << endl;
+            std::cout << "bad quadrant" << std::endl;
            dX = 0.;
            dY = 0.;
        }
@ -174,19 +174,19 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
            ex = (etax - etamin) / etastepX;
            ey = (etay - etamin) / etastepY;
            if (ex < 0) {
-                cout << "x*" << ex << endl;
+                std::cout << "x*" << ex << std::endl;
                ex = 0;
            }
            if (ex >= nbetaX) {
-                cout << "x?" << ex << endl;
+                std::cout << "x?" << ex << std::endl;
                ex = nbetaX - 1;
            }
            if (ey < 0) {
-                cout << "y*" << ey << " " << nbetaY << endl;
+                std::cout << "y*" << ey << " " << nbetaY << std::endl;
                ey = 0;
            }
            if (ey >= nbetaY) {
-                cout << "y?" << ey << " " << nbetaY << endl;
+                std::cout << "y?" << ey << " " << nbetaY << std::endl;
                ey = nbetaY - 1;
            }

@ -236,7 +236,7 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
        // calcMyEta(totquad,quad,cl,etax, etay);
        calcEta(totquad, cc, etax, etay);

-        //     cout <<"******"<< etax << " " << etay << endl;
+        //     std::cout <<"******"<< etax << " " << etay << std::endl;

        return addToFlatFieldDistribution(etax, etay);
    }
@ -270,16 +270,16 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
    /*     cc[0][1] = cl[yoff * 3 + xoff + 1]; */
    /*     cc[1][1] = cl[(yoff + 1) * 3 + xoff + 1]; */

-    /*     /\* cout << cl[0] << " " << cl[1] << " " << cl[2] << endl;   *\/ */
-    /*     /\* cout << cl[3] << " " << cl[4] << " " << cl[5] << endl;   *\/ */
-    /*     /\* cout << cl[6] << " " << cl[7] << " " << cl[8] << endl;   *\/ */
-    /*     /\* cout <<"******"<<totquad << " " << quad << endl;  *\/ */
-    /*     /\* cout << cc[0][0]<< " " << cc[0][1] << endl;  *\/ */
-    /*     /\* cout << cc[1][0]<< " " << cc[1][1] << endl;  *\/ */
+    /*     /\* std::cout << cl[0] << " " << cl[1] << " " << cl[2] << std::endl;   *\/ */
+    /*     /\* std::cout << cl[3] << " " << cl[4] << " " << cl[5] << std::endl;   *\/ */
+    /*     /\* std::cout << cl[6] << " " << cl[7] << " " << cl[8] << std::endl;   *\/ */
+    /*     /\* std::cout <<"******"<<totquad << " " << quad << std::endl;  *\/ */
+    /*     /\* std::cout << cc[0][0]<< " " << cc[0][1] << std::endl;  *\/ */
+    /*     /\* std::cout << cc[1][0]<< " " << cc[1][1] << std::endl;  *\/ */
    /*     // calcMyEta(totquad,quad,cl,etax, etay); */
    /*     calcEta(totquad, cc, etax, etay); */

-    /*     //     cout <<"******"<< etax << " " << etay << endl; */
+    /*     //     std::cout <<"******"<< etax << " " << etay << std::endl; */

    /*     return addToFlatFieldDistribution(etax, etay); */
    /* } */
@ -331,7 +331,7 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {

    virtual int *getInterpolatedImage() {
        int ipx, ipy;
-        // cout << "ff" << endl;
+        // std::cout << "ff" << std::endl;
        calcDiff(1, hhx, hhy); // get flat
        double avg = 0;
        for (ipx = 0; ipx < nSubPixelsX; ipx++)
@ -347,8 +347,8 @@ class eta2InterpolationBase : public virtual etaInterpolationBase {
                ipy = iby % nSubPixelsY - nSubPixelsY / 2;
                if (ipy < 0)
                    ipy = nSubPixelsY + ipy;
-                // cout << ipx << " " << ipy << " " << ibx << " " << iby <<
-                // endl;
+                // std::cout << ipx << " " << ipy << " " << ibx << " " << iby <<
+                // std::endl;
                if (flat[ipx + ipy * nSubPixelsX] > 0)
                    hintcorr[ibx + iby * nSubPixelsX * nPixelsX] =
                        hint[ibx + iby * nSubPixelsX * nPixelsX] *
--- a/slsDetectorCalibration/interpolations/etaInterpolationBase.h
+++ b/slsDetectorCalibration/interpolations/etaInterpolationBase.h
@ -21,14 +21,14 @@ class etaInterpolationBase : public slsInterpolation {
                         double emax = 0)
        : slsInterpolation(nx, ny, ns, nsy), hhx(NULL), hhy(NULL), heta(NULL),
          nbetaX(nb), nbetaY(nby), etamin(emin), etamax(emax) {
-        // cout << "eb " << nb << " " << emin << " " << emax << endl;
-        // cout << nb << " " << etamin << " " << etamax << endl;
+        // std::cout << "eb " << nb << " " << emin << " " << emax << std::endl;
+        // std::cout << nb << " " << etamin << " " << etamax << std::endl;
        if (nbetaX <= 0) {
-            // cout << "aaa:" <<endl;
+            // std::cout << "aaa:" <<endl;
            nbetaX = nSubPixelsX * 10;
        }
        if (nbetaY <= 0) {
-            // cout << "aaa:" <<endl;
+            // std::cout << "aaa:" <<endl;
            nbetaY = nSubPixelsY * 10;
        }
        if (etamin >= etamax) {
@ -145,9 +145,9 @@ class etaInterpolationBase : public slsInterpolation {
        uint32_t nny;
        float *gm = ReadFromTiff(imgname, nnx, nny);
        /* if (nnx!=nny) { */
-        /*   cout << "different number of bins in x " << nnx << "  and y " <<
-         * nny<< " !"<< endl; */
-        /*   cout << "Aborting read"<< endl; */
+        /*   std::cout << "different number of bins in x " << nnx << "  and y " <<
+         * nny<< " !"<< std::endl; */
+        /*   std::cout << "Aborting read"<< std::endl; */
        /*   return 0; */
        /* } */
        nbetaX = nnx;
@ -254,12 +254,12 @@ class etaInterpolationBase : public slsInterpolation {
            if (ibx >= 0 && ibx < nSubPixelsX && iby >= 0 &&
                iby < nSubPixelsY) {
                //
-                // if (ibx>0 && iby>0) cout << ibx << " " << iby << " " << ii <<
-                // endl;
+                // if (ibx>0 && iby>0) std::cout << ibx << " " << iby << " " << ii <<
+                // std::endl;
                ftest[ibx + iby * nSubPixelsX] += heta[ii];
            } else
-                cout << "Bad interpolation " << ii << " " << ibx << " " << iby
-                     << endl;
+                std::cout << "Bad interpolation " << ii << " " << ibx << " " << iby
+                     << std::endl;
        }

        sprintf(tit, "/scratch/ftest_%d.tiff", ind);
@ -282,7 +282,7 @@ class etaInterpolationBase : public slsInterpolation {
        }
        sprintf(tit, "/scratch/eta_bad_%d.tiff", ind);
        WriteToTiff(etah, tit, nbetaX, nbetaY);
-        // cout << "Index: " << ind << "\t Bad bins: "<< nbad << endl;
+        // std::cout << "Index: " << ind << "\t Bad bins: "<< nbad << std::endl;
        // int ibx=0, iby=0;

        delete[] ftest;
@ -330,9 +330,9 @@ class etaInterpolationBase : public slsInterpolation {
            }
        }

-        //  cout << endl << endl;
+        //  std::cout << std::endl << std::endl;
        for (ipy = 0; ipy < nSubPixelsY; ipy++) {
-            cout.width(5);
+            std::cout.width(5);
            // flat_y[ipy]=p_tot_y[ipy];//avg/nSubPixels;
            for (ipx = 0; ipx < nSubPixelsX; ipx++) {

@ -353,19 +353,19 @@ class etaInterpolationBase : public slsInterpolation {
                //"   ";
            }

-            /* cout << "** "  << setprecision(4) <<  flat_y[ipy]; */
-            // cout << "\n";
+            /* std::cout << "** "  << setprecision(4) <<  flat_y[ipy]; */
+            // std::cout << "\n";
        }
-        /* cout << "**" << endl; cout.width(5); */
+        /* std::cout << "**" << std::endl; std::cout.width(5); */
        /* for (ipx=0; ipx<nSubPixels; ipx++) { */
-        /*   cout  << setprecision(4) <<  flat_x[ipx] << " "; */
+        /*   std::cout  << setprecision(4) <<  flat_x[ipx] << " "; */
        /* } */
-        // cout << "**" << endl; cout.width(5);
-        // cout << "Min diff: " << mindiff/sqrt(avg) << " Max diff: " <<
-        // maxdiff/sqrt(avg) << " Nbad: " << nbad << endl;
+        // std::cout << "**" << std::endl; std::cout.width(5);
+        // std::cout << "Min diff: " << mindiff/sqrt(avg) << " Max diff: " <<
+        // maxdiff/sqrt(avg) << " Nbad: " << nbad << std::endl;

-        //   cout << "Bad pixels: " <<
-        //   100.*(float)nbad/((float)(nSubPixels*nSubPixels)) << " %" << endl;
+        //   std::cout << "Bad pixels: " <<
+        //   100.*(float)nbad/((float)(nSubPixels*nSubPixels)) << " %" << std::endl;
        delete[] p_tot_x;
        delete[] p_tot_y;
        delete[] p_tot;
--- a/slsDetectorCalibration/interpolations/etaInterpolationPosXY.h
+++ b/slsDetectorCalibration/interpolations/etaInterpolationPosXY.h
@ -14,8 +14,8 @@ class etaInterpolationPosXY : public virtual etaInterpolationBase {
                          int nb = -1, int nby = -1, double emin = 1,
                          double emax = 0)
        : etaInterpolationBase(nx, ny, ns, nsy, nb, nby, emin, emax){
-              //  cout << "epxy " << nb << " " << emin << " " << emax << endl;
-              //  cout << nbeta << " " << etamin << " " << etamax << endl;
+              //  std::cout << "epxy " << nb << " " << emin << " " << emax << std::endl;
+              //  std::cout << nbeta << " " << etamin << " " << etamax << std::endl;
          };

    etaInterpolationPosXY(etaInterpolationPosXY *orig)
@ -32,14 +32,14 @@ class etaInterpolationPosXY : public virtual etaInterpolationBase {

        ///*Eta Distribution Rebinning*///
        // double bsize=1./nSubPixels; //precision
-        // cout<<"nPixelsX = "<<nPixelsX<<" nPixelsY = "<<nPixelsY<<" nSubPixels
+        // std::cout<<"nPixelsX = "<<nPixelsX<<" nPixelsY = "<<nPixelsY<<" nSubPixels
        // = "<<nSubPixels<<endl;
        double tot_eta = 0;
        double tot_eta_x = 0;
        double tot_eta_y = 0;
        for (int ip = 0; ip < nbetaX * nbetaY; ip++)
            tot_eta += heta[ip];
-        cout << "total eta entries is :" << tot_eta << endl;
+        std::cout << "total eta entries is :" << tot_eta << std::endl;
        if (tot_eta <= 0) {
            ok = 0;
            return;
@ -57,7 +57,7 @@ class etaInterpolationPosXY : public virtual etaInterpolationBase {

            for (int iby = 0; iby < nbetaY; iby++) {
                etay = etamin + iby * etastepY;
-                // cout << etax << endl;
+                // std::cout << etax << std::endl;

                // tot_eta_x+=hx[iby];
                if (etay >= 0 && etay <= 1)
@ -90,7 +90,7 @@ class etaInterpolationPosXY : public virtual etaInterpolationBase {

            for (int ibx = 0; ibx < nbetaX; ibx++) {
                etax = etamin + ibx * etastepX;
-                // cout << etax << endl;
+                // std::cout << etax << std::endl;
                if (etax >= 0 && etax <= 1)
                    hx[ibx] = heta[ibx + ib * nbetaX];
                else {
@ -178,7 +178,7 @@ class eta2InterpolationPosXY : public virtual eta2InterpolationBase,
        : etaInterpolationBase(nx, ny, ns, nsy, nb, nby, emin, emax),
          eta2InterpolationBase(nx, ny, ns, nsy, nb, nby, emin, emax),
          etaInterpolationPosXY(nx, ny, ns, nsy, nb, nby, emin, emax){
-              //  cout << "e2pxy " << nb << " " << emin << " " << emax << endl;
+              //  std::cout << "e2pxy " << nb << " " << emin << " " << emax << std::endl;
          };

    eta2InterpolationPosXY(eta2InterpolationPosXY *orig)
@ -198,8 +198,8 @@ class eta3InterpolationPosXY : public virtual eta3InterpolationBase,
        : etaInterpolationBase(nx, ny, ns, nsy, nb, nby, emin, emax),
          eta3InterpolationBase(nx, ny, ns, nsy, nb, nby, emin, emax),
          etaInterpolationPosXY(nx, ny, ns, nsy, nb, nby, emin, emax){
-              //   cout << "e3pxy " << nbeta << " " << etamin << " " << etamax
-              //   << " " << nSubPixels<< endl;
+              //   std::cout << "e3pxy " << nbeta << " " << etamin << " " << etamax
+              //   << " " << nSubPixels<< std::endl;
          };

    eta3InterpolationPosXY(eta3InterpolationPosXY *orig)
--- a/slsDetectorCalibration/interpolations/slsInterpolation.h
+++ b/slsDetectorCalibration/interpolations/slsInterpolation.h
@ -22,7 +22,7 @@ enum quadrant {

 #include <iostream>
 #include <stdio.h>
-using namespace std;
+//using namespace std;

 //#ifdef MYROOT1
 //: public TObject
@ -128,7 +128,7 @@ class slsInterpolation {
                        nSubPixelsY * nPixelsY);
            delete[] gm;
        } else
-            cout << "Could not allocate float image " << endl;
+	  std::cout << "Could not allocate float image " << std::endl;
        return NULL;
    }

@ -323,7 +323,7 @@ class slsInterpolation {
                if (ix > 1)
                    sumR += cl[ix + iy * 3];
                if (iy < 1)
-                    sumB = cl[ix + iy * 3];
+		  sumB = cl[ix + iy * 3]; //???? not "+="? VH
                if (iy > 1)
                    sumT += cl[ix + iy * 3];
            }
@ -472,13 +472,13 @@ class slsInterpolation {
                val = cl[ix + 3 * iy];
                sum += val;
                if (iy == 0)
-                    l += val;
-                if (iy == 2)
-                    r += val;
-                if (ix == 0)
                    b += val;
-                if (ix == 2)
+                if (iy == 2)
                    t += val;
+                if (ix == 0)
+                    l += val;
+                if (ix == 2)
+                    r += val;
            }
        }
        if (sum > 0) {
@ -526,6 +526,185 @@ class slsInterpolation {
        return calcEta3X(cli, etax, etay, sum);
    }

+    /************************************************/
+    /* Additional strixel eta functions by Viktoria */
+    /************************************************/
+    //Etax: only central row, etay: only central column
+    static int calcEta1x3( double* cl, double& etax, double& etay, double& toth, double& totv ) {
+      double l, r, t, b;
+      //sum = cl[0] + cl[1] + cl[2] + cl[3] + cl[4] + cl[5] + cl[6] + cl[7] + cl[8];
+      toth = cl[3] + cl[4] + cl[5];
+      if (toth > 0) {
+	l = cl[3];
+	r = cl[5];
+      }
+      etax = (-l + r) / toth;
+      totv = cl[1] + cl[4] + cl[7];
+      if (toth > 0) {
+	b = cl[1];
+	t = cl[7];
+      }
+      etay = (-b + t) / totv;
+      return -1;
+    }
+
+    static int calcEta1x3( int* cl, double& etax, double& etay, double& toth, double& totv ) {
+      double cli[9];
+      for ( int ix = 0; ix != 9; ++ix )
+	cli[ix] = cl[ix];
+      return calcEta1x3( cli, etax, etay, toth , totv );
+    }
+
+    //Eta 1x2 essentially the same as etaL, but we also return toth and totv
+    static int calcEta1x2(double totquad, int corner, double sDum[2][2],
+			  double &etax, double &etay, double& toth, double& totv) {
+        double t, r;
+        if (totquad > 0) {
+            switch (corner) {
+            case TOP_LEFT:
+                t = sDum[1][1];
+                r = sDum[0][1];
+                toth = sDum[0][1] + sDum[0][0];
+                totv = sDum[0][1] + sDum[1][1];
+                break;
+            case TOP_RIGHT:
+                t = sDum[1][0];
+                r = sDum[0][1];
+                toth = sDum[0][1] + sDum[0][0];
+                totv = sDum[1][0] + sDum[0][0];
+                break;
+            case BOTTOM_LEFT:
+                r = sDum[1][1];
+                t = sDum[1][1];
+                toth = sDum[1][0] + sDum[1][1];
+                totv = sDum[0][1] + sDum[1][1];
+                break;
+            case BOTTOM_RIGHT:
+                t = sDum[1][0];
+                r = sDum[1][1];
+                toth = sDum[1][0] + sDum[1][1];
+                totv = sDum[1][0] + sDum[0][0];
+                break;
+            default:
+                etax = -1000;
+                etay = -1000;
+                return 0;
+            }
+            // etax=r/totquad;
+            // etay=t/totquad;
+            etax = r / toth;
+            etay = t / totv;
+        }
+        return 0;
+    }
+
+    static int calcEta1x2( double *cl, double &etax, double &etay, double &sum,
+			   double &totquad, double sDum[2][2], double& toth, double& totv ) {
+        int corner = calcQuad( cl, sum, totquad, sDum );
+        calcEta1x2( totquad, corner, sDum, etax, etay, toth, totv );
+        return corner;
+    }
+
+    static int calcEta1x2( int *cl, double &etax, double &etay, double &sum,
+			 double &totquad, double sDum[2][2], double& toth, double& totv ) {
+        int corner = calcQuad( cl, sum, totquad, sDum );
+        calcEta1x2( totquad, corner, sDum, etax, etay, toth , totv );
+        return corner;
+    }
+
+    //Two functions to calculate 2x3 or 3x2 eta
+    static int calcEta2x3( double* cl, double totquad, int corner, double& etax, double& etay, double& tot6 ) {
+      double t, b, r;
+      if (totquad > 0) {
+	switch (corner) {
+	case TOP_LEFT:
+	case BOTTOM_LEFT:
+	  t = cl[6] + cl[7];
+	  b = cl[0] + cl[1];
+	  r = cl[1] + cl[4] + cl[7];
+	  tot6 = cl[0] + cl[1] + cl[3] + cl[4] + cl[6] + cl[7];
+	  break;
+	case TOP_RIGHT:
+	case BOTTOM_RIGHT:
+	  t = cl[7] + cl[8];
+	  b = cl[1] + cl[2];
+	  r = cl[2] + cl[5] + cl[8];
+	  tot6 = cl[1] + cl[2] + cl[4] + cl[5] + cl[7] + cl[8];
+	  break;
+	default:
+	  etax = -1000;
+	  etay = -1000;
+	  return -1;
+	}
+	etax = r / tot6;
+	etay = (-b + t) / tot6;
+      }
+      return -1;
+    }
+
+    static int calcEta3x2( double* cl, double totquad, int corner, double& etax, double& etay, double& tot6 ) {
+      double t, l, r;
+      if (totquad > 0) {
+	switch (corner) {
+	case TOP_LEFT:
+	case TOP_RIGHT:
+	  l = cl[3] + cl[6];
+	  r = cl[5] + cl[8];
+	  t = cl[6] + cl[7] + cl[8];
+	  tot6 = cl[3] + cl[4] + cl[5] + cl[6] + cl[7] + cl[8];
+	  break;
+	case BOTTOM_LEFT:
+	case BOTTOM_RIGHT:
+	  l = cl[0] + cl[3];
+	  r = cl[2] + cl[5];
+	  t = cl[3] + cl[4] + cl[5];
+	  tot6 = cl[0] + cl[1] + cl[2] + cl[3] + cl[4] + cl[5];
+	  break;
+	default:
+	  etax = -1000;
+	  etay = -1000;
+	  return -1;
+	}
+	etax = (-l + r) / tot6;
+	etay = t / tot6;
+      }
+      return -1;
+    }
+
+    //overload including both eta2x3 and eta3x2
+    //ornt (orientation of long side (3) of eta) decides which eta is chosen
+    enum orientation {
+      HORIZONTAL_ORIENTATION = 0,
+      VERTICAL_ORIENTATION = 1, 
+      UNDEFINED_ORIENTATION = -1
+    };
+    static int calcEta2x3( int ornt, double* cl, double& etax, double& etay, double& tot6 ) {
+      double sum{};
+      double totquad{};
+      double sDum[2][2]{};
+      int corner = calcQuad( cl, sum, totquad, sDum );
+      switch (ornt) {
+      case HORIZONTAL_ORIENTATION:
+	calcEta3x2( cl, totquad, corner, etax, etay, tot6 );
+	break;
+      case VERTICAL_ORIENTATION:
+	calcEta2x3( cl, totquad, corner, etax, etay, tot6 );
+	break;
+      default:
+	etax = -1000;
+	etay = -1000;
+	return -1;
+      }
+      return corner;
+    }
+
+    static int calcEta2x3( int strxo, int* cl, double& etax, double& etay, double& tot6 ) {
+      double cli[9]{};
+      for ( int ix = 0; ix != 9; ++ix )
+	cli[ix] = cl[ix];
+      return calcEta2x3( strxo, cli, etax, etay, tot6 );
+    }
+
    /* static int calcMyEta(double totquad, int quad, double *cl, double &etax,
     * double &etay) { */
    /*   double l,r,t,b, sum; */
--- a/slsDetectorCalibration/jungfrauExecutables/Makefile
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile
@ -0,0 +1 @@
+Makefile.zmqrootdisp
--- a/slsDetectorCalibration/jungfrauExecutables/Makefile.rawdataprocess
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile.rawdataprocess
@ -14,7 +14,19 @@ jungfrauRawDataProcess:  jungfrauRawDataProcess.cpp  $(INCS) clean
 			 g++ -o jungfrauRawDataProcess  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DMODULE

 jungfrauRawDataProcessStrx:  jungfrauRawDataProcess.cpp  $(INCS) clean
-			 g++ -o jungfrauRawDataProcessStrx  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRX 
+			 g++ -o jungfrauRawDataProcessStrx  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRX
+
+jungfrauRawDataProcessStrxChip1:  jungfrauRawDataProcess.cpp  $(INCS) clean
+			 g++ -o jungfrauRawDataProcessStrxChip1  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRXCHIP1
+
+jungfrauRawDataProcessStrxChip6:  jungfrauRawDataProcess.cpp  $(INCS) clean
+			 g++ -o jungfrauRawDataProcessStrxChip6  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRXCHIP6
+
+jungfrauRawDataProcessStrxChip1Aldo:  jungfrauRawDataProcess.cpp  $(INCS) clean
+			 g++ -o jungfrauRawDataProcessStrxChip1Aldo  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRXCHIP1 -DALDO
+
+jungfrauRawDataProcessStrxChip6Aldo:  jungfrauRawDataProcess.cpp  $(INCS) clean
+			 g++ -o jungfrauRawDataProcessStrxChip6Aldo  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRXCHIP6 -DALDO

 jungfrauRawDataProcessStrxAldo:  jungfrauRawDataProcess.cpp  $(INCS) clean
 			 g++ -o jungfrauRawDataProcessStrxAldo  jungfrauRawDataProcess.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL -DJFSTRX -DALDO
--- a/slsDetectorCalibration/jungfrauExecutables/Makefile.zmqrootdisp
+++ b/slsDetectorCalibration/jungfrauExecutables/Makefile.zmqrootdisp
@ -18,7 +18,7 @@ LDFLAG= -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt -ltiff   -O3

 default: onlinedisp_zmq

-onlinedisp_zmq: onlinedisp_zmq.cpp onlinedisp_zmq.h 
+onlinedisp_zmq: onlinedisp_zmq.cpp onlinedisp_zmq.h ../dataStructures/jungfrauLGADStrixelsData_new.h
 # flags from root-config --cflags --glibs
 	g++ -o onlinedisp_zmq onlinedisp_zmq.cpp  -I. -I$(ROOTSYS)/include -Wall -g -lm  -L. -lzmq -pthread -lrt -L$(ROOTSYS)/lib -lGui -lCore  -lRIO -lNet -lHist -lGraf -lGraf3d -lGpad -lTree -lRint -lPostscript -lMatrix  -lPhysics -lMathCore -lThread -m64 $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 

--- a/slsDetectorCalibration/jungfrauExecutables/jungfrauRawDataProcess.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/jungfrauRawDataProcess.cpp
@ -10,8 +10,7 @@

 #define RAWDATA

-#ifndef JFSTRX
-#ifndef JFSTRXOLD
+#if !defined JFSTRX && !defined JFSTRXOLD && !defined JFSTRXCHIP1 && !defined JFSTRXCHIP6
 #ifndef MODULE
 #include "jungfrauHighZSingleChipData.h"
 #endif
@ -19,10 +18,13 @@
 #include "jungfrauModuleData.h"
 #endif
 #endif
-#endif
+
 #ifdef JFSTRX
 #include "jungfrauLGADStrixelsData.h"
 #endif
+#if defined JFSTRXCHIP1 || defined JFSTRXCHIP6
+#include "jungfrauLGADStrixelsDataSingleChip.h"
+#endif
 #ifdef JFSTRXOLD
 #include "jungfrauStrixelsHalfModuleOldDesign.h"
 #endif
@ -56,15 +58,14 @@ int main(int argc, char *argv[]) {

    int fifosize = 1000;
    int nthreads = 10;
-    int csize = 3;
+    int csize = 3; //3
    int nsigma = 5;
    int nped = 10000;

    int cf = 0;


-#ifndef JFSTRX
-#ifndef JFSTRXOLD
+#if !defined JFSTRX && !defined JFSTRXOLD && !defined JFSTRXCHIP1 && !defined JFSTRXCHIP6
 #ifndef MODULE
    jungfrauHighZSingleChipData *decoder = new jungfrauHighZSingleChipData();
    int nx = 256, ny = 256;
@ -72,17 +73,26 @@ int main(int argc, char *argv[]) {
 #ifdef MODULE
    jungfrauModuleData *decoder = new jungfrauModuleData();
    int nx = 1024, ny = 512;
+#endif
+#endif

-#endif
-#endif
-#endif
 #ifdef JFSTRX
-    cout << "bbb" << endl;
+    cout << "Jungfrau strixel full module readout" << endl;
    jungfrauLGADStrixelsData *decoder = new jungfrauLGADStrixelsData();
    int nx = 1024/5, ny = 512*5;
 #endif
+#ifdef JFSTRXCHIP1
+    std::cout << "Jungfrau strixel LGAD single chip 1" << std::endl;
+    jungfrauLGADStrixelsDataSingleChip *decoder = new jungfrauLGADStrixelsDataSingleChip(1);
+    int nx = 256/3, ny = 256*5;
+#endif
+#ifdef JFSTRXCHIP6
+    std::cout << "Jungfrau strixel LGAD single chip 6" << std::endl;
+    jungfrauLGADStrixelsDataSingleChip *decoder = new jungfrauLGADStrixelsDataSingleChip(6);
+    int nx = 256/3, ny = 256*5;
+#endif
 #ifdef JFSTRXOLD
-    cout << "ccc" << endl;
+    std::cout << "Jungfrau strixels old design" << std::endl;
    jungfrauStrixelsHalfModuleOldDesign *decoder = new jungfrauStrixelsHalfModuleOldDesign();
    int nx = 1024*3, ny = 512/3;
 #endif
@ -180,7 +190,7 @@ int main(int argc, char *argv[]) {
    uint32_t nnx, nny;

    singlePhotonDetector *filter = new singlePhotonDetector(
-        decoder, csize, nsigma, 1, NULL, nped, 200, -1, -1, gainmap, NULL);
+        decoder, 3, nsigma, 1, NULL, nped, 200, -1, -1, gainmap, NULL);

    if (gainfname) {

@ -211,6 +221,8 @@ int main(int argc, char *argv[]) {
    // multiThreadedAnalogDetector(filter,nthreads,fifosize);
    multiThreadedCountingDetector *mt =
        new multiThreadedCountingDetector(filter, nthreads, fifosize);
+    mt->setClusterSize(csize,csize);
+
 #ifndef ANALOG
    mt->setDetectorMode(ePhotonCounting);
    cout << "Counting!" << endl;
--- a/slsDetectorCalibration/jungfrauExecutables/onlinedisp_zmq.cpp
+++ b/slsDetectorCalibration/jungfrauExecutables/onlinedisp_zmq.cpp
@ -7,17 +7,23 @@ sls::zmqHeader zHeader;
 #define NPRO 50
 #define NPRI 50

-//#define JFSTRX
+#define JFSTRX
 #ifdef JFSTRX
-#include "jungfrauLGADStrixelsData.h"
-#else
-#include "jungfrauModuleData.h"
+#include "jungfrauLGADStrixelsData_new.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorData.h"
+using header = sls::defs::sls_receiver_header;
 #endif


-
 int main(int argc, char* argv[]) 
 {
+
+
+
+
+
+
  goout=1;
  hasallpede=false;
  dophotonmap=true;  if ((argc<3)) {printf("USAGE: command photon_energy_(peakinADC) [rx_ip]  [port] \n"); return -1  ;}
@ -43,9 +49,19 @@ int main(int argc, char* argv[])
 #ifdef JFSTRX
    cout << "JFSTRX" << endl;
    jungfrauLGADStrixelsData *decoder = new jungfrauLGADStrixelsData();
-    nx = 1024/5; ny= 512*5;
+
+    decoder->getDetectorSize(nx,ny);
+
+    
+    
+
+    cout<<    decoder->dataMap[22][22] <<endl;
+
+
 #else
    nx = 1024; ny= 512;
+
+
 #endif


@ -57,7 +73,7 @@ int main(int argc, char* argv[])
 
  HDraw_every=20;
  fixranges=false;
-
+  int group;
  
  hchptr = (short*) malloc(NCH*sizeof(short)); 

@ -80,29 +96,85 @@ int main(int argc, char* argv[])
  char hname[100];


+#ifdef JFSTRX
+  int nxx=79; int nyy=165;
+  his1000= new TH2F("his1000","2d, chip 1 group 1 (25um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);
+  his1060= new TH2F("his1060","2d,  chip 6 group 1 (25um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);
+  nxx=47; nyy=320; //320;
+  his1001= new TH2F("his1001","2d, chip 1 group 2 (15um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);
+  his1061= new TH2F("his1061","2d, chip 6 group 2 (15um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);
+  nxx=59; nyy=476; //476;
+  his1002= new TH2F("his1002","2d, chip 1 group 3 (18.75um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);
+  his1062= new TH2F("his1002","2d, chip 6 group 3 (18.75um) pede corr.",nxx,-0.5,nxx-0.5,nyy,-0.5,nyy-0.5);

+  his1000->SetOption("colz");
+  his1001->SetOption("colz");
+  his1002->SetOption("colz");
+  his1060->SetOption("colz");
+  his1061->SetOption("colz");
+  his1062->SetOption("colz");
+
+#else
  his1000= new TH2F("his1000","2d , ev. pede corrected",nx,-0.5,nx-0.5,ny,-0.5,ny-0.5);
  his1000->SetOption("colz");
+#endif
+
  his2000= new TH2F("his2000","2d gain ",nx,-0.5,nx-0.5,ny,-0.5,ny-0.5);
  his2000->GetZaxis()->SetRangeUser(0,4);

  if (dophotonmap) {
-    his3000= new TH2F("his3000"," photon map  ",nx,-0.5,nx-0.5,ny,-0.5,ny-0.5);
+    his3000= new TH2F("his3000"," photon map  ",1024,-0.5,1024-0.5,512,-0.5,512-0.5);
  }
  else {
-    his3000= new TH2F("his3000"," raw adc  ",nx,-0.5,nx-0.5,ny,-0.5,ny-0.5);
+    his3000= new TH2F("his3000"," raw adc  ",1024,-0.5,1024-0.5,512,-0.5,512-0.5);
  }
 
-  his4500= new TH2F("his45000","L vs R",101,-50,500,101,-50,500);
+  his4500= new TH2F("his4500","T vs B",101,-500,MAX_POS,101,-500,MAX_POS);
  hchip=new TH1I*[8];
+#ifdef JFSTRX
+  for (i=0;i<8;i++) {
+    if(i<3)
+      sprintf(hname,"%d_hchip1group%d",i,i+1);
+    else if (i>4)
+      sprintf(hname,"%d_hchip6group%d",i, i-4);
+    else
+      sprintf(hname,"%d_",i);
+    hchip[i] = new TH1I(hname,hname,NBIN,MIN_POS,MAX_POS);
+  }
+#else
  for (i=0;i<8;i++) {
    sprintf(hname,"hchip%d",i);
    hchip[i] = new TH1I(hname,hname,NBIN,MIN_POS,MAX_POS);
  }
+#endif

  cout <<"end of histo booking" <<endl;
  if  (A2==NULL)  A2 = new TCanvas("A2","Plotting Canvas gain",150,10,500,250);
-  if  (A3==NULL)  A3 = new TCanvas("A3","Plotting Canvas ADC",150,360,1200,550);
+  if  (A3==NULL)  {
+#ifdef JFSTRX
+    A3 = new TCanvas("A3","Plotting Canvas ADC",150,360,1200,750);
+    p1 = new TPad("p1","p1",0.01,0.5,0.49,1.);
+    p1->Draw();
+    p2 = new TPad("p2","p2",0.51,0.75,0.99,0.97);
+    p2->Draw();
+    p3 = new TPad("p3","p3",0.01,0.25,0.49,0.47);
+    p3->Draw();
+    p4 = new TPad("p4","p4",0.51,0.53,0.99,0.75);
+    p4->Draw();
+    p5 = new TPad("p5","p5",0.01,0.03,0.49,0.25);
+    p5->Draw();
+    p6 = new TPad("p6","p6",0.51,0.,0.99,0.5);
+    p6->Draw();
+    //A3->Divide(2,3);
+
+    // TVirtualPad* g=A3->cd(1);
+    // g->SetCanvasSize( g->GetWw(), 2*g->GetWw());
+    //  g=A3->cd(6);
+    // g->SetCanvasSize( g->GetWw(), 2*g->GetWw());
+#else
+    A3 = new TCanvas("A3","Plotting Canvas ADC",150,360,1200,550);
+#endif
+    }
  if  (A4==NULL)  A4 = new TCanvas("A4","Plotting Canvas PHs",750,300,1000,800);
  A4->Clear();
  A4->Divide(4,2,0.005,0.005);
@ -131,7 +203,14 @@ int main(int argc, char* argv[])
    }

    {
-
+     
+       
+      memcpy(&croi, &zHeader.detSpec1, 8);  
+      ROIxmin=croi.xmin;
+      ROIxmax=croi.xmax;
+      ROIymin=croi.ymin;
+      ROIymax=croi.ymax;
+      cout<<" ROIymin "<<  ROIymin<<endl;
      framesinstream++;
      running++;
     
@ -143,7 +222,19 @@ int main(int argc, char* argv[])
 
      npacket=0;
      if  (show2Ds)  {
+#ifdef JFSTRX
 	his1000->Reset(); 
+	his1001->Reset(); 
+	his1002->Reset();
+	his1060->Reset(); 
+	his1061->Reset(); 
+	his1062->Reset();
+#else
+
+	his1000->Reset(); 
+#endif
+
+
 	his2000->Reset(); 
 	if (!dophotonmap) his3000->Reset(); //FOR RAW ADC DISPLAY 
      }
@ -187,10 +278,28 @@ int main(int argc, char* argv[])
 	  if (fill1Ds) {
 	    if (((i%1024)<1004)&&((i%1024)>20)&&((i/1024)>20)) { //skip the pix near guardring for PH plots
 	      ichip= i/(256*256*4)*4+((i/256)%4)  ;
-	   
+#ifdef JFSTRX
+	      int new_ichip=0;
+	      //exclude border rows of each group
+	      if (ichip==1) {
+		if (i<=(1024*(64-2))) new_ichip=0; //chip 1 group 1
+		if (i>(1024*(64+6))&&(i<=(1024*(64*2-4)))) new_ichip=1; //chip 1 group 2
+		if (i>(1024*(64*2+5))) new_ichip=2; //chip 1 group 3
+	      }
+
+	      if (ichip==6) {
+		if (i<=(1024*(256+2*64-5))) new_ichip=7; //chip 6 group 3
+		if (i>(1024*(256+2*64+4))&&(i<=(1024*(256+64*3-6)))) new_ichip=6; //chip 6 group 2
+		if (i>(1024*(256+64*3-4))) new_ichip=5; //chip 6 group 1
+	      }
+
+	      hchip[new_ichip]->Fill(adcpedecorr,1);
+
+#else	   
 	      hchip[ichip]->Fill(adcpedecorr,1);
+#endif
 	    
-	      if (((i%256)<253)&&((i%256)>2)) his4500->Fill(adcpedecorrold,adcpedecorr,1);
+	      //	      if (((i%256)<253)&&((i%256)>2)) his4500->Fill(adcpedecorrold,adcpedecorr,1);
 	      adcpedecorrold=adcpedecorr;
 	    
 	    
@ -200,33 +309,110 @@ int main(int argc, char* argv[])

 	

-	  if ((show2Ds)) {
-	    factor=2.0;
-	    value=adcpedecorr;
-	    if ((i%256==0)||(i%256==255)) value=int(value/factor);
-	    if ((i/1024==255)||(i/1024==256)||(i/1024==767)||(i/1024==768)) value=int(value/factor);
-
-	    his1000->Fill(float(i%1024),float(int (i/1024)),value);
-
-	    if (!dophotonmap) his3000->Fill(float(i%1024),float(int (i/1024)) ,adcvalue);
 	  
-	    his2000->Fill(float(i%1024),float(int (i/1024)) ,gain);
-
-	    value=(int)(hchptr[i]);
-	 
-	    if ((i%256==0)||(i%256==255)) value=int(value/factor);
-	    if ((i/1024==255)||(i/1024==256)||(i/1024==767)||(i/1024==768)) value=int(value/factor);
-	    if (dophotonmap) his3000->Fill(float(i%1024),float(int (i/1024)),float(value));
-
-	  }
 	}//   for (i=0 ;i<NCH-0;i++)
+
+
+	if ((show2Ds)) {
+	  for (ipx=0;ipx<nx;ipx++){
+	    for (ipy=0;ipy<ny;ipy++){
+	    // for (ipx=0;ipx<nx;ipx++){
+#ifdef JFSTRX
+
+	      //cout<<i<< " cdcsdcvsvcsc  " << group << "  " << (decoder->dataMap[ipy][ipx])/2 << endl; 
+	      i=int (((decoder->dataMap[ipy][ipx])-sizeof(header)) /2);
+	      group=(decoder->groupmap[ipy][ipx]);
+	     
+	      //     cout<<i<< "  "<<ipx<<"  "<<ipy<< "  " << group <<endl; 
+
+  
+
+
+#else	      
+	      i=ipx+ipy*1024;
+#endif
+
+
+
+		value= ((image_data[i]) & 0x3fff) -fpeded[i];
+#ifndef JFSTRX
+		if ((i%256==0)||(i%256==255)) value=int(value/factor);
+		if ((i/1024==255)||(i/1024==256)||(i/1024==767)||(i/1024==768)) value=int(value/factor);
+#endif
+
+		//	        his1000->Fill(float(ipx),float(ipy),value);
+		//	if ((ipy>165)&&(ipy<320+165)){ his1000->Fill(float(ipx)*5/3.0,float(ipy),value);}
+		//	else  { his1000->Fill(float(ipx),float(ipy),value);}
+
+#ifdef JFSTRX
+		static const int mc1g1y_start = 0;
+		static const int mc1g2y_start = g1_nrows;
+		static const int mc1g3y_start = g1_nrows+g2_nrows;
+
+		static const int mc6g3y_start = g1_nrows+g2_nrows+g3_nrows;
+		static const int mc6g2y_start = mc6g3y_start + g3_nrows;
+		static const int mc6g1y_start = mc6g3y_start  + g3_nrows + g2_nrows;
+
+		if (group==0) {
+		  if (ipy<165){
+		    his1000->Fill(float(ipx),float(ipy-mc1g1y_start),value);}
+		  if (ipy>=mc6g1y_start){
+		    his1060->Fill(float(ipx),float(ipy-mc6g1y_start),value);}
+		}
+		if (group==1) {
+		  if (ipy<(165+320)){ 
+		    his1001->Fill(float(ipx),float(ipy-mc1g2y_start),value);}
+		  if ( (ipy>=mc6g2y_start) && (ipy<mc6g1y_start) ){his4500->Fill(value,oldvalue,1.0);
+		    oldvalue=value;
+		    his1061->Fill(float(ipx),float(ipy-mc6g2y_start),value);}
+		}
+		if (group==2) {
+		  if (ipy<(165+320+476))
+		    his1002->Fill(float(ipx),float(ipy-mc1g3y_start),value);
+		  if ( (ipy>=mc6g3y_start) && (ipy<mc6g2y_start) )
+		    his1062->Fill(float(ipx),float(ipy-mc6g3y_start),value);
+		}
+	 
+#else
+
+	his1000->Fill(float(ipx),float(ipy),value);
+	
+
+
+#endif
+
+	
+
+	his2000->Fill(float(ipx),float(ipy) ,gain);
+
+		// if (!dophotonmap)his3000->Fill(float(ipx),float(ipy) ,value);
+		// value=(int)(hchptr[i]);
+		// if (dophotonmap) his3000->Fill(float(ipx),float(ipy),float(value));
+		
+	    }// for ipx
+	  } //for ipy
+
+	  for (ipx=0;ipx<1024;ipx++){
+	    for (ipy=0;ipy<512;ipy++){
+	      i=ipx+ipy*1024;
+	      value= ((image_data[i]) & 0x3fff) -fpeded[i];
+	      if (!dophotonmap)his3000->Fill(float(ipx),float(ipy) ,value);
+	      value=(int)(hchptr[i]);
+	      if (dophotonmap) his3000->Fill(float(ipx),float(ipy),float(value));
+	    }
+	  }
+
+	}// endo of show2d 
+	   	  	  
+
+
      }// /end of do something 
   


      if   ((show2Ds)) {

-	for (ipx=0;ipx<NCH;ipx++) hchptr[(ipx)]=0;
+	for (i=0;i<NCH;i++) hchptr[(i)]=0;



@ -419,10 +605,31 @@ void SetRanges() {

 void axisreset(){
  fixranges=false;
+#ifdef JFSTRX
+  his1000->GetXaxis()->UnZoom();
+  his1000->GetYaxis()->UnZoom();
+  his1000->GetZaxis()->UnZoom();
+  his1001->GetXaxis()->UnZoom();
+  his1001->GetYaxis()->UnZoom();
+  his1001->GetZaxis()->UnZoom();
+  his1002->GetXaxis()->UnZoom();
+  his1002->GetYaxis()->UnZoom();
+  his1002->GetZaxis()->UnZoom();
+  his1060->GetXaxis()->UnZoom();
+  his1060->GetYaxis()->UnZoom();
+  his1060->GetZaxis()->UnZoom();
+  his1061->GetXaxis()->UnZoom();
+  his1061->GetYaxis()->UnZoom();
+  his1061->GetZaxis()->UnZoom();
+  his1062->GetXaxis()->UnZoom();
+  his1062->GetYaxis()->UnZoom();
+  his1062->GetZaxis()->UnZoom();
+#else
  his1000->GetXaxis()->UnZoom();

  his1000->GetYaxis()->UnZoom();
  his1000->GetZaxis()->UnZoom();
+#endif
  his2000->GetXaxis()->UnZoom();
  his2000->GetYaxis()->UnZoom();

@ -540,7 +747,6 @@ void Plot1DHistos(void){

 void Plot2DHistos(void){
  gStyle->SetOptStat(0);
-  A3->cd();

  //  if (bw_flag) LoadPaletteBW(1.0);

@ -553,8 +759,24 @@ void Plot2DHistos(void){
  }

  his1000->SetMinimum(-200);
-  his1000->Draw();

+#ifdef JFSTRX
+  p5->cd();
+  his1000->Draw("colz");
+  p3->cd();
+  his1001->Draw("colz");
+  p1->cd();
+  his1002->Draw("colz");
+  p2->cd();
+  his1060->Draw("colz");
+  p4->cd();
+  his1061->Draw("colz");
+  p6->cd();
+  his1062->Draw("colz");
+#else
+  A3->cd();
+  his1000->Draw("colz");
+#endif
  A3->Update();
  A2->cd();
  // if (bw_flag)  LoadPaletteFalse();
@ -565,9 +787,16 @@ void Plot2DHistos(void){
  A2->Update(); 
  A5->cd();

-  his3000->GetXaxis()->SetRange(his1000->GetXaxis()->GetFirst(),his1000->GetXaxis()->GetLast());
-  his3000->GetYaxis()->SetRange(his1000->GetYaxis()->GetFirst(),his1000->GetYaxis()->GetLast());
+  //his3000->GetXaxis()->SetRange(his1000->GetXaxis()->GetFirst(),his1000->GetXaxis()->GetLast());
+  //his3000->GetYaxis()->SetRange(his1000->GetYaxis()->GetFirst(),his1000->GetYaxis()->GetLast());
  his3000->Draw("colz");
+
+  box = new TBox(ROIxmin,ROIymin,ROIxmax,ROIymax);
+  box->SetLineColor(kRed);
+  
+  box->SetFillStyle(0);
+  box->SetLineWidth(2);
+  box->Draw();
  A5->Update();
 
  A6->cd();
--- a/slsDetectorCalibration/jungfrauExecutables/onlinedisp_zmq.h
+++ b/slsDetectorCalibration/jungfrauExecutables/onlinedisp_zmq.h
@ -56,6 +56,7 @@ using namespace sls;
 #include "TMath.h"
 #include "TFile.h"
 #include "TStyle.h"
+#include "TBox.h"
 #include "TSystem.h"
 #include "TTimer.h"
 #include "TProfile.h"
@ -81,7 +82,7 @@ using namespace sls;
 #define OFFSET 0
 #define NBIN 500  
 #define MIN_POS  -500.5   // 400.5   
-#define MAX_POS 3499.5   //-100.5
+#define MAX_POS 8499.5   //-100.5


 #define NCH 524288
@ -92,7 +93,7 @@ int portnum;
 FILE * sfilefd;

 short* hchptr; // photon counted map "histogram"
-int value;
+int value,oldvalue;
 float factor=1.84;
 int npacket=0;
 int totalnpacket=0;
@ -105,6 +106,7 @@ struct hostent      *server;
 
 int i=0;
 int ipx=0;
+int ipy=0;
 bool haveconnection;


@ -112,6 +114,12 @@ TStyle *gStyle;
 TApplication* rootapp;
 TCanvas *A2;
 TCanvas *A3;
+TPad *p1;
+TPad *p2;
+TPad *p3;
+TPad *p4;
+TPad *p5;
+TPad *p6;
 TCanvas *A4;
 TCanvas *A5;
 TCanvas *A6;
@ -139,6 +147,18 @@ bool fill1Ds;
 bool pede_flag;
 bool dophotonmap;

+      typedef struct {
+        uint16_t xmin;
+     	uint16_t xmax;
+     	uint16_t ymin;
+     	uint16_t ymax;
+      } receriverRoi_compact;   
+     receriverRoi_compact croi;
+TBox *box;
+uint16_t ROIxmin;
+uint16_t ROIxmax;
+uint16_t ROIymin;
+uint16_t ROIymax;     
 int nx, ny;
 int nframes;
 int goout;
@ -154,7 +174,8 @@ int frameIndex_old;
 char pedefilename[128];
 int  framenum,bunchid;

-TH2F* his1000;
+TH2F* his1000;TH2F* his1001;TH2F* his1002;
+TH2F* his1060;TH2F* his1061;TH2F* his1062;
 TH2F* his2000;
 TH2F* his3000;
 TH2F* his4500;
--- a/slsDetectorCalibration/moenchExecutables/moench03NoInterpolation.cpp
+++ b/slsDetectorCalibration/moenchExecutables/moench03NoInterpolation.cpp
@ -30,13 +30,14 @@ int main(int argc, char *argv[]) {
    int runmax = atoi(argv[5]);
    int nsubpix = atoi(argv[6]);

-    int etabins = 1000; // nsubpix*2*100;
-    double etamin = -1, etamax = 2;
+    // int etabins = 1000; // nsubpix*2*100;
+    // double etamin = -1, etamax = 2;
    int quad;
    double sum, totquad;
    double sDum[2][2];
-    double etax, etay, int_x, int_y;
-    int ok;
+    // double etax, etay;
+    double int_x, int_y;
+    // int ok;

    int ix, iy, isx, isy;

--- a/slsDetectorCalibration/moenchExecutables/moenchRawDataProcess.cpp
+++ b/slsDetectorCalibration/moenchExecutables/moenchRawDataProcess.cpp
@ -86,17 +86,10 @@ int main(int argc, char *argv[]) {
    
 #endif

-
-    int nx = 400, ny = 400;
-
+    //Read detector size from decoder
+    int nx , ny;
    decoder->getDetectorSize(nx, ny);
-#ifdef CORR
-    int ncol_cm = CM_ROWS;
-    double xt_ghost = C_GHOST;
-#endif
-    moench03CommonMode *cm = NULL;
-    moench03GhostSummation *gs;
-    double *gainmap = NULL;
+
    //float *gm;

    int ff, np;
@ -171,8 +164,15 @@ int main(int argc, char *argv[]) {

    uint32_t nnx, nny;

+
+    moench03CommonMode *cm = nullptr;
+    moench03GhostSummation *gs = nullptr;
+    double *gainmap = nullptr;
+
 #ifdef CORR
-    cout << "Applying common mode  " << ncol_cm << endl;
+    int ncol_cm = CM_ROWS;
+    double xt_ghost = C_GHOST;
+    std::cout << "Applying common mode  " << ncol_cm << endl;
    cm = new moench03CommonMode(ncol_cm);

    // cout << "Applying ghost corrections " << xt_ghost << endl;
--- a/slsDetectorCalibration/multiThreadedAnalogDetector.h
+++ b/slsDetectorCalibration/multiThreadedAnalogDetector.h
@ -69,6 +69,11 @@ class threadedAnalogDetector {
    };
    virtual double setThreshold(double th) { return det->setThreshold(th); };

+    virtual double setClusterSize(int csx, int csy) { 
+      //cout << "44" << endl; 
+      return det->setClusterSize(csx); 
+    };
+
    virtual void setROI(int xmin, int xmax, int ymin, int ymax) {
        det->setROI(xmin, xmax, ymin, ymax);
    };
--- a/slsDetectorCalibration/multiThreadedCountingDetector.h
+++ b/slsDetectorCalibration/multiThreadedCountingDetector.h
@ -19,7 +19,7 @@ using namespace std;

 class multiThreadedCountingDetector : public multiThreadedAnalogDetector {
  public:
-    multiThreadedCountingDetector(singlePhotonDetector *d, int n, int fs = 1000)
+ multiThreadedCountingDetector(singlePhotonDetector *d, int n, int fs = 1000)
        : multiThreadedAnalogDetector(d, n, fs){};
    // virtual
    // ~multiThreadedCountingDetector{multiThreadedAnalogDetector::~multiThreadedAnalogDetector();};
@ -33,6 +33,11 @@ class multiThreadedCountingDetector : public multiThreadedAnalogDetector {
        for (int i = 0; i < nThreads; i++)
            (dets[i])->setEnergyRange(emi, ema);
    };
+    virtual void setClusterSize(int sizex, int sizey) {
+        for (int i = 0; i < nThreads; i++)
+	  ((dets[i]))->setClusterSize(sizex, sizey);
+	//std::cout << "+++++++++++++ sizex " << sizex << std::endl;
+    };
 };

 #endif
--- a/slsDetectorCalibration/singlePhotonDetector.h
+++ b/slsDetectorCalibration/singlePhotonDetector.h
@ -174,8 +174,9 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
                clusterSizeY = clusterSize;
            else
                clusterSizeY = 1;
-            for (int ip = 0; ip < nx * ny; ip++)
+            for (int ip = 0; ip < nx * ny; ip++) {
                (clusters + ip)->set_cluster_size(clusterSize, clusterSizeY);
+	    }
            // cluster=new single_photon_hit(clusterSize,clusterSizeY);
        }
        return clusterSize;
@ -533,6 +534,7 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
 		      (clusters + nph)->print();
 		      cout << max << " " <<  val[iy * nx + ix] << endl;
 		    }
+		    //else (clusters + nph)->print();
                    good = 1;
                    if (eMin > 0 && tot < eMin)
                        good = 0;
--- a/slsDetectorCalibration/single_photon_hit.h
+++ b/slsDetectorCalibration/single_photon_hit.h
@ -44,14 +44,12 @@ class single_photon_hit {
        // fwrite((void*)this, 1, 3*sizeof(int)+4*sizeof(double)+sizeof(quad),
        // myFile);  // if (fwrite((void*)this, 1,
        // sizeof(int)+2*sizeof(int16_t), myFile))
-#ifdef OLDFORMAT
-        if (fwrite((void *)&iframe, 1, sizeof(int), myFile)) {
-        };
-#endif
 #ifndef WRITE_QUAD
        // printf("no quad ");
-        if (fwrite((void *)&x, sizeof(int16_t), 2, myFile))
+        if ( fwrite( (void*)&x, sizeof(int16_t), 1, myFile ) ) {
+	  if ( fwrite( (void*)&y, sizeof(int16_t), 1, myFile ) )
            return fwrite((void *)data, sizeof(int), dx * dy, myFile);
+	}
 #endif
 #ifdef WRITE_QUAD
        //  printf("quad ");
@ -109,14 +107,27 @@ class single_photon_hit {
        // fread((void*)this, 1,  3*sizeof(int)+4*sizeof(double)+sizeof(quad),
        // myFile);

-#ifdef OLDFORMAT
-        if (fread((void *)&iframe, 1, sizeof(int), myFile)) {
-        }
-#endif
 #ifndef WRITE_QUAD
-        // printf( "no quad \n");
+        //printf( "no quad \n");
+	//This reads two values of size int16_t into x
+	//If x is located next to y (int16_t distance), this reads the values into x and y
+	//How can I be sure, this is always the case?
+	//If, e.g., the memory is padded after int16_t x, do we read the padding instead of y?
+	//How can I be sure the memory is packed and y follows right after x with no padding?
+	//Anyway, this is dangerous if anyone, at any point, changes the order of variable declaration,
+	//or uses another architecture (64 bit vs 32 bit for instance).
+	/*
        if (fread((void *)&x, sizeof(int16_t), 2, myFile))
            return fread((void *)data, sizeof(int), dx * dy, myFile);
+	*/
+	
+	//Suggestion
+	if ( fread( (void*)&x, sizeof(int16_t), 1, myFile) ) {     //reads x
+	  if ( fread( (void*)&y, sizeof(int16_t), 1, myFile ) )    //reads y
+	  return fread( (void*)data, sizeof(int), dx*dy, myFile ); //reads and returns data
+	}
+	
+	
 #endif
 #ifdef WRITE_QUAD
        int qq[4];
@ -217,7 +228,7 @@ class single_photon_hit {
        // int ix, iy;

      printf("***************\n");
-      printf("** %d %d **\n",x,y);
+      printf("** %d %d ** %d %d **\n", x, y, dx, dy);
        for (int iy = 0; iy < dy; iy++) {
            for (int ix = 0; ix < dx; ix++) {
                printf("%d \t", data[ix + iy * dx]);
@ -261,10 +272,11 @@ class single_photon_hit {
       x within the cluster (center is (0,0)) \param iy coordinate y within the
       cluster (center is (0,0)) \returns value of the cluster element
  */
-    double get_data(int ix, int iy = 0) {
-        return data[(iy + dy / 2) * dx + ix + dx / 2];
+    //Why not make these const? VH
+    double get_data(int ix, int iy = 0) const {
+      return data[(iy + dy / 2) * dx + ix + dx / 2]; //NOTE: those are int divisions
    };
-    int *get_cluster() { return data; };
+    int *get_cluster() const { return data; };

    int iframe; /**< frame number */
    double
--- a/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
@ -332,7 +332,7 @@ void getServerVersion(char *version) { strcpy(version, APICTB); }

 uint64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return REQRD_FRMWR_VRSN;
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_VERSION_BRD_RVSN_MSK) >>
            FPGA_VERSION_BRD_RVSN_OFST);
--- a/slsDetectorServers/eigerDetectorServer/FebControl.c
+++ b/slsDetectorServers/eigerDetectorServer/FebControl.c
@ -1742,7 +1742,7 @@ int Feb_Control_WriteRegister_BitMask(uint32_t offset, uint32_t data,

 int Feb_Control_ReadRegister_BitMask(uint32_t offset, uint32_t *retval,
                                     uint32_t bitmask) {
-        
+
    uint32_t actualOffset = offset;
    char side[2][10] = {"right", "left"};
    unsigned int addr[2] = {Feb_Control_rightAddress, Feb_Control_leftAddress};
@ -2213,7 +2213,7 @@ int Feb_Control_GetFPGAHardwareVersion(int *retval) {
    }
    unsigned int value = 0;
    if (!Feb_Control_ReadRegister_BitMask(FEB_REG_STATUS, &value,
-                                           FEB_REG_STATUS_FX30_MSK)) {
+                                          FEB_REG_STATUS_FX30_MSK)) {
        LOG(logERROR,
            ("Trouble reading FEB_REG_STATUS reg to feb hardware version\n"));
        return 0;
--- a/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
@ -133,8 +133,8 @@ void basictests() {
         "Software Version         : %s\n"
         "********************************************************\n",
         (unsigned int)ipadd, (long long unsigned int)macadd,
-         (long long int)fwversion,
-         (long long int)sw_fw_apiversion, REQUIRED_FIRMWARE_VERSION, swversion));
+         (long long int)fwversion, (long long int)sw_fw_apiversion,
+         REQUIRED_FIRMWARE_VERSION, swversion));

    // update default udpdstip and udpdstmac (1g is hardware ip and hardware
    // mac)
@ -406,35 +406,36 @@ void initControlServer() {
        Beb_Beb();
        LOG(logDEBUG1, ("Control server: BEB Initialization done\n"));

-    // Getting the feb versions after initialization
-    char hversion[MAX_STR_LENGTH] = {0};
-    memset(hversion, 0, MAX_STR_LENGTH);
-    getHardwareVersion(hversion);
-    int64_t fwversion = getFirmwareVersion();
-    int64_t feblfwversion = getFrontEndFirmwareVersion(FRONT_LEFT);
-    int64_t febrfwversion = getFrontEndFirmwareVersion(FRONT_RIGHT);
-    LOG(logINFOBLUE,
-        ("\n********************************************************\n"
-         "Feb Versions\n"
-         "Hardware Version         : %s\n"
-         "Firmware (Febl) Version  : %lld\n"
-         "Firmware (Febr) Version  : %lld\n"
-         "********************************************************\n",
-        hversion,  (long long int)feblfwversion,
-         (long long int)febrfwversion));
+        // Getting the feb versions after initialization
+        char hversion[MAX_STR_LENGTH] = {0};
+        memset(hversion, 0, MAX_STR_LENGTH);
+        getHardwareVersion(hversion);
+        int64_t fwversion = getFirmwareVersion();
+        int64_t feblfwversion = getFrontEndFirmwareVersion(FRONT_LEFT);
+        int64_t febrfwversion = getFrontEndFirmwareVersion(FRONT_RIGHT);
+        LOG(logINFOBLUE,
+            ("\n********************************************************\n"
+             "Feb Versions\n"
+             "Hardware Version         : %s\n"
+             "Firmware (Febl) Version  : %lld\n"
+             "Firmware (Febr) Version  : %lld\n"
+             "********************************************************\n",
+             hversion, (long long int)feblfwversion,
+             (long long int)febrfwversion));

-    // ensure febl, febr and beb fw versions are the same
-    if (fwversion != feblfwversion || fwversion != febrfwversion) {
-        sprintf(initErrorMessage,
+        // ensure febl, febr and beb fw versions are the same
+        if (fwversion != feblfwversion || fwversion != febrfwversion) {
+            sprintf(
+                initErrorMessage,
                "Inconsistent firmware versions in feb and beb. [Beb: %lld, "
                "Febl: %lld Febr: %lld]\n",
                (long long int)fwversion, (long long int)feblfwversion,
                (long long int)febrfwversion);
-        LOG(logERROR, (initErrorMessage));
-        initError = FAIL;
-        return;
-    }
-    
+            LOG(logERROR, (initErrorMessage));
+            initError = FAIL;
+            return;
+        }
+
 #endif
        // also reads config file and deactivates
        setupDetector();
--- a/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
@ -256,7 +256,7 @@ void getServerVersion(char *version) { strcpy(version, APIGOTTHARD2); }

 u_int64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return REQRD_FRMWRE_VRSN;
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_COMPILATION_DATE_MSK) >>
            FPGA_COMPILATION_DATE_OFST);
--- a/slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
@ -275,7 +275,7 @@ void getServerVersion(char *version) { strcpy(version, APIGOTTHARD); }

 u_int64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return 1;
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_VERSION_MSK) >> FPGA_VERSION_OFST);
 }
--- a/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/jungfrauDetectorServer/slsDetectorFunctionList.c
@ -266,7 +266,7 @@ void getServerVersion(char *version) { strcpy(version, APIJUNGFRAU); }

 u_int64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return REQRD_FRMWRE_VRSN;
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_COMPILATION_DATE_MSK) >>
            FPGA_COMPILATION_DATE_OFST);
--- a/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
@ -270,7 +270,8 @@ void getServerVersion(char *version) { strcpy(version, APIMOENCH); }

 u_int64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return (isHardwareVersion_1_0() ? REQRD_FRMWRE_VRSN
+                                    : REQRD_FRMWRE_VRSN_BOARD2);
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_COMPILATION_DATE_MSK) >>
            FPGA_COMPILATION_DATE_OFST);
--- a/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
+++ b/slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
@ -250,7 +250,7 @@ void getServerVersion(char *version) { strcpy(version, APIMYTHEN3); }

 u_int64_t getFirmwareVersion() {
 #ifdef VIRTUAL
-    return 0;
+    return REQRD_FRMWRE_VRSN;
 #endif
    return ((bus_r(FPGA_VERSION_REG) & FPGA_COMPILATION_DATE_MSK) >>
            FPGA_COMPILATION_DATE_OFST);
--- a/slsDetectorSoftware/src/Detector.cpp
+++ b/slsDetectorSoftware/src/Detector.cpp
@ -1182,7 +1182,8 @@ Result<std::string> Detector::getRxHostname(Positions pos) const {
 }

 void Detector::setRxHostname(const std::string &receiver, Positions pos) {
-    pimpl->Parallel(&Module::setReceiverHostname, pos, receiver,
+    auto host = pimpl->verifyUniqueRxHost(receiver, pos);
+    pimpl->Parallel(&Module::setReceiverHostname, pos, host.first, host.second,
                    pimpl->getInitialChecks());
    updateRxRateCorrections();
 }
@ -1190,17 +1191,15 @@ void Detector::setRxHostname(const std::string &receiver, Positions pos) {
 void Detector::setRxHostname(const std::vector<std::string> &name) {
    // set all to same rx_hostname
    if (name.size() == 1) {
-        pimpl->Parallel(&Module::setReceiverHostname, {}, name[0],
-                        pimpl->getInitialChecks());
+        auto host = pimpl->verifyUniqueRxHost(name[0], {});
+        pimpl->Parallel(&Module::setReceiverHostname, {}, host.first,
+                        host.second, pimpl->getInitialChecks());
    } else {
-        if ((int)name.size() != size()) {
-            throw RuntimeError(
-                "Receiver hostnames size " + std::to_string(name.size()) +
-                " does not match detector size " + std::to_string(size()));
-        }
+        auto hosts = pimpl->verifyUniqueRxHost(name);
        // set each rx_hostname
        for (int idet = 0; idet < size(); ++idet) {
-            pimpl->Parallel(&Module::setReceiverHostname, {idet}, name[idet],
+            pimpl->Parallel(&Module::setReceiverHostname, {idet},
+                            hosts[idet].first, hosts[idet].second,
                            pimpl->getInitialChecks());
        }
    }
@ -1217,10 +1216,12 @@ void Detector::setRxPort(int port, int module_id) {
        for (auto &it : port_list) {
            it = port++;
        }
+        // no need to verify hostname-port combo as unique port(incremented)
        for (int idet = 0; idet < size(); ++idet) {
            pimpl->Parallel(&Module::setReceiverPort, {idet}, port_list[idet]);
        }
    } else {
+        pimpl->verifyUniqueRxHost(port, module_id);
        pimpl->Parallel(&Module::setReceiverPort, {module_id}, port);
    }
 }
@ -2460,10 +2461,12 @@ Result<int> Detector::getControlPort(Positions pos) const {
 }

 void Detector::setControlPort(int value, Positions pos) {
+    pimpl->verifyUniqueDetHost(value, pos);
    pimpl->Parallel(&Module::setControlPort, pos, value);
 }

 Result<int> Detector::getStopPort(Positions pos) const {
+    // not verifying unique stop port (control port is sufficient)
    return pimpl->Parallel(&Module::getStopPort, pos);
 }

--- a/slsDetectorSoftware/src/DetectorImpl.cpp
+++ b/slsDetectorSoftware/src/DetectorImpl.cpp
@ -279,31 +279,14 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
    }
 }

-void DetectorImpl::addModule(const std::string &hostname) {
-    LOG(logINFO) << "Adding module " << hostname;
-
-    int port = DEFAULT_TCP_CNTRL_PORTNO;
-    std::string host = hostname;
-    auto res = split(hostname, ':');
-    if (res.size() > 1) {
-        host = res[0];
-        port = StringTo<int>(res[1]);
-    }
-
-    if (host != "localhost") {
-        for (auto &module : modules) {
-            if (module->getHostname() == host) {
-                LOG(logWARNING)
-                    << "Module " << host << "already part of the Detector!"
-                    << std::endl
-                    << "Remove it before adding it back in a new position!";
-                return;
-            }
-        }
-    }
+void DetectorImpl::addModule(const std::string &name) {
+    LOG(logINFO) << "Adding module " << name;
+    auto host = verifyUniqueDetHost(name);
+    std::string hostname = host.first;
+    int port = host.second;

    // get type by connecting
-    detectorType type = Module::getTypeFromDetector(host, port);
+    detectorType type = Module::getTypeFromDetector(hostname, port);

    // gotthard cannot have more than 2 modules (50um=1, 25um=2
    if ((type == GOTTHARD || type == GOTTHARD2) && modules.size() > 2) {
@ -316,7 +299,7 @@ void DetectorImpl::addModule(const std::string &hostname) {
    shm()->totalNumberOfModules = modules.size();
    modules[pos]->setControlPort(port);
    modules[pos]->setStopPort(port + 1);
-    modules[pos]->setHostname(host, shm()->initialChecks);
+    modules[pos]->setHostname(hostname, shm()->initialChecks);

    // module type updated by now
    shm()->detType = Parallel(&Module::getDetectorType, {})
@ -1538,6 +1521,129 @@ defs::xy DetectorImpl::calculatePosition(int moduleIndex,
    return pos;
 }

+void DetectorImpl::verifyUniqueDetHost(const int port,
+                                       std::vector<int> positions) const {
+    // port for given positions
+    if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
+        positions.resize(modules.size());
+        std::iota(begin(positions), end(positions), 0);
+    }
+    std::vector<std::pair<std::string, int>> hosts(size());
+    for (auto it : positions) {
+        hosts[it].second = port;
+    }
+    verifyUniqueHost(true, hosts);
+}
+
+void DetectorImpl::verifyUniqueRxHost(const int port,
+                                      const int moduleId) const {
+    std::vector<std::pair<std::string, int>> hosts(size());
+    hosts[moduleId].second = port;
+    verifyUniqueHost(false, hosts);
+}
+
+std::pair<std::string, int>
+DetectorImpl::verifyUniqueDetHost(const std::string &name) {
+    // extract port
+    // C++17 could be auto [hostname, port] = ParseHostPort(name);
+    auto res = ParseHostPort(name);
+    std::string hostname = res.first;
+    int port = res.second;
+    if (port == 0) {
+        port = DEFAULT_TCP_CNTRL_PORTNO;
+    }
+
+    int detSize = size();
+    // mod not yet added
+    std::vector<std::pair<std::string, int>> hosts(detSize + 1);
+    hosts[detSize].first = hostname;
+    hosts[detSize].second = port;
+
+    verifyUniqueHost(true, hosts);
+    return std::make_pair(hostname, port);
+}
+
+std::pair<std::string, int>
+DetectorImpl::verifyUniqueRxHost(const std::string &name,
+                                 std::vector<int> positions) const {
+    // no checks if setting to none
+    if (name == "none" || name.empty()) {
+        return make_pair(name, 0);
+    }
+    // extract port
+    // C++17 could be auto [hostname, port] = ParseHostPort(name);
+    auto res = ParseHostPort(name);
+    std::string hostname = res.first;
+    int port = res.second;
+
+    // hostname and port for given positions
+    if (positions.empty() || (positions.size() == 1 && positions[0] == -1)) {
+        positions.resize(modules.size());
+        std::iota(begin(positions), end(positions), 0);
+    }
+
+    std::vector<std::pair<std::string, int>> hosts(size());
+    for (auto it : positions) {
+        hosts[it].first = hostname;
+        hosts[it].second = port;
+    }
+
+    verifyUniqueHost(false, hosts);
+    return std::make_pair(hostname, port);
+}
+
+std::vector<std::pair<std::string, int>>
+DetectorImpl::verifyUniqueRxHost(const std::vector<std::string> &names) const {
+    if ((int)names.size() != size()) {
+        throw RuntimeError(
+            "Receiver hostnames size " + std::to_string(names.size()) +
+            " does not match detector size " + std::to_string(size()));
+    }
+
+    // extract ports
+    std::vector<std::pair<std::string, int>> hosts;
+    for (const auto &name : names) {
+        hosts.push_back(ParseHostPort(name));
+    }
+
+    verifyUniqueHost(false, hosts);
+    return hosts;
+}
+
+void DetectorImpl::verifyUniqueHost(
+    bool isDet, std::vector<std::pair<std::string, int>> &hosts) const {
+
+    // fill from shm if not provided
+    for (int i = 0; i != size(); ++i) {
+        if (hosts[i].first.empty()) {
+            hosts[i].first = (isDet ? modules[i]->getHostname()
+                                    : modules[i]->getReceiverHostname());
+        }
+        if (hosts[i].second == 0) {
+            hosts[i].second = (isDet ? modules[i]->getControlPort()
+                                     : modules[i]->getReceiverPort());
+        }
+    }
+
+    // remove the ones without a hostname
+    hosts.erase(std::remove_if(hosts.begin(), hosts.end(),
+                               [](const std::pair<std::string, int> &x) {
+                                   return (x.first == "none" ||
+                                           x.first.empty());
+                               }),
+                hosts.end());
+
+    // must be unique
+    if (hasDuplicates(hosts)) {
+        throw RuntimeError(
+            "Cannot set due to duplicate hostname-port number pairs.");
+    }
+
+    for (auto it : hosts) {
+        LOG(logDEBUG) << it.first << " " << it.second << std::endl;
+    }
+}
+
 defs::ROI DetectorImpl::getRxROI() const {
    if (shm()->detType == CHIPTESTBOARD) {
        throw RuntimeError("RxRoi not implemented for this Detector");
--- a/slsDetectorSoftware/src/DetectorImpl.h
+++ b/slsDetectorSoftware/src/DetectorImpl.h
@ -300,6 +300,17 @@ class DetectorImpl : public virtual slsDetectorDefs {
                              Positions pos = {});
    void setDefaultDac(defs::dacIndex index, int defaultValue,
                       defs::detectorSettings sett, Positions pos);
+
+    void verifyUniqueDetHost(const int port, std::vector<int> positions) const;
+    void verifyUniqueRxHost(const int port, const int moduleId) const;
+
+    std::pair<std::string, int> verifyUniqueDetHost(const std::string &name);
+    std::pair<std::string, int>
+    verifyUniqueRxHost(const std::string &name,
+                       std::vector<int> positions) const;
+    std::vector<std::pair<std::string, int>>
+    verifyUniqueRxHost(const std::vector<std::string> &names) const;
+
    defs::ROI getRxROI() const;
    void setRxROI(const defs::ROI arg);
    void clearRxROI();
@ -396,6 +407,10 @@ class DetectorImpl : public virtual slsDetectorDefs {
    defs::xy getPortGeometry() const;
    defs::xy calculatePosition(int moduleIndex, defs::xy geometry) const;

+    void
+    verifyUniqueHost(bool isDet,
+                     std::vector<std::pair<std::string, int>> &hosts) const;
+
    const int detectorIndex{0};
    SharedMemory<sharedDetector> shm{0, -1};
    SharedMemory<CtbConfig> ctb_shm{0, -1, CtbConfig::shm_tag()};
--- a/slsDetectorSoftware/src/Module.cpp
+++ b/slsDetectorSoftware/src/Module.cpp
@ -73,8 +73,8 @@ void Module::setHostname(const std::string &hostname,
    auto client = DetectorSocket(shm()->hostname, shm()->controlPort);
    client.close();
    try {
-        initialDetectorServerChecks();
        checkDetectorVersionCompatibility();
+        initialDetectorServerChecks();
        LOG(logINFO) << "Module Version Compatibility - Success";
    } catch (const RuntimeError &e) {
        if (!initialChecks) {
@ -99,9 +99,28 @@ Module::getFrontEndFirmwareVersion(const fpgaPosition fpgaPosition) const {
 }

 std::string Module::getControlServerLongVersion() const {
-    char retval[MAX_STR_LENGTH]{};
-    sendToDetector(F_GET_SERVER_VERSION, nullptr, retval);
-    return retval;
+    try {
+        char retval[MAX_STR_LENGTH]{};
+        sendToDetector(F_GET_SERVER_VERSION, nullptr, retval);
+        return retval;
+    }
+    // throw with old server version (sends 8 bytes)
+    catch (RuntimeError &e) {
+        std::string emsg = std::string(e.what());
+        if (emsg.find(F_GET_SERVER_VERSION) && emsg.find("8 bytes")) {
+            throwDeprecatedServerVersion();
+        }
+        throw;
+    }
+}
+
+void Module::throwDeprecatedServerVersion() const {
+    uint64_t res = sendToDetectorStop<int64_t>(F_GET_SERVER_VERSION);
+    std::cout << std::endl;
+    std::ostringstream os;
+    os << "Detector Server (Control) version (0x" << std::hex << res
+       << ") is incompatible with this client. Please update detector server!";
+    throw RuntimeError(os.str());
 }

 std::string Module::getStopServerLongVersion() const {
@ -1310,30 +1329,33 @@ std::string Module::getReceiverHostname() const {
    return std::string(shm()->rxHostname);
 }

-void Module::setReceiverHostname(const std::string &receiverIP,
+void Module::setReceiverHostname(const std::string &hostname, const int port,
                                 const bool initialChecks) {
-    LOG(logDEBUG1) << "Setting up Receiver hostname with " << receiverIP;
+    {
+        std::ostringstream oss;
+        oss << "Setting up Receiver hostname with " << hostname;
+        if (port != 0) {
+            oss << " at port " << port;
+        }
+        LOG(logDEBUG1) << oss.str();
+    }

    if (getRunStatus() == RUNNING) {
        throw RuntimeError("Cannot set receiver hostname. Acquisition already "
                           "running. Stop it first.");
    }

-    if (receiverIP == "none") {
+    if (hostname == "none") {
        memset(shm()->rxHostname, 0, MAX_STR_LENGTH);
        strcpy_safe(shm()->rxHostname, "none");
        shm()->useReceiverFlag = false;
        return;
    }

-    // start updating
-    std::string host = receiverIP;
-    auto res = split(host, ':');
-    if (res.size() > 1) {
-        host = res[0];
-        shm()->rxTCPPort = std::stoi(res[1]);
+    strcpy_safe(shm()->rxHostname, hostname.c_str());
+    if (port != 0) {
+        shm()->rxTCPPort = port;
    }
-    strcpy_safe(shm()->rxHostname, host.c_str());
    shm()->useReceiverFlag = true;

    try {
--- a/slsDetectorSoftware/src/Module.h
+++ b/slsDetectorSoftware/src/Module.h
@ -93,6 +93,7 @@ class Module : public virtual slsDetectorDefs {
    int64_t getFrontEndFirmwareVersion(const fpgaPosition fpgaPosition) const;
    std::string getControlServerLongVersion() const;
    std::string getStopServerLongVersion() const;
+    void throwDeprecatedServerVersion() const;
    std::string getDetectorServerVersion() const;
    std::string getHardwareVersion() const;
    std::string getKernelVersion() const;
@ -280,7 +281,7 @@ class Module : public virtual slsDetectorDefs {
     * ************************************************/
    bool getUseReceiverFlag() const;
    std::string getReceiverHostname() const;
-    void setReceiverHostname(const std::string &receiver,
+    void setReceiverHostname(const std::string &hostname, const int port,
                             const bool initialChecks);
    int getReceiverPort() const;
    int setReceiverPort(int port_number);
--- a/slsReceiverSoftware/src/Arping.cpp
+++ b/slsReceiverSoftware/src/Arping.cpp
@ -5,9 +5,9 @@

 #include <chrono>
 #include <signal.h>
+#include <sys/wait.h>
 #include <thread>
 #include <unistd.h>
-#include<sys/wait.h>

 namespace sls {

@ -17,9 +17,7 @@ namespace sls {
 #define gettid() syscall(SYS_gettid)
 #endif

-void func(int signum) {
-    wait(NULL);
-}
+void func(int signum) { wait(NULL); }

 Arping::Arping() {}

@ -122,7 +120,8 @@ std::string Arping::ExecuteCommands() {
        FILE *sysFile = popen(cmd.c_str(), "r");
        if (sysFile == NULL) {
            std::ostringstream os;
-            os << "Could not Arping (" << cmd << " ) : Popen fail (" << strerror(errno) << ')';
+            os << "Could not Arping (" << cmd << " ) : Popen fail ("
+               << strerror(errno) << ')';
            return os.str();
        }

@ -134,7 +133,7 @@ std::string Arping::ExecuteCommands() {
        // check exit status of command
        if (pclose(sysFile)) {
            std::ostringstream os;
-            os << "Could not arping (" << cmd << ") : " <<  strerror(errno);
+            os << "Could not arping (" << cmd << ") : " << strerror(errno);
            return os.str();
        } else {
            LOG(logDEBUG) << output;
--- a/slsReceiverSoftware/src/MasterAttributes.cpp
+++ b/slsReceiverSoftware/src/MasterAttributes.cpp
@ -636,7 +636,7 @@ void MasterAttributes::GetMoenchBinaryAttributes(

 #ifdef HDF5C
 void MasterAttributes::WriteMoenchHDF5Attributes(H5::H5File *fd,
-                                                  H5::Group *group) {
+                                                 H5::Group *group) {
    MasterAttributes::WriteHDF5Exptime(fd, group);
    MasterAttributes::WriteHDF5Period(fd, group);
    MasterAttributes::WriteHDF5NumUDPInterfaces(fd, group);
--- a/slsSupportLib/include/sls/container_utils.h
+++ b/slsSupportLib/include/sls/container_utils.h
@ -10,6 +10,7 @@
 #include <string>
 #include <type_traits>
 #include <vector>
+// #include <utility> //support pair in vectors

 #include "sls/TypeTraits.h"

@ -148,6 +149,12 @@ Squash(const Container &c, typename Container::value_type default_value = {}) {
    return default_value;
 }

+template <typename Container> bool hasDuplicates(Container c) {
+    std::sort(c.begin(), c.end());
+    auto pos = std::adjacent_find(c.begin(), c.end());
+    return pos != c.end(); // if we found something there are duplicates
+}
+
 template <typename T>
 typename std::enable_if<is_container<T>::value, bool>::type
 removeDuplicates(T &c) {
--- a/slsSupportLib/include/sls/string_utils.h
+++ b/slsSupportLib/include/sls/string_utils.h
@ -5,6 +5,7 @@
 #include <cassert>
 #include <cstring>
 #include <string>
+#include <utility>
 #include <vector>

 namespace sls {
@ -59,4 +60,6 @@ bool is_int(const std::string &s);
 bool replace_first(std::string *s, const std::string &substr,
                   const std::string &repl);

+std::pair<std::string, int> ParseHostPort(const std::string &s);
+
 } // namespace sls
--- a/slsSupportLib/include/sls/versionAPI.h
+++ b/slsSupportLib/include/sls/versionAPI.h
@ -10,4 +10,4 @@
 #define APIMOENCH    "developer 0x230224"
 #define APILIB       "developer 0x230224"
 #define APIRECEIVER  "developer 0x230224"
-#define APIEIGER "developer 0x230224"
+#define APIEIGER     "developer 0x230224"
--- a/slsSupportLib/src/string_utils.cpp
+++ b/slsSupportLib/src/string_utils.cpp
@ -50,4 +50,17 @@ bool replace_first(std::string *s, const std::string &substr,
    return false;
 }

+std::pair<std::string, int> ParseHostPort(const std::string &s) {
+    // TODO deal with to many :, port not there?
+    // no port return hostname as is and port as 0
+    std::string host;
+    int port{0};
+    auto res = split(s, ':');
+    host = res[0];
+    if (res.size() > 1) {
+        port = std::stoi(res[1]);
+    }
+    return std::make_pair(host, port);
+}
+
 }; // namespace sls
--- a/slsSupportLib/tests/test-container_utils.cpp
+++ b/slsSupportLib/tests/test-container_utils.cpp
@ -136,6 +136,23 @@ TEST_CASE("compare a vector of arrays", "[support]") {
    CHECK(minusOneIfDifferent(vec1) == arr);
 }

+TEST_CASE("check if vector has duplicates") {
+    std::vector<int> vec{1, 0, 2, 5, 3, 1, 8, 6};
+    REQUIRE(hasDuplicates(vec) == true);
+}
+
+TEST_CASE("check for duplicates in vector of pairs") {
+    std::vector<std::pair<std::string, int>> vec;
+    vec.emplace_back("localhost", 1954);
+    REQUIRE(hasDuplicates(vec) == false);
+
+    vec.emplace_back("localhost", 1800);
+    REQUIRE(hasDuplicates(vec) == false);
+
+    vec.emplace_back("localhost", 1954);
+    REQUIRE(hasDuplicates(vec) == true);
+}
+
 TEST_CASE("remove duplicates from vector") {
    std::vector<int> v{5, 6, 5, 3};
    auto r = removeDuplicates(v);
--- a/slsSupportLib/tests/test-string_utils.cpp
+++ b/slsSupportLib/tests/test-string_utils.cpp
@ -108,6 +108,21 @@ TEST_CASE("replace --help") {
    REQUIRE(s == "list");
 }

+TEST_CASE("port host") {
+    std::string hostport = "localhost:1954";
+    auto res = ParseHostPort(hostport);
+    REQUIRE(res.first == "localhost");
+    REQUIRE(res.second == 1954);
+}
+
+TEST_CASE("port missing") {
+    // TODO! is this the intended result?
+    std::string host = "localhost";
+    auto res = ParseHostPort(host);
+    REQUIRE(res.first == "localhost");
+    REQUIRE(res.second == 0);
+}
+
 // TEST_CASE("concat things not being strings")

 } // namespace sls
Author	SHA1	Message	Date
Erik Frojdh	7d7a4e79d0	minor fixes	2023-03-31 09:40:03 +02:00
Erik Fröjdh	3b8c612103	Fixed build of the moenchZmqExecutables (#706 ) * changed to pure virtual methods for Clone and setClusterSize * added std:: * added moench to the github actions build	2023-03-29 15:01:22 +02:00
Erik Fröjdh	08c0c59a28	Added github actions for build and run unit tests (#705 )	2023-03-28 16:27:01 +02:00
Dhanya Thattil	7e01095684	Fix tests (#698 ) * fix firmwareversion to reqd version as fw version cannot be 0 for virtual	2023-03-28 15:22:36 +02:00
mozzanica	500442fd6b	modified ZMQonline display for stripsel usage. (#699 ) * modified ZMQonline display for stripsel usage. modified dataprocessor to overwrite header.detspec1 with ROI in case of ROI. * Removing changes to the slsReceiver, moved to branch jf_zeromq_display_rxroi	2023-03-22 14:25:02 +01:00
Dhanya Thattil	b67c6dea08	ensuring no duplicate rx hostname port combo (#604 ) * rx_hostname and port combo to one, or hostname to all, or a vector of hostnames and ports, ignoring none or empty, then verifying no duplicates for the host port combo including from shared memory * extracted function for rx_hostname (#694) * c++14 revert * unique hostname-port combo for port, hostname, rx_tcpport (#696) * verify unique combo for rx_port as well * check unique hostname-port combo also when setting control port, hostname, rx_hostname and rx_tcpport --------- Co-authored-by: Erik Fröjdh <erik.frojdh@gmail.com> Co-authored-by: Erik Frojdh <erik.frojdh@psi.ch>	2023-03-20 12:30:12 +01:00
Dhanya Thattil	c9215a6d9b	fix old server version in 64 bits (#697 ) * check server version before initial checks, catch old server version exception, get old server version as 64 bit and print it alon gwith exception	2023-03-20 10:31:27 +01:00
vhinger182	1bdf83e101	Resolve merge conflict in jungfrauExecutables	2023-03-17 16:43:08 +01:00
vhinger182	1bd813d620	Fix bug to allow larger clusters	2023-03-17 15:34:08 +01:00
vhinger182	943a85cbd5	Update data structures and eta functions for JF strixels	2023-03-17 15:33:01 +01:00
Dhanya Thattil	fc24558314	formatting	2023-03-17 14:42:11 +01:00