detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-24 15:20:02 +02:00
Code Issues Actions Packages Releases Activity

rxr:removed delte and initialize memebers

Browse Source
This commit is contained in:
maliakal_d 2020-08-05 13:23:45 +02:00
parent 7b6f4d0b5b
commit 6c3f0d18ec
2 changed files with 71 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
slsReceiverSoftware/src/Implementation.cpp
View File

@ -23,13 +23,16 @@
/** cosntructor & destructor */ /** cosntructor & destructor */
Implementation::Implementation(const detectorType d) { Implementation::Implementation(const detectorType d) {
InitializeMembers();
// network configuration (UDP)
for (int i = 0; i < MAX_NUMBER_OF_LISTENING_THREADS; ++i) {
udpPortNum[i] = DEFAULT_UDP_PORTNO + i;
}
setDetectorType(d); setDetectorType(d);
} }
Implementation::~Implementation() { DeleteMembers(); } Implementation::~Implementation() {
void Implementation::DeleteMembers() {
delete generalData; delete generalData;
generalData = nullptr; generalData = nullptr;
additionalJsonHeader.clear(); additionalJsonHeader.clear();
@ -43,103 +46,6 @@ void Implementation::DeleteMembers() {
ctbDbitList.clear(); ctbDbitList.clear();
} }
void Implementation::InitializeMembers() {
// config parameters
numThreads = 1;
myDetectorType = GENERIC;
for (int i = 0; i < MAX_DIMENSIONS; ++i)
numDet[i] = 0;
modulePos = 0;
detHostname = "";
silentMode = false;
fifoDepth = 0;
frameDiscardMode = NO_DISCARD;
framePadding = true;
// file parameters
fileFormatType = BINARY;
filePath = "/";
fileName = "run";
fileIndex = 0;
fileWriteEnable = true;
masterFileWriteEnable = true;
overwriteEnable = true;
framesPerFile = 0;
// acquisition
status = IDLE;
stoppedFlag = false;
// network configuration (UDP)
numUDPInterfaces = 1;
eth.resize(MAX_NUMBER_OF_LISTENING_THREADS);
udpPortNum.resize(MAX_NUMBER_OF_LISTENING_THREADS);
for (int i = 0; i < MAX_NUMBER_OF_LISTENING_THREADS; ++i) {
eth[i] = "";
udpPortNum[i] = DEFAULT_UDP_PORTNO + i;
}
udpSocketBufferSize = 0;
actualUDPSocketBufferSize = 0;
// zmq parameters
dataStreamEnable = false;
streamingFrequency = 1;
streamingTimerInMs = DEFAULT_STREAMING_TIMER_IN_MS;
streamingStartFnum = 0;
streamingPort = 0;
streamingSrcIP = sls::IpAddr{};
// detector parameters
numberOfTotalFrames = 0;
numberOfFrames = 1;
numberOfTriggers = 1;
numberOfBursts = 1;
numberOfAdditionalStorageCells = 0;
numberOfGates = 0;
timingMode = AUTO_TIMING;
burstMode = BURST_INTERNAL;
acquisitionPeriod = std::chrono::nanoseconds(SAMPLE_TIME_IN_NS);
acquisitionTime = std::chrono::nanoseconds(0);
acquisitionTime1 = std::chrono::nanoseconds(0);
acquisitionTime2 = std::chrono::nanoseconds(0);
acquisitionTime3 = std::chrono::nanoseconds(0);
gateDelay1 = std::chrono::nanoseconds(0);
gateDelay2 = std::chrono::nanoseconds(0);
gateDelay3 = std::chrono::nanoseconds(0);
subExpTime = std::chrono::nanoseconds(0);
subPeriod = std::chrono::nanoseconds(0);
numberOfAnalogSamples = 0;
numberOfDigitalSamples = 0;
counterMask = 0;
dynamicRange = 16;
roi.xmin = -1;
roi.xmax = -1;
tengigaEnable = false;
flippedDataX = 0;
quadEnable = false;
activated = true;
deactivatedPaddingEnable = true;
numLinesReadout = MAX_EIGER_ROWS_PER_READOUT;
readoutType = ANALOG_ONLY;
adcEnableMaskOneGiga = BIT32_MASK;
adcEnableMaskTenGiga = BIT32_MASK;
ctbDbitOffset = 0;
ctbAnalogDataBytes = 0;
// callbacks
startAcquisitionCallBack = nullptr;
pStartAcquisition = nullptr;
acquisitionFinishedCallBack = nullptr;
pAcquisitionFinished = nullptr;
rawDataReadyCallBack = nullptr;
rawDataModifyReadyCallBack = nullptr;
pRawDataReady = nullptr;
// class objects
generalData = nullptr;
}
void Implementation::SetLocalNetworkParameters() { void Implementation::SetLocalNetworkParameters() {
// to increase Max length of input packet queue // to increase Max length of input packet queue
int max_back_log; int max_back_log;

130
slsReceiverSoftware/src/Implementation.h
View File

@ -251,8 +251,6 @@ class Implementation : private virtual slsDetectorDefs {
void *arg); void *arg);
private: private:
void DeleteMembers();
void InitializeMembers();
void SetLocalNetworkParameters(); void SetLocalNetworkParameters();
void SetThreadPriorities(); void SetThreadPriorities();
void SetupFifoStructure(); void SetupFifoStructure();
@ -269,89 +267,89 @@ class Implementation : private virtual slsDetectorDefs {
* ************************************************/ * ************************************************/
// config parameters // config parameters
int numThreads; int numThreads{1};
detectorType myDetectorType; detectorType myDetectorType{GENERIC};
int numDet[MAX_DIMENSIONS]; int numDet[MAX_DIMENSIONS] = {0, 0};
int modulePos; int modulePos{0};
std::string detHostname; std::string detHostname;
bool silentMode; bool silentMode{false};
uint32_t fifoDepth; uint32_t fifoDepth{0};
frameDiscardPolicy frameDiscardMode; frameDiscardPolicy frameDiscardMode{NO_DISCARD};
bool framePadding; bool framePadding{true};
pid_t parentThreadId; pid_t parentThreadId;
pid_t tcpThreadId; pid_t tcpThreadId;
// file parameters // file parameters
fileFormat fileFormatType; fileFormat fileFormatType{BINARY};
std::string filePath; std::string filePath{"/"};
std::string fileName; std::string fileName{"run"};
uint64_t fileIndex; uint64_t fileIndex{0};
bool fileWriteEnable; bool fileWriteEnable{true};
bool masterFileWriteEnable; bool masterFileWriteEnable{true};
bool overwriteEnable; bool overwriteEnable{true};
uint32_t framesPerFile; uint32_t framesPerFile{0};
// acquisition // acquisition
std::atomic<runStatus> status; std::atomic<runStatus> status{IDLE};
bool stoppedFlag; bool stoppedFlag{false};
// network configuration (UDP) // network configuration (UDP)
int numUDPInterfaces; int numUDPInterfaces{1};
std::vector<std::string> eth; std::vector<std::string> eth; //(MAX_NUMBER_OF_LISTENING_THREADS);
std::vector<uint32_t> udpPortNum; std::vector<uint32_t> udpPortNum; //(MAX_NUMBER_OF_LISTENING_THREADS);
int64_t udpSocketBufferSize; int64_t udpSocketBufferSize{0};
int64_t actualUDPSocketBufferSize; int64_t actualUDPSocketBufferSize{0};
// zmq parameters // zmq parameters
bool dataStreamEnable; bool dataStreamEnable{false};
uint32_t streamingFrequency; uint32_t streamingFrequency{1};
uint32_t streamingTimerInMs; uint32_t streamingTimerInMs{DEFAULT_STREAMING_TIMER_IN_MS};
uint32_t streamingStartFnum; uint32_t streamingStartFnum{0};
uint32_t streamingPort; uint32_t streamingPort{0};
sls::IpAddr streamingSrcIP; sls::IpAddr streamingSrcIP = sls::IpAddr{};
std::map<std::string, std::string> additionalJsonHeader; std::map<std::string, std::string> additionalJsonHeader;
// detector parameters // detector parameters
uint64_t numberOfTotalFrames; uint64_t numberOfTotalFrames{0};
uint64_t numberOfFrames; uint64_t numberOfFrames{1};
uint64_t numberOfTriggers; uint64_t numberOfTriggers{1};
uint64_t numberOfBursts; uint64_t numberOfBursts{1};
int numberOfAdditionalStorageCells; int numberOfAdditionalStorageCells{0};
int numberOfGates; int numberOfGates{0};
timingMode timingMode; timingMode timingMode{AUTO_TIMING};
burstMode burstMode; burstMode burstMode{BURST_INTERNAL};
ns acquisitionPeriod; ns acquisitionPeriod = std::chrono::nanoseconds(SAMPLE_TIME_IN_NS);
ns acquisitionTime; ns acquisitionTime = std::chrono::nanoseconds(0);
ns acquisitionTime1; ns acquisitionTime1 = std::chrono::nanoseconds(0);
ns acquisitionTime2; ns acquisitionTime2 = std::chrono::nanoseconds(0);
ns acquisitionTime3; ns acquisitionTime3 = std::chrono::nanoseconds(0);
ns gateDelay1; ns gateDelay1 = std::chrono::nanoseconds(0);
ns gateDelay2; ns gateDelay2 = std::chrono::nanoseconds(0);
ns gateDelay3; ns gateDelay3 = std::chrono::nanoseconds(0);
ns subExpTime; ns subExpTime = std::chrono::nanoseconds(0);
ns subPeriod; ns subPeriod = std::chrono::nanoseconds(0);
uint32_t numberOfAnalogSamples; uint32_t numberOfAnalogSamples{0};
uint32_t numberOfDigitalSamples; uint32_t numberOfDigitalSamples{0};
uint32_t counterMask; uint32_t counterMask{0};
uint32_t dynamicRange; uint32_t dynamicRange{16};
ROI roi; ROI roi{};
bool tengigaEnable; bool tengigaEnable{false};
int flippedDataX; int flippedDataX{0};
bool quadEnable; bool quadEnable{false};
bool activated; bool activated{true};
bool deactivatedPaddingEnable; bool deactivatedPaddingEnable{true};
int numLinesReadout; int numLinesReadout{MAX_EIGER_ROWS_PER_READOUT};
std::vector<int64_t> rateCorrections; std::vector<int64_t> rateCorrections;
readoutMode readoutType; readoutMode readoutType{ANALOG_ONLY};
uint32_t adcEnableMaskOneGiga; uint32_t adcEnableMaskOneGiga{BIT32_MASK};
uint32_t adcEnableMaskTenGiga; uint32_t adcEnableMaskTenGiga{BIT32_MASK};
std::vector<int> ctbDbitList; std::vector<int> ctbDbitList;
int ctbDbitOffset; int ctbDbitOffset{0};
int ctbAnalogDataBytes; int ctbAnalogDataBytes{0};
// callbacks // callbacks
int (*startAcquisitionCallBack)(std::string, std::string, uint64_t, int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,
uint32_t, void *); uint32_t, void *){nullptr};
void *pStartAcquisition; void *pStartAcquisition;
void (*acquisitionFinishedCallBack)(uint64_t, void *); void (*acquisitionFinishedCallBack)(uint64_t, void *);
void *pAcquisitionFinished; void *pAcquisitionFinished;