SOLARIS_QT6_DAQ/ClassDigitizer2Gen.h

137 lines
4.6 KiB
C
Raw Normal View History

2023-01-25 14:59:48 -05:00
#ifndef DIGITIZER_CLASS_H
#define DIGITIZER_CLASS_H
#include <CAEN_FELib.h>
#include <cstdlib>
#include <string>
#include <map>
2023-01-25 14:59:48 -05:00
#include "Event.h"
#define MaxOutFileSize 2*1024*1024*1024 //2GB
//#define MaxOutFileSize 20*1024*1024 //20MB
2023-01-25 14:59:48 -05:00
#define MaxNumberOfChannel 64
2023-02-08 17:35:04 -05:00
#include "DigiParameters.h"
//^=================== Digitizer Class
2023-01-25 14:59:48 -05:00
class Digitizer2Gen {
private:
uint64_t handle;
uint64_t ep_handle; ///end point handle
uint64_t ep_folder_handle; ///end point folder handle
uint64_t stat_handle;
//uint64_t stat_folder_handle;
bool isDummy;
2023-01-25 14:59:48 -05:00
bool isConnected;
int ret;
char retValue[256];
unsigned short serialNumber;
std::string FPGAType;
2023-01-25 14:59:48 -05:00
unsigned short nChannels;
unsigned short ch2ns;
void Initialization();
uint64_t realTime[MaxNumberOfChannel];
uint64_t deadTime[MaxNumberOfChannel];
uint64_t liveTime[MaxNumberOfChannel];
uint32_t triggerCount[MaxNumberOfChannel];
uint32_t savedEventCount[MaxNumberOfChannel];
unsigned short outFileIndex;
unsigned short dataStartIndetifier;
std::string outFileNameBase;
char outFileName[100];
FILE * outFile;
unsigned int outFileSize;
uint64_t FinishedOutFilesSize;
2023-01-25 14:59:48 -05:00
bool acqON;
2023-02-23 12:24:39 -05:00
//all read and read/write settings
2023-02-23 16:08:47 -05:00
std::string settingFileName;
2023-02-23 12:24:39 -05:00
std::vector<Reg> boardSettings;
std::vector<Reg> chSettings[MaxNumberOfChannel];
Reg VGASetting[4];
std::map<std::string, int> boardMap;
std::map<std::string, int> chMap;
2023-01-25 14:59:48 -05:00
public:
Digitizer2Gen();
~Digitizer2Gen();
2023-01-25 17:16:14 -05:00
2023-02-13 17:07:26 -05:00
unsigned short GetSerialNumber() const{return serialNumber;}
std::string GetFPGATyep() const {return FPGAType;}
2023-02-13 15:22:24 -05:00
void SetDummy(unsigned short sn);
2023-02-13 17:07:26 -05:00
bool IsDummy() const {return isDummy;}
2023-01-25 14:59:48 -05:00
int OpenDigitizer(const char * url);
bool IsConnected() const {return isConnected;}
int CloseDigitizer();
2023-02-07 18:58:00 -05:00
int GetRet() const {return ret;};
int FindIndex(const Reg para); // get index from DIGIPARA
2023-01-25 14:59:48 -05:00
std::string ReadValue(const char * parameter, bool verbose = false);
std::string ReadValue(const Reg para, int ch_index = -1, bool verbose = false); // read digitizer and save to memory
2023-02-23 12:24:39 -05:00
bool WriteValue(const char * parameter, std::string value);
bool WriteValue(const Reg para, std::string value, int ch_index = -1); // write digituzer and save to memory
2023-01-25 14:59:48 -05:00
void SendCommand(const char * parameter);
2023-02-08 17:35:04 -05:00
void SendCommand(std::string shortPara);
2023-01-25 14:59:48 -05:00
uint64_t GetHandle(const char * parameter);
uint64_t GetParentHandle(uint64_t handle);
std::string GetPath(uint64_t handle);
std::string ErrorMsg(const char * funcName);
void StartACQ();
void StopACQ();
bool IsAcqOn() const {return acqON;}
void SetPHADataFormat(unsigned short dataFormat); // 0 = all data,
// 1 = analog trace-0 only + flags
// 2 = no trace, only ch, energy, timestamp, fine_timestamp + flags
// 3 = only ch, energy, timestamp, minimum
// 15 = raw data
2023-01-25 14:59:48 -05:00
int ReadData();
2023-02-13 17:07:26 -05:00
int ReadStat(); // digitizer update it every 500 msec
2023-01-25 14:59:48 -05:00
void PrintStat();
2023-02-13 17:07:26 -05:00
uint32_t GetTriggerCount(int ch) const {return triggerCount[ch];}
uint64_t GetRealTime(int ch) const {return realTime[ch];}
2023-01-25 14:59:48 -05:00
void Reset();
void ProgramPHA(bool testPulse = false);
unsigned short GetNChannels() const {return nChannels;}
unsigned short GetCh2ns() const {return ch2ns;}
uint64_t GetHandle() const {return handle;}
Event *evt; // should be evt[MaxNumber], when full or stopACQ, save into file
2023-02-14 17:39:49 -05:00
void OpenOutFile(std::string fileName, const char * mode = "w");
2023-01-25 14:59:48 -05:00
void CloseOutFile();
void SaveDataToFile();
unsigned int GetFileSize() const {return outFileSize;}
uint64_t GetTotalFilesSize() const {return FinishedOutFilesSize + outFileSize;}
2023-01-25 14:59:48 -05:00
2023-02-23 16:08:47 -05:00
std::string GetSettingFileName() const {return settingFileName;}
void SetSettingFileName(std::string fileName) {settingFileName = fileName;}
2023-02-23 12:24:39 -05:00
void ReadAllSettings(); // read settings from digitier and save to memory
2023-03-02 15:00:59 -05:00
int SaveSettingsToFile(const char * saveFileName = NULL); //Save settings from memory to text file
int ReadAndSaveSettingsToFile(const char * saveFileName = NULL); // ReadAllSettings + text file
2023-02-23 16:08:47 -05:00
bool LoadSettingsFromFile(const char * loadFileName = NULL); // Load settings, write to digitizer and save to memory
std::string GetSettingValue(const Reg para, unsigned int ch_index = 0); // read from memory
2023-01-25 14:59:48 -05:00
};
#endif