modified struct (#729)

slsDetectorCalibration/dataStructures/moench03T1ReceiverDataNewRect.h

@@ -2,46 +2,43 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #ifndef MOENCH03T1RECDATANEWRECT_H
 #define MOENCH03T1RECDATANEWRECT_H
+
+#define VERT 
+//#define HOR 
+//#define OFF_1
+
+#ifndef MYROOT
+#include "sls/sls_detector_defs.h"
+#endif
+#ifdef MYROOT
+
+    typedef struct {
+        uint64_t frameNumber;
+        uint32_t expLength;
+        uint32_t packetNumber;
+        uint64_t bunchId;
+        uint64_t timestamp;
+        uint16_t modId;
+        uint16_t row;
+        uint16_t column;
+        uint16_t reserved;
+        uint32_t debug;
+        uint16_t roundRNumber;
+        uint8_t detType;
+        uint8_t version;
+    } sls_detector_header;
+#define MAX_NUM_PACKETS 512
+// using sls_bitset = std::bitset<MAX_NUM_PACKETS>;
+//  using bitset_storage = uint8_t[MAX_NUM_PACKETS / 8];
+  struct sls_receiver_header {
+        sls_detector_header detHeader; /**< is the detector header */
+        uint8_t packetsMask[64];        /**< is the packets caught bit mask */
+    };
+#endif
 #include "slsDetectorData.h"
+using namespace std;
 
-#define VERT 1
+class moench03T1ReceiverDataNewRect : public slsDetectorData<uint16_t> {
-
-/**
-    @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 frameNumber; /**< is the frame number */
-    uint32_t expLength; /**< is the subframe number (32 bit eiger) or real time
-                           exposure time in 100ns (others) */
-    uint32_t packetNumber; /**< is the packet number */
-    uint64_t bunchId;      /**< is the bunch id from beamline */
-    uint64_t timestamp;    /**< is the time stamp with 10 MHz clock */
-    uint16_t modId;  /**< is the unique module id (unique even for left, right,
-                        top, bottom) */
-    uint16_t xCoord; /**< is the x coordinate in the complete detector system */
-    uint16_t yCoord; /**< is the y coordinate in the complete detector system */
-    uint16_t zCoord; /**< is the z coordinate in the complete detector system */
-    uint32_t debug;  /**< is for debugging purposes */
-    uint16_t roundRNumber; /**< is the round robin set number */
-    uint8_t detType;       /**< is the detector type see :: detectorType */
-    uint8_t version; /**< is the version number of this structure format */
-} sls_detector_header;
-
-class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
 
   private:
     int iframe;
@@ -50,6 +47,16 @@ class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
     int sc_height;
     const int nSamples;
 
+    double ghost[200][25];
+
+    // Single point of definition if we need to customize
+#ifndef MYROOT
+    using header = sls::defs::sls_receiver_header;
+#endif
+#ifdef MYROOT
+    sls_receiver_header header;
+#endif
+
   public:
     /**
        Implements the slsReceiverData structure for the moench02 prototype read
@@ -58,15 +65,15 @@ class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
 
     */
 #ifdef HOR
-    moench03T1ReceiverDataNew(int ns = 5000)
+    moench03T1ReceiverDataNewRect(int ns = 5000)
         : slsDetectorData<uint16_t>(800, 200,
-                                    ns * 2 * 32 + sizeof(sls_detector_header)),
+                                    ns * 2 * 32 + sizeof(header)),
           nSamples(ns) {
 #endif
 #ifdef VERT
-        moench03T1ReceiverDataNew(int ns = 5000)
+        moench03T1ReceiverDataNewRect(int ns = 5000)
             : slsDetectorData<uint16_t>(
-                  200, 800, ns * 2 * 32 + sizeof(sls_detector_header)),
+                  200, 800, ns * 2 * 32 + sizeof(header)),
               nSamples(ns) {
 #endif
             int nadc = 32;
@@ -93,7 +100,7 @@ class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
 #ifdef OFF_1
             off = 1;
 #endif
-            cout << "This is a MOENCH with rectangular pixels!" << endl;
+	    std::cout << "This is a MOENCH with rectangular pixels!" << std::endl;
 
             for (int ip = 0; ip < npackets; ip++) {
                 for (int is = 0; is < 128; is++) {
@@ -109,11 +116,11 @@ class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
                             } else {
                                 row = 200 + i / sc_width;
                             }
-                            pix = sizeof(sls_detector_header) +
+                            pix = sizeof(header) +
                                   (nadc * i + iadc) * 2; //+16*(ip+1);
                             if (pix < 0 ||
                                 pix >= nSamples * 2 * 32 +
-                                           sizeof(sls_detector_header))
+                                           sizeof(header))
                                 cout << "Error: pointer " << dataMap[row][col]
                                      << " out of range " << endl;
                             ix = col;
@@ -177,151 +184,139 @@ class moench03T1ReceiverDataNew : public slsDetectorData<uint16_t> {
             //  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
 
-        Returns the frame number for the given dataset. Purely virtual func.
+    */
-        \param buff pointer to the dataset
+    double getValue(char *data, int ix, int iy = 0) override {
-        \returns frame number
+        uint16_t val = getChannel(data, ix, iy) & 0x3fff;
-
+        return val;
-     */
-
-        /* 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 ((sls_detector_header *)buff)->frameNumber;
-        }; //*((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 ((sls_detector_header *)buff)->packetNumber;
-        } //((*(((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;};
     };
 
+    virtual void calcGhost(char *data, int ix, int iy) {
+        double val = 0;
+        /* for (int ix=0; ix<25; ix++){ */
+        /*   for (int iy=0; iy<200; iy++) { */
+        val = 0;
+        //	cout << "** ";
+        for (int isc = 0; isc < 16; isc++) {
+            //  for (int ii=0; ii<2; ii++) {
+            val += getChannel(data, ix + 25 * isc, iy);
+            //  cout << "(" << isc << "," << val << " " ;
+            val += getChannel(data, ix + 25 * isc, 399 - iy);
+            // cout << val << " " ;
+            // }
+        }
+        ghost[iy][ix] = val; //-6224;
+                             //	cout << " --"<< endl;
+                             /*   }  */
+                             /* } */
+                             // cout << "*" << endl;
+    }
+
+    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) {
+        if (iy < 200)
+            return ghost[iy][ix % 25];
+        if (iy < 400)
+            return ghost[399 - iy][ix % 25];
+        return 0;
+    };
+
+    /**
+
+    Returns the frame number for the given dataset. Purely virtual func.
+    \param buff pointer to the dataset
+    \returns frame number
+
+ */
+
+    int getFrameNumber(char *buff) {
+      return ((sls::defs::sls_receiver_header *)buff)->detHeader.frameNumber;
+    }
+
+    /**
+
+       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 ((sls::defs::sls_receiver_header  *)buff)->detHeader.packetNumber;
+    }
+
+    char *readNextFrame(std::ifstream &filebin) override {
+        int ff = -1, np = -1;
+        return readNextFrame(filebin, ff, np);
+    }
+
+    // not present in base class
+    virtual char *readNextFrame(std::ifstream &filebin, int &ff) {
+        int np = -1;
+        return readNextFrame(filebin, ff, np);
+    };
+
+    // not present in base class
+    virtual char *readNextFrame(std::ifstream &filebin, int &ff, int &np) {
+        char *data = new char[dataSize];
+        char *d = readNextFrame(filebin, ff, np, data);
+        if (d == NULL) {
+            delete[] data;
+            data = NULL;
+        }
+        return data;
+    }
+
+    // not present in base class
+    virtual char *readNextFrame(std::ifstream &filebin, int &ff, int &np,
+                                char *data) {
+        np = 0;
+        if (filebin.is_open()) {
+            if (filebin.read(data, dataSize)) {
+                ff = getFrameNumber(data);
+                np = getPacketNumber(data);
+                return data;
+            }
+        }
+        return nullptr;
+    }
+
+    /**
+
+       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
+
+    */
+    char *findNextFrame(char *data, int &ndata, int dsize) override {
+        if (dsize < dataSize)
+            ndata = dsize;
+        else
+            ndata = dataSize;
+        return data;
+    }
+
+    // int getPacketNumber(int x, int y) {return dataMap[y][x]/packetSize;};
+};
+
 #endif