fixed CM corrections

* 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>

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
 
 
 

slsDetectorCalibration/analogDetector.h

@@ -866,7 +866,7 @@ template <class dataType> class analogDetector {
             for (ix = xmin; ix < xmax; ++ix) {
                 if (det->isGood(ix, iy)) {
                     // addToPedestal(data,ix,iy,1);
-                    addToPedestal(data, ix, iy, cm);
+                    addToPedestal(data, ix, iy, 0);
                     /* if (ix==50 && iy==50) */
                     /*   cout<< "*ped* " << id << " " << ix << " " << iy << " "
                      * << det->getChannel(data,ix,iy) << " " <<
@@ -1097,6 +1097,8 @@ template <class dataType> class analogDetector {
         return thr;
     };
 
+    virtual int setClusterSize(int n = -1) { return 0;     };
+
     /**
        gets threshold value for conversion into number of photons
        \returns threshold value

slsDetectorCalibration/commonModeSubtractionNew.h

@@ -100,7 +100,10 @@ class commonModeSubtraction {
         if (iroi >= 0 && iroi < nROI) {
             if (nCm[iroi] > 0)
                 return mean[iroi] / nCm[iroi];
-        }
+	    else
+	      std::cout << ix << " " << iy << " no data in cm " << iroi << std::endl; 
+        } else
+	  std::cout << ix << " " << iy << " bad roi " << iroi << std::endl; 
         return 0;
     };
 
@@ -117,6 +120,8 @@ class commonModeSubtraction {
                 return sqrt(mean2[iroi] / nCm[iroi] -
                             (mean[iroi] / nCm[iroi]) *
                                 (mean[iroi] / nCm[iroi]));
+	    else
+	      std::cout << ix << " " << iy << " no data in cm " << iroi << std::endl; 
         }
         return 0;
     };

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
@@ -53,6 +61,9 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
         : slsDetectorData<uint16_t>(1024/5, 512*5,
                                     512 * 1024 * 2 + sizeof(header)) {
       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
@@ -61,44 +72,51 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
 #endif
             }
         }
-	int x0=256+10, x1=256+246;
-	int y0=10, y1=256-10;
+
+	//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;
-	cout << "G0" << endl;
-
-	//chip1
-
 	for (int ipx=x0; ipx<x1; ipx++) {
-	  for (int ipy=y0; ipy<y0+54; ipy++) {
+	  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
 	    ix=(ipx-x0+ox)/3;
 	    iy=(ipx-x0+ox)%3+(ipy-y0+oy)*3+ooy;
 	    dataMap[iy][ix] = sizeof(header) + (1024 * ipy + ipx) * 2;
-	    
-	    //  cout << ipx << " " << ipy << " " << ix << " " << iy << endl;
-
-
+	     //  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;
 	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;
 	  }
 	}
 	
-	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;
@@ -106,43 +124,50 @@ class jungfrauLGADStrixelsData : public slsDetectorData<uint16_t> {
 	}
 	
 	//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;
 	  }
 	}
-	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;
 	  }
 	}
 	
-	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;
@@ -206,7 +231,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 +248,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 +298,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 */

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

slsDetectorCalibration/dataStructures/jungfrauModuleData.h

@@ -3,6 +3,7 @@
 #ifndef JUNGFRAUMODULEDATA_H
 #define JUNGFRAUMODULEDATA_H
 #include "slsDetectorData.h"
+#include "sls/sls_detector_defs.h"
 
 //#define VERSION_V2
 /**
@@ -41,8 +42,15 @@ class jungfrauModuleData : public slsDetectorData<uint16_t> {
        1286 large etc.) \param c crosstalk parameter for the output buffer
 
    */
+   
+#ifdef ALDO //VH
+    using header = jf_header; //VH
+#else //VH
+    using header = sls::defs::sls_receiver_header;
+#endif //VH
+
 #ifndef ZMQ
-#define off sizeof(jf_header)
+#define off sizeof(header)
 #endif
 #ifdef ZMQ
 #define off 0
@@ -102,9 +110,13 @@ class jungfrauModuleData : public slsDetectorData<uint16_t> {
     /* 	unsigned char frameNumber[3]; */
     /* 	unsigned char bunchid[8]; */
     /* }; */
-
+    
     int getFrameNumber(char *buff) {
-        return ((jf_header *)buff)->bunchNumber;
+    #ifdef ALDO
+    return ((header *)buff)->bunchNumber; 
+    #else 
+    return ((header *)buff)->detHeader.frameNumber;
+    #endif 
     };
   
     /**

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

slsDetectorCalibration/dataStructures/slsDetectorData.h

@@ -217,6 +217,7 @@ void slsDetectorData<dataType>::setDataMap(int **dMap) {
             }
         }
     }
+    /* //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 (iy = 0; iy < ny; iy++) {
         for (ix = 0; ix < nx; ix++) {
             ip = dataMap[iy][ix] / sizeof(dataType);
@@ -224,7 +225,7 @@ void slsDetectorData<dataType>::setDataMap(int **dMap) {
             ymap[ip] = iy;
         }
     }
-
+     */
     // cout << "nx:" <<nx << " ny:" << ny << endl;
 }
 

slsDetectorCalibration/interpolations/slsInterpolation.h

@@ -22,11 +22,13 @@ enum quadrant {
 
 #include <iostream>
 #include <stdio.h>
-using namespace std;
+//using namespace std;
 
 //#ifdef MYROOT1
 //: public TObject
 //#endif
+using namespace std;
+
 class slsInterpolation {
 
   public:
@@ -128,7 +130,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 +325,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 +474,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 +528,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; */

slsDetectorCalibration/jungfrauCommonMode.h

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#ifndef COMMONMODEJF_H
+#define COMMONMODEJF_H
+
+#include "commonModeSubtractionNew.h"
+
+class commonModeSubtractionSuperColumnJF : public commonModeSubtraction {
+  public:
+    commonModeSubtractionSuperColumnJF()
+        : commonModeSubtraction(32){};
+    virtual int getROI(int ix, int iy) { int top=iy/256; int sc=ix/64; return sc+top*16; };
+/*
+    virtual void addToCommonMode(double val, int ix = 0, int iy = 0) {
+            int iroi = getROI(ix, iy);
+            // cout << iy << " " << ix << " " << iroi ;
+            if (iroi >= 0 && iroi < nROI) {
+                mean[iroi] += val;
+                mean2[iroi] += val * val;
+                nCm[iroi]++;
+                if (nCm[iroi] > 64*256)
+                    std::cout << "Too many pixels added " << nCm[iroi] << std::endl;
+           
+        }
+    };
+*/
+    virtual commonModeSubtractionSuperColumnJF *Clone() {
+        return new commonModeSubtractionSuperColumnJF();
+    };
+};
+
+
+class commonModeSubtractionChip : public commonModeSubtraction {
+  public:
+    commonModeSubtractionChip()
+        : commonModeSubtraction(8){};
+    virtual int getROI(int ix, int iy) { int top=iy/256; int sc=ix/256; return sc+top*4; };
+/*
+    virtual void addToCommonMode(double val, int ix = 0, int iy = 0) {
+            int iroi = getROI(ix, iy);
+            // cout << iy << " " << ix << " " << iroi ;
+            if (iroi >= 0 && iroi < nROI) {
+                mean[iroi] += val;
+                mean2[iroi] += val * val;
+                nCm[iroi]++;
+                if (nCm[iroi] > 64*256)
+                    std::cout << "Too many pixels added " << nCm[iroi] << std::endl;
+           
+        }
+    };
+*/
+    virtual commonModeSubtractionChip *Clone() {
+        return new commonModeSubtractionChip();
+    };
+};
+
+
+#endif

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

slsDetectorCalibration/jungfrauExecutables/jungfrauRawDataProcess.cpp

@@ -2,16 +2,19 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 //#include "sls/ansi.h"
 #include <iostream>
-#undef CORR
 
+//enable common mode subtraction
+#define CMS
+//disable common mode subtraction
+//#undef CMS
+#undef CORR
 #define C_GHOST 0.0004
 
 #define CM_ROWS 50
 
 #define RAWDATA
 
-#ifndef JFSTRX
-#ifndef JFSTRXOLD
+#if !defined JFSTRX && !defined JFSTRXOLD && !defined JFSTRXCHIP1 && !defined JFSTRXCHIP6
 #ifndef MODULE
 #include "jungfrauHighZSingleChipData.h"
 #endif
@@ -19,10 +22,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
@@ -34,15 +40,17 @@
 #include <map>
 #include <stdio.h>
 #include <sys/stat.h>
+//#include "commonModeSubtractionNew.h"
+#include "jungfrauCommonMode.h"
 
 #include <ctime>
 using namespace std;
 
 int main(int argc, char *argv[]) {
 
-    if (argc < 5) {
+    if (argc < 6) {
         cout << "Usage is " << argv[0]
-             << "indir outdir fname(no extension) fextension [runmin] [runmax] [pedfile (raw or tiff)] [threshold] "
+             << " indir outdir fname(no extension) fextension csize [runmin] [runmax] [pedfile (raw or tiff)] [threshold]"
                 "[nframes] [xmin xmax ymin ymax] [gainmap]"
              << endl;
         cout << "threshold <0 means analog; threshold=0 means cluster finder; "
@@ -51,58 +59,58 @@ int main(int argc, char *argv[]) {
         cout << "nframes <0 means sum everything; nframes=0 means one file per "
                 "run; nframes>0 means one file every nframes"
              << endl;
+
         return 1;
     }
 
     int fifosize = 1000;
-    int nthreads = 10;
-    int csize = 3;
+    int nthreads = 1;
+    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
+    cout << "This is a JF single chip!" <<endl;
     jungfrauHighZSingleChipData *decoder = new jungfrauHighZSingleChipData();
     int nx = 256, ny = 256;
 #endif
 #ifdef MODULE
+    cout << "This is a JF module!" <<endl;
     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
 
 
     decoder->getDetectorSize(nx, ny);
-
-
-
-
-
+    
     cout << "Detector size is " << nx << " " << ny << endl;
 
-
-
-
-
-
-
-
     double *gainmap = NULL;
     //float *gm;
 
@@ -114,47 +122,48 @@ int main(int argc, char *argv[]) {
     char *outdir = argv[2];
     char *fformat = argv[3];
     char *fext = argv[4];
+    sscanf(argv[5], "%d", &csize);
     int runmin = 0;
 
     // cout << "argc is " << argc << endl;
-    if (argc >= 6) {
-        runmin = atoi(argv[5]);
+    if (argc >= 7) {
+        runmin = atoi(argv[6]);
     }
 
     int runmax = runmin;
 
-    if (argc >= 7) {
-        runmax = atoi(argv[6]);
+    if (argc >= 8) {
+        runmax = atoi(argv[7]);
     }
 
     char *pedfile = NULL;
-    if (argc >= 8) {
-        pedfile = argv[7];
+    if (argc >= 9) {
+        pedfile = argv[8];
     }
     double thr = 0;
     double thr1 = 1;
 
-    if (argc >= 9) {
-        thr = atof(argv[8]);
+    if (argc >= 10) {
+        thr = atof(argv[9]);
     }
 
     int nframes = 0;
 
-    if (argc >= 10) {
-        nframes = atoi(argv[9]);
+    if (argc >= 11) {
+        nframes = atoi(argv[10]);
     }
 
     int xmin = 0, xmax = nx, ymin = 0, ymax = ny;
-    if (argc >= 14) {
-        xmin = atoi(argv[10]);
-        xmax = atoi(argv[11]);
-        ymin = atoi(argv[12]);
-        ymax = atoi(argv[13]);
+    if (argc >= 15) {
+        xmin = atoi(argv[11]);
+        xmax = atoi(argv[12]);
+        ymin = atoi(argv[13]);
+        ymax = atoi(argv[14]);
     }
 
     char *gainfname = NULL;
-    if (argc > 14) {
-        gainfname = argv[14];
+    if (argc > 15) {
+        gainfname = argv[15];
         cout << "Gain map file name is: " << gainfname << endl;
     }
 
@@ -178,9 +187,13 @@ int main(int argc, char *argv[]) {
     cout << "Nframes is " << nframes << endl;
 
     uint32_t nnx, nny;
-
+    commonModeSubtraction *cm = NULL;
+#ifdef CMS
+    cm = new commonModeSubtractionChip();//commonModeSubtraction(1,5);//commonModeSubtractionSuperColumnJF();
+    std::cout << "Enabled common mode subtraction" << std::endl;
+#endif
     singlePhotonDetector *filter = new singlePhotonDetector(
-        decoder, csize, nsigma, 1, NULL, nped, 200, -1, -1, gainmap, NULL);
+        decoder, 3, nsigma, 1, cm, nped, 200, -1, -1, gainmap, NULL);
 
     if (gainfname) {
 
@@ -211,6 +224,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;
@@ -238,13 +253,14 @@ int main(int argc, char *argv[]) {
     double *ped=new double[nx * ny];//, *ped1;
 
     int pos,pos1;
+    int ipixX=351, ipixY=331;
 
     if (pedfile) {
 
-      if (string(pedfile).find(".dat") != std::string::npos) {
+      if (string(pedfile).find(".raw") != std::string::npos) {
 	pos1=string(pedfile).rfind("/");
 	strcpy(froot,pedfile+pos1);
-	pos=string(froot).find(".dat");
+	pos=string(froot).find(".raw");
 	froot[pos]='\0';
       }
 
@@ -265,19 +281,43 @@ int main(int argc, char *argv[]) {
                 ff = -1;
                 while (decoder->readNextFrame(filebin, ff, np, buff)) {
 		  // if (np == 40) {
-		  if ((ifr+1) % 100 == 0) {
-		    cout << " ****" << decoder->getValue(buff,20,20);// << endl;
-		  }
+		  // if ((ifr+1) % 100 == 0) {
+		  //   cout << " ****" << decoder->getValue(buff,20,20);// << endl;
+		  // }
                         mt->pushData(buff);
+
+
+			// while (mt->isBusy()) 
+			//   ;
+			//if ((ifr+1) % 100 == 0)
+
+			// double pix=0,ped=0,sub=0,cmp=0, sub0=0;
+
+			// for (int ix=-1; ix<2; ix++) {
+			//   for (int iy=-1; iy<2; iy++) {
+			//     pix+=decoder->getValue(buff, ipixX+ix, ipixY+iy);
+			//     sub+=filter->subtractPedestal(buff, ipixX+ix, ipixY+iy, 1);
+			//     sub0+=filter->subtractPedestal(buff, ipixX+ix, ipixY+iy, 0);
+			//     ped+=filter->getPedestal(ipixX+ix, ipixY+iy);
+			//     cmp+=filter->getCommonMode(ipixX+ix, ipixY+iy);
+			//   }
+			// }
+
+			// cout << pix << " " << sub << " " sub0 << " " << ped << " " << cmp  << endl;
+
+
                         mt->nextThread();
                         mt->popFree(buff);
                         ifr++;
-                        if (ifr % 100 == 0) {
-			  cout << " ****" << ifr << " " << ff << " " << np << endl;
-			} //else
+                        // if (ifr % 100 == 0) {
+			//   cout << " ****" << ifr << " " << ff << " " << np << endl;
+			// } 
+
+			//else
                         //cout << ifr << " " << ff << " " << np << endl;
-			if (ifr>=1000)
-			  break;
+			// if (ifr>=1000)
+			//   break;
+			
                     ff = -1;
                 }
                 filebin.close();
@@ -358,7 +398,25 @@ int main(int argc, char *argv[]) {
 		  if ((ifr+1) % 100 == 0) {
 		    cout << " ****" << decoder->getValue(buff,20,20);// << endl;
 		  }
-                    mt->pushData(buff);
+                    mt->pushData(buff);	
+
+
+		    // while (mt->isBusy()) 
+
+			// double pix=0,ped=0,sub=0,cmp=0, sub0=0;
+
+			// for (int ix=-1; ix<2; ix++) {
+			//   for (int iy=-1; iy<2; iy++) {
+			//     pix+=decoder->getValue(buff, ipixX+ix, ipixY+iy);
+			//     sub+=filter->subtractPedestal(buff, ipixX+ix, ipixY+iy, 1);
+			//     sub0+=filter->subtractPedestal(buff, ipixX+ix, ipixY+iy, 0);
+			//     ped+=filter->getPedestal(ipixX+ix, ipixY+iy);
+			//     cmp+=filter->getCommonMode(ipixX+ix, ipixY+iy);
+			//   }
+			// }
+
+			// cout << pix << " " << sub << " " sub0 << " " << ped << " " << cmp  << endl;
+
                     // 	//         //pop
                     mt->nextThread();
                     mt->popFree(buff);

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);
     };

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

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;
@@ -395,14 +396,14 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
             return 0;
         }
         newFrame(data);
-
+	/*
         if (cmSub) {
             addToCommonMode(data);
             cm = 1;
         }
-
+	*/
         double *val = new double[ny * nx];
-
+	cm=0;
         for (iy = ymin; iy < ymax; ++iy) {
             for (ix = xmin; ix < xmax; ++ix) {
                 if (det->isGood(ix, iy) == 0)
@@ -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;
@@ -545,12 +547,50 @@ class singlePhotonDetector : public analogDetector<uint16_t> {
 
                 } else if (ee == PEDESTAL) {
                     addToPedestal(data, ix, iy, cm);
+		    if (cmSub) {
+		      addToCommonMode(data, ix, iy);
+		    }
                 } /*else {
                     eventMask[iy][ix]=PHOTON;
                     }*/
                   // eventMask[iy][ix]=ee;
             }
         }
+	
+	if (cmSub) {
+	  
+	  double cmv=0;
+	  for (int iph=0; iph<nph; iph++) {
+	    ix=(clusters + iph)->x ;
+	    iy=(clusters + nph)->y;
+	    
+	    for (ir = -(clusterSizeY / 2); ir < (clusterSizeY / 2) + 1;
+		 ir++) {
+	      for (ic = -(clusterSize / 2);
+		   ic < (clusterSize / 2) + 1; ic++) {
+		if ((iy + ir) >= 0 && (iy + ir) < ny &&
+		    (ix + ic) >= 0 && (ix + ic) < nx) {
+		  
+		  cmv=getCommonMode(ix+ic, iy+ir);
+		  //if (ir==0 && ic==0)
+		    //cout << cmv << endl;
+		  (clusters + iph)
+		    ->set_data((clusters + iph)
+		    ->get_data(ic,ir)-cmv, ic,ir);
+		}
+		
+	      }
+	      
+	    }
+	    
+	  }
+	  
+	  
+	}
+	
+
+	
+
 
         nphFrame = nph;
         nphTot += nph;

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

slsDetectorCalibration/tiffio/src/tiffIO.cpp

@@ -3,7 +3,8 @@
 
 #include "sls/tiffIO.h"
 #include <iostream>
-#include <tiffio.h>
+#include "/usr/include/tiffio.h"
+//#include <tiffio.h>
 
 void *WriteToTiff(float *imgData, const char *imgname, int ncol, int nrow) {
     constexpr uint32_t sampleperpixel = 1;

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;

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();

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);
 }
 

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");

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()};

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 {

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);

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;

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);

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) {

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

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"

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

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);

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