ngcdcsFINFO.hpp

Go to the documentation of this file.

#ifndef ngcdcsFINFO_H
#define ngcdcsFINFO_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/ngcbSTREAM.hpp>
#include <ngc/core/ngcbFITS.hpp>
#include <ngc/core/ngcppInt.h>
#include <ngc/core/ngcdcsTsTable.hpp>

#define ngcdcsMAX_FRAME_TYPES ngcppMAX_FRAME_TYPES

#define ngcdcsMAX_DET 32

struct ngcdcs_chip_t {
  int posX;

  int posY; 

  int nx;

  int ny;  

  int adjustMode; 

  int adjustX;

  int adjustY;

  int index;

  int rotAngle;

  int live;  

  int numOutput;  

  int pixPerChan;  

  int acqIdx; 

  double pixSpace; 

  double gain;

  double outGain[64];

  double ron;

  double pszx;

  double pszy;

  double xgap;

  double ygap;

  double rgap;

  char type[32];

  char name[32];

  char id[32];

  char date[16];   

  explicit ngcdcs_chip_t(int n=0) {
    int i;
 
    index = n;
    strcpy(type, "CHIP-TYPE");
    strcpy(name, "CHIP-NAME");
    strcpy(id, "CHIP-ID");
    strcpy(date, "YYYY-MM-DD");
    pixSpace = 1.0e-6;
    gain = 1.0;
    for (i=0;i<64;i++) outGain[i] = 0.0;  // use global gain
    ron = 0.0;
    pszx = 1.0;
    pszy = 1.0;
    numOutput = 4;
    pixPerChan = 0; // not set
    xgap = 0.0;
    ygap = 0.0;
    rgap = 0.0;
    rotAngle = 0;
    live = 1;
    posX = 1;
    posY = 1;
    nx = 256;
    ny = 256;
    adjustMode = 0; 
    adjustX = 1; 
    adjustY = 1;
    acqIdx = 0;     // auto-mapping
  }
};

struct ngcdcs_cfile_t {
  int desc[4];

  ngcdcs_cfile_t *next;

  ngcdcs_cfile_t() {
    next = NULL;
    memset(desc, 0, sizeof(desc));
  }

  ~ngcdcs_cfile_t() {
    if (next != NULL)
      {
      delete next; next = NULL;
      }
  }
};

class ngcdcs_cfile_list {
public:
  int size;

  int ftype;
  
  ngcdcs_cfile_t *entry;

  ngcdcs_cfile_list() {
    ftype = ngcppFRAME_NO_FRAME;
    Init_();
  }
  
  explicit ngcdcs_cfile_list(int f) {
    ftype = f;
    Init_();
  }

  ~ngcdcs_cfile_list() {
    delete first_;
    size = 0;
  }

  void Add(int pid, int id, int fcnt, int hcnt) {
    int *e = entry->desc;
    e[0] = pid; e[1] = id; e[2] = fcnt; e[3] = hcnt;
    entry->next = new ngcdcs_cfile_t();
    entry = entry->next;
    size++;
  }
  
  void Add(const char *ref) {
    int pid, id, fcnt, hcnt;
    if (sscanf(ref, "%10d_%10d_%*d_%10d_%10d", &pid, &id, &fcnt, &hcnt) == 4)
      {
      Add(pid, id, fcnt, hcnt);
      }
    else if (sscanf(ref, "%10d_%10d_%*d_*_%10d", &pid, &id, &hcnt) == 3)
      {
      Add(pid, id, -1, hcnt);
      }      
  }

  const int *Entry(int n) {
    if ((n < 0) || (n >= size))
      {
      return (NULL);
      }
    else
      {
      int i;
      ngcdcs_cfile_t *e = first_;
      for (i=0;i<n;i++) e = e->next;
      return (e->desc);
      }
  }

  void Entry2File(char *fileName, const int *e) {
    if ((e[2] == -1) && (e[3] == -1))
      {
      sprintf(fileName, "%d_%d_%d_*_*.frm", e[0], e[1], ftype);
      }
    else
      {
      if (e[2] == -1)
    {
    sprintf(fileName, "%d_%d_%d_*_%d.frm", e[0], e[1], ftype, e[3]);
    }
      else if (e[3] == -1)
    {
    sprintf(fileName, "%d_%d_%d_%d_*.frm", e[0], e[1], ftype, e[2]);
    }
      else
    {
    sprintf(fileName, "%d_%d_%d_%d_%d.frm", e[0], e[1], ftype, e[2], e[3]);
    }
      }
  }

  void FileName(char *fileName, int n) {
    const int *e = Entry(n);
    if (e == NULL) fileName[0] = '\0';
    else Entry2File(fileName, e);
  }
 
protected:
private:
  ngcdcs_cfile_t *first_;

  void Init_() {
    size = 0;
    entry = new ngcdcs_cfile_t();
    first_ = entry;
  }
};

class ngcdcsCUBE {
public:
  FILE *fd; 

  int naxis1;

  int naxis2; 

  int naxis3;

  int bitPix;  

  int divisor;    

  double bscale; 

  double bzero; 

  int ndit;    

  int sx; 

  int sy;    

  double expFactor; 

  double timeStamp;

  char fileName[512];

  char frameName[64];

  unsigned int cnt;

  int fcnt;

  int fcnt0;

  ngcb_off_t truncate;

  char reference[64];

  ngcdcs_cfile_list *fileList;

  ngcbSTREAM *stream;

  ngc::core::ngcdcs::TsTable timestamps;

  ngcdcsCUBE() {
    fd = NULL;
    naxis1 = 0;
    naxis2 = 0;
    naxis3 = 0;
    bitPix = 16;
    divisor = 1;
    bscale = 1.0;
    bzero = 0.0;
    ndit = 1;
    sx = 1;
    sy = 1;
    expFactor = 1.0;
    timeStamp = 0.0;
    fileName[0] = '\0';
    frameName[0] = '\0';
    cnt = 0;
    fcnt = 0;
    fcnt0 = 0;
    // cppcheck-suppress useInitializationList
    truncate = -1;
    reference[0] = '\0';
    fileList = NULL;
    stream = NULL;
  }

  ~ngcdcsCUBE() {
    Close();
  }

  ngcb_off_t Size() {
    return ((ngcb_off_t)naxis1 * (ngcb_off_t)naxis2 * (ngcb_off_t)(naxis3 * abs(bitPix/8)));
  }

  int Open(const char *path, const char *name) {
    naxis3 = 0;
    timeStamp = 0.0;
    truncate = -1;
    timestamps.Clear();
    fd = ngcb_fopen(path, "w");
    if (fd == NULL)
      {
      return (ngcbFAILURE);
      }
    else
      {
      char tmp[512];
      strcpy(tmp, path);
      strcpy(fileName, tmp);
      strcpy(tmp, name);
      strcpy(frameName, tmp);
      return (ngcbSUCCESS);
      }
  }

  void Close(int sync=0) {
    if (stream != NULL)
      {
      delete stream; stream = NULL;
      }
    if (fd != NULL)
      {
      if (truncate >= 0)
    {
    int fno = fileno(fd);
    if (fno >= 0) {fflush(fd); if (ngcb_ftruncate(fno, truncate) != 0);}
    }
 
      if (sync)
    {
    /*
     * Flush to disk
     */
    if (fflush(fd) == 0)
      {
      int fno = fileno(fd);
      if (fno >= 0) fsync(fno);
      }
    }
      
      /*
       * Close file
       */
      fclose(fd); fd = NULL;
 
      if ((naxis3 <= 0) || (truncate == 0))
    {
    if (strlen(fileName) > 0)
      {
      /*
       * Remove the file
       */
      remove(fileName); fileName[0] = '\0';
      }
    }
      }
  }
 
protected:
private:
};

struct ngcdcs_finfo_t {
  int type;

  char name[64];

  int fcnt; 

  double expFactor;

  int bitPix; 

  int divisor;    

  double bscale;

  double bzero; 

  int sx; 

  int sy; 

  int nx; 

  int ny;    

  double crpix1;

  double crpix2;

  int detIdx; 

  int expCnt; 

  int fcnt0; 

  int ndit; 

  int acq; 

  int recording;
  
  char utc[64]; 

  char reference[64];

  char where[512];

  int appDataSize;

  int appDataInline;

  char appData[ngcppAPP_HDR_SIZE];

  double timeStamp;
  
  ngcdcsCUBE *cube; 

  ngcbFITS *ehdr;   

  ngcdcs_finfo_t() {
    type = 0;
    name[0] = '\0';
    fcnt = 0;
    fcnt0 = 0;
    expFactor = 1.0;
    bitPix = 16;
    divisor = 1;
    bscale = 1.0;
    bzero = 0.0;
    ndit = 1;
    sx = 1;
    sy = 1;
    nx = 0;
    ny = 0;
    crpix1 = 0.0;
    crpix2 = 0.0;
    detIdx = 0;
    expCnt = 0;
    acq = 0;
    utc[0] = '\0';
    reference[0] = '\0';
    where[0] = '\0';
    appDataSize = 0;
    appDataInline = 1;
    memset(appData, 0, sizeof(appData));
    recording = 0;
    timeStamp = 0.0;
    cube = NULL;
    ehdr = NULL;
  }
};
 
#endif