SOLARIS_GTK4_DAQ/ClassDigitizer2Gen.h

#ifndef  DIGITIZER_CLASS_H
#define  DIGITIZER_CLASS_H


#include <CAEN_FELib.h>
#include <cstdlib>
#include <string>

//#include "Parameter.h"

#define MaxOutFileSize 2*1024*1024
#define MaxTraceLenght 2048

struct event {
  uint8_t  channel;    //  6 bit
  uint64_t timestamp;  // 48 bit
  uint64_t timestamp_ns; // 51 bit fine_timestamp not included
  double   timestamp_us;
  uint16_t fine_timestamp; // 16 bit
  uint16_t energy;   // 16 bit
  uint16_t flags_low_priority; // 12 bit
  uint16_t flags_high_priority; // 8 bit
  uint8_t  analog_probes_type[2];  // 3 bit
  uint8_t  digital_probes_type[4]; // 4 bit
  int32_t analog_probes0[MaxTraceLenght];  // 18 bit
  int32_t analog_probes1[MaxTraceLenght];
  uint8_t digital_probes0[MaxTraceLenght]; // 1 bit
  uint8_t digital_probes1[MaxTraceLenght];
  uint8_t digital_probes2[MaxTraceLenght];
  uint8_t digital_probes3[MaxTraceLenght];
  size_t   traceLenght; // 64 bit
  uint16_t trigger_threashold; // 16 bit
  uint8_t downSampling; // 8 bit
  bool board_fail;
  size_t   event_size;  // 64 bit
  bool flush; 
  uint32_t aggCounter; // 32 bit

  void PrintEnergyTimeStamp(){
    printf("ch: %2d, energy: %u, timestamp: %lu ch, traceLenght: %lu\n", channel, energy, timestamp, traceLenght);
  }

  void PrintAll(){
    printf("============== ch : %2d (0x%2X), fail: %d, flush: %d\n", channel, channel, board_fail, flush);
    printf("energy: %u, timestamp: %lu, fine_timestamp: %u \n", energy, timestamp, fine_timestamp);
    printf("flag (high): 0x%2X, (low): 0x%3X, traceLength: %lu\n", flags_high_priority, flags_low_priority, traceLenght);
    printf("Agg counter : %u, trigger : %u, downSampling: %u \n", aggCounter, trigger_threashold, downSampling);
    printf("AnaProbe Type: %u, %u\n", analog_probes_type[0], analog_probes_type[1]);
    printf("DigProbe Type: %u, %u, %u, %u\n", digital_probes_type[0], digital_probes_type[1], digital_probes_type[2], digital_probes_type[3]);
  }

  void PrintTrace(){
    for(int i = 0; i < traceLenght; i++){
      printf("%4d| %6d  %6d   %1d  %1d   %1d  %1d\n", i, analog_probes0[i], 
                                               analog_probes1[i], 
                                               digital_probes0[i], 
                                               digital_probes1[i], 
                                               digital_probes2[i], 
                                               digital_probes3[i]);
    }
  }

  uint64_t word; 

  uint64_t* GetWord1(){
    word = 0;
    word += timestamp;
    word += ((((uint64_t)channel & 0x3F) << 48));
    word += ((((uint64_t)board_fail) << 58));
    word += ((((uint64_t)flush) << 59));
    word += (((uint64_t) 0xA) << 60);
    return &word;
  }  
  
  uint64_t* GetWord2(){
    word = 0;
    word += energy;
    word += ((((uint64_t)fine_timestamp & 0x3FF) << 16));
    word += ((((uint64_t)flags_low_priority & 0xFFF) << 26));
    word += ((((uint64_t)flags_high_priority & 0xFF) << 38));
    word += ((((uint64_t)traceLenght) << 46));
    return &word;
  }

  uint64_t* GetWord3(){
    word = 0;
    word += trigger_threashold;
    word += ((((uint64_t)aggCounter) << 16));
    word += ((((uint64_t)downSampling) << 48));
    return &word;
  }
  
  uint64_t* GetWord4(){
    word = 0;
    word += analog_probes_type[0] & 0x7 ;
    word += (((uint64_t)(analog_probes_type[1] & 0x7)) << 3) ;
    word += (((uint64_t)(digital_probes_type[0] & 0xF)) << 6) ;
    word += (((uint64_t)(digital_probes_type[1] & 0xF)) << 10) ;
    word += (((uint64_t)(digital_probes_type[2] & 0xF)) << 14) ;
    word += (((uint64_t)(digital_probes_type[3] & 0xF)) << 18) ;
    return &word;
  }

  uint64_t* GetWordTrace(int i){
    word = 0;
    word += analog_probes0[i] & 0x7FFFF;
    word += (((uint64_t)analog_probes1[i] & 0x7FFFF) << 32) ;
    word += (((uint64_t)digital_probes0[i]) << 18) ;
    word += (((uint64_t)digital_probes1[i]) << 19) ;
    word += (((uint64_t)digital_probes2[i]) << 50) ;
    word += (((uint64_t)digital_probes3[i]) << 51) ;
    return &word;
  }

};

class Digitizer2Gen {
  private:
    uint64_t handle;    
    uint64_t ep_handle; ///end point handle
    uint64_t ep_folder_handle; ///end point folder handle
    bool isConnected;
    int ret;

    char retValue[256];

    std::string modelName;
    std::string cupVersion;
    std::string DPPVersion;
    std::string DPPType;
    unsigned short serialNumber;
    unsigned short adcBits;
    unsigned short nChannels;
    unsigned short adcRate;
    unsigned short ch2ns;

    std::string IPAddress;
    std::string netMask;
    std::string gateway;

    void Initialization();
    
    std::string ErrorMsg(const char * funcName);

    unsigned short outFileIndex;
    
  
  public:
    Digitizer2Gen();
    ~Digitizer2Gen();
  
    int OpenDigitizer(const char * url);
    int CloseDigitizer();
  
    std::string    ReadValue(const char * parameter);
    void          WriteValue(const char * parameter, std::string value);
    void         SendCommand(const char * parameter);

    uint64_t    GetHandle(const char * parameter);
    uint64_t    GetParentHandle(uint64_t handle);
    std::string GetPath(uint64_t handle);
    
    void StartACQ();
    void StopACQ();
    
    void SetPHADataFormat();
    int  ReadData();
    void ReadDataRaw(); //not impletmented

    void ProgramPHA(bool testPulse = false);
    
    unsigned short GetNChannels() {return nChannels;}
    unsigned short GetCh2ns()     {return ch2ns;}
    uint64_t       GetHandle()    {return handle;}
    
    event evt;  
    void SaveDataToFile(std::string fileName);

};

#endif