ngcdcsACQ.hpp

Go to the documentation of this file.

#ifndef ngcdcsACQ_H
#define ngcdcsACQ_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbSocket.h>
#include <ngc/core/ngcbOBJ.hpp>
#include <ngc/core/ngcbPARAM.hpp>
#include <ngc/core/ngcbIMGOP.hpp>
#include <ngc/core/ngcbDIC.hpp>
#include <ngc/core/ngcbTHREAD.hpp>
#include <ngc/core/ngcppInt.h>
#include <ngc/core/ngcdcsACQ_DATA.hpp>
#include <ngc/core/ngcdcsSUBFRM.hpp>
#include <ngc/core/ngcdcsEXP.hpp>
#include <ngc/core/ngcdcsRTD.hpp>
#include <ngc/core/ngcdcsSHM.hpp>
#include <ngc/core/ngcdcsSHM_IPC.hpp>
#include <ngc/core/ngcdcsDTT_COM.hpp>
 
/*
 * Error codes
 */
#define ngcdcsACQ_ERR_EXP_FILE  -3  //< exposure file-i/o error
#define ngcdcsACQ_ERR_EXP_PROC  -2  //< exposure post-processing error
#define ngcdcsACQ_ERR_FATAL     -1  //< fatal error
#define ngcdcsACQ_ERR_IO         1  //< i/o-error
#define ngcdcsACQ_ERR_OVERRUN    2  //< run-time error: buffer overrun
#define ngcdcsACQ_ERR_OVERFLOW   3  //< run-time error: FIFO overflow
#define ngcdcsACQ_ERR_EXEC       4  //< acquisition process exec failed
 
/*
 * Shared memory libraries
 */
#define ngcdcsSHM_LIB_NONE       0  //< shared memory interface disabled
#define ngcdcsSHM_LIB_TPL        1  //< shared memory interface template 
#define ngcdcsSHM_LIB_IPC        2  //< System V IPC shared memory interface
#define ngcdcsSHM_LIB_RTD        3  //< rtd/rtdcore library
 
/*
 * Acquisition module soft states
 */
#define ngcdcsACQ_STAT_IDLE      0x00000000  //< idle
#define ngcdcsACQ_STAT_READY     0x00000001  //< ready
#define ngcdcsACQ_STAT_RUNNING   0x00000002  //< running
#define ngcdcsACQ_STAT_FAILURE   0x00000004  //< failure
#define ngcdcsACQ_STAT_PAUSED    0x00000008  //< paused
 
/*
 * Test error defintions
 */ 
#define ngcdcsACQ_TESTERR_DATA_IO  0x400  //< data i/o failed
#define ngcdcsACQ_TESTERR_STORE    0x401  //< failed to store data to disk
#define ngcdcsACQ_TESTERR_POSTPROC 0x402  //< post-processing error
#define ngcdcsACQ_TESTERR_FATAL    0x404  //< fatal error

#define ngcdcsACQ_MAX_PROC ngcdcsEXP_MAX_CLIENTS

#define ngcdcsACQ_DEFAULT_BUFSIZE (2048 * 2048 * 4)

#define ngcdcsACQ_MAX_FILESIZE (2147483647 - ngcbFITS_BLOCK_LEN)
 
/*
 * Streaming modes
 */
#define ngcdcsACQ_STREAMING_NONE      0  //< no streaming buffer
#define ngcdcsACQ_STREAMING_DEFAULT  -1  //< default streaming size
#define ngcdcsACQ_STREAMING_AUTO     -2  //< automatic streaming size
#define ngcdcsACQ_STREAMING_PARALLEL -3  //< parallel streaming 
#define ngcdcsACQ_STREAMING_REQ      -4  //< requested streaming size 
#define ngcdcsCV16_SIZE 8192             //< buffer size for CV16 

struct ngcdcs_acq_dcf_t {
  int numDet;          //< Number of detectors in mosaic  
  int haveChipIndex;   //< Explicit chip index present
  int addIdx;          //< Flag to add detector index to filename
  int det0;            //< First detector in this instance
  int sx;              //< Lower left x (for HW-window)
  int sy;              //< Lower left y (for HW-window)
  int nx;              //< X-Dimension (for HW-window)
  int ny;              //< Y-Dimension (for HW-window)
  int splitX;          //< Split to FITS extension
  int splitY;          //< Split to FITS extension
  ngcdcs_chip_t *chip; //< Chip info           

  ngcdcs_acq_dcf_t() {
    numDet = 1;
    haveChipIndex = 1;
    addIdx = 0;
    det0 = 0;
    sx = 1;
    sy = 1;
    nx = 0;
    ny = 0;
    splitX = 1;
    splitY = 1;
    chip = NULL;
  } 
};

class ngcdcs_acq_stat_t {
public:
  double val; //< Mean value
  double max; //< Maximum value

  ngcdcs_acq_stat_t() {
    Clear();
  }

  void Clear() {
    val = 0.0; max = 0.0; n_ = 0.0;
  }

  void Add(double d) {
    if (d > 0.0)
      {
      n_ += 1.0;
      if (d > max) max = d;
      val = ((val * (n_ - 1.0)) + d) / n_;
      }
  }
 
protected:
 
private:
  double n_;
};

class ngcdcs_acqperf_t {
public:
  ngcdcs_acq_stat_t size;

  ngcdcs_acq_stat_t net;

  ngcdcs_acq_stat_t proc;

  ngcdcs_acq_stat_t file;

  ngcdcs_acq_stat_t disk; 

  ngcdcs_acq_stat_t close;

  ngcdcs_acq_stat_t fits;

  ngcdcs_acq_stat_t total;

  ngcdcs_acq_stat_t exp;

  ngcdcs_acqperf_t() {
  }

  void Add(ngcdcs_acqperf_t& p) {
    size.Add(p.size.val); net.Add(p.net.val); disk.Add(p.disk.val); 
    close.Add(p.close.val); file.Add(p.file.val); fits.Add(p.fits.val); 
    proc.Add(p.proc.val); total.Add(p.total.val); exp.Add(p.exp.val);
  }

  void Clear() {
    size.Clear(); net.Clear(); disk.Clear(); close.Clear(); file.Clear();
    fits.Clear(); proc.Clear(); total.Clear(); exp.Clear();
  }
 
protected:
private:
};

struct ngcdcs_recv_t {
  ngcbSEM *semStart;

  ngcbSEM *semCfg;

  int transferring;
  
  int simErr_io;
  
  int simErr_store;

  int simErr_fatal;

  int simErr_postproc;

  int status;

  int lastTransfer;

  ngcdcs_acqperf_t statistics;

  char erms[256];
  
  ngcdcs_recv_t &operator=(const ngcdcs_recv_t &other) {
    if (this != &other)
      {
      semStart = new ngcbSEM(0);
      semCfg = new ngcbSEMC(1);
      transferring = other.transferring;
      simErr_io = other.simErr_io;
      simErr_store = other.simErr_store;
      simErr_fatal = other.simErr_fatal;
      simErr_postproc = other.simErr_postproc;
      status = other.status;
      strcpy(erms, other.erms);
      lastTransfer = other.lastTransfer;
      }
    return (*this);
  }

  ngcdcs_recv_t(const ngcdcs_recv_t &other) {
    semStart = new ngcbSEM(0);
    semCfg = new ngcbSEMC(1);
    transferring = other.transferring;
    simErr_io = other.simErr_io;
    simErr_store = other.simErr_store;
    simErr_fatal = other.simErr_fatal;
    simErr_postproc = other.simErr_postproc;
    status = other.status;
    strcpy(erms, other.erms);
    lastTransfer = other.lastTransfer;
  }

  ngcdcs_recv_t() {
    semStart = new ngcbSEM(0);
    semCfg = new ngcbSEMC(1);
    transferring  = 0;
    simErr_io = 0;
    simErr_store = 0;
    simErr_fatal = 0;
    simErr_postproc = 0;
    status = ngcbSUCCESS;
    erms[0] = '\0';
    lastTransfer = 0;
  }

  ~ngcdcs_recv_t() {
    if (semStart != NULL) delete semStart;
    if (semCfg != NULL) delete semCfg;
  }
};

class ngcdcsACQ_SERVICE: public ngcbSERVICE
{
public:
  ngcdcsACQ_SERVICE() {}

  virtual ~ngcdcsACQ_SERVICE() {}

  virtual int FrameHandler(void *buffer, ngcdcs_finfo_t *finfo, char *erms) {
    USE(buffer); USE(finfo); USE(erms);
    return (ngcbSUCCESS);
  }

  virtual int FitsMerger(ngcbFITS *hdr, char *erms) {
    USE(hdr); USE(erms);
    return (ngcbSUCCESS);
  }

  virtual void AcqError(const char *erms, int id, void *descriptor) {
    USE(erms); USE(id); USE(descriptor);
  }
 
protected:
 
private:
 
};
 

class ngcdcsACQ: public ngcbOBJ, public ngcbTHREAD
{
public:
  ngcdcsACQ();

  explicit ngcdcsACQ(const ngcdcs_acq_cfg_t &cfg);

  explicit ngcdcsACQ(ngcbPARAM_LIST *p);

  ngcdcsACQ(const ngcdcs_acq_cfg_t &cfg, ngcbPARAM_LIST *p);

  virtual ~ngcdcsACQ();     

  size_t ppStackSize;

  ngcdcsSHM *shm;

  int shmLib;

  char shmName[64];

  int shmNumBuf;

  int status; 

  int ioError;

  char procName[256];

  char burstProcess[256];

  ngcdcs_acq_dcf_t detCfg;

  ssize_t allocSize; 

  int burstNum;

  int burstSkip;

  int connect; 

  int exp;

  int continuous; 

  int transfer;

  int guiding; 

  int queueSize; 

  int queueDump; 

  int diskMem;

  int flush;

  int timestamp_table;
  
  int diskMemSize;

  char diskMemPath[256]; 

  int largeFile;

  int simHighSpeed;
  
  int updateFrames;

  char moduleName[64];

  int chanSelect;

  int cmdPort;

  int dataPort;   

  int ppRev;

  int appRev;

  int appDataInline;

  int payloadSize;

  char rtdCmd[256];
  
  ngcdcsRTD *rtd;

  ngcdcsSUBFRM *subFrames;

  ngcbTHREAD_T mainThread;          

  ngcbIMGOP imgop;

  char darkFrame[256];

  char flatField[256];

  char badPixMask[256];

  char extName[80];

  int autoWinX;

  int autoWinY;

  int relaunch;
  
  void ErrState(const char *msg, int id); 

  void SimError(int error);  

  void AttachServices(ngcdcsACQ_SERVICE *s);
 
  int StartDebugger();

  int StopDebugger();

  int DebuggerRunning();
 
  /*
   * Configuration
   */

  void Profile(const char *id);

  void Configure(const ngcdcs_acq_cfg_t &newConf);
  
  void GetCfg(ngcdcs_acq_cfg_t *currentConf); 

  int Streaming(ssize_t size);

  int Alloc(ssize_t size);  

  int Alloc();

  void Free();                

  int ShmSelect(const char *libName, const char *nameSpace=NULL, int n=0);

  int ShmName(const char *nameSpace);

  int ShmNumBuf(int n);

  int ShmNoWait(int flag);

  int ShmNoWait() {return (shmNoWait_);}

  void Sim(int flag);   

  int Sim() {return (sim_);}

  void SofwMode(char *s);

  char *Host();

  int DataPath(const char *path);

  const char *DataPath();

  const char *Dev(int n=0);         

  int Pid();

  void Release();

  int Reset(); 

  int GetRecvStatus(int *err, int *stat);
 
 
  /*
   * Process execution
   */
  
  int Exec(); 

  int Exec(const char *newProcess); 

  void Abort(); 

  int FdCmd(); 

  int FdErr(); 

  void HandleFdCmdEvt(); 

  int HandleFdErrEvt(); 
 
 
  /*
   * Run control
   */

  char *StatusString();  

  int Start(double absTime = 0.0);

  int Stop();     

  int ResumeSim(); 

  int Restart(double absTime = 0.0); 

  void SetupId(int id = -1); 

  int NewSetup(); 

  int End();

  int ResetCnt();

  int Pause();  

  int Cont();                       

  int Cmd(const char *cmd, char *reply);  

  int UploadFits(int id, const char *path, int noCheck=0);

  int UploadBuf(int id, void *buffer, int size, int noCheck=0); 

  int Clear(int id);   

  int DarkFrame(const char *path);

  int FlatField(const char *path);

  int BadPixMask(const char *path);

  int ChanSelect(int chan);

  int SimTime(int ms);
   
  int SimTime();
   
 
 
  /*
   * Burst modes
   */

  int Burst(int num); 

  int BurstSkip(int num);  

  int Queue(int num);

  void QueueWin(int sx, int sy, int nx, int ny);

  void QueueAlign();

  int DiskMem(int flag); 

  int DiskMemPath(const char *path);

  int DiskMemCreate(int size); 

  int DiskMemDelete();              
 
 
  /*
   * Parameter interface
   */

  void Dictionary(ngcbDIC *dictionary); 

  int HwWin(int sx, int sy, int nx, int ny); 
 
   // synchronize parameter setup
  int SyncParam(int timeout = 20);
 
  // set parameter
  int SetParam(const char *paramName, const char *paramValue, int sync=1);

  int GetParam(const char *paramName, char *paramValue);  

  int ApplyParamList(ngcbPARAM_LIST *list, int sync = 1);

  int ApplyParamList(int sync = 1);                       
 
 
  /*
   * Exposure and frame setup
   */

  void Exposure(ngcdcsEXP *exposure); 

  ngcdcsEXP *Exposure();

  void NumExtBlocks(int n);

  int LocalMedia();

  int FrameDef(ngcdcs_framedef_t *frameDef); 

  ngcdcs_framedef_t *Frame(const char *name); 

  ngcdcs_framedef_t *Frame(int idx);  

  int FrameGen(const char *name, int flag);   

  void SeqStartTime(struct timeval &timeVal);

  const char *SeqStartTime(); 

  void ExpStartTime(struct timeval &timeVal);

  const char *ExpStartTime(); 

  double ExpStartTimeMJD(); 

  double ExpStartTimeUTC(); 

  int ExpSeqNo(); 

  int ExpActive();  

  int StartExposure(); 

  void StopExposure(); 

  int ExtDtt() {return dtt_.enabled;} 

  size_t FramesProcessed();

  size_t SizeRecorded();
 
  /*
   * Asynchronous data transfer
   */

  ngcdcsACQ_DATA data; 

  int StartTransferring(); 

  void StopTransferring(); 

  int Transferring();

  int LastTransfer(); 

  int GetServiceConfig(ngcpp_cfg_t *config);  

  int Transfer(int flag);
 
  int Guiding(int flag);
 
 
  /*
   * Statistics
   */

  unsigned int DmaCnt(int idx = 0);

  double Perf();

  double FrameRate();

  void Statistics(ngcdcs_acqperf_t *stat); 

  void ClearStatistics();              

  char *ErrMsg();   
 
protected: 
  virtual int DataConnect();       

  virtual int Store(char *buffer, ngcdcs_finfo_t finfo, char *where, 
            int store2tmp = 0); 

  virtual ngcdcsSHM *NewShm(const char *name);
 
private:
  char ermsMain_[256];    

  char ermsThr_[256];

  ngcdcsACQ_SERVICE *services_;

  ngcbTHREAD *debugThread_;

  int debugService_;

  int debugPort_;

  void Init_();

  void CheckResult_(int result); 

  void Debugger_(ngcbTHREAD *thr, void *arg);
 
 
 
  /*
   * Configuration
   */

  void NewStatus_(int);

  char statStr_[32];

  char profile_[32];

  int sim_;

  int simTime_;

  ngcdcs_acq_cfg_t cfg_;

  int errPort_; 

  int fdCmd_;

  int fdErr_; 

  int pid_;  

  char acqCmdLine_[256];

  int vb_; 

  char thisHost_[64]; 

  char acqHost_[64];      

  char acqDataPathReq_[256];

  char acqDataPath_[256];

  char procNameOrig_[256];            
 
 
  /*
   * Dynamic parameters
   */

  int numParam_; 

  ngcppPARAM_NAMES paramName_; 

  int paramType_[ngcppMAX_PARAMSIZE];

  int setupId_;

  ngcbDIC *dictionary_;

  ngcbPARAM_LIST *paramList_; 

  void Export_(ngcppPARAM_VALUES paramBuf);   
  
 
  /*
   * Data reception process
   */

  ngcdcsDTT_COM dtt_;

  ngcdcsEXP expLocal_;

  ngcdcsEXP *exposure_; 

  char seqStartTime_[64];

  void RecvProc_(ngcbTHREAD *thr, void *arg);

  ngcbTHREAD *recvThread_; 

  void RecvEvt_(ngcdcs_expevt_t evt);

  ngcdcs_recv_t recv_;

  int expActive_; 

  int numStore_;

  ngcdcs_acqperf_t statistics_;

  double expTime_;              

  int suspended_;

  size_t framesProcessed_;

  size_t sizeRecorded_;
 
  /*
   * Background receiver
   */

  void RecvBgProc_(ngcbTHREAD *thr, void *arg);

  ngcbTHREAD *recvBgThread_;
    
  ngcdcs_recv_t recvBg_;

  int RecvBgStart_(); 

  int RecvBgStop_();

  int RecvBgOn_();              
 
 
  /*
   * Frame type definitions
   */

  int types_;

  ngcdcs_framedef_t frame_[ngcdcsMAX_FRAME_TYPES];

  char *frameBuf_;

  size_t frameBufSize_;            

  int queueType_;

  int qsx_;

  int qsy_;

  int qnx_;

  int qny_;
 
 
  /*
   * Share memory interface
   */

  int shmNoWait_;

  void *ShMemAlloc_(size_t);

  void ShMemFree_(); 
 
 
  /*
   * Streaming buffer
   */

  ssize_t streamBufSize_;

  int streamBufMode_;

  void Streaming_(FILE *fd);

  void AutoStreaming_();
 
 
  /*
   * Data cube routines
   */

  int CubeOpen_(ngcdcs_framedef_t *f);
  
  int CubeHeader_();

  int CubeHeader_(ngcbFITS *fhdr, ngcdcsCUBE *cube);

  int CubeClose_(ngcdcsCUBE *cube, const char *fileName=NULL);

  int CubeNext_(ngcdcsCUBE *cube);
 
 
  /*
   * FITS-routines
   */
  unsigned short *cv16Buf_;

  ngcbFITS fits_; 

  ngcbFITS cubeHdr_;

  ngcbFITS efits_; 

  ngcb_off_t hdrSeek_; 

  ngcbFITS cfits_;

  FILE *fdExt_;  
  
  int ExtFitsOpen_();
  
  int ExtFitsPrimHeader_();
  
  int ExtFitsHeader_(ngcdcs_finfo_t finfo);

  void ExtFitsClear_(FILE *fd, ngcb_off_t offset);

  int ExtFitsUpdate_(FILE *fd);

  int ExtFitsClose_(int immediate=1);

  char extFitsFileName_[512];

  int MosaicWin_(ngcdcs_finfo_t finfo, int x, int y, int *sx, int *sy, 
         int *nx, int *ny, int *px, int *py);

  int Chip2Fits_(ngcbFITS *f, int idx, int splitX, int splitY, int doIdx=0);
  
  int WrCv16_(FILE *fd, const char *buffer, size_t size);

  int Win2File_(FILE *fd, char *buffer, int fx, int fy, int bitPix,
         int sx, int sy, int nx, int ny, int rot);

  int CompleteFits_(ngcbFITS *hdr);

  int StoreFits_(char *buffer, ngcdcs_finfo_t finfo, char *where,
         int store2Tmp = 0);

  int StoreFitsCube_(char *buffer, ngcdcs_finfo_t finfo, char *where);

  int StoreFitsExt_(char *buffer, ngcdcs_finfo_t finfo, char *where);
};
 
#endif