slsDetectorUsers.h

Go to the documentation of this file.

#ifndef SLS_DETECTOR_USERS_H
#define SLS_DETECTOR_USERS_H



class detectorData;
class multiSlsDetector;
class multiSlsDetectorCommand;

#include "sls_detector_defs.h"


#include <stdint.h>
#include <string>





/*
   \mainpage 
<CENTER><H1>API for SLS detectors data acquisition</H1></CENTER>
<HR>
*/
class slsDetectorUsers
 { 

 public:

   slsDetectorUsers(int& ret, int id=0);
   
   virtual ~slsDetectorUsers();

   std::string getDetectorDeveloper();

  int setOnline(int const online=-1);

  int setReceiverOnline(int const online=-1);


  void startMeasurement();

   int stopMeasurement();
 
   int getDetectorStatus();

   std::string getFilePath();

   std::string setFilePath(std::string s);

   std::string getFileName();  

   std::string setFileName(std::string s);  
  
   int getFileIndex();
  
   int setFileIndex(int i);

   std::string getFlatFieldCorrectionDir(); 
  
   std::string setFlatFieldCorrectionDir(std::string dir);
  
   std::string getFlatFieldCorrectionFile();
  
   int setFlatFieldCorrectionFile(std::string fname=""); 

  

   int enableFlatFieldCorrection(int i=-1);

   int enableCountRateCorrection(int i=-1);

   int enablePixelMaskCorrection(int i=-1);

   int enableAngularConversion(int i=-1);

   int enableWriteToFile(int i=-1);

   int setPositions(int nPos, double *pos);
  
   int getPositions(double *pos=NULL);
  
   int setDetectorSize(int x0=-1, int y0=-1, int nx=-1, int ny=-1);

   int getDetectorSize(int &x0, int &y0, int &nx, int &ny);
   int getMaximumDetectorSize(int &nx, int &ny);


   int setBitDepth(int i=-1);


 
   int setSettings(int isettings=-1);
   
   int getThresholdEnergy();  


   int setThresholdEnergy(int e_eV);

   int setThresholdEnergy(int e_ev, int tb, int isettings = -1, int id = -1);


   double setExposureTime(double t=-1, bool inseconds=false, int imod = -1);

   double setExposurePeriod(double t=-1, bool inseconds=false, int imod = -1);

   double setDelayAfterTrigger(double t=-1, bool inseconds=false, int imod = -1);

   int64_t setNumberOfGates(int64_t t=-1, int imod = -1);
  
   int64_t setNumberOfFrames(int64_t t=-1, int imod = -1);

   int64_t setNumberOfCycles(int64_t t=-1, int imod = -1);

   int setTimingMode(int pol=-1);

   int readConfigurationFile(std::string const fname);  


   int dumpDetectorSetup(std::string const fname); 
   int retrieveDetectorSetup(std::string const fname);

   std::string getDetectorType();

   int setReceiverMode(int n=-1);

   void registerDataCallback(int( *userCallback)(detectorData* d, int f, int s, void*), void *pArg);

   void registerRawDataCallback(int( *userCallback)(double* p, int n, void*), void *pArg);

  virtual void initDataset(int refresh);


  virtual void addFrame(double *data, double pos, double i0, double t, std::string fname, double var);

  virtual void finalizeDataset(double *a, double *v, double *e, int &np); 


   int enableDataStreamingFromReceiver(int i=-1);

   int enableDataStreamingToClient(int i=-1);

   int setReceiverDataStreamingOutPort(int i=-1);

   int setClientDataStreamingInPort(int i=-1);

   std::string setReceiverDataStreamingOutIP(std::string ip="");

   std::string setClientDataStreamingInIP(std::string ip="");

  int64_t getModuleFirmwareVersion(int imod=-1);

  int64_t getModuleSerialNumber(int imod=-1);

  int64_t getDetectorFirmwareVersion(int imod=-1);

  int64_t getDetectorSerialNumber(int imod=-1);

  int64_t getDetectorSoftwareVersion(int imod=-1);

  int64_t getThisSoftwareVersion();

  int enableGapPixels(int enable=-1);

  std::string setReceiverFramesDiscardPolicy(std::string f="get");

  int setReceiverPartialFramesPadding(int f = -1);

  int setReceiverFramesPerFile(int f = -1);

  int sendSoftwareTrigger();

  double getMeasuredPeriod(bool inseconds=false, int imod = -1);

  double getMeasuredSubFramePeriod(bool inseconds=false, int imod = -1);

   void registerAcquisitionFinishedCallback(int( *func)(double,int, void*), void *pArg);
  
   void registerGetPositionCallback( double (*func)(void*),void *arg);
   void registerConnectChannelsCallback( int (*func)(void*),void *arg);
   void registerDisconnectChannelsCallback( int (*func)(void*),void *arg);  
   void registerGoToPositionCallback( int (*func)(double,void*),void *arg);
   void registerGoToPositionNoWaitCallback( int (*func)(double,void*),void *arg);
   void registerGetI0Callback( double (*func)(int,void*),void *arg);

   std::string putCommand(int narg, char *args[], int pos=-1);

   std::string getCommand(int narg, char *args[], int pos=-1);

   /************************************************************************

                            ADVANCED FUNCTIONS

   *********************************************************************/
   int setClockDivider(int value);

   int setParallelMode(int value);

   int setOverflowMode(int value);

   int setAllTrimbits(int val, int id = -1);

   int setDAC(std::string dac, int val, int id = -1);

   int getADC(std::string adc, int id = -1);

   int startReceiver();

   int stopReceiver();

   int startAcquisition();

   int stopAcquisition();

   int setReceiverSilentMode(int i);

   int setHighVoltage(int i);

   int resetFramesCaughtInReceiver();

   int setReceiverFifoDepth(int i = -1);

   int setFlowControl10G(int i = -1);

   int setTenGigabitEthernet(int i = -1);

   int getNMods();

   double setSubFrameExposureTime(double t=-1, bool inseconds=false, int imod = -1);

   double setSubFrameExposureDeadTime(double t=-1, bool inseconds=false, int imod = -1);

    int64_t setNumberOfStorageCells(int64_t t=-1, int imod = -1);

    int setStoragecellStart(int pos=-1);

    int setROI(int n=-1, slsDetectorDefs::ROI roiLimits[]=NULL, int imod = -1);

    slsDetectorDefs::ROI* getROI(int &n, int imod = -1);

  /************************************************************************

                           STATIC FUNCTIONS

  *********************************************************************/  

  static std::string runStatusType(int s){                  \
    switch (s) {                            \
    case 0:     return std::string("idle");                 \
    case 1:       return std::string("error");              \
    case 2:      return  std::string("waiting");                \
    case 3:      return std::string("finished");                \
    case 4:      return std::string("data");                    \
    case 5:      return std::string("running");             \
    case 6:     return std::string("stoppped");             \
    default:       return std::string("unknown");               \
    }};



  static int getDetectorSettings(std::string s){        \
    if (s=="standard") return 0;            \
    if (s=="fast") return 1;                \
    if (s=="highgain") return 2;            \
    if (s=="dynamicgain") return 3;         \
    if (s=="lowgain") return 4;             \
    if (s=="mediumgain") return 5;          \
    if (s=="veryhighgain") return 6;            \
    return -1;                       };

  static std::string getDetectorSettings(int s){\
    switch(s) {                     \
    case 0:      return std::string("standard");\
    case 1:      return std::string("fast");\
    case 2:      return std::string("highgain");\
    case 3:    return std::string("dynamicgain");   \
    case 4:    return std::string("lowgain");       \
    case 5:    return std::string("mediumgain");    \
    case 6:    return std::string("veryhighgain");          \
    default:    return std::string("undefined");            \
    }};



  static std::string getTimingMode(int f){  \
    switch(f) {                      \
    case 0:      return std::string( "auto");           \
    case 1: return std::string("trigger");          \
    case 2: return std::string("ro_trigger");               \
    case 3: return std::string("gating");           \
    case 4: return std::string("triggered_gating"); \
    case 5: return std::string("burst_trigger");    \
    default:    return std::string( "unknown");             \
    }      };

  static int getTimingMode(std::string s){          \
    if (s== "auto") return 0;                       \
    if (s== "trigger") return 1;                    \
    if (s== "ro_trigger") return 2;                 \
    if (s== "gating") return 3;                     \
    if (s== "triggered_gating") return 4;           \
    return -1;                          };


 private:
  multiSlsDetector *myDetector;
  multiSlsDetectorCommand *myCmd;
 };

#endif