dont add detector id for .trim

* Modified Jungfrau speed settings for HW1.0 - FW fix version 1.1.1, compilation date 210218

* Corrected bug. DBIT clk phase is implemented in both HW version 1.0 and 2.0. Previous version did not update the DBIT phase shift on the configuration of a speed.

The new server has been compiled

Co-authored-by: lopez_c <carlos.lopez-cuenca@psi.ch>

CMakeLists.txt

@@ -167,7 +167,7 @@ if (NOT TARGET libzmq)
             HINTS ${ZeroMQ_DIR}
         )
     else()
-        find_package(ZeroMQ 4)
+        find_package(ZeroMQ 4 QUIET)
     endif()
     
 

RELEASE.txt

@@ -1,7 +1,7 @@
-SLS Detector Package 5.1.0 released on 22.03.2020 (Minor Release)
+SLS Detector Package 5.X.X released on XX.XX.2021 (Minor Release)
 ===================================================================
 
-This document describes the differences between 5.1.0 and 5.0.1 releases.   
+This document describes the differences between X and Y releases.   
 
 
 
@@ -19,69 +19,21 @@ This document describes the differences between 5.1.0 and 5.0.1 releases.
 1. New Features
 ===============
 
-    Client
-    ------
+    Setting Mythen3 gain from command line
 
-    1. Added settings and threshold features for Mythen3.
-    2. Internal modification of acquire for Mythen3.
-    3. Added getMaster for Mythen3
-    4. Mythen3, API function to set pattern from memory
-
-
-    Mythen3 server
-    -----------------
-
-    1. Setting timing to auto, sets timing to trigger for slaves
+4. Firmware Requirements
+========================
     
 
-2. Resolved Issues
-==================
 
-
-    Receiver
-    --------
-
-    1.  Current code only calls Implementation::setDetectorType from constructor, 
-	    but potential memory leak if called out of constructor context. Fixed.
-
-
-    Client
-    ------
-
-    1.  Fixed missing scanParameters class in Python 
-
-    2.  cmk.sh refactored to have better option handling
-
-    3.  Fixed hardcoded path accidentally ending up in the exported CMake package
-
-    Server
-    --------
-
-    1.  Bottom port not mirrored correctly for Eiger quad
-
-
-
-
-
-3. Firmware Requirements
-========================
-        
-    Mythen3: 0x210201
-    Jungfrau: 0x210218 (1.0 pcb)
-              0x200721 (2.0 pcb, not changed)
-
-    Other detectors no updates from 5.0.0
-
-
-
-4. Known Issues
+5. Known Issues
 ===============
 
     No updates from 5.0.0
 
 
 
-5. Download, Documentation & Support
+6. Download, Documentation & Support
 ====================================
 
     Download

python/scripts/compile_servers.py

@@ -49,13 +49,13 @@ args = parser.parse_args()
 
 
 servers = [
-     "eigerDetectorServer",
-     "jungfrauDetectorServer",
+#     "eigerDetectorServer",
+#     "jungfrauDetectorServer",
       "mythen3DetectorServer",
-     "gotthard2DetectorServer",
-     "gotthardDetectorServer",
-     "ctbDetectorServer",
-     "moenchDetectorServer",
+#     "gotthard2DetectorServer",
+#     "gotthardDetectorServer",
+#     "ctbDetectorServer",
+#     "moenchDetectorServer",
 ]
 
 

python/scripts/generate_enums.py

@@ -11,6 +11,8 @@ import subprocess
 
 from parse import remove_comments
 
+allow_bitwise_op = ["M3_GainCaps"]
+
 def single_line_enum(line):
     sub = line[line.find('{')+1:line.find('}')]
     return sub.strip().split(',')
@@ -49,7 +51,11 @@ def extract_enums(lines):
 def generate_enum_string(enums):
     data = []
     for key, value in enums.items():
-        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}")\n')
+        if key in allow_bitwise_op:
+            tag=", py::arithmetic()"
+        else:
+            tag=""
+        data.append(f'py::enum_<slsDetectorDefs::{key}>(Defs, "{key}"{tag})\n')
         for v in value:
             data.append(f'\t.value("{v}", slsDetectorDefs::{key}::{v})\n')
         data.append('.export_values();\n\n')

python/slsdet/enums.py

@@ -14,4 +14,5 @@ clockIndex = _slsdet.slsDetectorDefs.clockIndex
 readoutMode = _slsdet.slsDetectorDefs.readoutMode
 masterFlags = _slsdet.slsDetectorDefs.masterFlags
 burstMode = _slsdet.slsDetectorDefs.burstMode
-timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+timingSourceType = _slsdet.slsDetectorDefs.timingSourceType
+M3_GainCaps = _slsdet.slsDetectorDefs.M3_GainCaps

python/src/detector.cpp

@@ -1136,6 +1136,16 @@ void init_det(py::module &m) {
              (Result<bool>(Detector::*)(sls::Positions) const) &
                  Detector::getMaster,
              py::arg() = Positions{})
+        .def("getChipStatusRegister",
+             (Result<int>(Detector::*)(sls::Positions) const) &
+                 Detector::getChipStatusRegister,
+             py::arg() = Positions{})
+        .def("setGainCaps",
+             (void (Detector::*)(int, sls::Positions)) & Detector::setGainCaps,
+             py::arg(), py::arg() = Positions{})
+        .def("getGainCaps",
+             (Result<int>(Detector::*)(sls::Positions)) & Detector::getGainCaps,
+             py::arg() = Positions{})
         .def("getNumberOfAnalogSamples",
              (Result<int>(Detector::*)(sls::Positions) const) &
                  Detector::getNumberOfAnalogSamples,

python/src/enums.cpp

@@ -277,4 +277,14 @@ void init_enums(py::module &m) {
         .value("TIMING_EXTERNAL",
                slsDetectorDefs::timingSourceType::TIMING_EXTERNAL)
         .export_values();
+
+    py::enum_<slsDetectorDefs::M3_GainCaps>(Defs, "M3_GainCaps",
+                                            py::arithmetic())
+        .value("M3_C10pre", slsDetectorDefs::M3_GainCaps::M3_C10pre)
+        .value("M3_C15sh", slsDetectorDefs::M3_GainCaps::M3_C15sh)
+        .value("M3_C30sh", slsDetectorDefs::M3_GainCaps::M3_C30sh)
+        .value("M3_C50sh", slsDetectorDefs::M3_GainCaps::M3_C50sh)
+        .value("M3_C225ACsh", slsDetectorDefs::M3_GainCaps::M3_C225ACsh)
+        .value("M3_C15pre", slsDetectorDefs::M3_GainCaps::M3_C15pre)
+        .export_values();
 }

slsDetectorCalibration/circularFifo.h

@@ -0,0 +1,156 @@
+#pragma once
+/* CircularFifo.h 
+* Code & platform dependent issues with it was originally
+* published at http://www.kjellkod.cc/threadsafecircularqueue
+* 2009-11-02
+* @author Kjell Hedstr<74>m, hedstrom@kjellkod.cc
+* modified by the sls detetor group
+* */
+
+//#include "sls_receiver_defs.h"
+#include <semaphore.h>
+#include <vector>
+#include <iostream>
+
+typedef  double double32_t;
+typedef  float float32_t;
+typedef  int int32_t;
+
+
+
+/** Circular Fifo (a.k.a. Circular Buffer)
+* Thread safe for one reader, and one writer */
+template<typename Element>
+class CircularFifo {
+public:
+
+   CircularFifo(unsigned int Size) : tail(0), head(0){
+	   Capacity = Size + 1;
+	   array.resize(Capacity);
+	   sem_init(&data_mutex,0,0);
+	   sem_init(&free_mutex,0,Size);
+   }
+   virtual ~CircularFifo() {
+       sem_destroy(&data_mutex);
+	   sem_destroy(&free_mutex);
+   }
+
+   bool push(Element*& item_, bool no_block=false);
+   bool pop(Element*& item_, bool no_block=false);
+
+   bool isEmpty() const;
+   bool isFull() const;
+
+   int getDataValue() const;
+   int getFreeValue() const;
+
+private:
+   std::vector <Element*> array;
+   unsigned int tail; // input index
+   unsigned int head; // output index
+   unsigned int Capacity;
+   mutable sem_t data_mutex;
+   mutable sem_t free_mutex;
+   unsigned int increment(unsigned int idx_) const;
+};
+
+template<typename Element>
+int CircularFifo<Element>::getDataValue() const
+{
+   int value;
+   sem_getvalue(&data_mutex, &value);
+   return value;
+}
+
+template<typename Element>
+int CircularFifo<Element>::getFreeValue() const
+{
+    int value;
+    sem_getvalue(&free_mutex, &value);
+    return value;
+}
+
+
+/** Producer only: Adds item to the circular queue.
+* If queue is full at 'push' operation no update/overwrite
+* will happen, it is up to the caller to handle this case
+*
+* \param item_ copy by reference the input item
+* \param no_block if true, return immediately if fifo is full
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::push(Element*& item_, bool no_block)
+{
+    // check for fifo full
+    if (no_block && isFull())
+        return false;
+
+    sem_wait(&free_mutex);
+    array[tail] = item_;
+    tail = increment(tail);
+    sem_post(&data_mutex);
+    return true;
+}
+
+/** Consumer only: Removes and returns item from the queue
+* If queue is empty at 'pop' operation no retrieve will happen
+* It is up to the caller to handle this case
+*
+* \param item_ return by reference the wanted item
+* \param no_block if true, return immediately if fifo is full
+* \return whether operation was successful or not */
+template<typename Element>
+bool CircularFifo<Element>::pop(Element*& item_, bool no_block)
+{
+    // check for fifo empty
+    if (no_block && isEmpty())
+        return false;
+
+   sem_wait(&data_mutex);
+   item_ = array[head];
+   head = increment(head);
+   sem_post(&free_mutex);
+   return true;
+}
+
+/** Useful for testinng and Consumer check of status
+  * Remember that the 'empty' status can change quickly
+  * as the Procuder adds more items.
+  *
+  * \return true if circular buffer is empty */
+template<typename Element>
+bool CircularFifo<Element>::isEmpty() const
+{
+    return (getDataValue() == 0);
+}
+
+/** Useful for testing and Producer check of status
+  * Remember that the 'full' status can change quickly
+  * as the Consumer catches up.
+  *
+  * \return true if circular buffer is full.  */
+template<typename Element>
+bool CircularFifo<Element>::isFull() const
+{
+    return (getFreeValue() == 0);
+}
+
+/** Increment helper function for index of the circular queue
+* index is inremented or wrapped
+*
+*  \param idx_ the index to the incremented/wrapped
+*  \return new value for the index */
+template<typename Element>
+unsigned int CircularFifo<Element>::increment(unsigned int idx_) const
+{
+   // increment or wrap
+   // =================
+   //    index++;
+   //    if(index == array.lenght) -> index = 0;
+   //
+   //or as written below:
+   //    index = (index+1) % array.length
+   idx_ = (idx_+1) % Capacity;
+   return idx_;
+}
+

slsDetectorCalibration/dataStructures/jungfrauHighZSingleChipData.h

@@ -0,0 +1,238 @@
+#ifndef JUNGFRAUHIGHZSINGLECHIPDATA_H
+#define  JUNGFRAUHIGHZSINGLECHIPDATA_H
+#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
+    */
+    typedef struct {
+        uint64_t bunchNumber;    /**< is the frame number */
+        uint64_t pre;    /**< something */
+
+    } jf_header;
+
+
+
+
+class jungfrauHighZSingleChipData : public slsDetectorData<uint16_t> {
+ 
+ private:
+  
+  int iframe;
+ 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
+
+  */
+ jungfrauHighZSingleChipData(): slsDetectorData<uint16_t>(256, 256, 256*256*2+sizeof(jf_header)) {
+
+
+     for (int ix=0; ix<256; ix++) {
+       for (int iy=0; iy<256; iy++) {
+	 dataMap[iy][ix]=sizeof(jf_header)+(256*iy+ix)*2;
+#ifdef HIGHZ
+	 dataMask[iy][ix]=0x3fff;
+#endif
+	 }
+     }
+    
+    iframe=0;
+    //  cout << "data struct created" << 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){return ((jf_header*)buff)->bunchNumber;};//*((int*)(buff+5))&0xffffff;};   
+
+  /**
+
+     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){return 0;}//((*(((int*)(buff+4))))&0xff)+1;};   
+
+/*    /\** */
+
+/*      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){ndata=dsize; setDataSize(dsize);  return data;}; */
+
+
+/*    /\** */
+
+/*      Loops over a file stream until a complete frame is found (i.e. all packets 0 to nPackets, same frame number). Can be overloaded for different kind of detectors!  */
+/*      \param filebin input file stream (binary) */
+/*      \returns pointer to the begin of the last good frame, NULL if no frame is found or last frame is incomplete */
+
+/*   *\/ */
+/*     virtual char *readNextFrame(ifstream &filebin){ */
+/*       //	int afifo_length=0;   */
+/*       uint16_t *afifo_cont;  */
+/*       int ib=0; */
+/*       if (filebin.is_open()) { */
+/* 	afifo_cont=new uint16_t[dataSize/2]; */
+/*  	while (filebin.read(((char*)afifo_cont)+ib,2)) { */
+/* 	  ib+=2; */
+/* 	  if (ib==dataSize) break; */
+/* 	} */
+/* 	if (ib>0) { */
+/* 	  iframe++; */
+/* 	  // cout << ib << "-" << endl; */
+/* 	  return (char*)afifo_cont; */
+/* 	} else { */
+/* 	  delete [] afifo_cont; */
+/* 	  return NULL; */
+/* 	} */
+/*       }      */
+/*       return NULL; */
+/*     }; */
+
+
+  virtual char *readNextFrame(ifstream &filebin) {
+    int ff=-1, np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(ifstream &filebin, int &ff) {
+    int np=-1;
+    return readNextFrame(filebin, ff, np);
+  };
+
+  virtual char *readNextFrame(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;
+  }
+
+
+
+
+  virtual char *readNextFrame(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/moench03T1ZmqDataNew.h

@@ -14,6 +14,8 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
   const int nSamples;
   const int offset;
 
+
+
   double ghost[200][25];
   double xtalk;
 
@@ -29,17 +31,22 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 
   */
   // moench03T1ZmqDataNew(int ns=5000): slsDetectorData<uint16_t>(400, 400, ns*32*2+sizeof(int)), nSamples(ns), offset(sizeof(int)), xtalk(0.00021) {
- moench03T1ZmqDataNew(int ns=5000, int oo=0): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
-
+ moench03T1ZmqDataNew(int ns=5000, int oo=2*2): slsDetectorData<uint16_t>(400, 400, ns*32*2+oo), nSamples(ns), offset(oo), xtalk(0.00021) {
+    cout << "M0.3" << endl;
     int nadc=32;
     int sc_width=25;
     int sc_height=200;
-
-    int adc_nr[32]={300,325,350,375,300,325,350,375,		\
+    
+     int adc_nr[32]={300,325,350,375,300,325,350,375,	\
     		    200,225,250,275,200,225,250,275,\
     		    100,125,150,175,100,125,150,175,\
     		    0,25,50,75,0,25,50,75};
-
+   
+     /*   int adc_nr[32]={350,375,150,175,350,375,150,175,	\
+    		    300,325,100,125,300,325,100,125,\
+    		    250,275,50,75,250,275,50,75,\
+    		    200,225,0,25,200,225,0,25};
+     */
     int row, col;
     
     int isample;
@@ -50,11 +57,11 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
     int i;
     int adc4(0);
   
-    for (int ip=0; ip<npackets; ip++) {
-      for (int is=0; is<128; is++) {
-
+    //for (int ip=0; ip<npackets; ip++) {
+    // for (int is=0; is<128; is++) {
+    for (i=0; i<nSamples; i++) {
 	for (iadc=0; iadc<nadc; iadc++) {
-	  i=128*ip+is;
+	  //i=128*ip+is;
 	  adc4=(int)iadc/4;
 	  if (i<sc_width*sc_height) {
 	    //  for (int i=0; i<sc_width*sc_height; i++) {
@@ -70,7 +77,7 @@ class moench03T1ZmqDataNew : public slsDetectorData<uint16_t> {
 	  }
 	}
       }
-    }
+  // }
 
     
     int ii=0;

slsDetectorCalibration/energyCalibration.cpp

@@ -0,0 +1,798 @@
+#include "energyCalibration.h"
+
+#ifdef __CINT
+#define MYROOT
+#endif
+
+
+#ifdef MYROOT
+#include <TMath.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TGraphErrors.h>
+#endif
+
+#include <iostream>
+
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }
+
+
+using namespace std;
+
+#ifdef MYROOT
+
+Double_t energyCalibrationFunctions::pedestal(Double_t *x, Double_t *par) { 
+    return par[0]-par[1]*sign*x[0];                                      
+}
+
+
+Double_t energyCalibrationFunctions::gaussChargeSharing(Double_t *x, Double_t *par) { 
+  Double_t f, arg=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  // Gaussian + error function + pedestal
+  return par[4]*f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingKb(Double_t *x, Double_t *par) { 
+  Double_t f, arg=0,argb=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+    argb=sign*(x[0]-(par[6]*par[2]))/par[3]; // using absolute kb mean might seem better but like this the ratio can be fixed
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  f=f+par[7]*(TMath::Exp(-1*argb*argb/2.));
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  f=f+par[7]*par[5]/2.*(TMath::Erfc(argb/(TMath::Sqrt(2.)))); 
+  // Gaussian + error function + pedestal
+  return par[4]*f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingKaDoublet(Double_t *x, Double_t *par) { 
+  Double_t f, f2, arg=0, arg2=0;
+  // Gaussian exponent
+  if (par[3]!=0) {
+    arg=sign*(x[0]-par[2])/par[3];
+    arg2=sign*(x[0]-par[6])/par[3];
+  }
+  // the Gaussian
+  f=TMath::Exp(-1*arg*arg/2.); 
+  f2=TMath::Exp(-1*arg2*arg2/2.); 
+  // Gaussian + error function
+  f=f+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); 
+  f2=f2+par[5]/2.*(TMath::Erfc(arg/(TMath::Sqrt(2.)))); // shouldn't this be arg2?
+  // Gaussian + error function + pedestal
+  return par[4]*f+par[7]*f2+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::gaussChargeSharingPixel(Double_t *x, Double_t *par) { 
+  Double_t f;
+  if (par[3]<=0 || par[2]*(*x)<=0 || par[5]<0 || par[4]<=0) return 0;
+
+  Double_t pp[3];
+
+  pp[0]=0;
+  pp[1]=par[2];
+  pp[2]=par[3];
+  
+
+  f=(par[5]-par[6]*(TMath::Log(*x/par[2])))*erfBox(x,pp);
+  f+=par[4]*TMath::Gaus(*x, par[2], par[3], kTRUE);
+  return f+pedestal(x,par);                                       
+}
+
+Double_t energyCalibrationFunctions::erfBox(Double_t *z, Double_t *par) {
+
+  
+  
+  Double_t m=par[0];
+  Double_t M=par[1];
+  
+  if (par[0]>par[1]) {
+    m=par[1];
+    M=par[0];
+  }
+  
+  if (m==M)
+    return 0;
+
+
+  if (par[2]<=0) {
+    if (*z>=m && *z<=M)
+      return 1./(M-m);
+    else
+      return 0;
+
+  }
+
+  return (TMath::Erfc((z[0]-M)/par[2])-TMath::Erfc((z[0]-m)/par[2]))*0.5/(M-m);
+
+}
+
+
+// basic erf function
+Double_t energyCalibrationFunctions::erfFunction(Double_t *x, Double_t *par) {	
+  double arg=0;
+  if (par[1]!=0) arg=(par[0]-x[0])/par[1];
+  return ((par[2]/2.*(1+TMath::Erf(sign*arg/(TMath::Sqrt(2))))));  
+};
+  
+
+Double_t energyCalibrationFunctions::erfFunctionChargeSharing(Double_t *x, Double_t *par) {	       
+  Double_t f;		
+  
+  f=erfFunction(x, par+2)*(1+par[5]*(par[2]-x[0]))+par[0]-par[1]*x[0]*sign;		
+  return f;								
+};
+  
+  
+Double_t energyCalibrationFunctions::erfFuncFluo(Double_t *x, Double_t *par) {
+  Double_t f;							       
+  f=erfFunctionChargeSharing(x, par)+erfFunction(x, par+6)*(1+par[9]*(par[6]-x[0])); 
+  return f;							
+};
+#endif
+
+double energyCalibrationFunctions::median(double *x, int n){
+  // sorts x into xmed array and returns median 
+  // n is number of values already in the xmed array
+  double xmed[n];
+  int k,i,j;
+
+  for (i=0; i<n; i++) {
+    k=0;
+    for (j=0; j<n; j++) {
+      if(*(x+i)>*(x+j))
+	k++;
+      if (*(x+i)==*(x+j)) {
+	if (i>j) 
+	  k++;
+      }
+    }
+    xmed[k]=*(x+i);
+  }
+  k=n/2;
+  return xmed[k];
+}
+
+
+int energyCalibrationFunctions::quick_select(int arr[], int n){
+    int low, high ;
+    int median;
+    int middle, ll, hh;
+
+    low = 0 ; high = n-1 ; median = (low + high) / 2;
+    for (;;) {
+        if (high <= low) /* One element only */
+            return arr[median] ;
+
+        if (high == low + 1) {  /* Two elements only */
+            if (arr[low] > arr[high])
+                ELEM_SWAP(arr[low], arr[high]) ;
+            return arr[median] ;
+        }
+
+    /* Find median of low, middle and high items; swap into position low */
+    middle = (low + high) / 2;
+    if (arr[middle] > arr[high])    ELEM_SWAP(arr[middle], arr[high]) ;
+    if (arr[low] > arr[high])       ELEM_SWAP(arr[low], arr[high]) ;
+    if (arr[middle] > arr[low])     ELEM_SWAP(arr[middle], arr[low]) ;
+
+    /* Swap low item (now in position middle) into position (low+1) */
+    ELEM_SWAP(arr[middle], arr[low+1]) ;
+
+    /* Nibble from each end towards middle, swapping items when stuck */
+    ll = low + 1;
+    hh = high;
+    for (;;) {
+        do ll++; while (arr[low] > arr[ll]) ;
+        do hh--; while (arr[hh]  > arr[low]) ;
+
+        if (hh < ll)
+        break;
+
+        ELEM_SWAP(arr[ll], arr[hh]) ;
+    }
+
+    /* Swap middle item (in position low) back into correct position */
+    ELEM_SWAP(arr[low], arr[hh]) ;
+
+    /* Re-set active partition */
+    if (hh <= median)
+        low = ll;
+        if (hh >= median)
+        high = hh - 1;
+    }
+}
+
+int energyCalibrationFunctions::kth_smallest(int *a, int n, int k){
+    register int i,j,l,m ;
+    register double x ;
+
+    l=0 ; m=n-1 ;
+    while (l<m) {
+        x=a[k] ;
+        i=l ;
+        j=m ;
+        do {
+            while (a[i]<x) i++ ;
+            while (x<a[j]) j-- ;
+            if (i<=j) {
+                ELEM_SWAP(a[i],a[j]) ;
+                i++ ; j-- ;
+            }
+        } while (i<=j) ;
+        if (j<k) l=i ;
+        if (k<i) m=j ;
+    }
+    return a[k] ;
+}
+
+
+
+#ifdef MYROOT
+Double_t energyCalibrationFunctions::spectrum(Double_t *x, Double_t *par) {
+  return gaussChargeSharing(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumkb(Double_t *x, Double_t *par) {
+  return gaussChargeSharingKb(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumkadoublet(Double_t *x, Double_t *par) {
+  return gaussChargeSharingKaDoublet(x,par);	
+}
+
+Double_t energyCalibrationFunctions::spectrumPixel(Double_t *x, Double_t *par) {
+  return gaussChargeSharingPixel(x,par);	
+}
+
+
+Double_t energyCalibrationFunctions::scurve(Double_t *x, Double_t *par) {
+  return erfFunctionChargeSharing(x,par);
+}
+
+
+Double_t energyCalibrationFunctions::scurveFluo(Double_t *x, Double_t *par) {
+  return erfFuncFluo(x,par);						
+}
+#endif
+
+energyCalibration::energyCalibration() : 
+#ifdef MYROOT	
+					 fit_min(-1),	
+					 fit_max(-1),	
+					 bg_offset(-1),	
+					 bg_slope(-1),	
+					 flex(-1),
+					 noise(-1),
+					 ampl(-1),
+					 cs_slope(-1),
+					 kb_mean(-1),
+					 kb_frac(-1),
+					 mean2(-1),
+					 ampl2(-1),
+					 fscurve(NULL),
+					 fspectrum(NULL),
+					 fspectrumkb(NULL),
+					 fspectrumkadoublet(NULL),
+#endif
+					 funcs(NULL),
+					 plot_flag(1), // fit parameters output to screen
+					 cs_flag(1)
+{
+
+#ifdef MYROOT	
+  funcs=new energyCalibrationFunctions();
+  
+  fscurve=new TF1("fscurve",funcs,&energyCalibrationFunctions::scurve,0,1000,6,"energyCalibrationFunctions","scurve");	
+  fscurve->SetParNames("Background Offset","Background Slope","Inflection Point","Noise RMS", "Number of Photons","Charge Sharing Slope");
+
+  fspectrum=new TF1("fspectrum",funcs,&energyCalibrationFunctions::spectrum,0,1000,6,"energyCalibrationFunctions","spectrum");	
+  fspectrum->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal");
+  fspectrumkb=new TF1("fspectrumkb",funcs,&energyCalibrationFunctions::spectrumkb,0,1000,8,"energyCalibrationFunctions","spectrumkb");	
+  fspectrumkb->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","kb mean","kb frac");
+
+  fspectrumkadoublet=new TF1("fspectrumkadoublet",funcs,&energyCalibrationFunctions::spectrumkadoublet,0,1000,8,"energyCalibrationFunctions","spectrumkadoublet");	
+  fspectrumkadoublet->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","ka2 mean","n2");
+
+  fspixel=new TF1("fspixel",funcs,&energyCalibrationFunctions::spectrumPixel,0,1000,7,"energyCalibrationFunctions","spectrumPixel");	
+  fspixel->SetParNames("Background Pedestal","Background slope", "Peak position","Noise RMS", "Number of Photons","Charge Sharing Pedestal","Corner");
+
+#endif
+
+
+}
+
+
+
+void energyCalibration::fixParameter(int ip, Double_t val){
+  
+  fscurve->FixParameter(ip, val);
+  fspectrum->FixParameter(ip, val);
+  fspectrumkb->FixParameter(ip, val);
+  fspectrumkadoublet->FixParameter(ip, val);
+}
+
+
+void energyCalibration::releaseParameter(int ip){
+
+  fscurve->ReleaseParameter(ip);
+  fspectrum->ReleaseParameter(ip);
+  fspectrumkb->ReleaseParameter(ip);
+  fspectrumkadoublet->ReleaseParameter(ip);
+}
+
+
+
+
+
+
+
+energyCalibration::~energyCalibration(){ 
+#ifdef MYROOT
+  delete fscurve;
+  delete fspectrum;
+  delete fspectrumkb;
+  delete fspectrumkadoublet;
+#endif
+  
+}
+
+#ifdef MYROOT
+
+
+
+
+
+TH1F* energyCalibration::createMedianHistogram(TH2F* h2, int ch0, int nch, int direction) {
+
+  if (h2==NULL || nch==0)
+    return NULL;
+
+  double *x=new double[nch];
+  TH1F *h1=NULL;
+  
+  double val=-1;
+
+  if (direction==0) {
+    h1=new TH1F("median","Median",h2->GetYaxis()->GetNbins(),h2->GetYaxis()->GetXmin(),h2->GetYaxis()->GetXmax());
+    for (int ib=0; ib<h1->GetXaxis()->GetNbins(); ib++) {
+      for (int ich=0; ich<nch; ich++) {
+	x[ich]=h2->GetBinContent(ch0+ich+1,ib+1);
+      }
+      val=energyCalibrationFunctions::median(x, nch);
+      h1->SetBinContent(ib+1,val);
+    }
+  } else if (direction==1) {   
+    h1=new TH1F("median","Median",h2->GetXaxis()->GetNbins(),h2->GetXaxis()->GetXmin(),h2->GetXaxis()->GetXmax());
+    for (int ib=0; ib<h1->GetYaxis()->GetNbins(); ib++) {
+      for (int ich=0; ich<nch; ich++) {
+	x[ich]=h2->GetBinContent(ib+1,ch0+ich+1);
+      }
+      val=energyCalibrationFunctions::median(x, nch);
+      h1->SetBinContent(ib+1,val);
+    }
+  }
+  delete [] x;
+
+  return h1;
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void energyCalibration::setStartParameters(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+}
+
+void energyCalibration::setStartParametersKb(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+  kb_mean=par[6];
+  kb_frac=par[7];
+  //fit_min = 400; // used for soleil flat field
+  //fit_max = 800;
+}
+
+void energyCalibration::setStartParametersKaDoublet(Double_t *par){	
+  bg_offset=par[0];						
+  bg_slope=par[1];						
+  flex=par[2];							
+  noise=par[3];							
+  ampl=par[4];							
+  cs_slope=par[5];						
+  mean2=par[6];
+  ampl2=par[7];
+  //fit_min = 400; // used for soleil flat field
+  //fit_max = 800;
+}
+
+
+void energyCalibration::getStartParameters(Double_t *par){	
+  par[0]=bg_offset;
+  par[1]=bg_slope;
+  par[2]=flex;
+  par[3]=noise;
+  par[4]=ampl;				
+  par[5]=cs_slope;				
+}
+
+#endif
+int energyCalibration::setChargeSharing(int p) {
+  if (p>=0) {
+    cs_flag=p; 
+#ifdef MYROOT  
+    if (p) {
+      fscurve->ReleaseParameter(5);
+      fspectrum->ReleaseParameter(1);
+      fspectrumkb->ReleaseParameter(1);
+      fspectrumkadoublet->ReleaseParameter(1);
+    } else {
+      fscurve->FixParameter(5,0);
+      fspectrum->FixParameter(1,0);
+      fspectrumkb->FixParameter(1,0);
+      fspectrumkadoublet->FixParameter(1,0);
+    }
+#endif
+  } 
+  
+  return cs_flag;
+}
+
+ 
+#ifdef MYROOT  
+void energyCalibration::initFitFunction(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[6];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+void energyCalibration::initFitFunctionKb(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[8];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+
+  if (kb_mean==-1)
+    mypar[6]=0;
+  else
+    mypar[6]=kb_mean;
+
+  if (kb_frac==-1)
+    mypar[7]=0;
+  else
+    mypar[7]=kb_frac;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+void energyCalibration::initFitFunctionKaDoublet(TF1 *fun, TH1 *h1) {
+
+ Double_t min=fit_min, max=fit_max; 
+
+ Double_t mypar[8];
+  
+ if (max==-1) 
+    max=h1->GetXaxis()->GetXmax();
+ 
+  if (min==-1) 
+    min=h1->GetXaxis()->GetXmin();
+
+  
+  if (bg_offset==-1)
+    mypar[0]=0;
+  else
+    mypar[0]=bg_offset;
+
+
+  if (bg_slope==-1)
+    mypar[1]=0;
+  else
+    mypar[1]=bg_slope;
+
+
+  if (flex==-1)
+    mypar[2]=(min+max)/2.;
+  else
+    mypar[2]=flex;
+
+
+  if (noise==-1)
+    mypar[3]=0.1;
+  else
+    mypar[3]=noise;
+
+  if (ampl==-1)
+    mypar[4]=h1->GetBinContent(h1->GetXaxis()->FindBin(0.5*(max+min)));
+  else
+    mypar[4]=ampl;
+
+  if (cs_slope==-1)
+    mypar[5]=0;
+  else
+    mypar[5]=cs_slope;
+
+  if (mean2==-1)
+    mypar[6]=0;
+  else
+    mypar[6]=mean2;
+
+  if (ampl2==-1)
+    mypar[7]=0;
+  else
+    mypar[7]=ampl2;
+ 
+  fun->SetParameters(mypar);
+
+  fun->SetRange(min,max);
+
+}
+
+TF1* energyCalibration::fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<6; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<8; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar) {
+
+
+  TF1* fitfun;
+
+  char fname[100];
+
+  strcpy(fname, fun->GetName());
+
+  if (plot_flag) {
+    h1->Fit(fname,"R0Q");
+  } else
+    h1->Fit(fname,"R0Q");
+
+
+  fitfun= h1->GetFunction(fname);
+  fitfun->GetParameters(mypar);
+  for (int ip=0; ip<8; ip++) {
+    emypar[ip]=fitfun->GetParError(ip);
+  }
+  return fitfun;
+}
+
+TF1* energyCalibration::fitSCurve(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunction(fscurve,h1);
+  return fitFunction(fscurve, h1, mypar, emypar);
+}
+
+
+
+
+
+TF1* energyCalibration::fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunction(fspectrum,h1);
+  return fitFunction(fspectrum, h1, mypar, emypar);
+}
+
+TF1* energyCalibration::fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunctionKb(fspectrumkb,h1);
+  return fitFunctionKb(fspectrumkb, h1, mypar, emypar);
+}
+
+TF1* energyCalibration::fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar) {
+  initFitFunctionKaDoublet(fspectrumkadoublet,h1);
+  return fitFunctionKaDoublet(fspectrumkadoublet, h1, mypar, emypar);
+}
+
+
+TGraphErrors* energyCalibration::linearCalibration(int nscan, Double_t *en, Double_t *een, Double_t *fl, Double_t *efl, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff) { 
+ 
+  TGraphErrors *gr;
+ 
+  Double_t  mypar[2];
+ 
+  gr = new TGraphErrors(nscan,en,fl,een,efl);
+
+  if (plot_flag) {
+    gr->Fit("pol1");
+    gr->SetMarkerStyle(20);
+  } else
+    gr->Fit("pol1","0Q");
+        
+  TF1 *fitfun= gr->GetFunction("pol1"); 
+  fitfun->GetParameters(mypar);
+
+  egain=fitfun->GetParError(1);
+  eoff=fitfun->GetParError(0);
+
+  gain=funcs->setScanSign()*mypar[1];
+  
+  off=mypar[0]; 
+  
+  return gr;
+}
+
+
+TGraphErrors* energyCalibration::calibrate(int nscan, Double_t *en, Double_t *een, TH1F **h1, Double_t &gain, Double_t &off, Double_t &egain, Double_t &eoff, int integral) {
+
+  TH1F *h;
+
+  Double_t mypar[6], emypar[6];
+  Double_t fl[nscan], efl[nscan];
+  
+
+  for (int ien=0; ien<nscan; ien++) {
+    h=h1[ien];
+    if (integral)
+      fitSCurve(h,mypar,emypar);
+    else
+      fitSpectrum(h,mypar,emypar);
+
+    fl[ien]=mypar[2];
+    efl[ien]=emypar[2];
+  }
+  return linearCalibration(nscan,en,een,fl,efl,gain,off, egain, eoff);
+
+}
+
+#endif
+
+
+
+

slsDetectorCalibration/energyCalibration.h

@@ -98,6 +98,8 @@ class energyCalibrationFunctions {
       par[5] is the fractional height of the charge sharing pedestal (scales with par[3])
   */
   Double_t gaussChargeSharing(Double_t *x, Double_t *par);
+  Double_t gaussChargeSharingKb(Double_t *x, Double_t *par);
+  Double_t gaussChargeSharingKaDoublet(Double_t *x, Double_t *par);
   /** 
       Gaussian Function with charge sharing pedestal
       par[0] is the absolute height of the background pedestal
@@ -153,6 +155,8 @@ Double_t erfFuncFluo(Double_t *x, Double_t *par);
       par[5] is the fractional height of the charge sharing pedestal (scales with par[4]
   */
   Double_t spectrum(Double_t *x, Double_t *par);
+  Double_t spectrumkb(Double_t *x, Double_t *par);
+  Double_t spectrumkadoublet(Double_t *x, Double_t *par);
 
   /** 
       static function Gaussian with charge sharing pedestal with the correct scan sign
@@ -285,7 +289,9 @@ class energyCalibration  {
       par[5] is the angual coefficient of the charge sharing slope (scales with par[3]) -- always positive
   */
   void setStartParameters(Double_t *par);
-  
+  void setStartParametersKb(Double_t *par);
+  void setStartParametersKaDoublet(Double_t *par);
+
 /** get start parameters for the s-curve function
     \param par parameters, -1 means auto-calculated
       par[0] is the  pedestal 
@@ -315,16 +321,8 @@ class energyCalibration  {
      \returns the fitted function - can be used e.g. to get the Chi2 or similar
   */
   TF1 *fitSpectrum(TH1 *h1, Double_t *mypar, Double_t *emypar);
-
-
-  /**
-     fits histogram with the spectrum
-     \param h1 1d-histogram to be fitted
-     \param mypar pointer to fit parameters array 
-     \param emypar pointer to fit parameter errors
-     \returns the fitted function - can be used e.g. to get the Chi2 or similar
-  */
-  TF1 *fitSpectrumPixel(TH1 *h1, Double_t *mypar, Double_t *emypar);
+  TF1 *fitSpectrumKb(TH1 *h1, Double_t *mypar, Double_t *emypar);
+  TF1 *fitSpectrumKaDoublet(TH1 *h1, Double_t *mypar, Double_t *emypar);
 
 
   /**
@@ -399,6 +397,8 @@ class energyCalibration  {
 */
   
   void initFitFunction(TF1 *fun, TH1 *h1);
+  void initFitFunctionKb(TF1 *fun, TH1 *h1);
+  void initFitFunctionKaDoublet(TF1 *fun, TH1 *h1);
 
 
   /**
@@ -410,6 +410,8 @@ class energyCalibration  {
      \returns the fitted function - can be used e.g. to get the Chi2 or similar
   */
   TF1 *fitFunction(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
+  TF1 *fitFunctionKb(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
+  TF1 *fitFunctionKaDoublet(TF1 *fun, TH1 *h1, Double_t *mypar, Double_t *emypar);  
 
 #endif
 
@@ -423,11 +425,16 @@ class energyCalibration  {
   Double_t noise; /**< start value for the noise */
   Double_t ampl; /**< start value for the number of photons */
   Double_t cs_slope; /**< start value for the charge sharing slope */
-
+  Double_t kb_mean;
+  Double_t kb_frac;
+  Double_t mean2;
+  Double_t ampl2;
 
   TF1 *fscurve; /**< function with which the s-curve will be fitted */
 
   TF1 *fspectrum; /**< function with which the spectrum will be fitted */
+  TF1 *fspectrumkb; /**< function with which the spectrum will be fitted */
+  TF1 *fspectrumkadoublet; /**< function with which the spectrum will be fitted */
 
   TF1 *fspixel; /**< function with which the spectrum will be fitted */
 

slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder

@@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ 
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=jungfrauClusterFinder.cpp
+
+
+all: jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+
+
+jungfrauClusterFinder:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinder  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  
+
+
+jungfrauClusterFinderHighZ:  jungfrauClusterFinder.cpp  $(INCS) clean
+			 g++ -o jungfrauClusterFinderHighZ  jungfrauClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DHIGHZ 
+
+
+
+
+jungfrauMakeEta:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauMakeEta jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+jungfrauInterpolation:  jungfrauInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauInterpolation jungfrauInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+jungfrauNoInterpolation:  jungfrauNoInterpolation.cpp  $(INCS) clean
+			 g++ -o jungfrauNoInterpolation jungfrauNoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+jungfrauPhotonCounter: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounter  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+jungfrauAnalog: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalog  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+jungfrauPhotonCounterHighZ: jungfrauPhotonCounter.cpp   $(INCS) clean
+			 g++ -o jungfrauPhotonCounterHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+jungfrauAnalogHighZ: jungfrauPhotonCounter.cpp  $(INCS) clean
+			 g++ -o jungfrauAnalogHighZ  jungfrauPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  jungfrauClusterFinder jungfrauMakeEta jungfrauInterpolation jungfrauNoInterpolation jungfrauPhotonCounter jungfrauAnalog
+
+

slsDetectorCalibration/jungfrauExecutables/Makefile.cluster_finder~

@@ -0,0 +1,47 @@
+#module add CBFlib/0.9.5
+INCDIR=-I. -I../ -I../interpolations  -I../interpolations/etaVEL  -I../dataStructures  -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/
+
+LDFLAG= ../tiffIO.cpp -L/usr/lib64/ -lpthread -lm  -lstdc++   -pthread -lrt    -ltiff -O3  -std=c++11
+
+MAIN=moench03ClusterFinder.cpp
+
+
+all: moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+
+
+moenchClusterFinder:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinder  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER 
+
+
+moenchClusterFinderHighZ:  moench03ClusterFinder.cpp  $(INCS) clean
+			 g++ -o moenchClusterFinderHighZ  moench03ClusterFinder.cpp $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DSAVE_ALL  -DNEWRECEIVER -DHIGHZ 
+
+
+
+
+moenchMakeEta:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchMakeEta moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) -DFF
+
+moenchInterpolation:  moench03Interpolation.cpp  $(INCS) clean
+			 g++ -o moenchInterpolation moench03Interpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  
+
+moenchNoInterpolation:  moench03NoInterpolation.cpp  $(INCS) clean
+			 g++ -o moenchNoInterpolation moench03NoInterpolation.cpp    $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF) 
+
+moenchPhotonCounter: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounter  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER
+
+moenchAnalog: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalog  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG
+
+moenchPhotonCounterHighZ: moenchPhotonCounter.cpp   $(INCS) clean
+			 g++ -o moenchPhotonCounterHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DHIGHZ
+
+moenchAnalogHighZ: moenchPhotonCounter.cpp  $(INCS) clean
+			 g++ -o moenchAnalogHighZ  moenchPhotonCounter.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWRECEIVER -DANALOG -DHIGHZ
+
+clean: 	
+	rm -f  moenchClusterFinder moenchMakeEta moenchInterpolation moenchNoInterpolation moenchPhotonCounter moenchAnalog
+
+

slsDetectorCalibration/jungfrauExecutables/Makefile.zmq

@@ -0,0 +1,23 @@
+
+INCDIR=   -I. -I../dataStructures ../tiffIO.cpp -I../ -I../interpolations/ -I../../slsSupportLib/include/ -I../../slsReceiverSoftware/include/ -I../../libs/rapidjson/
+LDFLAG= -L/usr/lib64/ -lpthread -lm  -lstdc++  -lzmq -pthread -lrt -ltiff   -O3  -std=c++11 -Wall -L../../build/bin/ -lSlsSupport
+#-L../../bin -lhdf5  -L.
+
+#DESTDIR?=../bin
+
+all:  moenchZmqProcess moenchZmq04Process
+ #moenchZmqProcessCtbGui
+
+moenchZmqProcess:  moenchZmqProcess.cpp   clean
+		      g++ -o moenchZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP 
+
+moenchZmq04Process:  moenchZmqProcess.cpp   clean
+		      g++ -o moench04ZmqProcess  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DMOENCH04 
+
+#moenchZmqProcessCtbGui:  moenchZmqProcess.cpp   clean
+#		      g++ -o moenchZmqProcessCtbGui  moenchZmqProcess.cpp  $(LDFLAG) $(INCDIR) $(LIBHDF5) $(LIBRARYCBF)  -DNEWZMQ -DINTERP -DCTBGUI
+
+clean: 	
+	rm -f  moenchZmqProcess  
+
+

slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp

@@ -0,0 +1,161 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#include "jungfrauHighZSingleChipData.h"
+
+
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+  jungfrauHighZSingleChipData *decoder=new  jungfrauHighZSingleChipData();
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+
+  int* image;
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+
+  	mt->pushData(buff);
+  	mt->nextThread();
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauClusterFinder.cpp~

@@ -0,0 +1,237 @@
+//#include "sls/ansi.h"
+#include <iostream>
+
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+#ifdef REORDERED
+#include "moench03T1ReorderedData.h"
+#endif
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<6) {
+    cout << "Usage is " << argv[0] << "indir outdir fname runmin runmax " << endl;
+    return 1;
+  }
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=1;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int nx=400, ny=400;
+  int save=1;
+  int nsigma=5;
+  int nped=1000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+
+
+
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+#ifdef REORDERED
+  moench03T1ReorderedData *decoder=new  moench03T1ReorderedData();
+  cout << "REORDERED DATA!"<<endl;
+#endif
+
+
+  decoder->getDetectorSize(nx,ny);
+  cout << "nx " << nx << " ny " << ny << endl;
+
+  //moench03T1ZmqData *decoder=new  moench03T1ZmqData();
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, 0, nped, 200);
+  //  char tit[10000];
+  cout << "filter " << endl;
+
+
+
+  // filter->readPedestals("/scratch/ped_100.tiff");
+  // interp->readFlatField("/scratch/eta_100.tiff",etamin,etamax);
+  // cout << "filter "<< endl;
+  
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+  filter->newDataSet();
+
+
+  int ff, np;
+  int dsize=decoder->getDataSize();
+  cout << " data size is " << dsize;
+  
+
+  char data[dsize];
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=atoi(argv[4]);
+  int runmax=atoi(argv[5]);
+  
+  char fname[10000];
+  char outfname[10000];
+  char imgfname[10000];
+  char pedfname[10000];
+  //  strcpy(pedfname,argv[6]);
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "fileformat is " << fformat << endl;
+  
+
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+ 
+
+
+
+
+
+
+
+  char* buff;
+  multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+
+ 
+  mt->setDetectorMode(ePhotonCounting);
+  mt->setFrameMode(eFrame);
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  cout << "mt " << endl;
+
+  int ifr=0;
+ 
+
+  for (int irun=runmin; irun<runmax; irun++) {
+    sprintf(fn,fformat,irun);
+    sprintf(fname,"%s/%s.raw",indir,fn);
+    sprintf(outfname,"%s/%s.clust",outdir,fn);
+    sprintf(imgfname,"%s/%s.tiff",outdir,fn);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    if (filebin.is_open()){
+      of=fopen(outfname,"w");
+      if (of) {
+  	mt->setFilePointer(of);
+	//	cout << "file pointer set " << endl;
+      } else {
+  	cout << "Could not open "<< outfname << " for writing " << endl;
+  	mt->setFilePointer(NULL);
+  	return 1;
+      }
+      //     //while read frame 
+      ff=-1;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	// for (int ix=0; ix<400; ix++)
+	//   for (int iy=0; iy<400; iy++) {
+	//     if (decoder->getChannel(buff, ix, iy)<3000 || decoder->getChannel(buff, ix, iy)>8000) {
+	//       cout <<  ifr << " " << ff << " " << ix << " " << iy << " " << decoder->getChannel(buff, ix, iy) << endl ;
+	//     }
+	//   }
+
+  	mt->pushData(buff);
+  // 	//         //pop
+  	mt->nextThread();
+  // // 		//	cout << " " << (void*)buff;
+  	mt->popFree(buff);
+	ifr++;
+	if (ifr%10000==0) cout << ifr << " " << ff << endl;
+	ff=-1;
+      }
+        cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}//wait until all data are processed from the queues
+      if (of)
+  	fclose(of);
+      
+      mt->writeImage(imgfname);
+      mt->clearImage();
+   
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+
+    } else 
+     cout << "Could not open "<< fname << " for reading " << endl;
+      
+    
+  }
+    
+
+  return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauInterpolation.cpp

@@ -0,0 +1,250 @@
+
+#include "sls/ansi.h"
+#include <iostream>
+
+//#include "moench03T1ZmqData.h"
+//#define DOUBLE_SPH
+//#define MANYFILES
+
+#ifdef DOUBLE_SPH
+#include "single_photon_hit_double.h"
+#endif
+
+#ifndef DOUBLE_SPH
+#include "single_photon_hit.h"
+#endif
+
+//#include "etaInterpolationPosXY.h"
+#include "noInterpolation.h"
+#include "etaInterpolationPosXY.h"
+//#include "etaInterpolationCleverAdaptiveBins.h"
+//#include "etaInterpolationRandomBins.h"
+using namespace std;
+#define NC 400
+#define NR 400
+#define MAX_ITERATIONS (nSubPixels*100)
+
+#define XTALK
+
+int main(int argc, char *argv[]) {
+
+#ifndef FF
+  if (argc<9) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile outfile runmin runmax ns cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  
+#ifdef FF
+  if (argc<7) {
+    cout << "Wrong usage! Should be: "<< argv[0] << " infile  etafile runmin runmax cmin cmax" << endl;
+    return 1;
+  }
+#endif
+  int iarg=4;
+  char infname[10000];
+  char fname[10000];
+  char outfname[10000];
+#ifndef FF
+  iarg=4;
+#endif
+
+#ifdef FF
+  iarg=3;
+#endif
+  int runmin=atoi(argv[iarg++]);
+  int runmax=atoi(argv[iarg++]); 
+  cout << "Run min: " << runmin << endl;
+  cout << "Run max: " << runmax << endl;
+  
+  int nsubpix=4;
+#ifndef FF
+  nsubpix=atoi(argv[iarg++]);
+  cout << "Subpix: " << nsubpix << endl;
+#endif
+  float cmin=atof(argv[iarg++]);
+  float cmax=atof(argv[iarg++]);
+  cout << "Energy min: " << cmin << endl;
+  cout << "Energy max: " << cmax << endl;
+  //int etabins=500;
+  int etabins=1000;//nsubpix*2*100;
+  double etamin=-1, etamax=2;
+  //double etamin=-0.1, etamax=1.1;
+  double eta3min=-2, eta3max=2;
+  int quad;
+  double sum, totquad;
+  double sDum[2][2];
+  double etax, etay, int_x, int_y;
+  double eta3x, eta3y, int3_x, int3_y, noint_x, noint_y;
+  int ok;
+  int f0=-1;
+  int ix, iy, isx, isy;
+  int nframes=0, lastframe=-1;
+  double d_x, d_y, res=5, xx, yy;
+  int nph=0, badph=0, totph=0;
+    FILE *f=NULL;
+
+#ifdef DOUBLE_SPH
+    single_photon_hit_double cl(3,3);
+#endif
+
+#ifndef DOUBLE_SPH
+    single_photon_hit cl(3,3);
+#endif
+
+    int nSubPixels=nsubpix;
+#ifndef NOINTERPOLATION
+   eta2InterpolationPosXY *interp=new eta2InterpolationPosXY(NC, NR, nsubpix, etabins, etamin, etamax);
+   //eta2InterpolationCleverAdaptiveBins *interp=new eta2InterpolationCleverAdaptiveBins(NC, NR, nsubpix, etabins, etamin, etamax);  
+#endif
+#ifdef NOINTERPOLATION
+    noInterpolation *interp=new noInterpolation(NC, NR, nsubpix);  
+#endif
+
+
+ 
+#ifndef FF
+#ifndef NOINTERPOLATION
+    cout << "read ff " << argv[2] << endl;
+    sprintf(fname,"%s",argv[2]);
+    interp->readFlatField(fname);
+    interp->prepareInterpolation(ok);//, MAX_ITERATIONS);
+#endif
+    // return 0;
+#endif
+#ifdef FF
+    cout << "Will write eta file " << argv[2] << endl;
+#endif
+
+    int *img;
+    float *totimg=new float[NC*NR*nsubpix*nsubpix];
+    for (ix=0; ix<NC; ix++) {
+      for (iy=0; iy<NR; iy++) {
+	for (isx=0; isx<nsubpix; isx++) {
+	  for (isy=0; isy<nsubpix; isy++) {
+	    totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]=0;
+	      }
+	}
+      }
+    }
+
+#ifdef FF
+      sprintf(outfname,argv[2]);
+#endif     
+
+    int irun;
+    for (irun=runmin; irun<runmax; irun++) {
+      sprintf(infname,argv[1],irun);
+#ifndef FF
+      sprintf(outfname,argv[3],irun);
+#endif
+ 
+      f=fopen(infname,"r");
+      if (f) {
+	cout << infname << endl;
+	nframes=0;
+	f0=-1;
+
+	while (cl.read(f)) {
+	  totph++;
+	  if (lastframe!=cl.iframe) {
+	    lastframe=cl.iframe;
+	    // cout << cl.iframe << endl;
+	    // f0=cl.iframe;
+	    if (nframes==0) f0=lastframe;
+	    nframes++;
+	  }
+	  //quad=interp->calcQuad(cl.get_cluster(), sum, totquad, sDum);
+	  quad=interp->calcEta(cl.get_cluster(), etax, etay, sum, totquad, sDum);
+	    if (sum>cmin && totquad/sum>0.8 && totquad/sum<1.2 && sum<cmax ) {
+	    nph++;
+	    //  if (sum>200 && sum<580) {
+	    //  interp->getInterpolatedPosition(cl.x,cl.y, totquad,quad,cl.get_cluster(),int_x, int_y);
+// #ifdef SOLEIL
+// 	    if (cl.x>210 && cl.x<240 && cl.y>210 && cl.y<240) {
+// #endif
+#ifndef FF
+	    // interp->getInterpolatedPosition(cl.x,cl.y, cl.get_cluster(),int_x, int_y);  
+	    interp->getInterpolatedPosition(cl.x,cl.y, etax, etay, quad,int_x, int_y);
+	      // cout <<"**************"<< endl;
+	      // cout << cl.x << " " << cl.y << " " << sum << endl;
+	      // cl.print();
+	      // cout << int_x << " " << int_y << endl;
+	      // cout <<"**************"<< endl;
+	    //  if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	    interp->addToImage(int_x, int_y);
+	    if (int_x<0 || int_y<0 || int_x>400 || int_y>400) {
+	      cout <<"**************"<< endl;
+	      cout << cl.x << " " << cl.y << " " << sum << endl;
+	      cl.print();
+	      cout << int_x << " " << int_y << endl;
+	      cout <<"**************"<< endl;
+	    }
+#endif
+#ifdef FF
+	    //	interp->addToFlatField(cl.get_cluster(), etax, etay);
+// #ifdef UCL
+// 	    if (cl.x>50)
+// #endif
+// 	    if (etax!=0 && etay!=0 && etax!=1 && etay!=1)
+	      interp->addToFlatField(etax, etay);
+	    //  if (etax==0 || etay==0) cout << cl.x << " " << cl.y << endl;
+	     
+#endif
+// #ifdef SOLEIL
+// 	    }
+// #endif
+	    
+	    if (nph%1000000==0) cout << nph << endl;
+	    if (nph%10000000==0) { 
+#ifndef FF
+		interp->writeInterpolatedImage(outfname);
+#endif
+#ifdef FF 
+		interp->writeFlatField(outfname);
+#endif
+		
+		}
+	  }
+	    
+	} 
+	  
+	  
+	fclose(f);
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+	
+#ifndef FF
+	interp->writeInterpolatedImage(outfname); 
+
+	img=interp->getInterpolatedImage();
+	for (ix=0; ix<NC; ix++) {
+	  for (iy=0; iy<NR; iy++) {
+	    for (isx=0; isx<nsubpix; isx++) {
+	      for (isy=0; isy<nsubpix; isy++) {
+		totimg[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)]+=img[ix*nsubpix+isx+(iy*nsubpix+isy)*(NC*nsubpix)];
+		}
+	    }
+	  }
+	}
+	cout << "Read " << nframes << " frames (first frame: " << f0 << " last frame: " << lastframe << " delta:" << lastframe-f0 << ") nph="<< nph <<endl;
+	interp->clearInterpolatedImage();
+#endif
+	
+      } else
+	cout << "could not open file " << infname << endl;
+    }
+#ifndef FF
+    sprintf(outfname,argv[3],11111);
+    WriteToTiff(totimg, outfname,NC*nsubpix,NR*nsubpix);
+#endif 
+    
+#ifdef FF
+	interp->writeFlatField(outfname);
+#endif
+
+    cout << "Filled " << nph << " (/"<< totph <<") " << endl; 
+    return 0;
+}
+

slsDetectorCalibration/jungfrauExecutables/jungfrauPhotonCounter.cpp

@@ -0,0 +1,453 @@
+//#include "sls/ansi.h"
+#include <iostream>
+#define CORR
+
+#define C_GHOST 0.0004
+
+#define CM_ROWS 50
+
+//#define VERSION_V1
+
+//#include "moench03T1ZmqData.h"
+#ifdef NEWRECEIVER
+#ifndef RECT
+#include "moench03T1ReceiverDataNew.h"
+#endif
+
+#ifdef RECT
+#include "moench03T1ReceiverDataNewRect.h"
+#endif
+
+#endif
+
+
+#ifdef CSAXS_FP
+#include "moench03T1ReceiverData.h"
+#endif 
+#ifdef OLDDATA
+#include "moench03Ctb10GbT1Data.h"
+#endif 
+
+// #include "interpolatingDetector.h"
+//#include "etaInterpolationPosXY.h"
+// #include "linearInterpolation.h"
+// #include "noInterpolation.h"
+#include "multiThreadedCountingDetector.h"
+//#include "multiThreadedAnalogDetector.h"
+#include "singlePhotonDetector.h"
+#include "moench03GhostSummation.h"
+#include "moench03CommonMode.h"
+//#include "interpolatingDetector.h"
+
+#include <stdio.h>
+#include <map>
+#include <fstream>
+#include <sys/stat.h>
+
+#include <ctime>
+using namespace std;
+
+
+int main(int argc, char *argv[]) {
+
+
+  if (argc<4) {
+    cout << "Usage is " << argv[0] << "indir outdir fname [runmin] [runmax] [pedfile] [threshold] [nframes] [xmin xmax ymin ymax] [gainmap]" << endl;
+    cout << "threshold <0 means analog; threshold=0 means cluster finder; threshold>0 means photon counting" << endl;
+    cout << "nframes <0 means sum everything; nframes=0 means one file per run; nframes>0 means one file every nframes" << endl;
+    return 1;
+  }
+
+  int p=10000;
+  int fifosize=1000;
+  int nthreads=10;
+  int nsubpix=25;
+  int etabins=nsubpix*10;
+  double etamin=-1, etamax=2;
+  int csize=3;
+  int save=1;
+  int nsigma=5;
+  int nped=10000;
+  int ndark=100;
+  int ok;
+  int iprog=0;
+
+  int cf=0;
+
+#ifdef NEWRECEIVER
+#ifdef RECT
+  cout << "Should be rectangular!" <<endl;
+#endif
+  moench03T1ReceiverDataNew *decoder=new  moench03T1ReceiverDataNew();
+  cout << "RECEIVER DATA WITH ONE HEADER!"<<endl;
+#endif
+
+#ifdef CSAXS_FP
+  moench03T1ReceiverData *decoder=new  moench03T1ReceiverData();
+  cout << "RECEIVER DATA WITH ALL HEADERS!"<<endl;
+#endif
+
+#ifdef OLDDATA
+  moench03Ctb10GbT1Data *decoder=new  moench03Ctb10GbT1Data();
+  cout << "OLD RECEIVER DATA!"<<endl;
+#endif
+
+  int nx=400, ny=400;
+
+  decoder->getDetectorSize(nx,ny);
+
+  int ncol_cm=CM_ROWS;
+  double xt_ghost=C_GHOST;
+  moench03CommonMode *cm=NULL;
+  moench03GhostSummation *gs;
+  double *gainmap=NULL;
+  float *gm;
+
+
+
+  int size = 327680;////atoi(argv[3]);
+  
+  int* image;
+	//int* image =new int[327680/sizeof(int)];
+
+  int ff, np;
+  //cout << " data size is " << dsize;
+  
+
+
+  ifstream filebin;
+  char *indir=argv[1];
+  char *outdir=argv[2];
+  char *fformat=argv[3];
+  int runmin=0;
+  
+  // cout << "argc is " << argc << endl;
+ if (argc>=5) {
+   runmin=atoi(argv[4]);
+  }
+
+ int runmax=runmin;
+
+ if (argc>=6) {
+   runmax=atoi(argv[5]);
+  }
+
+  char *pedfile=NULL;
+  if (argc>=7) {
+    pedfile=argv[6];
+  }
+  double thr=0;
+  double thr1=1;
+
+  if (argc>=8) {
+    thr=atof(argv[7]);
+  }
+  
+
+  int nframes=0;
+  
+  if (argc>=9) {
+    nframes=atoi(argv[8]);
+  }
+
+  int xmin=0, xmax=nx, ymin=0, ymax=ny;
+  if (argc>=13) {
+    xmin=atoi(argv[9]);
+    xmax=atoi(argv[10]);
+    ymin=atoi(argv[11]);
+    ymax=atoi(argv[12]);
+  }
+
+  
+  char *gainfname=NULL;
+  if (argc>13) {
+    gainfname=argv[13];
+    cout << "Gain map file name is: " << gainfname << endl;
+  }
+
+  
+
+
+  char ffname[10000];
+  char fname[10000];
+  char imgfname[10000];
+  char cfname[10000];
+  char fn[10000];
+  
+  std::time_t end_time;
+
+  FILE *of=NULL;
+  cout << "input directory is " << indir << endl;
+  cout << "output directory is " << outdir << endl;
+  cout << "input file is " << fformat << endl;
+  cout << "runmin is " << runmin << endl;
+  cout << "runmax is " << runmax << endl;
+  if (pedfile)
+    cout << "pedestal file is " << pedfile << endl;
+ if (thr>0) 
+    cout << "threshold is " << thr << endl;
+ cout << "Nframes is " << nframes << endl;
+ 
+ uint32 nnx, nny;
+ double *gmap;
+
+  // if (gainfname) {
+  //   gm=ReadFromTiff(gainfname, nny, nnx);
+  //   if (gm && nnx==nx && nny==ny) {
+  //     gmap=new double[nx*ny];
+  //     for (int i=0; i<nx*ny; i++) {
+  // 	gmap[i]=gm[i];
+  //     }
+  //     delete gm;
+  //   } else
+  //     cout << "Could not open gain map " << gainfname << endl;
+  // }
+
+#ifdef CORR
+ cout << "Applying common mode  " << ncol_cm << endl;
+  cm=new moench03CommonMode(ncol_cm);
+  
+
+  cout << "Applying ghost corrections " << xt_ghost << endl;
+  gs=new moench03GhostSummation(decoder, xt_ghost);
+#endif
+
+  singlePhotonDetector *filter=new singlePhotonDetector(decoder,csize, nsigma, 1, cm, nped, 200, -1, -1, gainmap, gs);
+
+  if (gainfname) {
+
+    if (filter->readGainMap(gainfname))
+      cout << "using gain map " << gainfname << endl;
+    else
+      cout << "Could not open gain map " << gainfname << endl;
+  } else
+    thr=0.15*thr;
+  filter->newDataSet();
+  int dsize=decoder->getDataSize();
+
+
+  char data[dsize];
+
+
+
+
+
+  //#ifndef ANALOG
+  if (thr>0) {
+    cout << "threshold is " << thr << endl;
+    //#ifndef ANALOG
+    filter->setThreshold(thr);
+    //#endif
+      cf=0;
+
+  } else
+    cf=1;
+  //#endif
+
+
+  filter->setROI(xmin,xmax,ymin,ymax);
+  std::time(&end_time);
+  cout << std::ctime(&end_time) <<   endl;
+
+  char* buff;
+
+  // multiThreadedAnalogDetector *mt=new multiThreadedAnalogDetector(filter,nthreads,fifosize);
+ multiThreadedCountingDetector *mt=new multiThreadedCountingDetector(filter,nthreads,fifosize);
+#ifndef ANALOG
+    mt->setDetectorMode(ePhotonCounting);
+    cout << "Counting!" << endl;
+  if (thr>0) {
+    cf=0;
+  } 
+#endif
+//{
+#ifdef ANALOG
+      mt->setDetectorMode(eAnalog);
+      cout << "Analog!" << endl;
+      cf=0;
+      //thr1=thr;
+#endif  
+      //  }
+  
+  mt->StartThreads();
+  mt->popFree(buff);
+
+
+  //  cout << "mt " << endl;
+
+  int ifr=0;
+
+  double ped[nx*ny], *ped1;
+
+
+  if (pedfile) {
+
+    cout << "PEDESTAL " << endl;
+    sprintf(imgfname,"%s/pedestals.tiff",outdir);
+
+    if (string(pedfile).find(".tif")==std::string::npos){
+      sprintf(fname,"%s.raw",pedfile);
+      cout << fname << endl ;
+      std::time(&end_time);
+      cout << "aaa" << std::ctime(&end_time) <<   endl;
+      
+      
+      mt->setFrameMode(ePedestal);
+      // sprintf(fn,fformat,irun);
+      filebin.open((const char *)(fname), ios::in | ios::binary);
+      //      //open file
+      if (filebin.is_open()){
+	ff=-1;
+	while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	  if (np==40) {
+	    mt->pushData(buff);
+	    mt->nextThread();
+	    mt->popFree(buff);
+	    ifr++;
+	    if (ifr%100==0) 
+	      cout << ifr << " " << ff << " " << np << endl;
+	  } else
+	    cout << ifr << " " << ff << " " << np << endl;
+	  ff=-1;
+	}
+	filebin.close();	 
+	while (mt->isBusy()) {;}
+	
+      } else 
+	cout << "Could not open pedestal file "<< fname << " for reading " << endl;
+    } else {
+      float *pp=ReadFromTiff(pedfile, nny, nnx);
+      if (pp && nnx==nx && nny==ny) {
+	for (int i=0; i<nx*ny; i++) {
+	  ped[i]=pp[i];
+	}
+	delete [] pp;
+	mt->setPedestal(ped);
+	// ped1=mt->getPedestal();
+	
+	// for (int i=0; i<nx*ny; i++) {
+
+	//   cout << ped[i]<<"/"<<ped1[i] << " " ;
+	// }
+	cout << "Pedestal set from tiff file " << pedfile << endl;
+      } else {
+	cout << "Could not open pedestal tiff file "<< pedfile << " for reading " << endl;
+      }
+    }
+    mt->writePedestal(imgfname);
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<   endl;
+  }
+  
+
+
+  ifr=0;
+  int ifile=0;
+  
+  mt->setFrameMode(eFrame);
+
+  for (int irun=runmin; irun<=runmax; irun++) {
+    cout << "DATA " ;
+    // sprintf(fn,fformat,irun);
+    sprintf(ffname,"%s/%s.raw",indir,fformat);
+    sprintf(fname,ffname,irun);
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    sprintf(imgfname,ffname,irun);
+    sprintf(ffname,"%s/%s.clust",outdir,fformat);
+    sprintf(cfname,ffname,irun);
+    cout << fname << " " ;
+    cout << imgfname << endl;
+    std::time(&end_time);
+    cout << std::ctime(&end_time) <<    endl;
+    //  cout <<  fname << " " << outfname << " " << imgfname <<  endl;
+    filebin.open((const char *)(fname), ios::in | ios::binary);
+    //      //open file
+    ifile=0;
+    if (filebin.is_open()){
+      if (thr<=0 && cf!=0) { //cluster finder
+	  if (of==NULL) {
+	    of=fopen(cfname,"w");
+	    if (of) {
+	    mt->setFilePointer(of);
+	    cout << "file pointer set " << endl;
+	    } else {
+	      cout << "Could not open "<< cfname << " for writing " << endl;
+	      mt->setFilePointer(NULL);
+	      return 1;
+	    }
+	  }
+      }
+      //     //while read frame 
+      ff=-1;
+      ifr=0;
+      while (decoder->readNextFrame(filebin, ff, np,buff)) {
+	if (np==40) {
+	//	cout << "*"<<ifr++<<"*"<<ff<< endl;
+	//	cout << ff << " " << np << endl;
+  	//         //push
+	  mt->pushData(buff);
+	  // 	//         //pop
+	  mt->nextThread();
+	  // // 		//	cout << " " << (void*)buff;
+	  mt->popFree(buff);
+
+
+
+
+	  ifr++;
+	  if (ifr%100==0) cout << ifr << " " << ff << endl;
+	  if (nframes>0) {
+	    if (ifr%nframes==0) {
+	      //The name has an additional "_fXXXXX" at the end, where "XXXXX" is the initial frame number of the image (0,1000,2000...)
+	      
+	      sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	      sprintf(imgfname,ffname,irun);
+	      //cout << "Writing tiff to " << imgfname << " " << thr1 << endl;
+	      mt->writeImage(imgfname, thr1);
+	      mt->clearImage();
+	      ifile++;
+	    }
+	  }
+	} else
+	  cout << ifr << " " << ff << " " << np << endl;
+	ff=-1;
+      }
+      cout << "--" << endl;
+      filebin.close();	 
+      //      //close file 
+      //     //join threads
+      while (mt->isBusy()) {;}
+      if (nframes>=0) {
+	if (nframes>0) {
+	    sprintf(ffname,"%s/%s_f%05d.tiff",outdir,fformat,ifile);
+	    sprintf(imgfname,ffname,irun);
+	} else {
+	  sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+	  sprintf(imgfname,ffname,irun);
+	}
+	cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+	mt->writeImage(imgfname, thr1);
+	mt->clearImage();
+	if (of) {
+	  fclose(of);
+	  of=NULL;
+	  mt->setFilePointer(NULL);
+	}
+      }	
+      std::time(&end_time);
+      cout << std::ctime(&end_time) <<   endl;
+    } else 
+      cout << "Could not open "<< fname << " for reading " << endl;
+  }
+  if (nframes<0){
+    sprintf(ffname,"%s/%s.tiff",outdir,fformat);
+    strcpy(imgfname,ffname);
+    cout << "Writing tiff to " << imgfname << " " << thr1 <<endl;
+    mt->writeImage(imgfname, thr1);
+  }
+    
+
+
+  return 0;
+}
+

slsDetectorCalibration/moenchExecutables/CMakeLists.txt

@@ -3,11 +3,11 @@ find_package(TIFF REQUIRED)
 
 #Moench ZMQ
 add_executable(moenchZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP)
+target_compile_definitions(moenchZmqProcess PRIVATE NEWZMQ INTERP)
 
 #Moench04 ZMQ
 add_executable(moench04ZmqProcess moenchZmqProcess.cpp ../tiffIO.cpp)
-add_compile_definitions(moenchZmqProcess NEWZMQ INTERP MOENCH04)
+target_compile_definitions(moench04ZmqProcess PRIVATE NEWZMQ INTERP MOENCH04)
 
 
 #Both executables should have the same includes and output dirs

slsDetectorCalibration/moenchExecutables/moenchZmqProcess.cpp

@@ -1,6 +1,8 @@
 //#define WRITE_QUAD
 #define DEVELOPER
 #undef CORR
+#undef MOENCH04
+
 #define C_GHOST 0.0004
 
 #define CM_ROWS 20
@@ -28,6 +30,7 @@
 #include <fstream> 
 #include "tiffIO.h"
 
+
 #include <rapidjson/document.h> //json header in zmq stream
 
 #include<iostream>
@@ -135,9 +138,11 @@ int main(int argc, char *argv[]) {
 
   //slsDetectorData *det=new moench03T1ZmqDataNew(); 
 #ifndef MOENCH04
+  cout << "This is a Moench03" << endl;
   moench03T1ZmqDataNew *det=new moench03T1ZmqDataNew(); 
 #endif
 #ifdef MOENCH04
+  cout << "This is a Moench04" << endl;
   moench04CtbZmq10GbData *det=new moench04CtbZmq10GbData(); 
 #endif
   cout << endl << " det" <<endl;
@@ -614,61 +619,8 @@ int main(int argc, char *argv[]) {
 	      version=zHeader.version;//doc["version"].GetUint();
 	      /*document["bitmode"].GetUint(); zHeader.dynamicRange
 
-document["fileIndex"].GetUint64(); zHeader.fileIndex
 
-document["detshape"][0].GetUint();
-zHeader.ndetx
-
-document["detshape"][1].GetUint();
-zHeader.ndety
-
-document["shape"][0].GetUint();
-zHeader.npixelsx
-
-document["shape"][1].GetUint();
-zHeader.npixelsy
-
-document["size"].GetUint(); zHeader.imageSize
-
-document["acqIndex"].GetUint64(); zHeader.acqIndex
-
-document["frameIndex"].GetUint64(); zHeader.frameIndex
-
-document["fname"].GetString(); zHeader.fname
-
-document["frameNumber"].GetUint64(); zHeader.frameNumber
-
-document["expLength"].GetUint(); zHeader.expLength
-
-document["packetNumber"].GetUint(); zHeader.packetNumber
-
-document["bunchId"].GetUint64(); zHeader.bunchId
-
-document["timestamp"].GetUint64(); zHeader.timestamp
-
-document["modId"].GetUint(); zHeader.modId
-
-document["row"].GetUint(); zHeader.row
-
-document["column"].GetUint(); zHeader.column
-
-document["reserved"].GetUint(); zHeader.reserved
-
-document["debug"].GetUint(); zHeader.debug
-
-document["roundRNumber"].GetUint(); zHeader.roundRNumber
-
-document["detType"].GetUint(); zHeader.detType
-
-document["version"].GetUint(); zHeader.version
-
-document["flippedDataX"].GetUint(); zHeader.flippedDataX
-
-document["quad"].GetUint(); zHeader.quad
-
-document["completeImage"].GetUint(); zHeader.completeImage
 	      */
-	      //dataSize=size;
 
 	      //strcpy(fname,filename.c_str());
 	      fname=filename;

slsDetectorCalibration/multiThreadedAnalogDetector.h

@@ -17,7 +17,7 @@
 #include <pthread.h>
 
 #include "analogDetector.h"
-#include "sls/CircularFifo.h"
+#include "circularFifo.h"
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -123,7 +123,7 @@ public:
      return fifoFree->pop(ptr);
    }
 
-   virtual int isBusy() {if (fifoData->isEmpty() && busy==0) return 0; else return 1;}
+   virtual int isBusy() {if (fifoData->isEmpty() && busy==0) return 0; return 1;}
    
    //protected:
    /** Implement this method in your subclass with the code you want your thread to run. */

slsDetectorServers/mythen3DetectorServer/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_executable(mythen3DetectorServer_virtual
     slsDetectorFunctionList.c
+    mythen3.c
     ../slsDetectorServer/src/slsDetectorServer.c
     ../slsDetectorServer/src/slsDetectorServer_funcs.c
     ../slsDetectorServer/src/communication_funcs.c
@@ -10,7 +11,8 @@ add_executable(mythen3DetectorServer_virtual
     ../slsDetectorServer/src/LTC2620_Driver.c
     ../slsDetectorServer/src/ALTERA_PLL_CYCLONE10.c   
     ../slsDetectorServer/src/programFpgaNios.c
-    ../slsDetectorServer/src/readDefaultPattern.c         
+    ../slsDetectorServer/src/readDefaultPattern.c 
+    ../slsDetectorServer/src/loadPattern.c         
     ../slsDetectorServer/src/sharedMemory.c
 )
 

slsDetectorServers/mythen3DetectorServer/Makefile

@@ -13,7 +13,7 @@ DESTDIR		?= 	bin
 INSTMODE	= 	0777
 
 SRCS	=	slsDetectorFunctionList.c 
-SRCS	+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c
+SRCS	+=	$(main_src)slsDetectorServer.c $(main_src)slsDetectorServer_funcs.c $(main_src)communication_funcs.c $(main_src)nios.c $(main_src)DAC6571.c $(main_src)common.c $(main_src)LTC2620_Driver.c $(main_src)ALTERA_PLL_CYCLONE10.c $(main_src)/programFpgaNios.c $(main_src)readDefaultPattern.c $(main_src)/sharedMemory.c $(main_src)/loadPattern.c mythen3.c
 
 OBJS 	= 	$(SRCS:.c=.o) 
  
@@ -40,4 +40,4 @@ clean:
 	rm -rf $(DESTDIR)/$(PROGS)  *.o *.gdb $(main_src)*.o
 	
 
-	
+	

slsDetectorServers/mythen3DetectorServer/mythen3.c

@@ -0,0 +1,374 @@
+
+#include "clogger.h"
+#include "common.h"
+#include "mythen3.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#include <string.h>
+
+/*
+// Common C/C++ structure to handle pattern data
+typedef struct __attribute__((packed)) {
+    uint64_t word[MAX_PATTERN_LENGTH];
+    uint64_t ioctrl;
+    uint32_t limits[2];
+    // loop0 start, loop0 stop .. loop2 start, loop2 stop
+    uint32_t loop[6];
+    uint32_t nloop[3];
+    uint32_t wait[3];
+    uint64_t waittime[3];
+} patternParameters;
+*/
+
+int chipStatusRegister=0;
+
+int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
+
+int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
+
+extern enum TLogLevel trimmingPrint ;
+
+
+int getChipStatusRegister(){
+  return chipStatusRegister;
+}
+
+int gainCapsToCsr(int caps){
+  //Translates bit representation
+  int csr = 0;
+  if (!(caps & M3_C10pre))
+    csr |= 1 << _CSR_C10pre;
+  if (caps & M3_C15sh)
+    csr |= 1 << CSR_C15sh;
+  if (caps & M3_C30sh)
+    csr |= 1 << CSR_C30sh;
+  if (caps & M3_C50sh)
+    csr |= 1 << CSR_C50sh;
+  if (caps & M3_C225ACsh)
+    csr |= 1 << CSR_C225ACsh;
+  if (!(caps & M3_C15pre))
+    csr |= 1 << _CSR_C15pre;
+
+  return csr;
+}
+
+int csrToGainCaps(int csr){
+  //Translates bit representation
+  int caps = 0;
+  if (!(csr & (1 << _CSR_C10pre)))
+    caps |= M3_C10pre;
+  if (csr & (1 << CSR_C15sh))
+    caps |= M3_C15sh;
+  if (csr & (1 << CSR_C30sh))
+    caps |= M3_C30sh;
+  if (csr & (1 << CSR_C50sh))
+    caps |= M3_C50sh;
+  if (csr & (1 << CSR_C225ACsh))
+    caps |= M3_C225ACsh;
+  if (!(csr & (1 << _CSR_C15pre)))
+    caps |= M3_C15pre;
+
+  return caps;
+}
+
+patternParameters *setChipStatusRegisterPattern(int csr) {
+  int iaddr=0;
+  int  nbits=18;
+  int error=0;
+  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
+  int patword=0;
+  
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+  patword=setBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_resStorage,patword);
+  patword=setBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_resStorage,patword);
+  patword=clearBit(SIGNAL_resCounter,patword);
+  for (int i=0; i<8; i++)
+    pat->word[iaddr++]=patword;
+  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
+  for (int ib=nbits-1; ib>=0; ib--) {
+    if (csr&(1<<ib))
+      patword=setBit(SIGNAL_serialIN,patword);
+    else
+      patword=clearBit(SIGNAL_serialIN,patword);
+    for (int i=0; i<4; i++)
+      pat->word[iaddr++]=patword;
+    patword=setBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+    patword=clearBit(SIGNAL_CHSclk,patword);
+    pat->word[iaddr++]=patword;
+  }
+
+  patword=clearBit(SIGNAL_serialIN,patword);
+  for (int i=0; i<2; i++)
+    pat->word[iaddr++]=patword;
+  patword=setBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STO,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+  patword=clearBit(SIGNAL_STATLOAD,patword);
+  for (int i=0; i<5; i++)
+    pat->word[iaddr++]=patword;
+
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  if (error != 0) {
+    free(pat);
+    return NULL;
+  }
+  chipStatusRegister=csr;
+  return pat;
+
+}
+
+patternParameters *setInterpolation(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_interp);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_interp);
+
+  return setChipStatusRegisterPattern(csr);
+}
+
+
+
+patternParameters *setPumpProbe(int mask) {
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_pumprobe);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_pumprobe);
+
+  return setChipStatusRegisterPattern(csr);
+
+}
+patternParameters *setDigitalPulsing(int mask) {
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_dpulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_dpulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setAnalogPulsing(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_apulse);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_apulse);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+patternParameters *setNegativePolarity(int mask){
+
+  int csr;
+  if (mask)
+    csr=chipStatusRegister|(1<< CSR_invpol);
+  else
+    csr=chipStatusRegister & ~(1<< CSR_invpol);
+
+  return setChipStatusRegisterPattern(csr);
+  
+}
+
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits) {
+
+  patternParameters *pat = malloc(sizeof(patternParameters));
+  memset(pat, 0, sizeof(patternParameters));
+  
+
+    // validate
+  for (int ichan = ichip * NCHAN_1_COUNTER * NCOUNTERS; ichan < ichip * NCHAN_1_COUNTER * NCOUNTERS+NCHAN_1_COUNTER*NCOUNTERS; ichan++) {
+    if (trimbits[ichan]<0)  {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - setting it to 0\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=0;
+    }
+    if (trimbits[ichan] > 63) {
+      LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid - settings it to 63\n",
+		     trimbits[ichan], ichan));
+      trimbits[ichan]=63;
+    }
+  }
+  LOG(logINFO, ("Trimbits validated\n"));
+  trimmingPrint = logDEBUG5;
+
+    
+  // trimming
+  int error = 0;
+  uint64_t patword = 0;
+  int iaddr = 0;
+  
+  LOG(logDEBUG1, (" Chip %d\n", ichip));
+  iaddr = 0;
+  patword = 0;
+  pat->word[iaddr++]=patword;
+  
+  // chip select
+  patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // reset trimbits
+  patword = setBit(SIGNAL_resStorage, patword);
+  patword = setBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_resStorage, patword);
+  patword = clearBit(SIGNAL_resCounter, patword);
+  pat->word[iaddr++]=patword;
+  pat->word[iaddr++]=patword;
+  
+  // select first channel
+  patword = setBit(SIGNAL_CHSserialIN, patword);
+  pat->word[iaddr++]=patword;
+  // 1 clk pulse
+  patword = setBit(SIGNAL_CHSclk, patword);
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSclk, patword);
+  // clear 1st channel
+  pat->word[iaddr++]=patword;
+  patword = clearBit(SIGNAL_CHSserialIN, patword);
+  // 2 clk pulses
+  for (int i = 0; i < 2; i++) {
+    patword = setBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+    patword = clearBit(SIGNAL_CHSclk, patword);
+    pat->word[iaddr++]=patword;
+  }
+  
+  // for each channel (all chips)
+  for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
+    LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
+    int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+		       NCOUNTERS * ich] +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 1] *
+      64 +
+      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
+	       NCOUNTERS * ich + 2] *
+      64 * 64;
+    
+    // push 6 0 bits
+    for (int i = 0; i < 3; i++) {
+      patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    for (int i = 0; i < 3; i++) {
+      if (mask[i])
+	patword = setBit(SIGNAL_serialIN, patword);
+      else
+	patword = clearBit(SIGNAL_serialIN, patword);
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    
+    // deserialize
+    for (int i = 0; i < 18; i++) {
+      if (val & (1 << i)) {
+	patword = setBit(SIGNAL_serialIN, patword);
+      } else {
+	patword = clearBit(SIGNAL_serialIN, patword);
+      }
+      patword = clearBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+      
+      patword = setBit(SIGNAL_clk, patword);
+      pat->word[iaddr++]=patword;
+    }
+    pat->word[iaddr++]=patword;
+    pat->word[iaddr++]=patword;
+    
+    // move to next channel
+    for (int i = 0; i < 3; i++) {
+      patword = setBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+      patword = clearBit(SIGNAL_CHSclk, patword);
+      pat->word[iaddr++]=patword;
+    }
+  }
+  // chip unselect
+  patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
+  pat->word[iaddr++]=patword;
+  
+  // last iaddr check
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  
+  if (iaddr >= MAX_PATTERN_LENGTH) {
+    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
+		   iaddr, MAX_PATTERN_LENGTH));
+    error = 1;
+  }
+  // set pattern wait address
+  for (int i = 0; i <= 2; i++)
+    pat->wait[i]=MAX_PATTERN_LENGTH - 1;
+  // pattern loop
+  for (int i = 0; i <= 2; i++) {
+    //int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
+    pat->loop[i * 2 + 0]=MAX_PATTERN_LENGTH - 1;
+    pat->loop[i * 2 + 1]=MAX_PATTERN_LENGTH - 1;
+    pat->nloop[i]=0;
+  }
+  
+  // pattern limits
+  {
+    pat->limits[0]=0;
+    pat->limits[1]=iaddr;
+  }
+  
+  trimmingPrint = logINFO;
+  if (error == 0) {
+    
+    LOG(logINFO, ("All trimbits have been loaded\n"));
+  } else {
+    free(pat);
+    return NULL;
+  }
+  return pat;
+}

slsDetectorServers/mythen3DetectorServer/mythen3.h

@@ -0,0 +1,68 @@
+#ifndef MYTHEN3_H
+#define MYTHEN3_H
+
+#include "Pattern.h"
+
+/** Signal Definitions */
+#define SIGNAL_TBLoad_1    (0)
+#define SIGNAL_TBLoad_2    (1)
+#define SIGNAL_TBLoad_3    (2)
+#define SIGNAL_TBLoad_4    (3)
+#define SIGNAL_TBLoad_5    (4)
+#define SIGNAL_TBLoad_6    (5)
+#define SIGNAL_TBLoad_7    (6)
+#define SIGNAL_TBLoad_8    (7)
+#define SIGNAL_TBLoad_9    (8)
+#define SIGNAL_TBLoad_10   (9)
+#define SIGNAL_AnaMode     (10)
+#define SIGNAL_CHSserialIN (11)
+#define SIGNAL_READOUT     (12)
+#define SIGNAL_pulse       (13)
+#define SIGNAL_EN1         (14)
+#define SIGNAL_EN2         (15)
+#define SIGNAL_EN3         (16)
+#define SIGNAL_clk         (17)
+#define SIGNAL_SRmode      (18)
+#define SIGNAL_serialIN    (19)
+#define SIGNAL_STO         (20)
+#define SIGNAL_STATLOAD    (21)
+#define SIGNAL_resStorage  (22)
+#define SIGNAL_resCounter  (23)
+#define SIGNAL_CHSclk      (24)
+#define SIGNAL_exposing    (25)
+
+
+//CHIP STARTUS REGISTER BITS
+#define CSR_spypads  0
+#define CSR_invpol  4
+#define CSR_dpulse  5
+#define CSR_interp  6
+#define _CSR_C10pre  7 //#default, negative polarity
+#define CSR_pumprobe  8
+#define CSR_apulse  9
+#define CSR_C15sh  10 
+#define CSR_C30sh  11 //#default
+#define CSR_C50sh  12
+#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
+#define _CSR_C15pre  14 // negative polarity
+
+#define CSR_default  (1<<_CSR_C10pre )|(1<< CSR_C30sh)
+
+#define GAIN_MASK ((1 << _CSR_C10pre) | ( 1 << CSR_C15sh) | (1 << CSR_C30sh) | (1 << CSR_C50sh) | (1 << CSR_C225ACsh) | ( 1 << _CSR_C15pre))
+
+
+int setBit(int ibit, int patword);
+int clearBit(int ibit, int patword);
+int getChipStatusRegister();
+int gainCapsToCsr(int caps);
+int csrToGainCaps(int csr);
+
+patternParameters *setChipStatusRegisterPattern(int csr);
+patternParameters *setChannelRegisterChip(int ichip, int *mask, int *trimbits);
+patternParameters *setInterpolation(int mask);
+patternParameters *setPumpProbe(int mask);
+patternParameters *setDigitalPulsing(int mask);
+patternParameters *setAnalogPulsing(int mask);
+patternParameters *setNegativePolarity(int mask);
+
+#endif

slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c

@@ -5,6 +5,8 @@
 #include "RegisterDefs.h"
 #include "clogger.h"
 #include "common.h"
+#include "mythen3.h"
+#include "loadPattern.h"
 #include "sharedMemory.h"
 #include "sls/versionAPI.h"
 #ifdef VIRTUAL
@@ -19,8 +21,6 @@
 #include <time.h>
 #endif
 
-/// NOT the right place to put it!
-int setChipStatusRegister(int csr);
 
 // Global variable from slsDetectorServer_funcs
 extern int debugflag;
@@ -47,11 +47,12 @@ enum detectorSettings thisSettings;
 sls_detector_module *detectorModules = NULL;
 int *detectorChans = NULL;
 int *detectorDacs = NULL;
+int *channelMask=NULL;
 
-enum TLogLevel trimmingPrint = logINFO;
 int32_t clkPhase[NUM_CLOCKS] = {};
 uint32_t clkDivider[NUM_CLOCKS] = {};
 
+enum TLogLevel trimmingPrint = logINFO;
 int highvoltage = 0;
 int detPos[2] = {};
 int64_t exptimeReg[NCOUNTERS] = {0, 0, 0};
@@ -374,7 +375,11 @@ void allocateDetectorStructureMemory() {
     // Allocation of memory
     detectorModules = malloc(sizeof(sls_detector_module));
     detectorChans = malloc(NCHIP * NCHAN * sizeof(int));
+    channelMask = malloc(NCHIP * NCHAN * sizeof(char));
+    memset(channelMask, 0, NCHIP * NCHAN * sizeof(char));
     detectorDacs = malloc(NDAC * sizeof(int));
+
+    
     LOG(logDEBUG1,
         ("modules from 0x%x to 0x%x\n", detectorModules, detectorModules));
     LOG(logDEBUG1, ("chans from 0x%x to 0x%x\n", detectorChans, detectorChans));
@@ -512,11 +517,11 @@ void setupDetector() {
     }
 
     powerChip(1);
-    if (initError != FAIL) {
-      initError = setChipStatusRegister(CSR_default);
-      //loadDefaultPattern(DEFAULT_PATTERN_FILE, initErrorMessage);
-      //startStateMachine(); //this was missing in previous code! runs the default pattern
+
+    if (!initError) {
+      setChipStatusRegister(CSR_default);
     }
+
     setAllTrimbits(DEFAULT_TRIMBIT_VALUE);
 }
 
@@ -1052,72 +1057,44 @@ int64_t getMeasurementTime() {
 
 /* parameters - module, speed, readout */
 
-int setModule(sls_detector_module myMod, char *mess) {
-
-    LOG(logINFO, ("Setting module\n"));
-
-    // settings
-    if (myMod.reg >= 0) {
-        setSettings((enum detectorSettings)myMod.reg);
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
-            sprintf(
-                mess,
-                "Could not set module. Could not set settings to %d, read %d\n",
-                myMod.reg, (int)getSettings());
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
-        detectorModules->reg = myMod.reg;
-    }
-    // custom trimbit file
-    else {
-        // changed for setsettings (direct),
-        // custom trimbit file (setmodule with myMod.reg as -1),
-        // change of dac (direct)
-        for (int i = 0; i < NCOUNTERS; ++i) {
-            setThresholdEnergy(i, -1);
-        }
-    }
-
-    // dacs
+int setDACS(int* dacs){
     for (int i = 0; i < NDAC; ++i) {
-        // ignore dacs with -1
-        if (myMod.dacs[i] != -1) {
-            setDAC((enum DACINDEX)i, myMod.dacs[i], 0);
-            if (myMod.dacs[i] != detectorDacs[i]) {
+        if (dacs[i] != -1) {
+            setDAC((enum DACINDEX)i, dacs[i], 0);
+            if (dacs[i] != detectorDacs[i]) {
                 // dont complain if that counter was disabled
                 if ((i == M_VTH1 || i == M_VTH2 || i == M_VTH3) &&
                     (detectorDacs[i] == DEFAULT_COUNTER_DISABLED_VTH_VAL)) {
                     continue;
                 }
-                sprintf(mess,
-                        "Could not set module. Could not set dac %d, wrote %d, "
-                        "read %d\n",
-                        i, myMod.dacs[i], detectorDacs[i]);
-                LOG(logERROR, (mess));
                 return FAIL;
             }
         }
     }
+    return OK;
+}
 
-    // if settings given and cannot be validated (after setting dacs), return
-    // error
-    if (myMod.reg >= 0) {
-        if (getSettings() != (enum detectorSettings)myMod.reg) {
-            sprintf(
-                mess,
-                "Could not set module. The dacs in file do not correspond to "
-                "settings %d\n",
-                myMod.reg);
-            LOG(logERROR, (mess));
-            return FAIL;
-        }
+
+int setModule(sls_detector_module myMod, char *mess) {
+    LOG(logINFO, ("Setting module\n"));
+
+    if (setChipStatusRegister(myMod.reg)){
+        sprintf(mess, "Could not CSR from module\n");
+        LOG(logERROR, (mess));
+        return FAIL;
+    }
+
+    if (setDACS(myMod.dacs)){
+        sprintf(mess, "Could not set dacs\n");
+        LOG(logERROR, (mess));
+        return FAIL;
     }
 
-    // threshold
     for (int i = 0; i < NCOUNTERS; ++i) {
         if (myMod.eV[i] >= 0) {
             setThresholdEnergy(i, myMod.eV[i]);
+        }else{
+            setThresholdEnergy(i, -1);
         }
     }
 
@@ -1136,155 +1113,31 @@ int setModule(sls_detector_module myMod, char *mess) {
     return OK;
 }
 
-int setBit(int ibit, int patword) { return patword |= (1 << ibit); }
-
-int clearBit(int ibit, int patword) { return patword &= ~(1 << ibit); }
-
 int setTrimbits(int *trimbits) {
-    LOG(logINFOBLUE, ("Setting trimbits\n"));
-
-    // validate
-    for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
-        if (trimbits[ichan] < 0 || trimbits[ichan] > 63) {
-            LOG(logERROR, ("Trimbit value (%d) for channel %d is invalid\n",
-                           trimbits[ichan], ichan));
-            return FAIL;
-        }
-    }
-    LOG(logINFO, ("Trimbits validated\n"));
-    trimmingPrint = logDEBUG5;
-
     // remember previous run clock
     uint32_t prevRunClk = clkDivider[SYSTEM_C0];
-
+    patternParameters *pat = NULL;
+    int error = 0;
     // set to trimming clock
     if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
         LOG(logERROR,
             ("Could not start trimming. Could not set to trimming clock\n"));
         return FAIL;
     }
-
-    // trimming
-    int error = 0;
-    uint64_t patword = 0;
-    int iaddr = 0;
+    /////////////////////////////////////////////////////////////////
     for (int ichip = 0; ichip < NCHIP; ichip++) {
-        if (error != 0) {
-            break;
-        }
-        LOG(logDEBUG1, (" Chip %d\n", ichip));
-        iaddr = 0;
-        patword = 0;
-        writePatternWord(iaddr++, patword);
 
-        // chip select
-        patword = setBit(SIGNAL_TBLoad_1 + ichip, patword);
-        writePatternWord(iaddr++, patword);
-
-        // reset trimbits
-        patword = setBit(SIGNAL_resStorage, patword);
-        patword = setBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_resStorage, patword);
-        patword = clearBit(SIGNAL_resCounter, patword);
-        writePatternWord(iaddr++, patword);
-        writePatternWord(iaddr++, patword);
-
-        // select first channel
-        patword = setBit(SIGNAL_CHSserialIN, patword);
-        writePatternWord(iaddr++, patword);
-        // 1 clk pulse
-        patword = setBit(SIGNAL_CHSclk, patword);
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSclk, patword);
-        // clear 1st channel
-        writePatternWord(iaddr++, patword);
-        patword = clearBit(SIGNAL_CHSserialIN, patword);
-        // 2 clk pulses
-        for (int i = 0; i < 2; i++) {
-            patword = setBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-            patword = clearBit(SIGNAL_CHSclk, patword);
-            writePatternWord(iaddr++, patword);
-        }
-
-        // for each channel (all chips)
-        for (int ich = 0; ich < NCHAN_1_COUNTER; ich++) {
-            LOG(logDEBUG1, (" Chip %d, Channel %d\n", ichip, ich));
-            int val = trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich] +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 1] *
-                          64 +
-                      trimbits[ichip * NCHAN_1_COUNTER * NCOUNTERS +
-                               NCOUNTERS * ich + 2] *
-                          64 * 64;
-
-            // push 6 0 bits
-            for (int i = 0; i < 6; i++) {
-                patword = clearBit(SIGNAL_serialIN, patword);
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-
-            // deserialize
-            for (int i = 0; i < 18; i++) {
-                if (val & (1 << i)) {
-                    patword = setBit(SIGNAL_serialIN, patword);
-                } else {
-                    patword = clearBit(SIGNAL_serialIN, patword);
-                }
-                patword = clearBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-
-                patword = setBit(SIGNAL_clk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-            writePatternWord(iaddr++, patword);
-            writePatternWord(iaddr++, patword);
-
-            // move to next channel
-            for (int i = 0; i < 3; i++) {
-                patword = setBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-                patword = clearBit(SIGNAL_CHSclk, patword);
-                writePatternWord(iaddr++, patword);
-            }
-        }
-        // chip unselect
-        patword = clearBit(SIGNAL_TBLoad_1 + ichip, patword);
-        writePatternWord(iaddr++, patword);
-
-        // last iaddr check
-        if (iaddr >= MAX_PATTERN_LENGTH) {
-            LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
-                           iaddr, MAX_PATTERN_LENGTH));
+        pat = setChannelRegisterChip(ichip, channelMask,
+                                     trimbits); // change here!!!
+        if (pat) {
+            error |= loadPattern(pat);
+            if (error == 0)
+                startPattern();
+            free(pat);
+        } else
             error = 1;
-            break;
-        }
-
-        // set pattern wait address
-        for (int i = 0; i <= 2; i++)
-            setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
-
-        // pattern loop
-        for (int i = 0; i <= 2; i++) {
-            int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-            setPatternLoop(i, &stop, &stop, &nloop);
-        }
-
-        // pattern limits
-        {
-            int start = 0, nloop = 0;
-            setPatternLoop(-1, &start, &iaddr, &nloop);
-        }
-        // send pattern to the chips
-        startPattern();
     }
-
+    /////////////////////////////////////////////////////////////////
     if (error == 0) {
         // copy trimbits locally
         for (int ichan = 0; ichan < ((detectorModules)->nchan); ++ichan) {
@@ -1292,7 +1145,6 @@ int setTrimbits(int *trimbits) {
         }
         LOG(logINFO, ("All trimbits have been loaded\n"));
     }
-
     trimmingPrint = logINFO;
     // set back to previous clock
     if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
@@ -1303,7 +1155,6 @@ int setTrimbits(int *trimbits) {
     if (error != 0) {
         return FAIL;
     }
-
     return OK;
 }
 
@@ -2780,76 +2631,51 @@ int getNumberOfDACs() { return NDAC; }
 int getNumberOfChannelsPerChip() { return NCHAN; }
 
 int setChipStatusRegister(int csr) {
-  int iaddr=0;
-  int  nbits=18;
-  int error=0;
-  //int start=0, stop=MAX_PATTERN_LENGTH, loop=0;
-  int patword=0;
-  patword=setBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<2; i++)
-    writePatternWord(iaddr++, patword);
-  patword=setBit(SIGNAL_resStorage,patword);
-  patword=setBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_resStorage,patword);
-  patword=clearBit(SIGNAL_resCounter,patword);
-  for (int i=0; i<8; i++)
-    writePatternWord(iaddr++, patword);
-  //#This version of the serializer pushes in the MSB first (compatible with the CSR bit numbering)
-  for (int ib=nbits-1; ib>=0; ib--) {
-    if (csr&(1<<ib))
-      patword=setBit(SIGNAL_serialIN,patword);
-    else
-      patword=clearBit(SIGNAL_serialIN,patword);
-    for (int i=0; i<4; i++)
-      writePatternWord(iaddr++, patword);
-    patword=setBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-    patword=clearBit(SIGNAL_CHSclk,patword);
-    writePatternWord(iaddr++, patword);
-  }
+    uint32_t prevRunClk = clkDivider[SYSTEM_C0];
+    patternParameters *pat = NULL;
 
-  patword=clearBit(SIGNAL_serialIN,patword);
-  for (int i=0; i<2; i++)
-      writePatternWord(iaddr++, patword);
-  patword=setBit(SIGNAL_STO,patword);
-  for (int i=0; i<5; i++)
-      writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STO,patword);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
-  patword=clearBit(SIGNAL_STATLOAD,patword);
-  for (int i=0; i<5; i++)
-    writePatternWord(iaddr++, patword);
+    int error = 0;
+    if (setClockDivider(SYSTEM_C0, DEFAULT_TRIMMING_RUN_CLKDIV) == FAIL) {
+        LOG(logERROR,
+            ("Could not set to trimming clock in order to change CSR\n"));
+        return FAIL;
+    }
+    pat = setChipStatusRegisterPattern(csr);
 
-  if (iaddr >= MAX_PATTERN_LENGTH) {
-    LOG(logERROR, ("Addr 0x%x is past max_address_length 0x%x!\n",
-		   iaddr, MAX_PATTERN_LENGTH));
-    error = 1;
-  }
-  // set pattern wait address
-  for (int i = 0; i <= 2; i++)
-    setPatternWaitAddress(i, MAX_PATTERN_LENGTH - 1);
-  
-  // pattern loop
-  for (int i = 0; i <= 2; i++) {
-    int stop = MAX_PATTERN_LENGTH - 1, nloop = 0;
-    setPatternLoop(i, &stop, &stop, &nloop);
-  }
-  
-  // pattern limits
-  {
-    int start = 0, nloop = 0;
-    setPatternLoop(-1, &start, &iaddr, &nloop);
-  }
-  // send pattern to the chips
-  startPattern();
-  
-  if (error != 0) {
-    return FAIL;
-  }
-  
-  return OK;
+    if (pat) {
+        error |= loadPattern(pat);
+        if (!error)
+            startPattern();
+        free(pat);
+    } else {
+        error = 1;
+    }
 
+    if (!error) {
+        LOG(logINFO, ("CSR is now: 0x%x\n", csr));
+    }
+
+    if (setClockDivider(SYSTEM_C0, prevRunClk) == FAIL) {
+        LOG(logERROR,
+            ("Could not set to previous run clock after changing CSR\n"));
+        return FAIL;
+    }
+    return OK;
+}
+
+int setGainCaps(int caps){
+    // Update only gain caps, leave the rest of the CSR unchanged
+    int csr = getChipStatusRegister();
+    csr &= ~GAIN_MASK;
+
+    caps = gainCapsToCsr(caps);
+    // caps &= GAIN_MASK;
+    csr |= caps;
+    return setChipStatusRegister(csr);
+}
+
+int getGainCaps(){
+    int csr = getChipStatusRegister();
+    int caps = csrToGainCaps(csr);
+    return caps; 
 }

slsDetectorServers/mythen3DetectorServer/slsDetectorServer_defs.h

@@ -158,47 +158,3 @@ typedef struct udp_header_struct {
 #define UDP_IP_HEADER_LENGTH_BYTES (28)
 #define PACKETS_PER_FRAME_10G      (2)
 #define PACKETS_PER_FRAME_1G       (20)
-
-/** Signal Definitions */
-#define SIGNAL_TBLoad_1    (0)
-#define SIGNAL_TBLoad_2    (1)
-#define SIGNAL_TBLoad_3    (2)
-#define SIGNAL_TBLoad_4    (3)
-#define SIGNAL_TBLoad_5    (4)
-#define SIGNAL_TBLoad_6    (5)
-#define SIGNAL_TBLoad_7    (6)
-#define SIGNAL_TBLoad_8    (7)
-#define SIGNAL_TBLoad_9    (8)
-#define SIGNAL_TBLoad_10   (9)
-#define SIGNAL_AnaMode     (10)
-#define SIGNAL_CHSserialIN (11)
-#define SIGNAL_READOUT     (12)
-#define SIGNAL_pulse       (13)
-#define SIGNAL_EN1         (14)
-#define SIGNAL_EN2         (15)
-#define SIGNAL_EN3         (16)
-#define SIGNAL_clk         (17)
-#define SIGNAL_SRmode      (18)
-#define SIGNAL_serialIN    (19)
-#define SIGNAL_STO         (20)
-#define SIGNAL_STATLOAD    (21)
-#define SIGNAL_resStorage  (22)
-#define SIGNAL_resCounter  (23)
-#define SIGNAL_CHSclk      (24)
-#define SIGNAL_exposing    (25)
-
-//CHIP STARTUS REGISTER BITS
-#define CSR_spypads  0
-#define CSR_invpol  4
-#define CSR_dpulse  5
-#define CSR_interp  6
-#define CSR_C10pre  7 //#default
-#define CSR_pumprobe  8
-#define CSR_apulse  9
-#define CSR_C15sh  10 
-#define CSR_C30sh  11 //#default
-#define CSR_C50sh  12
-#define CSR_C225ACsh  13 // Connects 225fF SHAPER AC cap (1: 225 to shaper, 225 to GND. 0: 450 to shaper) 
-#define CSR_C15pre  14 
-
-#define CSR_default  (1<<CSR_C10pre )|(1<< CSR_C30sh)

slsDetectorServers/slsDetectorServer/include/loadPattern.h

@@ -0,0 +1,6 @@
+#ifndef LOADPATTERN_H
+#define LOADPATTERN_H
+#include "Pattern.h"
+
+int loadPattern(patternParameters *pat);
+#endif

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -25,6 +25,10 @@
 #include "blackfin.h"
 #endif
 
+#if defined(MYTHEN3D) 
+#include "mythen3.h"
+#endif
+
 #include <stdio.h> // FILE
 #include <stdlib.h>
 #include <sys/types.h>
@@ -353,6 +357,10 @@ enum timingMode getTiming();
 #ifdef MYTHEN3D
 void setInitialExtSignals();
 int isMaster();
+int setGainCaps(int caps);
+int getGainCaps();
+int setChipStatusRegister(int csr);
+int setDACS(int* dacs);
 #endif
 #if defined(GOTTHARDD) || defined(MYTHEN3D)
 void setExtSignal(int signalIndex, enum externalSignalFlag mode);

slsDetectorServers/slsDetectorServer/include/slsDetectorServer_funcs.h

@@ -246,4 +246,7 @@ int is_virtual(int);
 int get_pattern(int);
 int load_default_pattern(int);
 int get_all_threshold_energy(int);
-int get_master(int);
+int get_master(int);
+int get_csr();
+int set_gain_caps(int);
+int get_gain_caps(int);

slsDetectorServers/slsDetectorServer/src/loadPattern.c

@@ -0,0 +1,105 @@
+#include "readDefaultPattern.h"
+#include "loadPattern.h"
+#include "clogger.h"
+#include "common.h"
+#include "sls/ansi.h"
+#include "sls/sls_detector_defs.h"
+#include "slsDetectorServer_defs.h"
+
+#if defined(CHIPTESTBOARDD) || defined(MOENCHD) || defined(MYTHEN3D)
+#include "Pattern.h"
+#endif
+
+#include <string.h>
+#include <unistd.h>
+
+extern char initErrorMessage[MAX_STR_LENGTH];
+
+#ifndef MYTHEN3D
+extern uint64_t writePatternIOControl(uint64_t word);
+#endif
+extern uint64_t writePatternWord(int addr, uint64_t word);
+extern int setPatternWaitAddress(int level, int addr);
+extern uint64_t setPatternWaitTime(int level, uint64_t t);
+extern void setPatternLoop(int level, int *startAddr, int *stopAddr,
+                           int *nLoop);
+
+int loadPattern(patternParameters *pat) {
+
+  int ret=OK;
+
+  for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
+    if ((i % 10 == 0) && pat->word[i] != 0) {
+      LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
+		    i, (long long int)pat->word[i]));
+    }
+    writePatternWord(i, pat->word[i]);
+  }
+#ifndef MYTHEN3D 
+   if (ret == OK) { 
+     uint64_t retval64 = writePatternIOControl(pat->ioctrl); 
+     //validate64(pat->ioctrl, retval64, "set pattern IO Control", HEX); 
+   } 
+#endif 
+        if (ret == OK) {
+            int numLoops = -1;
+            int retval0 = pat->limits[0];
+            int retval1 = pat->limits[1];
+            setPatternLoop(-1, &retval0, &retval1, &numLoops);
+            //validate(pat->limits[0], retval0,
+	    // "set pattern Limits start address", HEX);
+	//validate(pat->limits[1], retval1,
+	    //       "set pattern Limits start address", HEX);
+        }
+	uint64_t retval64;
+        if (ret == OK) {
+            for (int i = 0; i <= 2; ++i) {
+                char msg[128];
+                int retval0 = -1, retval1 = -1, numLoops = -1;
+
+                // patloop
+                retval0 = pat->loop[i * 2 + 0];
+                retval1 = pat->loop[i * 2 + 1];
+                numLoops = pat->nloop[i];
+                setPatternLoop(i, &retval0, &retval1, &numLoops);
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d start address", i);
+                //validate(pat->loop[i * 2 + 0], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d stop address", i);
+                //validate(pat->loop[i * 2 + 1], retval1, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d num loops", i);
+                //validate(pat->nloop[i], numLoops, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+                // patwait
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait address", i);
+                retval0 = setPatternWaitAddress(i, pat->wait[i]);
+                //validate(pat->wait[i], retval0, msg, HEX);
+                if (ret == FAIL) {
+                    break;
+                }
+
+                // patwaittime
+                memset(msg, 0, sizeof(msg));
+                sprintf(msg, "set pattern Loop %d wait time", i);
+                retval64 = setPatternWaitTime(i, pat->waittime[i]);
+                //validate64(pat->waittime[i], retval64, msg, HEX);
+                if (retval64 == FAIL) {
+                    break;
+                }
+	    }
+	}
+	return ret;
+}
+
+

slsDetectorServers/slsDetectorServer/src/readDefaultPattern.c

@@ -1,4 +1,5 @@
 #include "readDefaultPattern.h"
+#include "loadPattern.h"
 #include "clogger.h"
 #include "common.h"
 #include "sls/ansi.h"

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -369,6 +369,9 @@ void function_table() {
     flist[F_LOAD_DEFAULT_PATTERN] = &load_default_pattern;
     flist[F_GET_ALL_THRESHOLD_ENERGY] = &get_all_threshold_energy;
     flist[F_GET_MASTER] = &get_master;
+    flist[F_GET_CSR] = &get_csr;
+    flist[F_SET_GAIN_CAPS] = &set_gain_caps;
+    flist[F_GET_GAIN_CAPS] = &get_gain_caps;
 
     // check
     if (NUM_DET_FUNCTIONS >= RECEIVER_ENUM_START) {
@@ -1547,18 +1550,11 @@ int set_module(int file_des) {
     // only set
     else if (Server_VerifyLock() == OK) {
         // check index
+
+#if !(defined(EIGERD) || defined(MYTHEN3D))
+//TODO! Check if this is used for any detector
         switch (module.reg) {
-#ifdef EIGERD
-        case STANDARD:
-        case HIGHGAIN:
-        case LOWGAIN:
-        case VERYHIGHGAIN:
-        case VERYLOWGAIN:
-#elif MYTHEN3D
-        case STANDARD:
-        case FAST:
-        case HIGHGAIN:
-#elif JUNGFRAUD
+#ifdef JUNGFRAUD
         case DYNAMICGAIN:
         case DYNAMICHG0:
         case FIXGAIN1:
@@ -1577,10 +1573,12 @@ int set_module(int file_des) {
             modeNotImplemented("Settings", (int)module.reg);
             break;
         }
-
+#endif
         ret = setModule(module, mess);
         enum detectorSettings retval = getSettings();
+#if !(defined(EIGERD) || defined(MYTHEN3D))
         validate(module.reg, (int)retval, "set module (settings)", DEC);
+#endif
         LOG(logDEBUG1, ("Settings: %d\n", retval));
     }
     free(myChan);
@@ -7578,18 +7576,22 @@ int set_pattern(int file_des) {
 
     patternParameters *pat = malloc(sizeof(patternParameters));
     memset(pat, 0, sizeof(patternParameters));
-
-    // ignoring endianness for eiger
+      // ignoring endianness for eiger
     if (receiveData(file_des, pat, sizeof(patternParameters), INT32) < 0) {
         if (pat != NULL)
             free(pat);
         return printSocketReadError();
     }
-
+ 
     if (Server_VerifyLock() == OK) {
         LOG(logINFO, ("Setting Pattern from structure\n"));
         LOG(logINFO,
-            ("Setting Pattern Word (printing every 10 words that are not 0\n"));
+            ("Setting Pattern Word (printing every 10 words that are not 0\n"));   
+	/****************************************************************************************************************/
+	/* I SUGGEST TO VALIDATE THE VALUES HERE AND THEN WRITE THE PATTERN IN A SEPARATE FUNCTION WHICH COULD BE REUSED*/
+	/* added loadPattern.c/h - the same func could be reused also in readDefaultPattern                                  */
+	/***************************************************************************************************************/
+
         for (int i = 0; i < MAX_PATTERN_LENGTH; ++i) {
             if ((i % 10 == 0) && pat->word[i] != 0) {
                 LOG(logINFO, ("Setting Pattern Word (addr:0x%x, word:0x%llx)\n",
@@ -7662,6 +7664,7 @@ int set_pattern(int file_des) {
                 }
             }
         }
+	/******* DOWN TO HERE ***********/
     }
     if (pat != NULL)
         free(pat);
@@ -8383,3 +8386,63 @@ int get_master(int file_des){
 #endif
     return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
 }
+
+int get_csr(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int retval = -1;
+
+    LOG(logDEBUG1, ("Getting csr\n"));
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    retval = getChipStatusRegister();
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int set_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    int arg = 0;
+
+    if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+        return printSocketReadError();
+    LOG(logINFO, ("Setting gain caps to: %u\n", arg));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        setGainCaps(arg);
+        retval = getChipStatusRegister(); //TODO! fix 
+        LOG(logDEBUG1, ("gain caps retval: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}
+
+int get_gain_caps(int file_des){
+    ret = OK;
+    memset(mess, 0, sizeof(mess));
+    // int arg = 0;
+
+    // if (receiveData(file_des, &arg, sizeof(arg), INT32) < 0)
+    //     return printSocketReadError();
+    LOG(logINFO, ("Getting gain caps\n"));
+
+    int retval = -1;
+
+#ifndef MYTHEN3D
+    functionNotImplemented();
+#else
+    if (Server_VerifyLock() == OK) {
+        retval = getGainCaps();
+        LOG(logDEBUG1, ("Gain caps: %u\n", retval));
+    }
+#endif
+    return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
+}

slsDetectorSoftware/include/sls/Detector.h

@@ -498,7 +498,7 @@ class Detector {
 
     /** Non blocking: Abort detector acquisition. Status changes to IDLE or
      * STOPPED. Goes to stop server. */
-    void stopDetector();
+    void stopDetector(Positions pos = {});
 
     /** IDLE, ERROR, WAITING, RUN_FINISHED, TRANSMITTING, RUNNING, STOPPED \n
      * Goes to stop server */
@@ -1308,6 +1308,14 @@ class Detector {
 
     Result<bool> getMaster(Positions pos = {}) const;
 
+
+    //TODO! check if we really want to expose this !!!!!
+    Result<int> getChipStatusRegister(Positions pos = {}) const;
+
+    void setGainCaps(int caps, Positions pos = {});
+
+    Result<int> getGainCaps(Positions pos = {});
+
     ///@{
 
     /** @name CTB / Moench Specific */
@@ -1729,4 +1737,4 @@ class Detector {
     void updateRxRateCorrections();
 };
 
-} // namespace sls
+} // namespace sls

slsDetectorSoftware/src/CmdParser.cpp

@@ -55,6 +55,12 @@ void CmdParser::Parse(const std::string &s) {
         command_ = arguments_[0];
         arguments_.erase(begin(arguments_));
     }
+    //allow comma sep
+    for (auto& arg : arguments_){
+        if (arg.back() == ',')
+            arg.pop_back();
+    }
+
     DecodeIdAndPosition(command_.c_str());
 }
 

slsDetectorSoftware/src/CmdProxy.cpp

@@ -1981,6 +1981,43 @@ std::string CmdProxy::GateDelay(int action) {
     return os.str();
 }
 
+
+std::string CmdProxy::GainCaps(int action){
+    std::ostringstream os;
+    os << cmd << ' ';
+    if (action == defs::HELP_ACTION) {
+        os << "[cap1, cap2, ...]\n\t[Mythen3] gain, options: C10pre, C15sh, C30sh, C50sh, C225ACsh, C15pre"
+           << '\n';
+    } else if (action == defs::GET_ACTION) {
+        if (!args.empty())
+            WrongNumberOfParameters(0);
+
+        auto tmp = det->getGainCaps();
+        sls::Result<defs::M3_GainCaps> csr;
+        for (auto val : tmp){
+            if (val)
+                csr.push_back(static_cast<defs::M3_GainCaps>(val));
+        }
+            
+        os << OutString(csr) << '\n';
+    } else if (action == defs::PUT_ACTION) {
+        if (args.size() < 1) {
+            WrongNumberOfParameters(1);
+        }
+        int caps = 0;
+        for (const auto& arg:args){
+            if (arg != "0")
+                caps |= sls::StringTo<defs::M3_GainCaps>(arg);
+        }
+            
+        det->setGainCaps(caps);
+        os << OutString(args) << '\n';
+    } else {
+        throw sls::RuntimeError("Unknown action");
+    }
+    return os.str();
+}
+
 /* CTB / Moench Specific */
 
 std::string CmdProxy::Samples(int action) {

slsDetectorSoftware/src/CmdProxy.h

@@ -571,19 +571,6 @@ class CmdProxy {
         return ToString(value, unit);
     }
 
-    // inline unsigned int stoiHex(const std::string& s) {
-    //     unsigned long lresult = stoul(s, nullptr, 16);
-    //     unsigned int result = lresult;
-    //     if (result != lresult) {
-    //         throw std::out_of_range("cannot convert to unsigned int");
-    //     }
-    //     return result;
-    // }
-
-    // inline unsigned long int stoulHex(const std::string& s) {
-    //     unsigned long result = stoul(s, nullptr, 16);
-    //     return result;
-    // }
 
     using FunctionMap = std::map<std::string, std::string (CmdProxy::*)(int)>;
     using StringMap = std::map<std::string, std::string>;
@@ -970,6 +957,7 @@ class CmdProxy {
         {"gatedelay1", &CmdProxy::GateDelay},
         {"gatedelay2", &CmdProxy::GateDelay},
         {"gatedelay3", &CmdProxy::GateDelay},
+        {"gaincaps", &CmdProxy::GainCaps},
 
         /* CTB/ Moench Specific */
         {"samples", &CmdProxy::Samples},
@@ -1137,6 +1125,7 @@ class CmdProxy {
     /* Mythen3 Specific */
     std::string Counters(int action);
     std::string GateDelay(int action);
+    std::string GainCaps(int action);
     /* CTB/ Moench Specific */
     std::string Samples(int action);
     /* CTB Specific */
@@ -1455,7 +1444,7 @@ class CmdProxy {
         "\n\t[Mythen3] Starts detector readout. Status changes to TRANSMITTING "
         "and automatically returns to idle at the end of readout.");
 
-    EXECUTE_SET_COMMAND_NOID(stop, stopDetector,
+    EXECUTE_SET_COMMAND(stop, stopDetector,
                              "\n\tAbort detector acquisition. Status changes "
                              "to IDLE or STOPPED. Goes to stop server.");
 

slsDetectorSoftware/src/Detector.cpp

@@ -697,7 +697,7 @@ void Detector::startDetectorReadout() {
     pimpl->Parallel(&Module::startReadout, {});
 }
 
-void Detector::stopDetector() { pimpl->Parallel(&Module::stopAcquisition, {}); }
+void Detector::stopDetector(Positions pos) { pimpl->Parallel(&Module::stopAcquisition, pos); }
 
 Result<defs::runStatus> Detector::getDetectorStatus(Positions pos) const {
     return pimpl->Parallel(&Module::getRunStatus, pos);
@@ -1615,6 +1615,18 @@ Result<bool> Detector::getMaster(Positions pos) const{
     return pimpl->Parallel(&Module::isMaster, pos);
 }
 
+Result<int> Detector::getChipStatusRegister(Positions pos) const{
+    return pimpl->Parallel(&Module::getChipStatusRegister, pos);
+}
+
+void Detector::setGainCaps(int caps, Positions pos){
+    return pimpl->Parallel(&Module::setGainCaps, pos, caps);
+}
+
+Result<int> Detector::getGainCaps(Positions pos){
+    return pimpl->Parallel(&Module::getGainCaps, pos);
+}
+
 
 // CTB/ Moench Specific
 
@@ -2092,4 +2104,4 @@ std::vector<int> Detector::getPortNumbers(int start_port) {
     return res;
 }
 
-} // namespace sls
+} // namespace sls

slsDetectorSoftware/src/Module.cpp

@@ -412,7 +412,7 @@ void Module::loadSettingsFile(const std::string &fname) {
         if (shm()->myDetectorType == MYTHEN3) {
             serialNumberWidth = 4;
         }
-        if (fname.find(".sn") == std::string::npos) {
+        if ((fname.find(".sn") == std::string::npos) && (fname.find(".trim") == std::string::npos)) {
             ostfn << ".sn" << std::setfill('0') << std::setw(serialNumberWidth)
                   << std::dec << getSerialNumber();
         }
@@ -1998,6 +1998,18 @@ bool Module::isMaster() const{
     return sendToDetector<int>(F_GET_MASTER);
 }
 
+int Module::getChipStatusRegister() const{
+    return sendToDetector<int>(F_GET_CSR);
+}
+
+void Module::setGainCaps(int caps){
+    sendToDetector<int>(F_SET_GAIN_CAPS, caps);
+}
+
+int Module::getGainCaps(){
+    return sendToDetector<int>(F_GET_GAIN_CAPS);
+}
+
 // CTB / Moench Specific
 int Module::getNumberOfAnalogSamples() const {
     return sendToDetector<int>(F_GET_NUM_ANALOG_SAMPLES);
@@ -3195,6 +3207,9 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
         throw RuntimeError("Could not open settings file: " + fname);
     }
 
+    auto file_size = getFileSize(infile);
+
+
     // eiger
     if (shm()->myDetectorType == EIGER) {
         infile.read(reinterpret_cast<char *>(myMod.dacs),
@@ -3220,6 +3235,16 @@ sls_detector_module Module::readSettingsFile(const std::string &fname,
 
     // mythen3 (dacs, trimbits)
     else if (shm()->myDetectorType == MYTHEN3) {
+        int expected_size =
+            sizeof(int) * myMod.ndac + sizeof(int) * myMod.nchan + sizeof(myMod.reg);
+        if (file_size != expected_size) {
+            throw RuntimeError("The size of the settings file: " + fname +
+                               " differs from the expected size, " +
+                               std::to_string(file_size) + " instead of " +
+                               std::to_string(expected_size) + " bytes");
+        }
+        infile.read(reinterpret_cast<char *>(&myMod.reg),
+                    sizeof(myMod.reg));
         infile.read(reinterpret_cast<char *>(myMod.dacs),
                     sizeof(int) * (myMod.ndac));
         for (int i = 0; i < myMod.ndac; ++i) {

slsDetectorSoftware/src/Module.h

@@ -426,6 +426,9 @@ class Module : public virtual slsDetectorDefs {
     void setGateDelay(int gateIndex, int64_t value);
     std::array<time::ns, 3> getGateDelayForAllGates() const;
     bool isMaster() const;
+    int getChipStatusRegister() const;
+    void setGainCaps(int caps);
+    int getGainCaps();
 
     /**************************************************
      *                                                *

slsSupportLib/CMakeLists.txt

@@ -10,6 +10,7 @@ set(SOURCES
     src/ZmqSocket.cpp
     src/UdpRxSocket.cpp
     src/sls_detector_exceptions.cpp
+    # src/sls_detector_defs.cpp
 )
 
 # Header files to install as a part of the library

slsSupportLib/include/sls/ToString.h

@@ -36,6 +36,7 @@ std::string ToString(const defs::dacIndex s);
 std::string ToString(const std::vector<defs::dacIndex> &vec);
 std::string ToString(const defs::burstMode s);
 std::string ToString(const defs::timingSourceType s);
+std::string ToString(const defs::M3_GainCaps s);
 
 std::string ToString(const slsDetectorDefs::xy &coord);
 std::ostream &operator<<(std::ostream &os, const slsDetectorDefs::xy &coord);
@@ -297,6 +298,7 @@ template <> defs::readoutMode StringTo(const std::string &s);
 template <> defs::dacIndex StringTo(const std::string &s);
 template <> defs::burstMode StringTo(const std::string &s);
 template <> defs::timingSourceType StringTo(const std::string &s);
+template <> defs::M3_GainCaps StringTo(const std::string &s);
 
 template <> uint32_t StringTo(const std::string &s);
 template <> uint64_t StringTo(const std::string &s);

slsSupportLib/include/sls/file_utils.h

@@ -48,3 +48,7 @@ int writeDataFile(std::string fname, int nch, short int *data);
 
 // mkdir -p path implemented by recursive calls
 void mkdir_p(const std::string &path, std::string dir = "");
+
+namespace sls {
+int getFileSize(std::ifstream &ifs);
+}

slsSupportLib/include/sls/sls_detector_defs.h

@@ -394,6 +394,16 @@ typedef struct {
      */
     enum timingSourceType { TIMING_INTERNAL, TIMING_EXTERNAL };
 
+    //gain caps Mythen3
+    enum M3_GainCaps {
+        M3_C10pre= 1<<7, 
+        M3_C15sh = 1<<10, 
+        M3_C30sh = 1<<11,
+        M3_C50sh = 1<<12,
+        M3_C225ACsh = 1<<13,
+        M3_C15pre = 1<<14, 
+    };
+
 #ifdef __cplusplus
 
     /** scan structure */
@@ -625,6 +635,10 @@ typedef struct {
 #endif
 
 #ifdef __cplusplus
+
+
+
+
 // TODO! discuss this
 #include <vector> //hmm... but currently no way around
 namespace sls {

slsSupportLib/include/sls/sls_detector_funcs.h

@@ -221,6 +221,9 @@ enum detFuncs {
     F_LOAD_DEFAULT_PATTERN,
     F_GET_ALL_THRESHOLD_ENERGY,
     F_GET_MASTER,
+    F_GET_CSR,
+    F_SET_GAIN_CAPS,
+    F_GET_GAIN_CAPS,
 
     NUM_DET_FUNCTIONS,
     RECEIVER_ENUM_START = 256, /**< detector function should not exceed this

slsSupportLib/include/sls/versionAPI.h

@@ -1,5 +1,5 @@
 /** API versions */
-#define GITBRANCH    "5.1.0"
+#define GITBRANCH    "developer"
 #define APICTB 0x210225
 #define APIGOTTHARD 0x210225
 #define APIGOTTHARD2 0x210225

slsSupportLib/src/ToString.cpp

@@ -859,6 +859,44 @@ template <> defs::timingSourceType StringTo(const std::string &s) {
     throw sls::RuntimeError("Unknown timing source type " + s);
 }
 
+template <> defs::M3_GainCaps StringTo(const std::string &s){
+    if (s == "C10pre")
+        return defs::M3_C10pre;
+    if (s == "C15sh")
+        return defs::M3_C15sh;
+    if (s == "C30sh")
+        return defs::M3_C30sh;
+    if (s == "C50sh")
+        return defs::M3_C50sh;
+    if (s == "C225ACsh")
+        return defs::M3_C225ACsh;
+    if (s == "C15pre")
+        return defs::M3_C15pre;
+    throw sls::RuntimeError("Unknown gain cap " + s);
+    
+}
+
+
+std::string ToString(defs::M3_GainCaps s){
+    std::ostringstream os; 
+    if (s & defs::M3_C10pre)
+        os << "C10pre, ";
+    if (s & defs::M3_C15sh)
+        os << "C15sh, ";
+    if (s & defs::M3_C30sh)
+        os << "C30sh, ";
+    if (s & defs::M3_C50sh)
+        os << "C50sh, ";
+    if (s & defs::M3_C225ACsh)
+        os << "C225ACsh, ";
+    if (s & defs::M3_C15pre)
+        os << "C15pre, ";
+    auto rs = os.str();
+    rs.erase(rs.end()-2);
+    return rs;
+    
+}
+
 template <> uint32_t StringTo(const std::string &s) {
     int base = s.find("0x") != std::string::npos ? 16 : 10;
     return std::stoul(s, nullptr, base);

slsSupportLib/src/file_utils.cpp

@@ -3,6 +3,7 @@
 #include "sls/sls_detector_exceptions.h"
 
 #include <errno.h>
+#include <ios>
 #include <iostream>
 #include <sstream>
 #include <sys/stat.h>
@@ -92,3 +93,13 @@ void mkdir_p(const std::string &path, std::string dir) {
     if (i + 1 < path.length())
         mkdir_p(path.substr(i + 1), dir);
 }
+
+namespace sls {
+int getFileSize(std::ifstream &ifs) {
+    auto current_pos = ifs.tellg();
+    ifs.seekg(0, std::ios::end);
+    int file_size = ifs.tellg();
+    ifs.seekg(current_pos);
+    return file_size;
+}
+} // namespace sls

slsSupportLib/tests/CMakeLists.txt

@@ -1,5 +1,6 @@
 target_sources(tests PRIVATE 
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-bit_utils.cpp
+                ${CMAKE_CURRENT_SOURCE_DIR}/test-file_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-container_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-network_utils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/test-string_utils.cpp

slsSupportLib/tests/test-file_utils.cpp

@@ -0,0 +1,28 @@
+#include "catch.hpp"
+#include "sls/file_utils.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <iostream>
+#include <vector>
+
+TEST_CASE("Get size of empty file") {
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == 0);
+}
+
+TEST_CASE("Get size of file with data") {
+    constexpr size_t n_bytes = 137;
+    std::vector<char> data(n_bytes);
+    char fname[] = "temfile_XXXXXX";
+    int fh = mkstemp(fname);
+    write(fh, data.data(), n_bytes);
+
+    std::ifstream ifs(fname);
+    auto size = sls::getFileSize(ifs);
+    REQUIRE(size == n_bytes);
+    REQUIRE(ifs.tellg() == 0); //getting size resets pos!
+}
+