slsDetector/slsDetector.h

Go to the documentation of this file.

#ifndef SLS_DETECTOR_H
#define SLS_DETECTOR_H

#include "MySocketTCP.h"
#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstring>
#include <string>
#include <sstream>
 #include <queue>
extern "C" {
 #include <pthread.h>
}
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/uio.h>


#include "sls_detector_defs.h"

#define MAX_TIMERS 10
#define MAX_ROIS 100
#define MAX_BADCHANS 2000
#define MAXPOS 50

#define NMODMAXX 24
#define NMODMAXY 24
#define MAXMODS 36
#define NCHIPSMAX 10
#define NCHANSMAX 65536
#define NDACSMAX 16

#define DEFAULT_HOSTNAME  "localhost"
#define DEFAULT_SHM_KEY  5678

#define defaultTDead {170,90,750} 
class detectorData {
 public:
  detectorData(float *val=NULL, float *err=NULL, float *ang=NULL,  int f_ind=-1, char *fname="", int np=-1) : values(val), errors(err), angles(ang),  fileIndex(f_ind), npoints(np){strcpy(fileName,fname);};
    ~detectorData() {if (values) delete [] values; if (errors) delete [] errors; if (angles) delete [] angles;};
    //private:
    float *values; 
  float *errors; 
  float *angles;
  int fileIndex;
  char fileName[1000];
  int npoints;
};










using namespace std;
class slsDetector {



 public:
  

  enum {GET_ONLINE_FLAG, 
        OFFLINE_FLAG, 
        ONLINE_FLAG 
  };



typedef  struct sharedSlsDetector {
    int alreadyExisting;
    
    char hostname[MAX_STR_LENGTH];
    int controlPort;
    int stopPort;
    int dataPort;

    detectorType myDetectorType;


    char trimDir[MAX_STR_LENGTH];
    char calDir[MAX_STR_LENGTH];
    int nTrimEn;
    int trimEnergies[100];

           
    int fileIndex;
    char filePath[MAX_STR_LENGTH];
    char fileName[MAX_STR_LENGTH];

  /* size of the detector */
    
    int nMod[2];
    int nMods;
    int nModMax[2];
    int nModsMax;
    int nChans;
    int nChips;
    int nDacs;
    int nAdcs;
    int dynamicRange;
    int dataBytes;
    
    int correctionMask;
    float tDead;
    int nBadChans;
  char badChanFile[MAX_STR_LENGTH];
    int badChansList[MAX_BADCHANS];
    int nBadFF;
    int badFFList[MAX_BADCHANS];
    
  char angConvFile[MAX_STR_LENGTH];
    angleConversionConstant angOff[MAXMODS];
    int angDirection;
    float fineOffset;
    float globalOffset;
    int numberOfPositions;
    float detPositions[MAXPOS];
  float binSize;

  /* infos necessary for the readout to determine the size of the data */
    int nROI;
    ROI roiLimits[MAX_ROIS];
    readOutFlags roFlags;

 /* detector setup - not needed */
    detectorSettings currentSettings;
    int currentThresholdEV;
    int64_t timerValue[MAX_TIMERS];
    int clkDiv;
    
  /*offsets*/
    int ffoff;
    int fferroff;
    int modoff;
    int dacoff;
    int adcoff;
    int chipoff;
    int chanoff;

} sharedSlsDetector;



  slsDetector(detectorType type=GENERIC, int id=0);
  //slsDetector(string  const fname);
  //  ~slsDetector(){while(dataQueue.size()>0){}};
  ~slsDetector(){};


  int setOnline(int const online);  
  int exists() {return thisDetector->alreadyExisting;};

  virtual int readConfigurationFile(string const fname)=0;  
  virtual int writeConfigurationFile(string const fname)=0;


  /* 
     It should be possible to dump all the settings of the detector (including trimbits, threshold energy, gating/triggering, acquisition time etc.
     in a file and retrieve it for repeating the measurement with identicals ettings, if necessary
  */
  virtual int dumpDetectorSetup(string const fname)=0;  
  virtual int retrieveDetectorSetup(string const fname)=0;

  int setTCPSocket(string const name="", int const control_port=-1, int const stop_port=-1, int const data_port=-1);
  char* getHostname() {return thisDetector->hostname;};
  int getControlPort() {return  thisDetector->controlPort;};
  int getStopPort() {return thisDetector->stopPort;};
  int getDataPort() {return thisDetector->dataPort;};
 

  /* I/O */
  char* getTrimDir() {return thisDetector->trimDir;};
  char* setTrimDir(string s) {sprintf(thisDetector->trimDir, s.c_str()); return thisDetector->trimDir;};
  int getTrimEn(int *en=NULL) {if (en) {for (int ien=0; ien<thisDetector->nTrimEn; ien++) en[ien]=thisDetector->trimEnergies[ien];} return (thisDetector->nTrimEn);};

  virtual sls_detector_module* readTrimFile(string fname,  sls_detector_module* myMod=NULL)=0;

  virtual int writeTrimFile(string fname, sls_detector_module mod)=0; 
  
  virtual int writeTrimFile(string fname, int imod)=0;

  char* setFilePath(string s) {sprintf(thisDetector->filePath, s.c_str()); return thisDetector->filePath;};

  char* setFileName(string s) {sprintf(thisDetector->fileName, s.c_str()); return thisDetector->fileName;}; 

  int setFileIndex(int i) {thisDetector->fileIndex=i; return thisDetector->fileIndex;}; 
  
  char* getFilePath() {return thisDetector->filePath;};
  
  char* getFileName() {return thisDetector->fileName;};

  int getFileIndex() {return thisDetector->fileIndex;};
  
  string createFileName();
  
  virtual int writeDataFile(string fname, float *data, float *err=NULL, float *ang=NULL, char dataformat='f', int nch=-1)=0; 
  
  virtual int writeDataFile(string fname, int *data)=0;
  
  virtual int readDataFile(string fname, float *data, float *err=NULL, float *ang=NULL, char dataformat='f', int nch=0)=0;  

  virtual int readDataFile(string fname, int *data)=0;

  char* getCalDir() {cout << "cal dir is " << thisDetector->calDir; return thisDetector->calDir;};


  char* setCalDir(string s) {sprintf(thisDetector->calDir, s.c_str()); return thisDetector->calDir;}; 
  virtual int readCalibrationFile(string fname, float &gain, float &offset)=0;
  virtual int writeCalibrationFile(string fname, float gain, float offset)=0;


  virtual int readAngularConversion(string fname="")=0;
  virtual int writeAngularConversion(string fname="")=0;
 


  /* Communication to server */


  int execCommand(string cmd, string answer);
  
  int setDetectorType(detectorType type=GET_DETECTOR_TYPE);  

  int setDetectorType(string type);  

  void getDetectorType(char *type);


  // Detector configuration functions
  // Detector configuration functions
  int setNumberOfModules(int n, dimension d=X); // if n=GET_FLAG returns the number of installed modules

  /*
    returns the instrinsic size of the detector (maxmodx, maxmody, nchans, nchips, ndacs
    enum numberOf {
    MAXMODX,
    MAXMODY,
    CHANNELS,
    CHIPS,
    DACS
    }
  */


  int getMaxNumberOfModules(dimension d=X); //
 
 
  externalSignalFlag setExternalSignalFlags(externalSignalFlag pol=GET_EXTERNAL_SIGNAL_FLAG , int signalindex=0);

 
  externalCommunicationMode setExternalCommunicationMode(externalCommunicationMode pol=GET_EXTERNAL_COMMUNICATION_MODE);


  // Tests and identification
 
  int64_t getId(idMode mode, int imod=0);
  int digitalTest(digitalTestMode mode, int imod=0);
  int* analogTest(analogTestMode mode);
  
  int enableAnalogOutput(int ichan);
  
  int enableAnalogOutput(int imod, int ichip, int ichan);

  int giveCalibrationPulse(float vcal, int npulses);

  // Expert Initialization functions
 

  int writeRegister(int addr, int val);
  
  int readRegister(int addr);

  float setDAC(float val, dacIndex index, int imod=-1);
  
  float getADC(dacIndex index, int imod=0); 
 
  int setChannel(int64_t reg, int ichan=-1, int ichip=-1, int imod=-1);  

  int setChannel(sls_detector_channel chan);

  sls_detector_channel getChannel(int ichan, int ichip, int imod);
  


  int setChip(int reg, int ichip=-1, int imod=-1);
  
  int setChip(sls_detector_chip chip); 

  sls_detector_chip getChip(int ichip, int imod);


  int setModule(int reg, int imod=-1); 

  int setModule(sls_detector_module module);

  sls_detector_module *getModule(int imod);
 
  // calibration functions
  //  int setCalibration(int imod, detectorSettings isettings, float gain, float offset);
  //int getCalibration(int imod, detectorSettings isettings, float &gain, float &offset);
  

  /*
    calibrated setup of the threshold
  */  
  int getThresholdEnergy(int imod=-1);  

  int setThresholdEnergy(int e_eV, int imod=-1, detectorSettings isettings=GET_SETTINGS); 
 
  detectorSettings getSettings(int imod=-1);  

  detectorSettings setSettings(detectorSettings isettings, int imod=-1);


// Acquisition functions


  int startAcquisition();

  int stopAcquisition();
  
  int startReadOut();

  int getRunStatus();

  int* startAndReadAll();
  
  int startAndReadAllNoWait(); 

  int* getDataFromDetectorNoWait(); 

  int* readFrame(); 

  int* readAll();

  
  int* popDataQueue();

  detectorData* popFinalDataQueue();
  int64_t setTimer(timerIndex index, int64_t t=-1);

  int64_t getTimeLeft(timerIndex index);




  int setSpeed(speedVariable sp, int value=-1);

  // Flags
  int setDynamicRange(int n=-1);
 
  int setROI(int nroi=-1, int *xmin=NULL, int *xmax=NULL, int *ymin=NULL, int *ymax=NULL);
  

  int setReadOutFlags(readOutFlags flag);

  int executeTrimming(trimMode mode, int par1, int par2, int imod=-1);

 
  //Corrections

  int setFlatFieldCorrection(string fname=""); 

  int getFlatFieldCorrection(float *corr=NULL, float *ecorr=NULL);

  int setRateCorrection(float t=0);

  
  int getRateCorrection(float &t);  

  int getRateCorrection();
  
  int setBadChannelCorrection(string fname="");
  
  int getBadChannelCorrection(int *bad=NULL);

  char *getBadChannelCorrectionFile() {return thisDetector->badChanFile;};

  
  virtual int setAngularConversion(string fname="")=0;

  virtual int getAngularConversion(int &direction,  angleConversionConstant *angconv=NULL)=0;
  
  
  virtual char *getAngularConversion()=0;
  
  virtual float setGlobalOffset(float f)=0; 

  virtual float setFineOffset(float f)=0;
  virtual float getFineOffset()=0;
  
  virtual float getGlobalOffset()=0;

  virtual int setPositions(int nPos, float *pos)=0;
  virtual int getPositions(float *pos=NULL)=0;
  
  
  virtual float setBinSize(float bs)=0;

  virtual float getBinSize()=0;






  float* decodeData(int *datain);

  
  
  
  int flatFieldCorrect(float datain, float errin, float &dataout, float &errout, float ffcoefficient, float fferr);
  
  int flatFieldCorrect(float* datain, float *errin, float* dataout, float *errout);
 

  
  int rateCorrect(float datain, float errin, float &dataout, float &errout, float tau, float t);
  
  int rateCorrect(float* datain, float *errin, float* dataout, float *errout);

  
  virtual int resetMerging(float *mp, float *mv,float *me, int *mm)=0;
  virtual int addToMerging(float *p1, float *v1, float *e1, float *mp, float *mv,float *me, int *mm)=0;

  int finalizeMerging(float *mp, float *mv,float *me, int *mm);

  int exitServer();

  virtual void* processData(int delflag=1)=0; // thread function
  sls_detector_module*  createModule();
  void deleteModule(sls_detector_module *myMod);


  virtual void acquire(int delflag=1)=0;

 protected:
 
  sharedSlsDetector *thisDetector;

  int onlineFlag;
  
  int detId;
  
  int shmId;

  MySocketTCP *controlSocket;

  MySocketTCP *stopSocket;
  
  MySocketTCP *dataSocket; 
  
  queue<int*> dataQueue;
  queue<detectorData*> finalDataQueue;
  
  


  float currentPosition;
  
  float currentPositionIndex;
  
  float currentI0;
  


  float *mergingBins;

  float *mergingCounts;

  float *mergingErrors;

  int *mergingMultiplicity;
  





 
  float *ffcoefficients;
  float *fferrors;
  sls_detector_module *detectorModules;
  float *dacs;
  float *adcs;
  int *chipregs;
  int *chanregs;
  int *badChannelMask;

  int* getDataFromDetector();

  int initSharedMemory(detectorType type=GENERIC, int id=0);

  int freeSharedMemory();
  int initializeDetectorSize(detectorType type);
  int initializeDetectorStructure(); 
  int sendChannel(sls_detector_channel*); 
  int sendChip(sls_detector_chip*);
  int sendModule(sls_detector_module*);
  int receiveChannel(sls_detector_channel*);
  int receiveChip(sls_detector_chip*);
  int receiveModule(sls_detector_module*);
  
  void startThread();
  
  int fillBadChannelMask();
};


//static void* startProcessData(void *n);
#endif

---