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

wip

Browse Source
This commit is contained in:
maliakal_d 2021-07-01 14:23:33 +02:00
parent 0e7c643cf9
commit 9d8c68b1d0
15 changed files with 370 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
slsReceiverSoftware/src/BinaryDataFile.cpp
View File

@ -1,7 +1,6 @@
#include "BinaryDataFile.h"
#include "sls/logger.h"
BinaryDataFile::BinaryDataFile(int index) : File(BINARY), index_(index) {}
BinaryDataFile::BinaryDataFile(const int index) : File(BINARY), index_(index) {}
BinaryDataFile::~BinaryDataFile() { CloseFile(); }
@ -13,10 +12,10 @@ void BinaryDataFile::CloseFile() {
}
void BinaryDataFile::CreateFirstBinaryDataFile(
std::string filePath, std::string fileNamePrefix, uint64_t fileIndex,
bool overWriteEnable, bool silentMode, int detIndex,
int numUnitsPerDetector, uint32_t udpPortNumber,
uint32_t maxFramesPerFile) {
const std::string filePath, const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
const int modulePos, const int numUnitsPerReadout,
const uint32_t udpPortNumber, const uint32_t maxFramesPerFile) {
subFileIndex_ = 0;
numFramesInFile_ = 0;
@ -26,8 +25,8 @@ void BinaryDataFile::CreateFirstBinaryDataFile(
fileIndex_ = fileIndex;
overWriteEnable_ = overWriteEnable;
silentMode_ = silentMode;
detIndex_ = detIndex;
numUnitsPerDetector_ = numUnitsPerDetector;
detIndex_ = modulePos;
numUnitsPerReadout_ = numUnitsPerReadout;
udpPortNumber_ = udpPortNumber;
maxFramesPerFile_ = maxFramesPerFile;
@ -39,7 +38,7 @@ void BinaryDataFile::CreateFile() {
std::ostringstream os;
os << filePath_ << "/" << fileNamePrefix_ << "_d"
<< (detIndex_ * numUnitsPerDetector_ + index_) << "_f" << subFileIndex_
<< (detIndex_ * numUnitsPerReadout_ + index_) << "_f" << subFileIndex_
<< '_' << fileIndex_ << ".raw";
fileName_ = os.str();
@ -62,9 +61,9 @@ void BinaryDataFile::CreateFile() {
}
}
void BinaryDataFile::WriteToFile(char *buffer, int buffersize,
uint64_t currentFrameNumber,
uint32_t numPacketsCaught) {
void BinaryDataFile::WriteToFile(char *buffer, const int buffersize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) {
// check if maxframesperfile = 0 for infinite
if (maxFramesPerFile_ && (numFramesInFile_ >= maxFramesPerFile_)) {
CloseFile();

24
slsReceiverSoftware/src/BinaryDataFile.h
View File

@ -5,20 +5,22 @@
class BinaryDataFile : private virtual slsDetectorDefs, public File {
public:
BinaryDataFile(int index);
BinaryDataFile(const int index);
~BinaryDataFile();
void CloseFile() override;
void CreateFirstBinaryDataFile(std::string filePath,
std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, int detIndex,
int numUnitsPerDetector,
uint32_t udpPortNumber,
uint32_t maxFramesPerFile) override;
void CreateFirstBinaryDataFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode, const int modulePos,
const int numUnitsPerReadout,
const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile) override;
void WriteToFile(char *buffer, int buffersize, uint64_t currentFrameNumber,
uint32_t numPacketsCaught) override;
void WriteToFile(char *buffer, const int buffersize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) override;
private:
void CreateFile();
@ -35,7 +37,7 @@ class BinaryDataFile : private virtual slsDetectorDefs, public File {
bool overWriteEnable_{false};
bool silentMode_{false};
int detIndex_{0};
int numUnitsPerDetector_{0};
int numUnitsPerReadout_{0};
uint32_t udpPortNumber_{0};
uint32_t maxFramesPerFile_{0};
};

10
slsReceiverSoftware/src/BinaryMasterFile.cpp
View File

@ -1,6 +1,5 @@
#include "BinaryMasterFile.h"
#include "MasterAttributes.h"
#include "sls/logger.h"
BinaryMasterFile::BinaryMasterFile() : File(BINARY) {}
@ -13,10 +12,11 @@ void BinaryMasterFile::CloseFile() {
fd_ = nullptr;
}
void BinaryMasterFile::CreateMasterFile(std::string filePath,
std::string fileNamePrefix,
uint64_t fileIndex,
bool overWriteEnable, bool silentMode,
void BinaryMasterFile::CreateMasterFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode,
MasterAttributes *attr) {
// create file name
std::ostringstream os;

8
slsReceiverSoftware/src/BinaryMasterFile.h
View File

@ -10,9 +10,11 @@ class BinaryMasterFile : private virtual slsDetectorDefs, public File {
~BinaryMasterFile();
void CloseFile() override;
void CreateMasterFile(std::string filePath, std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, MasterAttributes *attr) override;
void CreateMasterFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode,
MasterAttributes *attr) override;
private:
FILE *fd_{nullptr};

249
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -23,63 +23,162 @@
#include <cstring>
#include <iostream>
const std::string DataProcessor::TypeName = "DataProcessor";
const std::string DataProcessor::typeName_ = "DataProcessor";
DataProcessor::DataProcessor(int ind, detectorType dtype, Fifo *f, bool act,
bool depaden, bool *dsEnable, uint32_t *freq,
uint32_t *timer, uint32_t *sfnum, bool *fp,
bool *sm, std::vector<int> *cdl, int *cdo,
int *cad)
: ThreadObject(ind, TypeName), fifo(f), myDetectorType(dtype),
dataStreamEnable(dsEnable), activated(act),
deactivatedPaddingEnable(depaden), streamingFrequency(freq),
streamingTimerInMs(timer), streamingStartFnum(sfnum), silentMode(sm),
framePadding(fp), ctbDbitList(cdl), ctbDbitOffset(cdo),
ctbAnalogDataBytes(cad), firstStreamerFrame(false) {
LOG(logDEBUG) << "DataProcessor " << ind << " created";
memset((void *)&timerBegin, 0, sizeof(timespec));
DataProcessor::DataProcessor(int index, detectorType detectorType, Fifo *fifo,
bool *activated, bool *deactivatedPaddingEnable,
bool *dataStreamEnable,
uint32_t *streamingFrequency,
uint32_t *streamingTimerInMs,
uint32_t *streamingStartFnum, bool *framePadding,
std::vector<int> *ctbDbitList, int *ctbDbitOffset,
int *ctbAnalogDataBytes, std::mutex *hdf5Lib)
: ThreadObject(index, typeName_), fifo_(fifo), detectorType_(detectorType),
dataStreamEnable_(dataStreamEnable), activated_(activated),
deactivatedPaddingEnable_(deactivatedPaddingEnable),
streamingFrequency_(streamingFrequency),
streamingTimerInMs_(streamingTimerInMs),
streamingStartFnum_(streamingStartFnum), framePadding_(framePadding),
ctbDbitList_(ctbDbitList), ctbDbitOffset_(ctbDbitOffset),
ctbAnalogDataBytes_(ctbAnalogDataBytes), firstStreamerFrame_(false),
hdf5Lib_(hdf5Lib) {
LOG(logDEBUG) << "DataProcessor " << index << " created";
memset((void *)&timerbegin_, 0, sizeof(timespec));
}
DataProcessor::~DataProcessor() {}
DataProcessor::~DataProcessor() { DeleteFiles(); }
/** getters */
bool DataProcessor::GetStartedFlag() { return startedFlag; }
bool DataProcessor::GetStartedFlag() { return startedFlag_; }
uint64_t DataProcessor::GetNumFramesCaught() { return numFramesCaught; }
uint64_t DataProcessor::GetNumFramesCaught() { return numFramesCaught_; }
uint64_t DataProcessor::GetCurrentFrameIndex() { return currentFrameIndex; }
uint64_t DataProcessor::GetCurrentFrameIndex() { return currentFrameIndex_; }
uint64_t DataProcessor::GetProcessedIndex() {
return currentFrameIndex - firstIndex;
return currentFrameIndex_ - firstIndex_;
}
void DataProcessor::SetFifo(Fifo *f) { fifo = f; }
void DataProcessor::SetFifo(Fifo *fifo) { fifo_ = fifo; }
void DataProcessor::ResetParametersforNewAcquisition() {
StopRunning();
startedFlag = false;
numFramesCaught = 0;
firstIndex = 0;
currentFrameIndex = 0;
firstStreamerFrame = true;
startedFlag_ = false;
numFramesCaught_ = 0;
firstIndex_ = 0;
currentFrameIndex_ = 0;
firstStreamerFrame_ = true;
}
void DataProcessor::RecordFirstIndex(uint64_t fnum) {
// listen to this fnum, later +1
currentFrameIndex = fnum;
currentFrameIndex_ = fnum;
startedFlag = true;
firstIndex = fnum;
startedFlag_ = true;
firstIndex_ = fnum;
LOG(logDEBUG1) << index << " First Index:" << firstIndex;
LOG(logDEBUG1) << index << " First Index:" << firstIndex_;
}
void DataProcessor::SetGeneralData(GeneralData *g) { generalData = g; }
void DataProcessor::SetGeneralData(GeneralData *generalData) {
generalData_ = generalData;
}
void DataProcessor::DeleteFiles() {
if (dataFile_ != nullptr) {
delete dataFile_;
dataFile_ = nullptr;
}
if (masterFile_ != nullptr) {
delete masterFile_;
masterFile_ = nullptr;
}
}
void DataProcessor::SetupFileWriter(const bool filewriteEnable,
const bool masterFilewriteEnable,
const fileFormat fileFormatType,
const int modulePos) {
DeleteFiles();
if (filewriteEnable) {
switch (fileFormatType) {
#ifdef HDF5C
case HDF5:
dataFile_ = new HDF5DataFile(index, hdf5Lib_);
if (modulePos == 0 && index == 0) {
if (masterFilewriteEnable) {
masterFile_ = new HDF5MasterFile(hdf5Lib_);
}
// virtual file
}
break;
#endif
case BINARY:
dataFile_ = new BinaryDataFile(index);
if (modulePos == 0 && index == 0 && masterFilewriteEnable) {
masterFile_ = new BinaryMasterFile();
}
break;
default:
throw sls::RuntimeError(
"Unknown file format (compile with hdf5 flags");
}
}
}
void DataProcessor::CreateFirstFiles(
MasterAttributes *attr, const std::string filePath,
const std::string fileNamePrefix, const uint64_t fileIndex,
const bool overWriteEnable, const bool silentMode, const int modulePos,
const int numUnitsPerReadout, const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile, const uint64_t numImages,
const uint32_t nPIxelsX, const uint32_t nPIxelsY,
const uint32_t dynamicRange) {
if (dataFile_ == nullptr) {
throw sls::RuntimeError("file object not contstructed");
}
dataFile_->CloseFile();
/*
#ifdef HDF5C
if (virtualFile_) {
virtualFile_->CloseFile();
}
#endif
*/
// master file write enabled
if (masterFile_) {
masterFile_->CloseFile();
masterFile_->CreateMasterFile(filePath, fileNamePrefix, fileIndex,
overWriteEnable, silentMode, attr);
}
switch (dataFile_->GetFileFormat()) {
#ifdef HDF5C
case HDF5:
dataFile_->CreateFirstHDF5DataFile(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, numUnitsPerReadout, udpPortNumber, maxFramesPerFile,
numImages, nPIxelsX, nPIxelsY, dynamicRange);
/*if (virtualFile_) {
virtualFile_->CreateFile();
}*/
break;
#endif
case BINARY:
dataFile_->CreateFirstBinaryDataFile(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, numUnitsPerReadout, udpPortNumber, maxFramesPerFile);
break;
default:
throw sls::RuntimeError("Unknown file format (compile with hdf5 flags");
}
}
void DataProcessor::ThreadExecution() {
char *buffer = nullptr;
fifo->PopAddress(buffer);
fifo_->PopAddress(buffer);
LOG(logDEBUG5) << "DataProcessor " << index
<< ", "
"pop 0x"
@ -97,21 +196,21 @@ void DataProcessor::ThreadExecution() {
try {
fnum = ProcessAnImage(buffer);
} catch (const std::exception &e) {
fifo->FreeAddress(buffer);
fifo_->FreeAddress(buffer);
return;
}
// stream (if time/freq to stream) or free
if (*dataStreamEnable && SendToStreamer()) {
if (*dataStreamEnable_ && SendToStreamer()) {
// if first frame to stream, add frame index to fifo header (might
// not be the first)
if (firstStreamerFrame) {
firstStreamerFrame = false;
if (firstStreamerFrame_) {
firstStreamerFrame_ = false;
(*((uint32_t *)(buffer + FIFO_DATASIZE_NUMBYTES))) =
(uint32_t)(fnum - firstIndex);
(uint32_t)(fnum - firstIndex_);
}
fifo->PushAddressToStream(buffer);
fifo_->PushAddressToStream(buffer);
} else {
fifo->FreeAddress(buffer);
fifo_->FreeAddress(buffer);
}
}
@ -119,10 +218,10 @@ void DataProcessor::StopProcessing(char *buf) {
LOG(logDEBUG1) << "DataProcessing " << index << ": Dummy";
// stream or free
if (*dataStreamEnable)
fifo->PushAddressToStream(buf);
if (*dataStreamEnable_)
fifo_->PushAddressToStream(buf);
else
fifo->FreeAddress(buf);
fifo_->FreeAddress(buf);
StopRunning();
LOG(logDEBUG1) << index << ": Processing Completed";
@ -133,37 +232,37 @@ uint64_t DataProcessor::ProcessAnImage(char *buf) {
auto *rheader = (sls_receiver_header *)(buf + FIFO_HEADER_NUMBYTES);
sls_detector_header header = rheader->detHeader;
uint64_t fnum = header.frameNumber;
currentFrameIndex = fnum;
currentFrameIndex_ = fnum;
uint32_t nump = header.packetNumber;
if (nump == generalData->packetsPerFrame) {
numFramesCaught++;
if (nump == generalData_->packetsPerFrame) {
numFramesCaught_++;
}
LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
if (!startedFlag) {
if (!startedFlag_) {
RecordFirstIndex(fnum);
if (*dataStreamEnable) {
if (*dataStreamEnable_) {
// restart timer
clock_gettime(CLOCK_REALTIME, &timerBegin);
timerBegin.tv_sec -= (*streamingTimerInMs) / 1000;
timerBegin.tv_nsec -= ((*streamingTimerInMs) % 1000) * 1000000;
clock_gettime(CLOCK_REALTIME, &timerbegin_);
timerbegin_.tv_sec -= (*streamingTimerInMs_) / 1000;
timerbegin_.tv_nsec -= ((*streamingTimerInMs_) % 1000) * 1000000;
// to send first image
currentFreqCount = *streamingFrequency - *streamingStartFnum;
currentFreqCount_ = *streamingFrequency_ - *streamingStartFnum_;
}
}
// frame padding
if (activated && *framePadding && nump < generalData->packetsPerFrame)
if (*activated_ && *framePadding_ && nump < generalData_->packetsPerFrame)
PadMissingPackets(buf);
// deactivated and padding enabled
else if (!activated && deactivatedPaddingEnable)
else if (!*activated_ && *deactivatedPaddingEnable_)
PadMissingPackets(buf);
// rearrange ctb digital bits (if ctbDbitlist is not empty)
if (!(*ctbDbitList).empty()) {
if (!(*ctbDbitList_).empty()) {
RearrangeDbitData(buf);
}
@ -195,7 +294,7 @@ uint64_t DataProcessor::ProcessAnImage(char *buf) {
bool DataProcessor::SendToStreamer() {
// skip
if ((*streamingFrequency) == 0u) {
if ((*streamingFrequency_) == 0u) {
if (!CheckTimer())
return false;
} else {
@ -210,26 +309,26 @@ bool DataProcessor::CheckTimer() {
clock_gettime(CLOCK_REALTIME, &end);
LOG(logDEBUG1) << index << " Timer elapsed time:"
<< ((end.tv_sec - timerBegin.tv_sec) +
(end.tv_nsec - timerBegin.tv_nsec) / 1000000000.0)
<< ((end.tv_sec - timerbegin_.tv_sec) +
(end.tv_nsec - timerbegin_.tv_nsec) / 1000000000.0)
<< " seconds";
// still less than streaming timer, keep waiting
if (((end.tv_sec - timerBegin.tv_sec) +
(end.tv_nsec - timerBegin.tv_nsec) / 1000000000.0) <
((double)*streamingTimerInMs / 1000.00))
if (((end.tv_sec - timerbegin_.tv_sec) +
(end.tv_nsec - timerbegin_.tv_nsec) / 1000000000.0) <
((double)*streamingTimerInMs_ / 1000.00))
return false;
// restart timer
clock_gettime(CLOCK_REALTIME, &timerBegin);
clock_gettime(CLOCK_REALTIME, &timerbegin_);
return true;
}
bool DataProcessor::CheckCount() {
if (currentFreqCount == *streamingFrequency) {
currentFreqCount = 1;
if (currentFreqCount_ == *streamingFrequency_) {
currentFreqCount_ = 1;
return true;
}
currentFreqCount++;
currentFreqCount_++;
return false;
}
@ -249,18 +348,18 @@ void DataProcessor::registerCallBackRawDataModifyReady(
void DataProcessor::PadMissingPackets(char *buf) {
LOG(logDEBUG) << index << ": Padding Missing Packets";
uint32_t pperFrame = generalData->packetsPerFrame;
uint32_t pperFrame = generalData_->packetsPerFrame;
auto *header = (sls_receiver_header *)(buf + FIFO_HEADER_NUMBYTES);
uint32_t nmissing = pperFrame - header->detHeader.packetNumber;
sls_bitset pmask = header->packetsMask;
uint32_t dsize = generalData->dataSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
dsize = generalData->vetoDataSize;
uint32_t dsize = generalData_->dataSize;
if (detectorType_ == GOTTHARD2 && index != 0) {
dsize = generalData_->vetoDataSize;
}
uint32_t fifohsize = generalData->fifoBufferHeaderSize;
uint32_t fifohsize = generalData_->fifoBufferHeaderSize;
uint32_t corrected_dsize =
dsize - ((pperFrame * dsize) - generalData->imageSize);
dsize - ((pperFrame * dsize) - generalData_->imageSize);
LOG(logDEBUG1) << "bitmask: " << pmask.to_string();
for (unsigned int pnum = 0; pnum < pperFrame; ++pnum) {
@ -277,7 +376,7 @@ void DataProcessor::PadMissingPackets(char *buf) {
<< std::endl;
// missing packet
switch (myDetectorType) {
switch (detectorType_) {
// for gotthard, 1st packet: 4 bytes fnum, CACA + CACA, 639*2 bytes
// data
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data +
@ -308,7 +407,7 @@ void DataProcessor::RearrangeDbitData(char *buf) {
// TODO! (Erik) Refactor and add tests
int totalSize = (int)(*((uint32_t *)buf));
int ctbDigitalDataBytes =
totalSize - (*ctbAnalogDataBytes) - (*ctbDbitOffset);
totalSize - (*ctbAnalogDataBytes_) - (*ctbDbitOffset_);
// no digital data
if (ctbDigitalDataBytes == 0) {
@ -319,19 +418,19 @@ void DataProcessor::RearrangeDbitData(char *buf) {
const int numSamples = (ctbDigitalDataBytes / sizeof(uint64_t));
const int digOffset = FIFO_HEADER_NUMBYTES + sizeof(sls_receiver_header) +
(*ctbAnalogDataBytes);
(*ctbAnalogDataBytes_);
// ceil as numResult8Bits could be decimal
const int numResult8Bits =
ceil((double)(numSamples * (*ctbDbitList).size()) / 8.00);
ceil((double)(numSamples * (*ctbDbitList_).size()) / 8.00);
std::vector<uint8_t> result(numResult8Bits);
uint8_t *dest = &result[0];
auto *source = (uint64_t *)(buf + digOffset + (*ctbDbitOffset));
auto *source = (uint64_t *)(buf + digOffset + (*ctbDbitOffset_));
// loop through digital bit enable vector
int bitoffset = 0;
for (auto bi : (*ctbDbitList)) {
for (auto bi : (*ctbDbitList_)) {
// where numbits * numsamples is not a multiple of 8
if (bitoffset != 0) {
bitoffset = 0;

186
slsReceiverSoftware/src/DataProcessor.h
View File

@ -19,86 +19,47 @@ class DataStreamer;
struct MasterAttributes;
#include <atomic>
#include <mutex>
#include <vector>
class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
public:
/**
* Constructor
* Calls Base Class CreateThread(), sets ErrorMask if error and increments
* NumberofDataProcessors
* @param ind self index
* @param dtype detector type
* @param f address of Fifo pointer
* @param act activated
* @param depaden deactivated padding enable
* @param dsEnable pointer to data stream enable
* @param dr pointer to dynamic range
* @param freq pointer to streaming frequency
* @param timer pointer to timer if streaming frequency is random
* @param sfnum pointer to streaming starting fnum
* @param fp pointer to frame padding enable
* @param sm pointer to silent mode
* @param qe pointer to quad Enable
* @param cdl pointer to vector or ctb digital bits enable
* @param cdo pointer to digital bits offset
* @param cad pointer to ctb analog databytes
*/
DataProcessor(int ind, detectorType dtype, Fifo *f, bool act, bool depaden,
bool *dsEnable, uint32_t *freq, uint32_t *timer,
uint32_t *sfnum, bool *fp, bool *sm, std::vector<int> *cdl,
int *cdo, int *cad);
DataProcessor(int index, detectorType detectorType, Fifo *fifo,
bool *activated, bool *deactivatedPaddingEnable,
bool *dataStreamEnable, uint32_t *streamingFrequency,
uint32_t *streamingTimerInMs, uint32_t *streamingStartFnum,
bool *framePadding, std::vector<int> *ctbDbitList,
int *ctbDbitOffset, int *ctbAnalogDataBytes,
std::mutex *hdf5Lib);
/**
* Destructor
* Calls Base Class DestroyThread() and decrements NumberofDataProcessors
*/
~DataProcessor() override;
//*** getters ***
/**
* Get acquisition started flag
* @return acquisition started flag
*/
bool GetStartedFlag();
/**
* Get Frames Complete Caught
* @return number of frames
*/
uint64_t GetNumFramesCaught();
/**
* Gets Actual Current Frame Index (that has not been subtracted from
* firstIndex) thats been processed
* @return -1 if no frames have been caught, else current frame index
*/
/** (-1 if no frames have been caught */
uint64_t GetCurrentFrameIndex();
/**
* Get Current Frame Index thats been processed
* @return -1 if no frames have been caught, else current frame index
*/
/** (-1 if no frames have been caught) */
uint64_t GetProcessedIndex();
/**
* Set Fifo pointer to the one given
* @param f address of Fifo pointer
*/
void SetFifo(Fifo *f);
/**
* Reset parameters for new acquisition
*/
void ResetParametersforNewAcquisition();
void SetGeneralData(GeneralData *generalData);
/**
* Set GeneralData pointer to the one given
* @param g address of GeneralData (Detector Data) pointer
*/
void SetGeneralData(GeneralData *g);
void DeleteFiles();
void SetupFileWriter(const bool filewriteEnable,
const bool masterFilewriteEnable,
const fileFormat fileFormatType, const int modulePos);
void CreateFirstFiles(MasterAttributes *attr, const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, const int modulePos,
const int numUnitsPerReadout,
const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile,
const uint64_t numImages, const uint32_t nPIxelsX,
const uint32_t nPIxelsY, const uint32_t dynamicRange);
/**
* Call back for raw data
@ -125,10 +86,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
void *arg);
private:
/**
* Record First Index
* @param fnum frame index to record
*/
void RecordFirstIndex(uint64_t fnum);
/**
@ -141,14 +98,12 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
/**
* Frees dummy buffer,
* reset running mask by calling StopRunning()
* @param buf address of pointer
*/
void StopProcessing(char *buf);
/**
* Process an image popped from fifo,
* write to file if fw enabled & update parameters
* @param buf address of pointer
* @returns frame number
*/
uint64_t ProcessAnImage(char *buf);
@ -174,10 +129,6 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
bool CheckCount();
/**
* Pad Missing Packets from the bit mask
* @param buf buffer
*/
void PadMissingPackets(char *buf);
/**
@ -186,75 +137,40 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
void RearrangeDbitData(char *buf);
/** type of thread */
static const std::string TypeName;
static const std::string typeName_;
/** GeneralData (Detector Data) object */
const GeneralData *generalData{nullptr};
/** Fifo structure */
Fifo *fifo;
// individual members
/** Detector Type */
detectorType myDetectorType;
/** Data Stream Enable */
bool *dataStreamEnable;
/** Activated/Deactivated */
bool activated;
/** Deactivated padding enable */
bool deactivatedPaddingEnable;
/** Pointer to Streaming frequency, if 0, sending random images with a timer
*/
uint32_t *streamingFrequency;
/** Pointer to the timer if Streaming frequency is random */
uint32_t *streamingTimerInMs;
/** Pointer to streaming starting fnum */
uint32_t *streamingStartFnum;
/** Current frequency count */
uint32_t currentFreqCount{0};
/** timer beginning stamp for random streaming */
struct timespec timerBegin;
/** Silent Mode */
bool *silentMode;
/** frame padding */
bool *framePadding;
/** ctb digital bits enable list */
std::vector<int> *ctbDbitList;
/** ctb digital bits offset */
int *ctbDbitOffset;
/** ctb analog databytes */
int *ctbAnalogDataBytes;
// acquisition start
/** Aquisition Started flag */
std::atomic<bool> startedFlag{false};
/** Frame Number of First Frame */
std::atomic<uint64_t> firstIndex{0};
const GeneralData *generalData_{nullptr};
Fifo *fifo_;
detectorType detectorType_;
bool *dataStreamEnable_;
bool *activated_;
bool *deactivatedPaddingEnable_;
/** if 0, sending random images with a timer */
uint32_t *streamingFrequency_;
uint32_t *streamingTimerInMs_;
uint32_t *streamingStartFnum_;
uint32_t currentFreqCount_{0};
struct timespec timerbegin_;
bool *framePadding_;
std::vector<int> *ctbDbitList_;
int *ctbDbitOffset_;
int *ctbAnalogDataBytes_;
std::atomic<bool> startedFlag_{false};
std::atomic<uint64_t> firstIndex_{0};
// for statistics
/** Number of complete frames caught */
uint64_t numFramesCaught{0};
uint64_t numFramesCaught_{0};
/** Frame Number of latest processed frame number */
std::atomic<uint64_t> currentFrameIndex{0};
std::atomic<uint64_t> currentFrameIndex_{0};
/** first streamer frame to add frame index in fifo header */
bool firstStreamerFrame{false};
bool firstStreamerFrame_{false};
File *dataFile_{nullptr};
File *masterFile_{nullptr};
std::mutex *hdf5Lib_;
// call back
/**

4
slsReceiverSoftware/src/File.cpp
View File

@ -2,8 +2,8 @@
#include <iostream>
File::File(slsDetectorDefs::fileFormat type) : type_(type) {}
File::File(const slsDetectorDefs::fileFormat format) : format_(format) {}
File::~File() {}
slsDetectorDefs::fileFormat File::GetFileType() { return type_; }
slsDetectorDefs::fileFormat File::GetFileFormat() const { return format_; }

69
slsReceiverSoftware/src/File.h
View File

@ -1,5 +1,6 @@
#pragma once
#include "sls/logger.h"
#include "sls/sls_detector_defs.h"
struct MasterAttributes;
@ -7,36 +8,60 @@ struct MasterAttributes;
class File : private virtual slsDetectorDefs {
public:
File(slsDetectorDefs::fileFormat type);
File(const slsDetectorDefs::fileFormat format);
virtual ~File();
fileFormat GetFileType();
virtual uint32_t GetFilesInAcquisition() = 0;
fileFormat GetFileFormat() const;
virtual void CloseFile() = 0;
virtual void CreateMasterFile(std::string filePath,
std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, MasterAttributes *attr) = 0;
virtual uint32_t GetFilesInAcquisition() const {
LOG(logERROR)
<< "This is a generic function GetFilesInAcquisition that "
"should be overloaded by a derived class";
return 0;
};
virtual void
CreateFirstBinaryDataFile(std::string filePath, std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, int detIndex,
int numUnitsPerDetector, uint32_t udpPortNumber,
uint32_t maxFramesPerFile) = 0;
virtual void CreateMasterFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode,
MasterAttributes *attr) {
LOG(logERROR) << "This is a generic function CreateMasterFile that "
"should be overloaded by a derived class";
};
virtual void CreateFirstBinaryDataFile(
const std::string filePath, const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, const int modulePos,
const int numUnitsPerReadout, const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile) {
LOG(logERROR)
<< "This is a generic function CreateFirstBinaryDataFile that "
"should be overloaded by a derived class";
};
virtual void CreateFirstHDF5DataFile(
std::string filePath, std::string fileNamePrefix, uint64_t fileIndex,
bool overWriteEnable, bool silentMode, int detIndex,
int numUnitsPerDetector, uint32_t udpPortNumber,
uint32_t maxFramesPerFile, uint64_t numImages, uint32_t nPIxelsX,
uint32_t nPIxelsY, uint32_t dynamicRange) = 0;
const std::string filePath, const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, const int modulePos,
const int numUnitsPerReadout, const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile, const uint64_t numImages,
const uint32_t nPIxelsX, const uint32_t nPIxelsY,
const uint32_t dynamicRange) {
LOG(logERROR)
<< "This is a generic function CreateFirstHDF5DataFile that "
"should be overloaded by a derived class";
};
virtual void WriteToFile(char *buffer, int buffersize,
uint64_t currentFrameNumber,
uint32_t numPacketsCaught) = 0;
virtual void WriteToFile(char *buffer, const int buffersize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) {
LOG(logERROR) << "This is a generic function WriteToFile that "
"should be overloaded by a derived class";
};
protected:
slsDetectorDefs::fileFormat type_;
slsDetectorDefs::fileFormat format_;
};

31
slsReceiverSoftware/src/HDF5DataFile.cpp
View File

@ -1,6 +1,5 @@
#include "HDF5DataFile.h"
#include "receiver_defs.h"
#include "sls/logger.h"
#include <iomanip>
@ -34,7 +33,7 @@ HDF5DataFile::HDF5DataFile(int index, std::mutex *hdf5Lib)
HDF5DataFile::~HDF5DataFile() { CloseFile(); }
uint32_t HDF5DataFile::GetFilesInAcquisition() {
uint32_t HDF5DataFile::GetFilesInAcquisition() const {
return numFilesInAcquisition_;
}
@ -70,11 +69,12 @@ void HDF5DataFile::CloseFile() {
}
void HDF5DataFile::CreateFirstHDF5DataFile(
std::string filePath, std::string fileNamePrefix, uint64_t fileIndex,
bool overWriteEnable, bool silentMode, int detIndex,
int numUnitsPerDetector, uint32_t udpPortNumber, uint32_t maxFramesPerFile,
uint64_t numImages, uint32_t nPIxelsX, uint32_t nPIxelsY,
uint32_t dynamicRange) {
const std::string filePath, const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
const int modulePos, const int numUnitsPerReadout,
const uint32_t udpPortNumber, const uint32_t maxFramesPerFile,
const uint64_t numImages, const uint32_t nPIxelsX, const uint32_t nPIxelsY,
const uint32_t dynamicRange) {
subFileIndex_ = 0;
numFramesInFile_ = 0;
@ -92,8 +92,8 @@ void HDF5DataFile::CreateFirstHDF5DataFile(
fileIndex_ = fileIndex;
overWriteEnable_ = overWriteEnable;
silentMode_ = silentMode;
detIndex_ = detIndex;
numUnitsPerDetector_ = numUnitsPerDetector;
detIndex_ = modulePos;
numUnitsPerReadout_ = numUnitsPerReadout;
udpPortNumber_ = udpPortNumber;
switch (dynamicRange_) {
@ -117,7 +117,7 @@ void HDF5DataFile::CreateFile() {
std::ostringstream os;
os << filePath_ << "/" << fileNamePrefix_ << "_d"
<< (detIndex_ * numUnitsPerDetector_ + index_) << "_f" << subFileIndex_
<< (detIndex_ * numUnitsPerReadout_ + index_) << "_f" << subFileIndex_
<< '_' << fileIndex_ << ".h5";
fileName_ = os.str();
@ -211,9 +211,9 @@ void HDF5DataFile::CreateFile() {
}
}
void HDF5DataFile::WriteToFile(char *buffer, int bufferSize,
uint64_t currentFrameNumber,
uint32_t numPacketsCaught) {
void HDF5DataFile::WriteToFile(char *buffer, const int buffersize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) {
// check if maxframesperfile = 0 for infinite
if (maxFramesPerFile_ && (numFramesInFile_ >= maxFramesPerFile_)) {
@ -233,7 +233,8 @@ void HDF5DataFile::WriteToFile(char *buffer, int bufferSize,
WriteParameterDatasets(currentFrameNumber, (sls_receiver_header *)(buffer));
}
void HDF5DataFile::WriteDataFile(uint64_t currentFrameNumber, char *buffer) {
void HDF5DataFile::WriteDataFile(const uint64_t currentFrameNumber,
char *buffer) {
std::lock_guard<std::mutex> lock(*hdf5Lib_);
uint64_t nDimx =
@ -260,7 +261,7 @@ void HDF5DataFile::WriteDataFile(uint64_t currentFrameNumber, char *buffer) {
}
}
void HDF5DataFile::WriteParameterDatasets(uint64_t currentFrameNumber,
void HDF5DataFile::WriteParameterDatasets(const uint64_t currentFrameNumber,
sls_receiver_header *rheader) {
std::lock_guard<std::mutex> lock(*hdf5Lib_);

31
slsReceiverSoftware/src/HDF5DataFile.h
View File

@ -12,29 +12,30 @@ using namespace H5;
class HDF5DataFile : private virtual slsDetectorDefs, public File {
public:
HDF5DataFile(int index, std::mutex *hdf5Lib);
HDF5DataFile(const int index, std::mutex *hdf5Lib);
~HDF5DataFile();
uint32_t GetFilesInAcquisition() override;
uint32_t GetFilesInAcquisition() const override;
void CloseFile() override;
void CreateFirstHDF5DataFile(std::string filePath,
std::string fileNamePrefix, uint64_t fileIndex,
bool overWriteEnable, bool silentMode,
int detIndex, int numUnitsPerDetector,
uint32_t udpPortNumber,
uint32_t maxFramesPerFile, uint64_t numImages,
uint32_t nPIxelsX, uint32_t nPIxelsY,
uint32_t dynamicRange) override;
void CreateFirstHDF5DataFile(
const std::string filePath, const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, const int modulePos,
const int numUnitsPerReadout, const uint32_t udpPortNumber,
const uint32_t maxFramesPerFile, const uint64_t numImages,
const uint32_t nPIxelsX, const uint32_t nPIxelsY,
const uint32_t dynamicRange) override;
void WriteToFile(char *buffer, int buffersize, uint64_t currentFrameNumber,
uint32_t numPacketsCaught) override;
void WriteToFile(char *buffer, const int buffersize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) override;
private:
void CreateFile();
void WriteDataFile(uint64_t currentFrameNumber, char *buffer);
void WriteParameterDatasets(uint64_t currentFrameNumber,
void WriteDataFile(const uint64_t currentFrameNumber, char *buffer);
void WriteParameterDatasets(const uint64_t currentFrameNumber,
sls_receiver_header *rheader);
void ExtendDataset();
@ -67,6 +68,6 @@ class HDF5DataFile : private virtual slsDetectorDefs, public File {
bool overWriteEnable_{false};
bool silentMode_{false};
int detIndex_{0};
int numUnitsPerDetector_{0};
int numUnitsPerReadout_{0};
uint32_t udpPortNumber_{0};
};

11
slsReceiverSoftware/src/HDF5MasterFile.cpp
View File

@ -1,6 +1,5 @@
#include "HDF5MasterFile.h"
#include "MasterAttributes.h"
#include "sls/logger.h"
HDF5MasterFile::HDF5MasterFile(std::mutex *hdf5Lib)
: File(HDF5), hdf5Lib_(hdf5Lib) {}
@ -22,10 +21,12 @@ void HDF5MasterFile::CloseFile() {
}
}
void HDF5MasterFile::CreateMasterFile(std::string filePath,
std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, MasterAttributes *attr) {
void HDF5MasterFile::CreateMasterFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode,
MasterAttributes *attr) {
std::ostringstream os;
os << filePath << "/" << fileNamePrefix << "_master"

8
slsReceiverSoftware/src/HDF5MasterFile.h
View File

@ -16,9 +16,11 @@ class HDF5MasterFile : private virtual slsDetectorDefs, public File {
~HDF5MasterFile();
void CloseFile() override;
void CreateMasterFile(std::string filePath, std::string fileNamePrefix,
uint64_t fileIndex, bool overWriteEnable,
bool silentMode, MasterAttributes *attr) override;
void CreateMasterFile(const std::string filePath,
const std::string fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode,
MasterAttributes *attr) override;
private:
std::mutex *hdf5Lib_;

1
slsReceiverSoftware/src/HDF5VirtualFile.cpp
View File

@ -1,5 +1,4 @@
#include "HDF5VirtualFile.h"
#include "sls/logger.h"
HDF5VirtualFile::HDF5VirtualFile(std::mutex *hdf5Lib)
: File(HDF5), hdf5Lib_(hdf5Lib) {}

30
slsReceiverSoftware/src/Implementation.cpp
View File

@ -169,11 +169,11 @@ void Implementation::setDetectorType(const detectorType d) {
&actualUDPSocketBufferSize, &framesPerFile, &frameDiscardMode,
&activated, &deactivatedPaddingEnable, &silentMode));
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, myDetectorType, fifo_ptr, activated,
deactivatedPaddingEnable, &dataStreamEnable,
i, myDetectorType, fifo_ptr, &activated,
&deactivatedPaddingEnable, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs, &streamingStartFnum,
&framePadding, &silentMode, &ctbDbitList, &ctbDbitOffset,
&ctbAnalogDataBytes));
&framePadding, &ctbDbitList, &ctbDbitOffset,
&ctbAnalogDataBytes, &hdf5Lib));
} catch (...) {
listener.clear();
dataProcessor.clear();
@ -236,8 +236,8 @@ void Implementation::setModulePositionId(const int id) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
/*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable, activated,
deactivatedPaddingEnable, (int *)numDet, &framesPerFile, &fileName,
fileFormatType, fileWriteEnable, masterFileWriteEnable, &activated,
&deactivatedPaddingEnable, (int *)numDet, &framesPerFile, &fileName,
&filePath, &fileIndex, &overwriteEnable, &modulePos, &numThreads,
&numberOfTotalFrames, &dynamicRange, &udpPortNum[i], generalData);*/
}
@ -348,7 +348,7 @@ void Implementation::setFileFormat(const fileFormat f) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
/*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable,
activated, deactivatedPaddingEnable, (int *)numDet,
&activated, &deactivatedPaddingEnable, (int *)numDet,
&framesPerFile, &fileName, &filePath, &fileIndex,
&overwriteEnable, &modulePos, &numThreads,
&numberOfTotalFrames, &dynamicRange, &udpPortNum[i],
@ -392,7 +392,7 @@ void Implementation::setFileWriteEnable(const bool b) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
/*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable,
activated, deactivatedPaddingEnable, (int *)numDet,
&activated, &deactivatedPaddingEnable, (int *)numDet,
&framesPerFile, &fileName, &filePath, &fileIndex,
&overwriteEnable, &modulePos, &numThreads, &numberOfTotalFrames,
&dynamicRange, &udpPortNum[i], generalData);*/
@ -412,7 +412,7 @@ void Implementation::setMasterFileWriteEnable(const bool b) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
/*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable,
activated, deactivatedPaddingEnable, (int *)numDet,
&activated, &deactivatedPaddingEnable, (int *)numDet,
&framesPerFile, &fileName, &filePath, &fileIndex,
&overwriteEnable, &modulePos, &numThreads, &numberOfTotalFrames,
&dynamicRange, &udpPortNum[i], generalData);*/
@ -908,11 +908,11 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
listener[i]->SetGeneralData(generalData);
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, myDetectorType, fifo_ptr, activated,
deactivatedPaddingEnable, &dataStreamEnable,
i, myDetectorType, fifo_ptr, &activated,
&deactivatedPaddingEnable, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs,
&streamingStartFnum, &framePadding, &silentMode,
&ctbDbitList, &ctbDbitOffset, &ctbAnalogDataBytes));
&streamingStartFnum, &framePadding, &ctbDbitList,
&ctbDbitOffset, &ctbAnalogDataBytes, &hdf5Lib));
dataProcessor[i]->SetGeneralData(generalData);
} catch (...) {
listener.clear();
@ -1553,7 +1553,7 @@ bool Implementation::setActivate(bool enable) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
/*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable,
activated, deactivatedPaddingEnable, (int *)numDet,
&activated, &deactivatedPaddingEnable, (int *)numDet,
&framesPerFile, &fileName, &filePath, &fileIndex,
&overwriteEnable, &modulePos, &numThreads, &numberOfTotalFrames,
&dynamicRange, &udpPortNum[i], generalData);*/
@ -1575,7 +1575,7 @@ void Implementation::setDeactivatedPadding(bool enable) {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
; /*dataProcessor[i]->SetupFileWriter(
fileFormatType, fileWriteEnable, masterFileWriteEnable,
activated, deactivatedPaddingEnable, (int *)numDet,
&activated, &deactivatedPaddingEnable, (int *)numDet,
&framesPerFile, &fileName, &filePath, &fileIndex,
&overwriteEnable, &modulePos, &numThreads,
&numberOfTotalFrames, &dynamicRange, &udpPortNum[i],

5
slsReceiverSoftware/src/Implementation.h
View File

@ -15,6 +15,7 @@ class slsDetectorDefs;
#include <exception>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
using ns = std::chrono::nanoseconds;
@ -349,7 +350,7 @@ class Implementation : private virtual slsDetectorDefs {
bool deactivatedPaddingEnable{true};
int numLinesReadout{MAX_EIGER_ROWS_PER_READOUT};
int thresholdEnergyeV{-1};
std::array<int, 3> thresholdAllEnergyeV={{-1, -1, -1}};
std::array<int, 3> thresholdAllEnergyeV = {{-1, -1, -1}};
std::vector<int64_t> rateCorrections;
readoutMode readoutType{ANALOG_ONLY};
uint32_t adcEnableMaskOneGiga{BIT32_MASK};
@ -375,4 +376,6 @@ class Implementation : private virtual slsDetectorDefs {
std::vector<std::unique_ptr<DataProcessor>> dataProcessor;
std::vector<std::unique_ptr<DataStreamer>> dataStreamer;
std::vector<std::unique_ptr<Fifo>> fifo;
std::mutex hdf5Lib;
};