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>


#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}

using namespace std;
class slsDetector {



 public:
  

  enum {GET_ONLINE_FLAG, 
        OFFLINE_FLAG, 
        ONLINE_FLAG 
  };


#include "sls_detector_defs.h"


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;
    int badChansList[MAX_BADCHANS];
    int nBadFF;
    int badFFList[MAX_BADCHANS];
    
    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;};

  int readConfigurationFile(string const fname);  
  int writeConfigurationFile(string const fname);


  /* 
     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
  */
  int dumpDetectorSetup(string const fname);  
  int retrieveDetectorSetup(string const fname);

  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) {for (int ien=0; ien<thisDetector->nTrimEn; ien++) en[ien]=thisDetector->trimEnergies[ien]; return (thisDetector->nTrimEn);};

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

  int writeTrimFile(string fname, sls_detector_module mod); 
  
  int writeTrimFile(string fname, int imod);

  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();
  
  int writeDataFile(string fname, float *data, float *err=NULL, float *ang=NULL, char dataformat='f', int nch=-1); 
  
  int writeDataFile(string fname, int *data);
  
  int readDataFile(string fname, float *data, float *err=NULL, float *ang=NULL, char dataformat='f', int nch=0);  

  int readDataFile(string fname, int *data);

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


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


  /* Communication to server */

  // General purpose functions

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

  int setDetectorType(string type);  

  void getDetectorType(char *type);


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

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

  int64_t getTimeLeft(timerIndex index);

  int setClockDivider(int i) {cout << "not implemented any longer!"<< endl; thisDetector->clkDiv=i;return thisDetector->clkDiv;};  

  int getClockDivider() {return thisDetector->clkDiv;};  

  int setSetLength(int i) {cout << "not implemented any longer!"<< endl; thisDetector->clkDiv=i;return 3;}; 

  int getSetLength() {return 3;};
  

  // 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 getFlatFieldCorrections(float *corr=NULL, float *ecorr=NULL);

  int setRateCorrection(float t=0);

  
  int getRateCorrections(float &t);  

  int getRateCorrections();
  
  int setBadChannelCorrection(string fname="");
  
  int getBadChannelCorrections(int *bad=NULL);

  
  int setAngularConversion(string fname="");

  int getAngularConversion(int &direction,  angleConversionConstant *angconv=NULL);
  
  float setGlobalOffset(float f){thisDetector->globalOffset=f; return thisDetector->globalOffset;}; 

  float setFineOffset(float f){thisDetector->fineOffset=f; return thisDetector->fineOffset;};
  float getFineOffset(){return thisDetector->fineOffset;};
  
  float getGlobalOffset(){return thisDetector->globalOffset;};

  int setPositions(int nPos, float *pos){thisDetector->numberOfPositions=nPos; for (int ip=0; ip<nPos; ip++) thisDetector->detPositions[ip]=pos[ip]; return thisDetector->numberOfPositions;};
  int getPositions(float *pos=NULL){ if (pos ) {for (int ip=0; ip<thisDetector->numberOfPositions; ip++) pos[ip]=thisDetector->detPositions[ip];} return thisDetector->numberOfPositions;};
  
  
  float setBinSize(float bs) {thisDetector->binSize=bs; return thisDetector->binSize;}
  float getBinSize() {return thisDetector->binSize;}






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

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

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

  int exitServer();

  void* processData(); // thread function
  sls_detector_module*  createModule();
  void deleteModule(sls_detector_module *myMod);


  void acquire();

 private:
 
  sharedSlsDetector *thisDetector;

  int onlineFlag;
  
  int detId;
  
  int shmId;

  MySocketTCP *controlSocket;

  MySocketTCP *stopSocket;
  
  MySocketTCP *dataSocket; 
  
  queue<int*> dataQueue;
  
  pthread_t dataProcessingThread;
  
  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

---