FSUDAQ_Qt6/ClassDigitizer.h

#ifndef DIGITIZER_H
#define DIGITIZER_H

#include <stdio.h>
#include <string>
#include <sstream>
#include <cmath>
#include <cstring>  ///memset
#include <iostream> ///cout
#include <bitset>

#include "CAENDigitizer.h"
#include "CAENDigitizerType.h"

#include "macro.h"
#include "ClassData.h"
#include "RegisterAddress.h"

//################################################################
class Digitizer{
  
  protected:
    
    Data * data;

    //^---- fixed parameter
    int                   portID;        /// port ID for optical link for using PCIe card, from 0, 1, 2, 3
    int                   boardID;       /// board identity
    int                   handle;        /// i don't know why, but better separete the handle from boardID
    int                   NumInputCh;      /// number of physical input channel
    int                   NumRegChannel;   /// number of Register channel
    bool                  isInputChEqRegCh;   /// is number of physical input channel = Register channel
    int                   NCoupledCh;    /// number of Coupled channel
    int                   ADCbits;       /// ADC bit
    int                   DPPType;       /// DPP verion
    int                   ModelType;     /// VME or DT
    unsigned int          ADCFullSize;   /// pow(2, ADCbits) - 1
    float                 tick2ns;         /// channel to ns
    unsigned int          MemorySizekSample; /// channel Memory size in kSample
    std::string           familyName;

    CAEN_DGTZ_BoardInfo_t BoardInfo;
    
    //^----- adjustable parameters
    bool                     softwareDisable;   /// not using the whole board
    uint32_t                 regChannelMask ;   /// the channel mask from NumInputCh
    uint32_t                 VMEBaseAddress; /// For direct USB or Optical-link connection, VMEBaseAddress must be 0    
    CAEN_DGTZ_ConnectionType LinkType;       /// USB or Optic
    CAEN_DGTZ_IOLevel_t      IOlev;          /// TTL signal (1 = 1.5 to 5V, 0 = 0 to 0.7V ) or NIM signal (1 = -1 to -0.8V, 0 = 0V)

    //^------- other parameters
    int  ret;            /// return value, refer to CAEN_DGTZ_ErrorCode
    bool isConnected;    /// true for digitizer communication estabished.
    bool AcqRun;         /// true when digitizer is taking data
    bool isDummy;        /// true for a dummy digitizer.

    //^-------- setting 
    std::string  settingFileName;          /// 
    FILE *       settingFile;              /// 
    bool         isSettingFileExist;         /// 
    bool         isSettingFileUpdate;
    bool         isSettingFilledinMemeory; /// false for disabled ReadAllSettingFromBoard()   
    bool         hasOverThresholdWidth;  /// for QDC
    unsigned int setting[SETTINGSIZE];     /// Setting, 4bytes x 2048 = 8192 bytes
    
    //^-------- other protected functions
    void         ErrorMsg(std::string header = "");

    uint32_t     returnData;

    uint32_t acqStatus;

    int ProgramBoard_PHA() ; /// program a default PHA board with dual trace
    int ProgramBoard_PSD() ; 
    int ProgramBoard_QDC() ;

    int ProgramChannel_PHA(short ch) ; /// program a default PHA Channel for Si-detector, ch = -1 for all channel
    int ProgramChannel_PSD(short ch) ; /// program a default PSD Channel for Si-detector, ch = -1 for all channel
    int ProgramChannel_QDC(short group) ; /// program a default QDC group for Si-detector, ch = -1 for all group

  public:
    Digitizer(); /// no digitizer open
    Digitizer(int boardID, int portID = 0, bool program = false, bool verbose = false); 
    virtual ~Digitizer();

    //^------ portID is for optical link for using PCIe card, from 0, 1, 2, 3
    int  OpenDigitizer(int boardID, int portID = 0, bool program = false, bool verbose = false);
    void SetDPPType        (int type) { this->DPPType = type;} /// for manual override, or, digitizer does not open
    void SetRegChannelMask    (uint32_t mask);
    void SetRegChannelOnOff   (unsigned short ch, bool onOff);
    int  CloseDigitizer();
    void Initalization();
    void Reset();
    bool IsDummy()         {return isDummy;}
    bool IsConnected()     {return isConnected;}
    
    void DisableBoard()    {softwareDisable = true;}
    void EnableBoard()     {softwareDisable = false;}
    bool IsBoardDisabled() const {return softwareDisable;}

    void PrintBoard();    
    void ProgramBoard();
    void ProgramChannel(short chOrGroup);

    void AutoSetDPPEventAggregation();
    
    //^================ ACQ control
    void   StopACQ();
    void   StartACQ();
    int    ReadData();
    bool   IsRunning() const {return AcqRun;}
    Data * GetData()   const {return data;}
    uint32_t GetACQStatusFromMemory() const {return acqStatus;}
    void   ReadAndPrintACQStatue();
    void   ReadACQStatus() { // Only use when ACQ is running;
      // printf("%s\n", __func__);
      //acqStatus = ReadRegister(DPP::AcquisitionStatus_R); 
      CAEN_DGTZ_ReadRegister(handle, DPP::AcquisitionStatus_R, &acqStatus);
    }

    unsigned int CalByteForBuffer(bool verbose = false);
    unsigned int CalByteForBufferCAEN();

    //^================= Settings
    /// write value to digitizer, memory, and settingFile (if exist)
    /// ONLY WriteRegister can have ch = -1, for writting all channels
    /// for board setting, ignore ch
    void WriteRegister (Reg registerAddress, uint32_t value, int ch = -1, bool isSave2MemAndFile = true); 
    /// read value from digitizer and memory, and save to memory, and settingFile(if exist), 
    /// for board setting, ignore ch
    uint32_t ReadRegister (Reg registerAddress, unsigned short ch = 0, bool isSave2MemAndFile = true, std::string str = "" ); 
    uint32_t PrintRegister(uint32_t address, std::string msg);
    
    //^================ Get Board info
    CAEN_DGTZ_BoardInfo_t GetBoardInfo()     const {return BoardInfo;}
    std::string GetModelName()               const {return BoardInfo.ModelName;}
    int         GetSerialNumber()            const {return BoardInfo.SerialNumber;}
    int         GetRegChannelMask()          { regChannelMask = GetSettingFromMemory(DPP::RegChannelEnableMask); return regChannelMask;}
    bool        GetInputChannelOnOff(unsigned ch) ;
    float       GetTick2ns()                 const {return tick2ns;}
    int         GetNumInputCh()              const {return NumInputCh;}
    int         GetNumRegChannels()          const {return NumRegChannel;}
    bool        IsInputChEqRegCh()           const {return isInputChEqRegCh;}
    int         GetCoupledChannels()         const {return NCoupledCh;}
    int         GetHandle()                  const {return handle;}
    int         GetDPPType()                 const {return DPPType;}
    int         GetModelType()               const {return ModelType;}
    std::string GetDPPString(int DPPType = 0);  /// if no input, use digitizer DPPType
    int         GetADCBits()                 const {return BoardInfo.ADC_NBits;}
    std::string GetROCVersion()              const {return BoardInfo.ROC_FirmwareRel;}
    std::string GetAMCVersion()              const {return BoardInfo.AMC_FirmwareRel;}
    CAEN_DGTZ_ConnectionType   GetLinkType() const {return LinkType;}
    int         GetErrorCode()               const {return ret;}
    unsigned int GetChMemSizekSample()       const {return MemorySizekSample;}
    std::string GetFamilyName()              const {return familyName;}
    bool        HasOverThresholdWidth_QDC()  const {return hasOverThresholdWidth;}
    
    //^================ Setting 
    Reg FindRegister(uint32_t address);
    /// board <--> memory functions
    void           ReadAllSettingsFromBoard  (bool force = false);
    void           ProgramSettingsToBoard    ();

    /// simply read settings from memory
    void           SetSettingToMemory        (Reg registerAddress, unsigned int value, unsigned short ch = 0);
    unsigned int   GetSettingFromMemory      (Reg registerAddress, unsigned short ch = 0);
    unsigned int * GetSettings()             {return setting;}    
    void           PrintSettingFromMemory();
    void           SetSettingFileUpdate(bool onOff) {isSettingFileUpdate = onOff;}     
    bool           IsSettingFileUpdate()  const {return isSettingFileUpdate;}
    bool           IsSettingFileExist()   const {return isSettingFileExist;}

    /// memory <--> file
    void         SaveAllSettingsAsText       (std::string fileName);
    void         SaveAllSettingsAsTextForRun (std::string fileName);
    void         SaveAllSettingsAsBin        (std::string fileName); 
    std::string  GetSettingFileName()        {return settingFileName;}
    /// tell the digitizer where to look at the setting file.
    /// if not exist, call SaveAllSettinsAsBin();
    void         SetSettingBinaryPath        (std::string fileName);
    /// load setting file to memory
    /// if problem, return -1; load without problem, return 0;
    int          LoadSettingBinaryToMemory   (std::string fileName); 
    void         SaveSettingToFile           (Reg registerAddress, unsigned int value,  unsigned short ch = 0); /// also save to memory
    unsigned int ReadSettingFromFile         (Reg registerAddress, unsigned short ch = 0); /// read from setting binary

    //============ old methods, that only manipulate digitizer register, not setting in memory
    void SetDPPAlgorithmControl(uint32_t bit, int ch);
    unsigned int ReadBits(Reg address, unsigned int bitLength, unsigned int bitSmallestPos, int ch );
    void SetBits(Reg address, unsigned int bitValue, unsigned int bitLength, unsigned int bitSmallestPos, int ch);
    void SetBits(Reg address, std::pair<unsigned short, unsigned short> bit, unsigned int bitValue, int ch){ SetBits(address, bitValue, bit.first, bit.second, ch);}
    static unsigned int ExtractBits(uint32_t value, std::pair<unsigned short, unsigned short> bit){ return ((value >> bit.second) & uint(pow(2, bit.first)-1) ); }

    //====== Board Config breakDown
    bool IsDualTrace_PHA()           {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 11) & 0x1 );}
    bool IsRecordTrace()             {return ( (GetSettingFromMemory(DPP::BoardConfiguration) >> 16) & 0x1 );}

    //QDC read recordLength
    uint32_t ReadQDCRecordLength();
    void SetQDCOptimialAggOrg();

    void SetTrace(bool onOff){
      SetBits(DPP::BoardConfiguration, DPP::Bit_BoardConfig::RecordTrace, onOff, -1);
    }

};


#endif