detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-13 05:17:13 +02:00
Code Issues Actions Packages Releases Activity

Format (#506)

Browse Source 
Formatted package
This commit is contained in:
Dhanya Thattil
2022-08-05 15:39:34 +02:00
committed by GitHub
parent 7173785b29
commit 6bf9dbf6d3
89 changed files with 1366 additions and 1210 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
slsReceiverSoftware/src/Arping.cpp
View File

@ -19,8 +19,8 @@ void Arping::SetInterfacesAndIps(const int index, const std::string &interface,
if (interface.empty() || ip.empty()) {
throw RuntimeError("Could not arping. Interface name and ip not "
"set up for interface " +
std::to_string(index));
"set up for interface " +
std::to_string(index));
}
// create commands to arping
std::ostringstream os;

1
slsReceiverSoftware/src/Arping.h
View File

@ -37,4 +37,3 @@ class Arping {
};
} // namespace sls

28
slsReceiverSoftware/src/BinaryDataFile.cpp
View File

@ -19,10 +19,12 @@ void BinaryDataFile::CloseFile() {
fd = nullptr;
}
void BinaryDataFile::CreateFirstBinaryDataFile(
const std::string& fNamePrefix,
const uint64_t fIndex, const bool ovEnable, const bool sMode,
const uint32_t uPortNumber, const uint32_t mFramesPerFile) {
void BinaryDataFile::CreateFirstBinaryDataFile(const std::string &fNamePrefix,
const uint64_t fIndex,
const bool ovEnable,
const bool sMode,
const uint32_t uPortNumber,
const uint32_t mFramesPerFile) {
subFileIndex = 0;
numFramesInFile = 0;
@ -41,15 +43,13 @@ void BinaryDataFile::CreateFile() {
numFramesInFile = 0;
std::ostringstream os;
os << fileNamePrefix << "_f" << subFileIndex
<< '_' << fileIndex << ".raw";
os << fileNamePrefix << "_f" << subFileIndex << '_' << fileIndex << ".raw";
fileName = os.str();
if (!overWriteEnable) {
if (nullptr == (fd = fopen(fileName.c_str(), "wx"))) {
fd = nullptr;
throw RuntimeError("Could not create/overwrite file " +
fileName);
throw RuntimeError("Could not create/overwrite file " + fileName);
}
} else if (nullptr == (fd = fopen(fileName.c_str(), "w"))) {
fd = nullptr;
@ -64,7 +64,10 @@ void BinaryDataFile::CreateFile() {
}
}
void BinaryDataFile::WriteToFile(char *imageData, sls_receiver_header& header, const int imageSize, const uint64_t currentFrameNumber, const uint32_t numPacketsCaught) {
void BinaryDataFile::WriteToFile(char *imageData, sls_receiver_header &header,
const int imageSize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) {
// check if maxframesperfile = 0 for infinite
if (maxFramesPerFile && (numFramesInFile >= maxFramesPerFile)) {
CloseFile();
@ -101,7 +104,12 @@ void BinaryDataFile::WriteToFile(char *imageData, sls_receiver_header& header, c
// if write error
if (ret != imageSize + sizeof(sls_receiver_header)) {
throw RuntimeError(std::to_string(index) + " : Write to file failed for image number " + std::to_string(currentFrameNumber) + ". Wrote " + std::to_string(ret) + " bytes instead of " + std::to_string(imageSize + sizeof(sls_receiver_header)));
throw RuntimeError(
std::to_string(index) +
" : Write to file failed for image number " +
std::to_string(currentFrameNumber) + ". Wrote " +
std::to_string(ret) + " bytes instead of " +
std::to_string(imageSize + sizeof(sls_receiver_header)));
}
}

12
slsReceiverSoftware/src/BinaryDataFile.h
View File

@ -14,14 +14,14 @@ class BinaryDataFile : private virtual slsDetectorDefs, public File {
fileFormat GetFileFormat() const override;
void CloseFile() override;
void CreateFirstBinaryDataFile(const std::string& fNamePrefix,
const uint64_t fIndex,
const bool ovEnable,
const bool sMode,
const uint32_t uPortNumber,
void CreateFirstBinaryDataFile(const std::string &fNamePrefix,
const uint64_t fIndex, const bool ovEnable,
const bool sMode, const uint32_t uPortNumber,
const uint32_t mFramesPerFile) override;
void WriteToFile(char *imageData, sls_receiver_header& header, const int imageSize, const uint64_t currentFrameNumber, const uint32_t numPacketsCaught) override;
void WriteToFile(char *imageData, sls_receiver_header &header,
const int imageSize, const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) override;
private:
void CreateFile();

9
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -22,7 +22,6 @@
#include <unistd.h>
#include <vector>
namespace sls {
using ns = std::chrono::nanoseconds;
@ -34,7 +33,6 @@ using Interface = ServerInterface;
#define gettid() syscall(SYS_gettid)
#endif
ClientInterface::~ClientInterface() {
killTcpThread = true;
LOG(logINFO) << "Shutting down TCP Socket on port " << portNumber;
@ -72,13 +70,13 @@ void ClientInterface::registerCallBackAcquisitionFinished(void (*func)(uint64_t,
}
void ClientInterface::registerCallBackRawDataReady(
void (*func)(sls_receiver_header&, char *, size_t, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t, void *), void *arg) {
rawDataReadyCallBack = func;
pRawDataReady = arg;
}
void ClientInterface::registerCallBackRawDataModifyReady(
void (*func)(sls_receiver_header&, char *, size_t &, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func;
pRawDataReady = arg;
}
@ -1176,7 +1174,8 @@ int ClientInterface::get_additional_json_header(Interface &socket) {
int ClientInterface::set_udp_socket_buffer_size(Interface &socket) {
auto size = socket.Receive<int>();
if (size == 0) {
throw RuntimeError("Receiver socket buffer size must be greater than 0.");
throw RuntimeError(
"Receiver socket buffer size must be greater than 0.");
}
if (size > 0) {
verifyIdle(socket);

18
slsReceiverSoftware/src/ClientInterface.h
View File

@ -34,7 +34,8 @@ class ClientInterface : private virtual slsDetectorDefs {
//***callback functions***
/** params: file path, file name, file index, image size */
void registerCallBackStartAcquisition(int (*func)(const std::string &, const std::string &,
void registerCallBackStartAcquisition(int (*func)(const std::string &,
const std::string &,
uint64_t, size_t, void *),
void *arg);
@ -43,12 +44,12 @@ class ClientInterface : private virtual slsDetectorDefs {
void *arg);
/** params: sls_receiver_header, pointer to data, image size */
void registerCallBackRawDataReady(void (*func)(sls_receiver_header&,
void registerCallBackRawDataReady(void (*func)(sls_receiver_header &,
char *, size_t, void *),
void *arg);
/** params: sls_receiver_header, pointer to data, reference to image size */
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header&,
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header &,
char *, size_t &,
void *),
void *arg);
@ -180,19 +181,18 @@ class ClientInterface : private virtual slsDetectorDefs {
}
}
int (ClientInterface::*flist[NUM_REC_FUNCTIONS])(
ServerInterface &socket);
int (ClientInterface::*flist[NUM_REC_FUNCTIONS])(ServerInterface &socket);
//***callback parameters***
int (*startAcquisitionCallBack)(const std::string &, const std::string &, uint64_t, size_t,
void *) = nullptr;
int (*startAcquisitionCallBack)(const std::string &, const std::string &,
uint64_t, size_t, void *) = nullptr;
void *pStartAcquisition{nullptr};
void (*acquisitionFinishedCallBack)(uint64_t, void *) = nullptr;
void *pAcquisitionFinished{nullptr};
void (*rawDataReadyCallBack)(sls_receiver_header&, char *, size_t,
void (*rawDataReadyCallBack)(sls_receiver_header &, char *, size_t,
void *) = nullptr;
void (*rawDataModifyReadyCallBack)(sls_receiver_header&, char *, size_t &,
void (*rawDataModifyReadyCallBack)(sls_receiver_header &, char *, size_t &,
void *) = nullptr;
void *pRawDataReady{nullptr};

118
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -28,8 +28,7 @@ namespace sls {
const std::string DataProcessor::typeName = "DataProcessor";
DataProcessor::DataProcessor(int index)
: ThreadObject(index, typeName) {
DataProcessor::DataProcessor(int index) : ThreadObject(index, typeName) {
LOG(logDEBUG) << "DataProcessor " << index << " created";
}
@ -40,41 +39,39 @@ bool DataProcessor::GetStartedFlag() const { return startedFlag; }
void DataProcessor::SetFifo(Fifo *f) { fifo = f; }
void DataProcessor::SetGeneralData(GeneralData *g) {
generalData = g;
}
void DataProcessor::SetGeneralData(GeneralData *g) { generalData = g; }
void DataProcessor::SetActivate(bool enable) { activated = enable; }
void DataProcessor::SetReceiverROI(ROI roi) {
receiverRoi = roi;
void DataProcessor::SetReceiverROI(ROI roi) {
receiverRoi = roi;
receiverRoiEnabled = receiverRoi.completeRoi() ? false : true;
receiverNoRoi = receiverRoi.noRoi();
}
void DataProcessor::SetDataStreamEnable(bool enable) { dataStreamEnable = enable; }
void DataProcessor::SetDataStreamEnable(bool enable) {
dataStreamEnable = enable;
}
void DataProcessor::SetStreamingFrequency(uint32_t value) {
void DataProcessor::SetStreamingFrequency(uint32_t value) {
streamingFrequency = value;
}
void DataProcessor::SetStreamingTimerInMs(uint32_t value) {
void DataProcessor::SetStreamingTimerInMs(uint32_t value) {
streamingTimerInMs = value;
}
void DataProcessor::SetStreamingStartFnum(uint32_t value) {
void DataProcessor::SetStreamingStartFnum(uint32_t value) {
streamingStartFnum = value;
}
void DataProcessor::SetFramePadding(bool enable) { framePadding = enable; }
void DataProcessor::SetCtbDbitList(std::vector<int> value) {
void DataProcessor::SetCtbDbitList(std::vector<int> value) {
ctbDbitList = value;
}
void DataProcessor::SetCtbDbitOffset(int value) {
ctbDbitOffset = value;
}
void DataProcessor::SetCtbDbitOffset(int value) { ctbDbitOffset = value; }
void DataProcessor::ResetParametersforNewAcquisition() {
StopRunning();
@ -84,7 +81,8 @@ void DataProcessor::ResetParametersforNewAcquisition() {
currentFrameIndex = 0;
firstStreamerFrame = true;
streamCurrentFrame = false;
completeImageToStreamBeforeCropping = make_unique<char[]>(generalData->imageSize);
completeImageToStreamBeforeCropping =
make_unique<char[]>(generalData->imageSize);
}
void DataProcessor::RecordFirstIndex(uint64_t fnum) {
@ -120,18 +118,18 @@ void DataProcessor::SetupFileWriter(const bool filewriteEnable,
dataFile = new BinaryDataFile(index);
break;
default:
throw RuntimeError(
"Unknown file format (compile with hdf5 flags");
throw RuntimeError("Unknown file format (compile with hdf5 flags");
}
}
}
void DataProcessor::CreateFirstFiles(
const std::string &fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
const uint32_t udpPortNumber,
const uint64_t numImages,
const bool detectorDataStream) {
void DataProcessor::CreateFirstFiles(const std::string &fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode,
const uint32_t udpPortNumber,
const uint64_t numImages,
const bool detectorDataStream) {
if (dataFile == nullptr) {
throw RuntimeError("file object not contstructed");
}
@ -158,8 +156,8 @@ void DataProcessor::CreateFirstFiles(
case HDF5:
dataFile->CreateFirstHDF5DataFile(
fileNamePrefix, fileIndex, overWriteEnable, silentMode,
udpPortNumber, generalData->framesPerFile,
numImages, nx, ny, generalData->dynamicRange);
udpPortNumber, generalData->framesPerFile, numImages, nx, ny,
generalData->dynamicRange);
break;
#endif
case BINARY:
@ -176,7 +174,7 @@ void DataProcessor::CreateFirstFiles(
uint32_t DataProcessor::GetFilesInAcquisition() const {
if (dataFile == nullptr) {
throw RuntimeError("No data file object created to get number of "
"files in acquiistion");
"files in acquiistion");
}
return dataFile->GetFilesInAcquisition();
}
@ -184,22 +182,22 @@ uint32_t DataProcessor::GetFilesInAcquisition() const {
std::string DataProcessor::CreateVirtualFile(
const std::string &filePath, const std::string &fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode,
const int modulePos,
const uint64_t numImages,
const int numModX, const int numModY,
std::mutex *hdf5LibMutex) {
const int modulePos, const uint64_t numImages, const int numModX,
const int numModY, std::mutex *hdf5LibMutex) {
if (receiverRoiEnabled) {
throw std::runtime_error("Skipping virtual hdf5 file since rx_roi is enabled.");
throw std::runtime_error(
"Skipping virtual hdf5 file since rx_roi is enabled.");
}
bool gotthard25um =
((generalData->detType == GOTTHARD || generalData->detType == GOTTHARD2) &&
(numModX * numModY) == 2);
bool gotthard25um = ((generalData->detType == GOTTHARD ||
generalData->detType == GOTTHARD2) &&
(numModX * numModY) == 2);
// 0 for infinite files
uint32_t framesPerFile =
((generalData->framesPerFile == 0) ? numFramesCaught : generalData->framesPerFile);
((generalData->framesPerFile == 0) ? numFramesCaught
: generalData->framesPerFile);
// TODO: assumption 1: create virtual file even if no data in other
// files (they exist anyway) assumption2: virtual file max frame index
@ -207,10 +205,10 @@ std::string DataProcessor::CreateVirtualFile(
// stop acquisition)
return masterFileUtility::CreateVirtualHDF5File(
filePath, fileNamePrefix, fileIndex, overWriteEnable, silentMode,
modulePos, generalData->numUDPInterfaces, framesPerFile,
generalData->nPixelsX, generalData->nPixelsY, generalData->dynamicRange,
numFramesCaught, numModX, numModY, dataFile->GetPDataType(),
dataFile->GetParameterNames(), dataFile->GetParameterDataTypes(),
modulePos, generalData->numUDPInterfaces, framesPerFile,
generalData->nPixelsX, generalData->nPixelsY, generalData->dynamicRange,
numFramesCaught, numModX, numModY, dataFile->GetPDataType(),
dataFile->GetParameterNames(), dataFile->GetParameterDataTypes(),
hdf5LibMutex, gotthard25um);
}
@ -220,7 +218,8 @@ void DataProcessor::LinkFileInMaster(const std::string &masterFileName,
std::mutex *hdf5LibMutex) {
if (receiverRoiEnabled) {
throw std::runtime_error("Should not be here, roi with hdf5 virtual should throw.");
throw std::runtime_error(
"Should not be here, roi with hdf5 virtual should throw.");
}
std::string fname{virtualFileName}, masterfname{masterFileName};
// if no virtual file, link data file
@ -266,14 +265,16 @@ void DataProcessor::ThreadExecution() {
auto *memImage = reinterpret_cast<image_structure *>(buffer);
// check dummy
LOG(logDEBUG1) << "DataProcessor " << index << ", Numbytes:" << memImage->size;
LOG(logDEBUG1) << "DataProcessor " << index
<< ", Numbytes:" << memImage->size;
if (memImage->size == DUMMY_PACKET_VALUE) {
StopProcessing(buffer);
return;
}
try {
ProcessAnImage(memImage->header, memImage->size, memImage->firstIndex, memImage->data);
ProcessAnImage(memImage->header, memImage->size, memImage->firstIndex,
memImage->data);
} catch (const std::exception &e) {
fifo->FreeAddress(buffer);
return;
@ -284,7 +285,8 @@ void DataProcessor::ThreadExecution() {
// copy the complete image back if roi enabled
if (receiverRoiEnabled) {
memImage->size = generalData->imageSize;
memcpy(memImage->data, &completeImageToStreamBeforeCropping[0], generalData->imageSize);
memcpy(memImage->data, &completeImageToStreamBeforeCropping[0],
generalData->imageSize);
}
fifo->PushAddressToStream(buffer);
} else {
@ -306,7 +308,8 @@ void DataProcessor::StopProcessing(char *buf) {
LOG(logDEBUG1) << index << ": Processing Completed";
}
void DataProcessor::ProcessAnImage(sls_receiver_header & header, size_t &size, size_t &firstImageIndex, char* data) {
void DataProcessor::ProcessAnImage(sls_receiver_header &header, size_t &size,
size_t &firstImageIndex, char *data) {
uint64_t fnum = header.detHeader.frameNumber;
LOG(logDEBUG1) << "DataProcessing " << index << ": fnum:" << fnum;
currentFrameIndex = fnum;
@ -335,7 +338,7 @@ void DataProcessor::ProcessAnImage(sls_receiver_header & header, size_t &size, s
RearrangeDbitData(size, data);
}
// 'stream Image' check has to be done here before crop image
// 'stream Image' check has to be done here before crop image
// stream (if time/freq to stream) or free
if (dataStreamEnable && SendToStreamer()) {
if (firstStreamerFrame) {
@ -348,11 +351,11 @@ void DataProcessor::ProcessAnImage(sls_receiver_header & header, size_t &size, s
streamCurrentFrame = false;
}
if (receiverRoiEnabled) {
// copy the complete image to stream before cropping
if (streamCurrentFrame) {
memcpy(&completeImageToStreamBeforeCropping[0], data, generalData->imageSize);
memcpy(&completeImageToStreamBeforeCropping[0], data,
generalData->imageSize);
}
CropImage(size, data);
}
@ -368,8 +371,7 @@ void DataProcessor::ProcessAnImage(sls_receiver_header & header, size_t &size, s
rawDataModifyReadyCallBack(header, data, size, pRawDataReady);
}
} catch (const std::exception &e) {
throw RuntimeError("Get Data Callback Error: " +
std::string(e.what()));
throw RuntimeError("Get Data Callback Error: " + std::string(e.what()));
}
// write to file
@ -425,18 +427,18 @@ bool DataProcessor::CheckCount() {
}
void DataProcessor::registerCallBackRawDataReady(
void (*func)(sls_receiver_header&, char *, size_t, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t, void *), void *arg) {
rawDataReadyCallBack = func;
pRawDataReady = arg;
}
void DataProcessor::registerCallBackRawDataModifyReady(
void (*func)(sls_receiver_header&, char *, size_t &, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func;
pRawDataReady = arg;
}
void DataProcessor::PadMissingPackets(sls_receiver_header header, char* data) {
void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
LOG(logDEBUG) << index << ": Padding Missing Packets";
uint32_t pperFrame = generalData->packetsPerFrame;
@ -493,7 +495,7 @@ void DataProcessor::PadMissingPackets(sls_receiver_header header, char* data) {
}
/** ctb specific */
void DataProcessor::RearrangeDbitData(size_t & size, char *data) {
void DataProcessor::RearrangeDbitData(size_t &size, char *data) {
int nAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
// TODO! (Erik) Refactor and add tests
int ctbDigitalDataBytes = size - nAnalogDataBytes - ctbDbitOffset;
@ -508,8 +510,7 @@ void DataProcessor::RearrangeDbitData(size_t & size, char *data) {
const int numSamples = (ctbDigitalDataBytes / sizeof(uint64_t));
// ceil as numResult8Bits could be decimal
const int numResult8Bits =
ceil((numSamples * ctbDbitList.size()) / 8.00);
const int numResult8Bits = ceil((numSamples * ctbDbitList.size()) / 8.00);
std::vector<uint8_t> result(numResult8Bits);
uint8_t *dest = &result[0];
@ -539,11 +540,12 @@ void DataProcessor::RearrangeDbitData(size_t & size, char *data) {
}
// copy back to memory and update size
memcpy(data + nAnalogDataBytes, result.data(), numResult8Bits * sizeof(uint8_t));
memcpy(data + nAnalogDataBytes, result.data(),
numResult8Bits * sizeof(uint8_t));
size = numResult8Bits * sizeof(uint8_t);
}
void DataProcessor::CropImage(size_t & size, char *data) {
void DataProcessor::CropImage(size_t &size, char *data) {
LOG(logDEBUG) << "Cropping Image to ROI " << ToString(receiverRoi);
int nPixelsX = generalData->nPixelsX;
int xmin = receiverRoi.xmin;

41
slsReceiverSoftware/src/DataProcessor.h
View File

@ -56,18 +56,18 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
void CreateFirstFiles(const std::string &fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode,
const uint32_t udpPortNumber,
const bool silentMode, const uint32_t udpPortNumber,
const uint64_t numImages,
const bool detectorDataStream);
#ifdef HDF5C
uint32_t GetFilesInAcquisition() const;
std::string CreateVirtualFile(
const std::string &filePath, const std::string &fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, const int modulePos,
const uint64_t numImages, const int numModX, const int numModY,
std::mutex *hdf5LibMutex);
std::string CreateVirtualFile(const std::string &filePath,
const std::string &fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode, const int modulePos,
const uint64_t numImages, const int numModX,
const int numModY, std::mutex *hdf5LibMutex);
void LinkFileInMaster(const std::string &masterFileName,
const std::string &virtualFileName,
const bool silentMode, std::mutex *hdf5LibMutex);
@ -82,10 +82,16 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
std::mutex *hdf5LibMutex);
/** params: sls_receiver_header, pointer to data, image size */
void registerCallBackRawDataReady(void (*func)(sls_receiver_header&, char *, size_t, void *), void *arg);
void registerCallBackRawDataReady(void (*func)(sls_receiver_header &,
char *, size_t, void *),
void *arg);
/** params: sls_receiver_header, pointer to data, reference to image size */
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header&, char *, size_t &, void *), void *arg);
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header &,
char *, size_t &,
void *),
void *arg);
private:
void RecordFirstIndex(uint64_t fnum);
@ -106,7 +112,8 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
* Process an image popped from fifo,
* write to file if fw enabled & update parameters
*/
void ProcessAnImage(sls_receiver_header & header, size_t &size, size_t &firstImageIndex, char* data);
void ProcessAnImage(sls_receiver_header &header, size_t &size,
size_t &firstImageIndex, char *data);
/**
* Calls CheckTimer and CheckCount for streaming frequency and timer
@ -129,15 +136,15 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
*/
bool CheckCount();
void PadMissingPackets(sls_receiver_header header, char* data);
void PadMissingPackets(sls_receiver_header header, char *data);
/**
* Align corresponding digital bits together (CTB only if ctbDbitlist is not
* empty)
*/
void RearrangeDbitData(size_t & size, char *data);
void RearrangeDbitData(size_t &size, char *data);
void CropImage(size_t & size, char *data);
void CropImage(size_t &size, char *data);
static const std::string typeName;
@ -182,7 +189,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
* dataPointer is the pointer to the data
* dataSize in bytes is the size of the data in bytes.
*/
void (*rawDataReadyCallBack)(sls_receiver_header&, char *, size_t,
void (*rawDataReadyCallBack)(sls_receiver_header &, char *, size_t,
void *) = nullptr;
/**
@ -193,7 +200,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject {
* revDatasize is the reference of data size in bytes. Can be modified to
* the new size to be written/streamed. (only smaller value).
*/
void (*rawDataModifyReadyCallBack)(sls_receiver_header&, char *, size_t &,
void (*rawDataModifyReadyCallBack)(sls_receiver_header &, char *, size_t &,
void *) = nullptr;
void *pRawDataReady{nullptr};

55
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -31,14 +31,12 @@ void DataStreamer::SetFifo(Fifo *f) { fifo = f; }
void DataStreamer::SetGeneralData(GeneralData *g) { generalData = g; }
void DataStreamer::SetFileIndex(uint64_t value) {
fileIndex = value;
}
void DataStreamer::SetFileIndex(uint64_t value) { fileIndex = value; }
void DataStreamer::SetNumberofPorts(xy np) { numPorts = np; }
void DataStreamer::SetFlipRows(bool fd) {
flipRows = fd;
void DataStreamer::SetFlipRows(bool fd) {
flipRows = fd;
// flip only right port of quad
if (quadEnable) {
flipRows = (index == 1 ? true : false);
@ -68,8 +66,10 @@ void DataStreamer::ResetParametersforNewAcquisition(const std::string &fname) {
delete[] completeBuffer;
completeBuffer = nullptr;
}
if (generalData->detType == GOTTHARD && generalData->detectorRoi.xmin != -1) {
adcConfigured = generalData->GetAdcConfigured(index, generalData->detectorRoi);
if (generalData->detType == GOTTHARD &&
generalData->detectorRoi.xmin != -1) {
adcConfigured =
generalData->GetAdcConfigured(index, generalData->detectorRoi);
completeBuffer = new char[generalData->imageSizeComplete];
memset(completeBuffer, 0, generalData->imageSizeComplete);
}
@ -82,8 +82,7 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, size_t firstImageIndex) {
<< ", First Streamer Index:" << fnum;
}
void DataStreamer::CreateZmqSockets(uint32_t port,
const IpAddr ip, int hwm) {
void DataStreamer::CreateZmqSockets(uint32_t port, const IpAddr ip, int hwm) {
uint32_t portnum = port + index;
std::string sip = ip.str();
try {
@ -117,12 +116,13 @@ void DataStreamer::CloseZmqSocket() {
void DataStreamer::ThreadExecution() {
char *buffer = nullptr;
fifo->PopAddressToStream(buffer);
LOG(logDEBUG5) << "DataStreamer " << index << ", pop 0x"
<< std::hex << (void *)(buffer) << std::dec << ":" << buffer;
LOG(logDEBUG5) << "DataStreamer " << index << ", pop 0x" << std::hex
<< (void *)(buffer) << std::dec << ":" << buffer;
auto *memImage = reinterpret_cast<image_structure *>(buffer);
// check dummy
LOG(logDEBUG1) << "DataStreamer " << index << ", Numbytes:" << memImage->size ;
LOG(logDEBUG1) << "DataStreamer " << index
<< ", Numbytes:" << memImage->size;
if (memImage->size == DUMMY_PACKET_VALUE) {
StopProcessing(buffer);
return;
@ -130,7 +130,8 @@ void DataStreamer::ThreadExecution() {
// streamer first index needn't be the very first index
if (!startedFlag) {
RecordFirstIndex(memImage->header.detHeader.frameNumber, memImage->firstIndex);
RecordFirstIndex(memImage->header.detHeader.frameNumber,
memImage->firstIndex);
}
ProcessAnImage(memImage->header.detHeader, memImage->size, memImage->data);
@ -142,8 +143,9 @@ void DataStreamer::ThreadExecution() {
void DataStreamer::StopProcessing(char *buf) {
LOG(logDEBUG1) << "DataStreamer " << index << ": Dummy";
if (!SendDummyHeader()) {
LOG(logERROR) << "Could not send zmq dummy header for streamer for port "
<< zmqSocket->GetPortNumber();
LOG(logERROR)
<< "Could not send zmq dummy header for streamer for port "
<< zmqSocket->GetPortNumber();
}
fifo->FreeAddress(buf);
@ -152,26 +154,29 @@ void DataStreamer::StopProcessing(char *buf) {
}
/** buf includes only the standard header */
void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size, char* data) {
void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size,
char *data) {
uint64_t fnum = header.frameNumber;
LOG(logDEBUG1) << "DataStreamer " << index << ": fnum:" << fnum;
// shortframe gotthard
if (completeBuffer) {
// disregarding the size modified from callback (always using
// imageSizeComplete instead of size because gui needs
// imageSizeComplete instead of size because gui needs
// imagesizecomplete and listener writes imagesize to size
if (!SendDataHeader(header, generalData->imageSizeComplete,
generalData->nPixelsXComplete, generalData->nPixelsYComplete)) {
generalData->nPixelsXComplete,
generalData->nPixelsYComplete)) {
LOG(logERROR) << "Could not send zmq header for fnum " << fnum
<< " and streamer " << index;
}
memcpy(completeBuffer + ((generalData->imageSize) * adcConfigured),
data, size);
if (!zmqSocket->SendData(completeBuffer, generalData->imageSizeComplete)) {
if (!zmqSocket->SendData(completeBuffer,
generalData->imageSizeComplete)) {
LOG(logERROR) << "Could not send zmq data for fnum " << fnum
<< " and streamer " << index;
}
@ -180,7 +185,8 @@ void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size, char*
// normal
else {
if (!SendDataHeader(header, size, generalData->nPixelsX, generalData->nPixelsY)) {
if (!SendDataHeader(header, size, generalData->nPixelsX,
generalData->nPixelsY)) {
LOG(logERROR) << "Could not send zmq header for fnum " << fnum
<< " and streamer " << index;
}
@ -199,7 +205,7 @@ int DataStreamer::SendDummyHeader() {
}
int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
uint32_t nx, uint32_t ny) {
uint32_t nx, uint32_t ny) {
zmqHeader zHeader;
zHeader.data = true;
zHeader.jsonversion = SLS_DETECTOR_JSON_HEADER_VERSION;
@ -250,9 +256,8 @@ int DataStreamer::SendDataHeader(sls_detector_header header, uint32_t size,
void DataStreamer::RestreamStop() {
if (!SendDummyHeader()) {
throw RuntimeError(
"Could not restream Dummy Header via ZMQ for port " +
std::to_string(zmqSocket->GetPortNumber()));
throw RuntimeError("Could not restream Dummy Header via ZMQ for port " +
std::to_string(zmqSocket->GetPortNumber()));
}
}

12
slsReceiverSoftware/src/DataStreamer.h
View File

@ -47,8 +47,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
* @param ip streaming source ip
* @param hwm streaming high water mark
*/
void CreateZmqSockets(uint32_t port, const IpAddr ip,
int hwm);
void CreateZmqSockets(uint32_t port, const IpAddr ip, int hwm);
void CloseZmqSocket();
void RestreamStop();
@ -57,7 +56,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
* Record First Index
*/
void RecordFirstIndex(uint64_t fnum, size_t firstImageIndex);
void ThreadExecution();
/**
@ -70,10 +69,10 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
* Process an image popped from fifo,
* write to file if fw enabled & update parameters
*/
void ProcessAnImage(sls_detector_header header, size_t size, char* data);
void ProcessAnImage(sls_detector_header header, size_t size, char *data);
int SendDummyHeader();
/**
* Create and send Json Header
* @param rheader header of image
@ -83,8 +82,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
* @returns 0 if error, else 1
*/
int SendDataHeader(sls_detector_header header, uint32_t size = 0,
uint32_t nx = 0, uint32_t ny = 0);
uint32_t nx = 0, uint32_t ny = 0);
static const std::string TypeName;
const GeneralData *generalData{nullptr};

5
slsReceiverSoftware/src/Fifo.h
View File

@ -23,7 +23,7 @@ class Fifo : private virtual slsDetectorDefs {
public:
Fifo(int index, size_t fifoItemSize, uint32_t fifoDepth);
~Fifo();
void FreeAddress(char *&address);
void GetNewAddress(char *&address);
@ -36,7 +36,7 @@ class Fifo : private virtual slsDetectorDefs {
int GetMaxLevelForFifoBound();
int GetMinLevelForFifoFree();
private:
/** also allocate memory & push addresses into free fifo */
void CreateFifos(size_t fifoItemSize);
@ -54,4 +54,3 @@ class Fifo : private virtual slsDetectorDefs {
};
} // namespace sls

47
slsReceiverSoftware/src/File.h
View File

@ -26,9 +26,8 @@ class File : private virtual slsDetectorDefs {
#ifdef HDF5C
virtual std::string GetFileName() const {
LOG(logERROR)
<< "This is a generic function GetFileName that "
"should be overloaded by a derived class";
LOG(logERROR) << "This is a generic function GetFileName that "
"should be overloaded by a derived class";
return std::string{};
}
@ -46,9 +45,8 @@ class File : private virtual slsDetectorDefs {
}
virtual std::vector<std::string> GetParameterNames() const {
LOG(logERROR)
<< "This is a generic function GetParameterNames that "
"should be overloaded by a derived class";
LOG(logERROR) << "This is a generic function GetParameterNames that "
"should be overloaded by a derived class";
return std::vector<std::string>{};
};
@ -60,26 +58,31 @@ class File : private virtual slsDetectorDefs {
};
virtual void CreateFirstHDF5DataFile(
const std::string& fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, 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";
const std::string &fileNamePrefix, const uint64_t fileIndex,
const bool overWriteEnable, const bool silentMode,
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";
};
#endif
virtual void CreateFirstBinaryDataFile(
const std::string& fileNamePrefix,
const uint64_t fileIndex, const bool overWriteEnable,
const bool silentMode, 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 CreateFirstBinaryDataFile(const std::string &fileNamePrefix,
const uint64_t fileIndex,
const bool overWriteEnable,
const bool silentMode,
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 WriteToFile(char *imageData, sls_receiver_header& header, const int imageSize, const uint64_t currentFrameNumber,const uint32_t numPacketsCaught) = 0;
virtual void WriteToFile(char *imageData, sls_receiver_header &header,
const int imageSize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) = 0;
};
} // namespace sls

2
slsReceiverSoftware/src/GeneralData.h
View File

@ -386,7 +386,7 @@ class Mythen3Data : public GeneralData {
int n = __builtin_popcount(mask);
if (n < 1 || n > 3) {
throw RuntimeError("Invalid number of counters " +
std::to_string(n) + ". Expected 1-3.");
std::to_string(n) + ". Expected 1-3.");
}
counterMask = mask;
ncounters = n;

97
slsReceiverSoftware/src/HDF5DataFile.cpp
View File

@ -28,18 +28,18 @@ HDF5DataFile::HDF5DataFile(int index, std::mutex *hdf5Lib)
};
H5::StrType strdatatype(H5::PredType::C_S1, sizeof(bitset_storage));
parameterDataTypes = std::vector<H5::DataType>{
H5::PredType::STD_U64LE, H5::PredType::STD_U32LE, H5::PredType::STD_U32LE,
H5::PredType::STD_U64LE, H5::PredType::STD_U64LE, H5::PredType::STD_U16LE,
H5::PredType::STD_U16LE, H5::PredType::STD_U16LE, H5::PredType::STD_U16LE,
H5::PredType::STD_U32LE, H5::PredType::STD_U16LE, H5::PredType::STD_U8LE,
H5::PredType::STD_U64LE, H5::PredType::STD_U32LE,
H5::PredType::STD_U32LE, H5::PredType::STD_U64LE,
H5::PredType::STD_U64LE, H5::PredType::STD_U16LE,
H5::PredType::STD_U16LE, H5::PredType::STD_U16LE,
H5::PredType::STD_U16LE, H5::PredType::STD_U32LE,
H5::PredType::STD_U16LE, H5::PredType::STD_U8LE,
H5::PredType::STD_U8LE, strdatatype};
}
HDF5DataFile::~HDF5DataFile() { CloseFile(); }
std::string HDF5DataFile::GetFileName() const {
return fileName;
}
std::string HDF5DataFile::GetFileName() const { return fileName; }
uint32_t HDF5DataFile::GetFilesInAcquisition() const {
return numFilesInAcquisition;
@ -54,9 +54,7 @@ std::vector<H5::DataType> HDF5DataFile::GetParameterDataTypes() const {
return parameterDataTypes;
}
slsDetectorDefs::fileFormat HDF5DataFile::GetFileFormat() const {
return HDF5;
}
slsDetectorDefs::fileFormat HDF5DataFile::GetFileFormat() const { return HDF5; }
void HDF5DataFile::CloseFile() {
std::lock_guard<std::mutex> lock(*hdf5Lib);
@ -68,8 +66,7 @@ void HDF5DataFile::CloseFile() {
fd = nullptr;
}
} catch (const H5::Exception &error) {
LOG(logERROR) << "Could not close data HDF5 handles of index "
<< index;
LOG(logERROR) << "Could not close data HDF5 handles of index " << index;
error.printErrorStack();
}
if (dataSpace) {
@ -90,9 +87,8 @@ void HDF5DataFile::CloseFile() {
}
void HDF5DataFile::CreateFirstHDF5DataFile(
const std::string& fNamePrefix,
const uint64_t fIndex, const bool owEnable, const bool sMode,
const uint32_t uPortNumber, const uint32_t mFramesPerFile,
const std::string &fNamePrefix, const uint64_t fIndex, const bool owEnable,
const bool sMode, const uint32_t uPortNumber, const uint32_t mFramesPerFile,
const uint64_t nImages, const uint32_t nX, const uint32_t nY,
const uint32_t dr) {
@ -134,8 +130,7 @@ void HDF5DataFile::CreateFile() {
numFilesInAcquisition++;
std::ostringstream os;
os << fileNamePrefix << "_f" << subFileIndex
<< '_' << fileIndex << ".h5";
os << fileNamePrefix << "_f" << subFileIndex << '_' << fileIndex << ".h5";
fileName = os.str();
std::lock_guard<std::mutex> lock(*hdf5Lib);
@ -160,10 +155,10 @@ void HDF5DataFile::CreateFile() {
fd = nullptr;
if (!overWriteEnable)
fd = new H5::H5File(fileName.c_str(), H5F_ACC_EXCL,
H5::FileCreatPropList::DEFAULT, fapl);
H5::FileCreatPropList::DEFAULT, fapl);
else
fd = new H5::H5File(fileName.c_str(), H5F_ACC_TRUNC,
H5::FileCreatPropList::DEFAULT, fapl);
H5::FileCreatPropList::DEFAULT, fapl);
// attributes - version
double dValue = HDF5_WRITER_VERSION;
@ -193,14 +188,14 @@ void HDF5DataFile::CreateFile() {
H5::DSetCreatPropList plistPara;
int fill_value = -1;
plist.setFillValue(dataType, &fill_value);
//plistPara.setFillValue(dataType, &fill_value);
// plistPara.setFillValue(dataType, &fill_value);
plist.setChunk(DATA_RANK, dimsChunk);
plistPara.setChunk(PARA_RANK, dimsChunkPara);
// dataset
dataSet = nullptr;
dataSet = new H5::DataSet(fd->createDataSet(
DATASET_NAME, dataType, *dataSpace, plist));
dataSet = new H5::DataSet(
fd->createDataSet(DATASET_NAME, dataType, *dataSpace, plist));
for (unsigned int i = 0; i < parameterNames.size(); ++i) {
H5::DataSet *ds = new H5::DataSet(fd->createDataSet(
parameterNames[i].c_str(), parameterDataTypes[i],
@ -210,8 +205,7 @@ void HDF5DataFile::CreateFile() {
} catch (const H5::Exception &error) {
error.printErrorStack();
CloseFile();
throw RuntimeError("Could not create HDF5 handles in object " +
index);
throw RuntimeError("Could not create HDF5 handles in object " + index);
}
if (!silentMode) {
LOG(logINFO) << "[" << udpPortNumber
@ -219,7 +213,10 @@ void HDF5DataFile::CreateFile() {
}
}
void HDF5DataFile::WriteToFile(char *imageData, sls_receiver_header& header, const int imageSize, const uint64_t currentFrameNumber, const uint32_t numPacketsCaught) {
void HDF5DataFile::WriteToFile(char *imageData, sls_receiver_header &header,
const int imageSize,
const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) {
// check if maxframesperfile = 0 for infinite
if (maxFramesPerFile && (numFramesInFile >= maxFramesPerFile)) {
@ -250,15 +247,15 @@ void HDF5DataFile::Convert12to16Bit(uint16_t *dst, uint8_t *src) {
}
void HDF5DataFile::WriteImageDatasets(const uint64_t currentFrameNumber,
char *buffer) {
char *buffer) {
// expand 12 bit to 16 bits
char *revBuffer = buffer;
if (dynamicRange == 12) {
revBuffer = (char *)malloc(EIGER_16_BIT_IMAGE_SIZE);
if (revBuffer == nullptr) {
throw RuntimeError("Could not allocate memory for 12 bit to "
"16 bit conversion in object " +
std::to_string(index));
"16 bit conversion in object " +
std::to_string(index));
}
Convert12to16Bit((uint16_t *)revBuffer, (uint8_t *)buffer);
}
@ -267,7 +264,7 @@ void HDF5DataFile::WriteImageDatasets(const uint64_t currentFrameNumber,
uint64_t nDimx =
((maxFramesPerFile == 0) ? currentFrameNumber
: currentFrameNumber % maxFramesPerFile);
: currentFrameNumber % maxFramesPerFile);
uint32_t nDimy = nPixelsY;
uint32_t nDimz = ((dynamicRange == 4) ? (nPixelsX / 2) : nPixelsX);
@ -291,7 +288,7 @@ void HDF5DataFile::WriteImageDatasets(const uint64_t currentFrameNumber,
LOG(logERROR) << "Could not write to file in object " << index;
error.printErrorStack();
throw RuntimeError("Could not write to file in object " +
std::to_string(index));
std::to_string(index));
}
}
@ -301,7 +298,7 @@ void HDF5DataFile::WriteParameterDatasets(const uint64_t currentFrameNumber,
uint64_t fnum =
((maxFramesPerFile == 0) ? currentFrameNumber
: currentFrameNumber % maxFramesPerFile);
: currentFrameNumber % maxFramesPerFile);
sls_detector_header header = rheader.detHeader;
hsize_t count[PARA_RANK] = {1};
@ -312,50 +309,50 @@ void HDF5DataFile::WriteParameterDatasets(const uint64_t currentFrameNumber,
dataSpacePara->selectHyperslab(H5S_SELECT_SET, count, start);
H5::DataSpace memspace(H5S_SCALAR);
dataSetPara[0]->write(&header.frameNumber, parameterDataTypes[0],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 1;
dataSetPara[1]->write(&header.expLength, parameterDataTypes[1],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 2;
dataSetPara[2]->write(&header.packetNumber, parameterDataTypes[2],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 3;
dataSetPara[3]->write(&header.bunchId, parameterDataTypes[3],
memspace, *dataSpacePara);
dataSetPara[3]->write(&header.bunchId, parameterDataTypes[3], memspace,
*dataSpacePara);
i = 4;
dataSetPara[4]->write(&header.timestamp, parameterDataTypes[4],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 5;
dataSetPara[5]->write(&header.modId, parameterDataTypes[5], memspace,
*dataSpacePara);
*dataSpacePara);
i = 6;
dataSetPara[6]->write(&header.row, parameterDataTypes[6], memspace,
*dataSpacePara);
*dataSpacePara);
i = 7;
dataSetPara[7]->write(&header.column, parameterDataTypes[7], memspace,
*dataSpacePara);
*dataSpacePara);
i = 8;
dataSetPara[8]->write(&header.reserved, parameterDataTypes[8],
memspace, *dataSpacePara);
dataSetPara[8]->write(&header.reserved, parameterDataTypes[8], memspace,
*dataSpacePara);
i = 9;
dataSetPara[9]->write(&header.debug, parameterDataTypes[9], memspace,
*dataSpacePara);
*dataSpacePara);
i = 10;
dataSetPara[10]->write(&header.roundRNumber, parameterDataTypes[10],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 11;
dataSetPara[11]->write(&header.detType, parameterDataTypes[11],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 12;
dataSetPara[12]->write(&header.version, parameterDataTypes[12],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
i = 13;
// contiguous bitset
if (sizeof(sls_bitset) == sizeof(bitset_storage)) {
dataSetPara[13]->write((char *)&(rheader.packetsMask),
parameterDataTypes[13], memspace,
*dataSpacePara);
parameterDataTypes[13], memspace,
*dataSpacePara);
}
// not contiguous bitset
@ -368,7 +365,7 @@ void HDF5DataFile::WriteParameterDatasets(const uint64_t currentFrameNumber,
storage[i >> 3] |= (bits[i] << (i & 7));
// write bitmask
dataSetPara[13]->write((char *)storage, parameterDataTypes[13],
memspace, *dataSpacePara);
memspace, *dataSpacePara);
}
i = 14;
} catch (const H5::Exception &error) {
@ -403,7 +400,7 @@ void HDF5DataFile::ExtendDataset() {
} catch (const H5::Exception &error) {
error.printErrorStack();
throw RuntimeError("Could not extend dataset in object " +
std::to_string(index));
std::to_string(index));
}
if (!silentMode) {
LOG(logINFO) << index << " Extending HDF5 dataset by " << extNumImages

17
slsReceiverSoftware/src/HDF5DataFile.h
View File

@ -23,15 +23,16 @@ class HDF5DataFile : private virtual slsDetectorDefs, public File {
void CloseFile() override;
void CreateFirstHDF5DataFile(
const std::string& fNamePrefix,
const uint64_t fIndex, const bool owEnable,
const bool sMode, const uint32_t uPortNumber,
const uint32_t mFramesPerFile, const uint64_t nImages,
const uint32_t nX, const uint32_t nY,
const uint32_t dr) override;
void CreateFirstHDF5DataFile(const std::string &fNamePrefix,
const uint64_t fIndex, const bool owEnable,
const bool sMode, const uint32_t uPortNumber,
const uint32_t mFramesPerFile,
const uint64_t nImages, const uint32_t nX,
const uint32_t nY, const uint32_t dr) override;
void WriteToFile(char *imageData, sls_receiver_header& header, const int imageSize, const uint64_t currentFrameNumber, const uint32_t numPacketsCaught) override;
void WriteToFile(char *imageData, sls_receiver_header &header,
const int imageSize, const uint64_t currentFrameNumber,
const uint32_t numPacketsCaught) override;
private:
void CreateFile();

198
slsReceiverSoftware/src/Implementation.cpp
View File

@ -76,13 +76,13 @@ void Implementation::SetupFifoStructure() {
// create fifo structure
try {
fifo.push_back(sls::make_unique<Fifo>(i, datasize, generalData->fifoDepth));
fifo.push_back(
sls::make_unique<Fifo>(i, datasize, generalData->fifoDepth));
} catch (...) {
fifo.clear();
generalData->fifoDepth = 0;
throw RuntimeError(
"Could not allocate memory for fifo structure " +
std::to_string(i) + ". FifoDepth is now 0.");
throw RuntimeError("Could not allocate memory for fifo structure " +
std::to_string(i) + ". FifoDepth is now 0.");
}
// set the listener & dataprocessor threads to point to the right fifo
if (listener.size())
@ -97,7 +97,8 @@ void Implementation::SetupFifoStructure() {
(double)(1024 * 1024)
<< " MB";
}
LOG(logINFO) << generalData->numUDPInterfaces << " Fifo structure(s) reconstructed";
LOG(logINFO) << generalData->numUDPInterfaces
<< " Fifo structure(s) reconstructed";
}
/**************************************************
@ -120,7 +121,7 @@ void Implementation::setDetectorType(const detectorType d) {
break;
default:
throw RuntimeError("This is an unknown receiver type " +
std::to_string(static_cast<int>(d)));
std::to_string(static_cast<int>(d)));
}
delete generalData;
@ -160,8 +161,7 @@ void Implementation::setDetectorType(const detectorType d) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
try {
listener.push_back(sls::make_unique<Listener>(
i, &status));
listener.push_back(sls::make_unique<Listener>(i, &status));
SetupListener(i);
dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
SetupDataProcessor(i);
@ -197,7 +197,7 @@ void Implementation::SetupDataProcessor(int i) {
dataProcessor[i]->SetActivate(activated);
dataProcessor[i]->SetReceiverROI(portRois[i]);
dataProcessor[i]->SetDataStreamEnable(dataStreamEnable);
dataProcessor[i]->SetStreamingFrequency(streamingFrequency);
dataProcessor[i]->SetStreamingFrequency(streamingFrequency);
dataProcessor[i]->SetStreamingTimerInMs(streamingTimerInMs);
dataProcessor[i]->SetStreamingStartFnum(streamingStartFnum);
dataProcessor[i]->SetFramePadding(framePadding);
@ -208,7 +208,8 @@ void Implementation::SetupDataProcessor(int i) {
void Implementation::SetupDataStreamer(int i) {
dataStreamer[i]->SetFifo(fifo[i].get());
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(streamingPort, streamingSrcIP, streamingHwm);
dataStreamer[i]->CreateZmqSockets(streamingPort, streamingSrcIP,
streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(additionalJsonHeader);
dataStreamer[i]->SetFileIndex(fileIndex);
dataStreamer[i]->SetFlipRows(flipRows);
@ -288,8 +289,8 @@ bool Implementation::getSilentMode() const { return silentMode; }
void Implementation::setSilentMode(const bool i) {
silentMode = i;
for (const auto &it : listener)
it->SetSilentMode(silentMode);
for (const auto &it : listener)
it->SetSilentMode(silentMode);
LOG(logINFO) << "Silent Mode: " << i;
}
@ -310,7 +311,7 @@ Implementation::getFrameDiscardPolicy() const {
void Implementation::setFrameDiscardPolicy(const frameDiscardPolicy i) {
frameDiscardMode = i;
for (const auto &it : listener)
for (const auto &it : listener)
it->SetFrameDiscardPolicy(frameDiscardMode);
LOG(logINFO) << "Frame Discard Policy: " << ToString(frameDiscardMode);
}
@ -367,7 +368,8 @@ void Implementation::setArping(const bool i,
// setup interface
for (int i = 0; i != generalData->numUDPInterfaces; ++i) {
// ignore eiger with 2 interfaces (only udp port)
if (i == 1 && (generalData->numUDPInterfaces == 1 || generalData->detType == EIGER)) {
if (i == 1 && (generalData->numUDPInterfaces == 1 ||
generalData->detType == EIGER)) {
break;
}
arping.SetInterfacesAndIps(i, eth[i], ips[i]);
@ -384,7 +386,8 @@ slsDetectorDefs::ROI Implementation::getReceiverROI() const {
void Implementation::setReceiverROI(const slsDetectorDefs::ROI arg) {
receiverRoi = arg;
if (generalData->numUDPInterfaces == 1 || generalData->detType == slsDetectorDefs::GOTTHARD2) {
if (generalData->numUDPInterfaces == 1 ||
generalData->detType == slsDetectorDefs::GOTTHARD2) {
portRois[0] = arg;
} else {
slsDetectorDefs::xy nPortDim(generalData->nPixelsX,
@ -454,7 +457,8 @@ void Implementation::setReceiverROI(const slsDetectorDefs::ROI arg) {
for (size_t i = 0; i != dataProcessor.size(); ++i)
dataProcessor[i]->SetReceiverROI(portRois[i]);
LOG(logINFO) << "receiver roi: " << ToString(receiverRoi);
if (generalData->numUDPInterfaces == 2 && generalData->detType != slsDetectorDefs::GOTTHARD2) {
if (generalData->numUDPInterfaces == 2 &&
generalData->detType != slsDetectorDefs::GOTTHARD2) {
LOG(logINFO) << "port rois: " << ToString(portRois);
}
}
@ -552,7 +556,9 @@ void Implementation::setOverwriteEnable(const bool b) {
<< (overwriteEnable ? "enabled" : "disabled");
}
uint32_t Implementation::getFramesPerFile() const { return generalData->framesPerFile; }
uint32_t Implementation::getFramesPerFile() const {
return generalData->framesPerFile;
}
void Implementation::setFramesPerFile(const uint32_t i) {
generalData->framesPerFile = i;
@ -609,7 +615,7 @@ double Implementation::getProgress() const {
totalFrames /= 2;
}
}
}
}
double progress = 0;
int index = 0;
@ -660,7 +666,7 @@ void Implementation::startReceiver() {
pStartAcquisition);
} catch (const std::exception &e) {
throw RuntimeError("Start Acquisition Callback Error: " +
std::string(e.what()));
std::string(e.what()));
}
if (rawDataReadyCallBack != nullptr) {
LOG(logINFO) << "Data Write has been defined externally";
@ -747,7 +753,7 @@ void Implementation::stopReceiver() {
} else if (portRois[i].noRoi()) {
summary = (i == 0 ? "\n\tNo Roi on Left Port"
: "\n\tNo Roi on Right Port");
} else {
} else {
std::ostringstream os;
os << "\n\tMissing Packets\t\t: " << mpMessage
<< "\n\tComplete Frames\t\t: " << nf
@ -763,16 +769,16 @@ void Implementation::stopReceiver() {
// callback
if (acquisitionFinishedCallBack) {
try {
acquisitionFinishedCallBack((tot / generalData->numUDPInterfaces),
pAcquisitionFinished);
acquisitionFinishedCallBack(
(tot / generalData->numUDPInterfaces),
pAcquisitionFinished);
} catch (const std::exception &e) {
// change status
status = IDLE;
LOG(logINFO) << "Receiver Stopped";
LOG(logINFO) << "Status: " << ToString(status);
throw RuntimeError(
"Acquisition Finished Callback Error: " +
std::string(e.what()));
throw RuntimeError("Acquisition Finished Callback Error: " +
std::string(e.what()));
}
}
}
@ -862,7 +868,8 @@ void Implementation::SetupWriter() {
try {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
std::ostringstream os;
os << filePath << "/" << fileName << "_d" << (modulePos * generalData->numUDPInterfaces + i);
os << filePath << "/" << fileName << "_d"
<< (modulePos * generalData->numUDPInterfaces + i);
std::string fileNamePrefix = os.str();
dataProcessor[i]->CreateFirstFiles(
fileNamePrefix, fileIndex, overwriteEnable, silentMode,
@ -893,8 +900,7 @@ void Implementation::StartMasterWriter() {
masterAttributes.framePadding = framePadding;
masterAttributes.scanParams = scanParams;
masterAttributes.totalFrames = numberOfTotalFrames;
masterAttributes.receiverRoi =
receiverRoiMetadata;
masterAttributes.receiverRoi = receiverRoiMetadata;
masterAttributes.exptime = acquisitionTime;
masterAttributes.period = acquisitionPeriod;
masterAttributes.burstMode = burstMode;
@ -908,18 +914,21 @@ void Implementation::StartMasterWriter() {
masterAttributes.quad = quadEnable;
masterAttributes.readNRows = readNRows;
masterAttributes.ratecorr = rateCorrections;
masterAttributes.adcmask =
generalData->tengigaEnable ? generalData->adcEnableMaskTenGiga : generalData->adcEnableMaskOneGiga;
masterAttributes.analog = (generalData->readoutType == ANALOG_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.analogSamples = generalData->nAnalogSamples;
masterAttributes.digital = (generalData->readoutType == DIGITAL_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.digitalSamples = generalData->nDigitalSamples;
masterAttributes.adcmask = generalData->tengigaEnable
? generalData->adcEnableMaskTenGiga
: generalData->adcEnableMaskOneGiga;
masterAttributes.analog =
(generalData->readoutType == ANALOG_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.analogSamples = generalData->nAnalogSamples;
masterAttributes.digital =
(generalData->readoutType == DIGITAL_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.digitalSamples = generalData->nDigitalSamples;
masterAttributes.dbitoffset = ctbDbitOffset;
masterAttributes.dbitlist = 0;
for (auto &i : ctbDbitList) {
@ -947,11 +956,10 @@ void Implementation::StartMasterWriter() {
// create virtual hdf5 file (if multiple files)
if (dataProcessor[0]->GetFilesInAcquisition() > 1 ||
(numPorts.x * numPorts.y) > 1) {
virtualFileName =
dataProcessor[0]->CreateVirtualFile(
filePath, fileName, fileIndex, overwriteEnable,
silentMode, modulePos, numberOfTotalFrames, numPorts.x, numPorts.y,
&hdf5LibMutex);
virtualFileName = dataProcessor[0]->CreateVirtualFile(
filePath, fileName, fileIndex, overwriteEnable, silentMode,
modulePos, numberOfTotalFrames, numPorts.x, numPorts.y,
&hdf5LibMutex);
}
// link file in master
if (masterFileWriteEnable) {
@ -962,7 +970,8 @@ void Implementation::StartMasterWriter() {
#endif
} catch (std::exception &e) {
// ignore it and just print it
LOG(logWARNING) << "Caught exception when handling virtual hdf5 file [" << e.what() << "]";
LOG(logWARNING) << "Caught exception when handling virtual hdf5 file ["
<< e.what() << "]";
}
}
@ -996,8 +1005,7 @@ int Implementation::getNumberofUDPInterfaces() const {
// not Eiger
void Implementation::setNumberofUDPInterfaces(const int n) {
if (generalData->detType == EIGER) {
throw RuntimeError(
"Cannot set number of UDP interfaces for Eiger");
throw RuntimeError("Cannot set number of UDP interfaces for Eiger");
}
if (generalData->numUDPInterfaces != n) {
@ -1020,8 +1028,7 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
// listener and dataprocessor threads
try {
listener.push_back(sls::make_unique<Listener>(
i, &status));
listener.push_back(sls::make_unique<Listener>(i, &status));
SetupListener(i);
dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
SetupDataProcessor(i);
@ -1042,7 +1049,7 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
if (dataStreamEnable) {
dataStreamer.clear();
dataStreamEnable = false;
for (const auto &it : dataProcessor)
for (const auto &it : dataProcessor)
it->SetDataStreamEnable(dataStreamEnable);
}
throw RuntimeError(
@ -1120,15 +1127,18 @@ int Implementation::getUDPSocketBufferSize() const {
void Implementation::setUDPSocketBufferSize(const int s) {
size_t listSize = listener.size();
if ((generalData->detType == JUNGFRAU || generalData->detType == GOTTHARD2) &&
if ((generalData->detType == JUNGFRAU ||
generalData->detType == GOTTHARD2) &&
(int)listSize != generalData->numUDPInterfaces) {
throw RuntimeError(
"Number of Interfaces " + std::to_string(generalData->numUDPInterfaces) +
" do not match listener size " + std::to_string(listSize));
throw RuntimeError("Number of Interfaces " +
std::to_string(generalData->numUDPInterfaces) +
" do not match listener size " +
std::to_string(listSize));
}
for (auto &l : listener) {
l->CreateDummySocketForUDPSocketBufferSize(s, actualUDPSocketBufferSize);
l->CreateDummySocketForUDPSocketBufferSize(s,
actualUDPSocketBufferSize);
}
}
@ -1158,16 +1168,15 @@ void Implementation::setDataStreamEnable(const bool enable) {
} catch (...) {
dataStreamer.clear();
dataStreamEnable = false;
for (const auto &it : dataProcessor)
it->SetDataStreamEnable(dataStreamEnable);
throw RuntimeError(
"Could not set data stream enable.");
for (const auto &it : dataProcessor)
it->SetDataStreamEnable(dataStreamEnable);
throw RuntimeError("Could not set data stream enable.");
}
}
SetThreadPriorities();
}
for (const auto &it : dataProcessor)
it->SetDataStreamEnable(dataStreamEnable);
it->SetDataStreamEnable(dataStreamEnable);
}
LOG(logINFO) << "Data Send to Gui: " << dataStreamEnable;
}
@ -1179,7 +1188,7 @@ uint32_t Implementation::getStreamingFrequency() const {
void Implementation::setStreamingFrequency(const uint32_t freq) {
streamingFrequency = freq;
for (const auto &it : dataProcessor)
it->SetStreamingFrequency(streamingFrequency);
it->SetStreamingFrequency(streamingFrequency);
LOG(logINFO) << "Streaming Frequency: " << streamingFrequency;
}
@ -1212,9 +1221,7 @@ void Implementation::setStreamingPort(const uint32_t i) {
LOG(logINFO) << "Streaming Port: " << streamingPort;
}
IpAddr Implementation::getStreamingSourceIP() const {
return streamingSrcIP;
}
IpAddr Implementation::getStreamingSourceIP() const { return streamingSrcIP; }
void Implementation::setStreamingSourceIP(const IpAddr ip) {
streamingSrcIP = ip;
@ -1250,8 +1257,7 @@ Implementation::getAdditionalJsonParameter(const std::string &key) const {
if (additionalJsonHeader.find(key) != additionalJsonHeader.end()) {
return additionalJsonHeader.at(key);
}
throw RuntimeError("No key " + key +
" found in additional json header");
throw RuntimeError("No key " + key + " found in additional json header");
}
void Implementation::setAdditionalJsonParameter(const std::string &key,
@ -1461,32 +1467,35 @@ void Implementation::setSubPeriod(const ns i) {
}
uint32_t Implementation::getNumberofAnalogSamples() const {
return generalData->nAnalogSamples;
return generalData->nAnalogSamples;
}
void Implementation::setNumberofAnalogSamples(const uint32_t i) {
if ( generalData->nAnalogSamples != i) {
if (generalData->nAnalogSamples != i) {
generalData->SetNumberOfAnalogSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Analog Samples: " << generalData->nAnalogSamples;
LOG(logINFO) << "Number of Analog Samples: " << generalData->nAnalogSamples;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getNumberofDigitalSamples() const {
return generalData->nDigitalSamples;
return generalData->nDigitalSamples;
}
void Implementation::setNumberofDigitalSamples(const uint32_t i) {
if ( generalData->nDigitalSamples != i) {
if (generalData->nDigitalSamples != i) {
generalData->SetNumberOfDigitalSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Digital Samples: " << generalData->nDigitalSamples;
LOG(logINFO) << "Number of Digital Samples: "
<< generalData->nDigitalSamples;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getCounterMask() const { return generalData->counterMask; }
uint32_t Implementation::getCounterMask() const {
return generalData->counterMask;
}
void Implementation::setCounterMask(const uint32_t i) {
if (generalData->counterMask != i) {
@ -1498,7 +1507,9 @@ void Implementation::setCounterMask(const uint32_t i) {
LOG(logINFO) << "Number of counters: " << ncounters;
}
uint32_t Implementation::getDynamicRange() const { return generalData->dynamicRange; }
uint32_t Implementation::getDynamicRange() const {
return generalData->dynamicRange;
}
void Implementation::setDynamicRange(const uint32_t i) {
if (generalData->dynamicRange != i) {
@ -1510,10 +1521,13 @@ void Implementation::setDynamicRange(const uint32_t i) {
LOG(logINFO) << "Dynamic Range: " << generalData->dynamicRange;
}
slsDetectorDefs::ROI Implementation::getROI() const { return generalData->detectorRoi; }
slsDetectorDefs::ROI Implementation::getROI() const {
return generalData->detectorRoi;
}
void Implementation::setDetectorROI(slsDetectorDefs::ROI arg) {
if (generalData->detectorRoi.xmin != arg.xmin || generalData->detectorRoi.xmax != arg.xmax) {
if (generalData->detectorRoi.xmin != arg.xmin ||
generalData->detectorRoi.xmax != arg.xmax) {
// only for gotthard
generalData->SetDetectorROI(arg);
SetupFifoStructure();
@ -1523,10 +1537,12 @@ void Implementation::setDetectorROI(slsDetectorDefs::ROI arg) {
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
bool Implementation::getTenGigaEnable() const { return generalData->tengigaEnable; }
bool Implementation::getTenGigaEnable() const {
return generalData->tengigaEnable;
}
void Implementation::setTenGigaEnable(const bool b) {
if ( generalData->tengigaEnable != b) {
if (generalData->tengigaEnable != b) {
generalData->SetTenGigaEnable(b);
SetupFifoStructure();
@ -1541,11 +1557,12 @@ void Implementation::setTenGigaEnable(const bool b) {
}
LOG(logDEBUG) << "Detector datastream updated [Left: "
<< ToString(detectorDataStream[LEFT])
<< ", Right: "
<< ToString(detectorDataStream[RIGHT]) << "]";
<< ", Right: " << ToString(detectorDataStream[RIGHT])
<< "]";
}
}
LOG(logINFO) << "Ten Giga: " << ( generalData->tengigaEnable ? "enabled" : "disabled");
LOG(logINFO) << "Ten Giga: "
<< (generalData->tengigaEnable ? "enabled" : "disabled");
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
@ -1596,7 +1613,7 @@ void Implementation::setDetectorDataStream(const portPosition port,
LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port)
<< " Port): " << ToString(detectorDataStream10GbE[index]);
// update datastream for 10g
if ( generalData->tengigaEnable) {
if (generalData->tengigaEnable) {
detectorDataStream[index] = detectorDataStream10GbE[index];
LOG(logDEBUG) << "Detector datastream updated ["
<< (index == 0 ? "Left" : "Right")
@ -1618,8 +1635,7 @@ void Implementation::setThresholdEnergy(const int value) {
void Implementation::setThresholdEnergy(const std::array<int, 3> value) {
thresholdAllEnergyeV = value;
LOG(logINFO) << "Threshold Energy (eV): "
<< ToString(thresholdAllEnergyeV);
LOG(logINFO) << "Threshold Energy (eV): " << ToString(thresholdAllEnergyeV);
}
void Implementation::setRateCorrections(const std::vector<int64_t> &t) {
@ -1670,8 +1686,8 @@ void Implementation::setTenGigaADCEnableMask(uint32_t mask) {
std::vector<int> Implementation::getDbitList() const { return ctbDbitList; }
void Implementation::setDbitList(const std::vector<int> &v) {
ctbDbitList = v;
void Implementation::setDbitList(const std::vector<int> &v) {
ctbDbitList = v;
for (const auto &it : dataProcessor)
it->SetCtbDbitList(ctbDbitList);
LOG(logINFO) << "Dbit list: " << ToString(ctbDbitList);
@ -1679,8 +1695,8 @@ void Implementation::setDbitList(const std::vector<int> &v) {
int Implementation::getDbitOffset() const { return ctbDbitOffset; }
void Implementation::setDbitOffset(const int s) {
ctbDbitOffset = s;
void Implementation::setDbitOffset(const int s) {
ctbDbitOffset = s;
for (const auto &it : dataProcessor)
it->SetCtbDbitOffset(ctbDbitOffset);
LOG(logINFO) << "Dbit offset: " << ctbDbitOffset;
@ -1707,7 +1723,7 @@ void Implementation::registerCallBackAcquisitionFinished(void (*func)(uint64_t,
}
void Implementation::registerCallBackRawDataReady(
void (*func)(sls_receiver_header&, char *, size_t, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t, void *), void *arg) {
rawDataReadyCallBack = func;
pRawDataReady = arg;
for (const auto &it : dataProcessor)
@ -1715,7 +1731,7 @@ void Implementation::registerCallBackRawDataReady(
}
void Implementation::registerCallBackRawDataModifyReady(
void (*func)(sls_receiver_header&, char *, size_t &, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t &, void *), void *arg) {
rawDataModifyReadyCallBack = func;
pRawDataReady = arg;
for (const auto &it : dataProcessor)

8
slsReceiverSoftware/src/Implementation.h
View File

@ -267,11 +267,11 @@ class Implementation : private virtual slsDetectorDefs {
void registerCallBackAcquisitionFinished(void (*func)(uint64_t, void *),
void *arg);
/** params: sls_receiver_header, pointer to data, image size */
void registerCallBackRawDataReady(void (*func)(sls_receiver_header&,
void registerCallBackRawDataReady(void (*func)(sls_receiver_header &,
char *, size_t, void *),
void *arg);
/** params: sls_receiver_header, pointer to data, reference to image size */
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header&,
void registerCallBackRawDataModifyReady(void (*func)(sls_receiver_header &,
char *, size_t &,
void *),
void *arg);
@ -380,9 +380,9 @@ class Implementation : private virtual slsDetectorDefs {
void *pStartAcquisition{nullptr};
void (*acquisitionFinishedCallBack)(uint64_t, void *){nullptr};
void *pAcquisitionFinished{nullptr};
void (*rawDataReadyCallBack)(sls_receiver_header&, char *, size_t,
void (*rawDataReadyCallBack)(sls_receiver_header &, char *, size_t,
void *){nullptr};
void (*rawDataModifyReadyCallBack)(sls_receiver_header&, char *, size_t &,
void (*rawDataModifyReadyCallBack)(sls_receiver_header &, char *, size_t &,
void *){nullptr};
void *pRawDataReady{nullptr};

148
slsReceiverSoftware/src/Listener.cpp
View File

@ -31,9 +31,7 @@ Listener::Listener(int index, std::atomic<runStatus> *status)
Listener::~Listener() = default;
bool Listener::isPortDisabled() const {
return disabledPort;
}
bool Listener::isPortDisabled() const { return disabledPort; }
uint64_t Listener::GetPacketsCaught() const { return numPacketsCaught; }
@ -84,22 +82,23 @@ void Listener::SetEthernetInterface(const std::string e) {
eth = "";
}
if (!eth.length()) {
LOG(logWARNING) << "ethernet interface for udp port " << udpPortNumber << " is empty. Listening to all";
LOG(logWARNING) << "ethernet interface for udp port " << udpPortNumber
<< " is empty. Listening to all";
}
}
void Listener::SetActivate(bool enable) {
void Listener::SetActivate(bool enable) {
activated = enable;
disabledPort = (!activated || !detectorDataStream || noRoi);
}
void Listener::SetDetectorDatastream(bool enable) {
void Listener::SetDetectorDatastream(bool enable) {
detectorDataStream = enable;
disabledPort = (!activated || !detectorDataStream || noRoi);
}
void Listener::SetNoRoi(bool enable) {
noRoi = enable;
noRoi = enable;
disabledPort = (!activated || !detectorDataStream || noRoi);
}
@ -107,10 +106,7 @@ void Listener::SetFrameDiscardPolicy(frameDiscardPolicy value) {
frameDiscardMode = value;
}
void Listener::SetSilentMode(bool enable) {
silentMode = enable;
}
void Listener::SetSilentMode(bool enable) { silentMode = enable; }
void Listener::ResetParametersforNewAcquisition() {
StopRunning();
@ -151,7 +147,7 @@ void Listener::RecordFirstIndex(uint64_t fnum) {
}
}
void Listener::CreateUDPSocket(int& actualSize) {
void Listener::CreateUDPSocket(int &actualSize) {
if (disabledPort) {
return;
}
@ -163,13 +159,14 @@ void Listener::CreateUDPSocket(int& actualSize) {
}
try {
udpSocket = make_unique<UdpRxSocket>(udpPortNumber, packetSize,
(eth.length() ? InterfaceNameToIp(eth).str().c_str()
: nullptr), generalData->udpSocketBufferSize);
udpSocket = make_unique<UdpRxSocket>(
udpPortNumber, packetSize,
(eth.length() ? InterfaceNameToIp(eth).str().c_str() : nullptr),
generalData->udpSocketBufferSize);
LOG(logINFO) << index << ": UDP port opened at port " << udpPortNumber;
} catch (...) {
throw RuntimeError("Could not create UDP socket on port " +
std::to_string(udpPortNumber));
std::to_string(udpPortNumber));
}
udpSocketAlive = true;
@ -188,12 +185,12 @@ void Listener::ShutDownUDPSocket() {
}
}
void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int& actualSize) {
void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize) {
// custom setup (s != 0)
// default setup at startup (s = 0)
int size = (s == 0 ? generalData->udpSocketBufferSize : s);
LOG(logINFO) << "Testing UDP Socket Buffer size " << size << " with test port "
<< udpPortNumber;
LOG(logINFO) << "Testing UDP Socket Buffer size " << size
<< " with test port " << udpPortNumber;
int previousSize = generalData->udpSocketBufferSize;
generalData->udpSocketBufferSize = size;
@ -209,10 +206,10 @@ void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int& actualSize) {
// create dummy socket
try {
UdpRxSocket g(udpPortNumber, packetSize,
(eth.length()
? InterfaceNameToIp(eth).str().c_str()
: nullptr), generalData->udpSocketBufferSize);
UdpRxSocket g(
udpPortNumber, packetSize,
(eth.length() ? InterfaceNameToIp(eth).str().c_str() : nullptr),
generalData->udpSocketBufferSize);
// doubled due to kernel bookkeeping (could also be less due to
// permissions)
@ -225,13 +222,13 @@ void Listener::CreateDummySocketForUDPSocketBufferSize(int s, int& actualSize) {
} catch (...) {
throw RuntimeError("Could not create a test UDP socket on port " +
std::to_string(udpPortNumber));
std::to_string(udpPortNumber));
}
// custom and didnt set, throw error
if (s != 0 && static_cast<int>(generalData->udpSocketBufferSize) != s) {
throw RuntimeError("Could not set udp socket buffer size. (No "
"CAP_NET_ADMIN privileges?)");
"CAP_NET_ADMIN privileges?)");
}
}
@ -245,8 +242,8 @@ void Listener::SetHardCodedPosition(uint16_t r, uint16_t c) {
void Listener::ThreadExecution() {
char *buffer;
fifo->GetNewAddress(buffer);
LOG(logDEBUG5) << "Listener " << index << ", pop 0x"
<< std::hex << (void *)(buffer) << std::dec << ":" << buffer;
LOG(logDEBUG5) << "Listener " << index << ", pop 0x" << std::hex
<< (void *)(buffer) << std::dec << ":" << buffer;
auto *memImage = reinterpret_cast<image_structure *>(buffer);
// udpsocket doesnt exist
@ -261,8 +258,8 @@ void Listener::ThreadExecution() {
// end of acquisition or discarding image
if (rc <= 0) {
fifo->FreeAddress(buffer);
return;
fifo->FreeAddress(buffer);
return;
}
// valid image, set size and push into fifo
@ -275,27 +272,28 @@ void Listener::ThreadExecution() {
if (numFramesStatistic >=
// second condition also for infinite #number of frames
(generalData->framesPerFile == 0 ? STATISTIC_FRAMENUMBER_INFINITE
: generalData->framesPerFile))
: generalData->framesPerFile))
PrintFifoStatistics();
}
}
void Listener::StopListening(char *buf, size_t & size) {
void Listener::StopListening(char *buf, size_t &size) {
size = DUMMY_PACKET_VALUE;
fifo->PushAddress(buf);
StopRunning();
LOG(logDEBUG1) << index << ": Listening Completed. Packets (" << udpPortNumber
<< ") : " << numPacketsCaught;
LOG(logDEBUG1) << index << ": Listening Completed. Packets ("
<< udpPortNumber << ") : " << numPacketsCaught;
}
/* buf includes the fifo header and packet header */
uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstData) {
uint32_t Listener::ListenToAnImage(sls_receiver_header &dstHeader,
char *dstData) {
uint64_t fnum = 0;
uint32_t pnum = 0;
uint64_t bnum = 0;
uint32_t numpackets = 0;
uint32_t dsize = generalData->dataSize;
uint32_t imageSize = generalData->imageSize;
uint32_t packetSize = generalData->packetSize;
@ -316,7 +314,8 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstDat
// carry over packet
if (carryOverFlag) {
LOG(logDEBUG3) << index << "carry flag";
GetPacketIndices(fnum, pnum, bnum, standardHeader, carryOverPacket.get(), srcDetHeader);
GetPacketIndices(fnum, pnum, bnum, standardHeader,
carryOverPacket.get(), srcDetHeader);
// future packet
if (fnum != currentFrameIndex) {
@ -327,10 +326,13 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstDat
carryOverFlag = false;
return 0;
}
return HandleFuturePacket(false, numpackets, fnum, isHeaderEmpty, imageSize, dstHeader);
return HandleFuturePacket(false, numpackets, fnum, isHeaderEmpty,
imageSize, dstHeader);
}
CopyPacket(dstData, carryOverPacket.get(), dsize, hsize, corrected_dsize, numpackets, isHeaderEmpty, standardHeader, dstHeader, srcDetHeader, pnum, bnum);
CopyPacket(dstData, carryOverPacket.get(), dsize, hsize,
corrected_dsize, numpackets, isHeaderEmpty, standardHeader,
dstHeader, srcDetHeader, pnum, bnum);
carryOverFlag = false;
}
@ -345,13 +347,15 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstDat
// end of acquisition
if (rc <= 0) {
if (numpackets == 0)
return 0;
return HandleFuturePacket(true, numpackets, fnum, isHeaderEmpty, imageSize, dstHeader);
return 0;
return HandleFuturePacket(true, numpackets, fnum, isHeaderEmpty,
imageSize, dstHeader);
}
numPacketsCaught++;
numPacketsCaught++;
numPacketsStatistic++;
GetPacketIndices(fnum, pnum, bnum, standardHeader, listeningPacket.get(), srcDetHeader);
GetPacketIndices(fnum, pnum, bnum, standardHeader,
listeningPacket.get(), srcDetHeader);
// Eiger Firmware in a weird state
if (generalData->detType == EIGER && fnum == 0) {
@ -376,16 +380,19 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstDat
LOG(logERROR) << "Bad packet " << pnum << "(fnum: " << fnum
<< "), throwing away. Packets caught so far: "
<< numpackets;
return 0;
return 0;
}
// future packet
if (fnum != currentFrameIndex) {
carryOverFlag = true;
memcpy(carryOverPacket.get(), &listeningPacket[0], packetSize);
return HandleFuturePacket(false, numpackets, fnum, isHeaderEmpty, imageSize, dstHeader);
return HandleFuturePacket(false, numpackets, fnum, isHeaderEmpty,
imageSize, dstHeader);
}
CopyPacket(dstData, listeningPacket.get(), dsize, hsize, corrected_dsize, numpackets, isHeaderEmpty, standardHeader, dstHeader, srcDetHeader, pnum, bnum);
CopyPacket(dstData, listeningPacket.get(), dsize, hsize,
corrected_dsize, numpackets, isHeaderEmpty, standardHeader,
dstHeader, srcDetHeader, pnum, bnum);
}
// complete image
@ -397,7 +404,10 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header & dstHeader, char *dstDat
return imageSize;
}
size_t Listener::HandleFuturePacket(bool EOA, uint32_t numpackets, uint64_t fnum, bool isHeaderEmpty, size_t imageSize, sls_receiver_header& dstHeader) {
size_t Listener::HandleFuturePacket(bool EOA, uint32_t numpackets,
uint64_t fnum, bool isHeaderEmpty,
size_t imageSize,
sls_receiver_header &dstHeader) {
switch (frameDiscardMode) {
case DISCARD_EMPTY_FRAMES:
if (!numpackets) {
@ -417,15 +427,17 @@ size_t Listener::HandleFuturePacket(bool EOA, uint32_t numpackets, uint64_t fnum
default:
break;
}
dstHeader.detHeader.packetNumber = numpackets;
dstHeader.detHeader.packetNumber = numpackets;
// for empty frames (padded)
if (isHeaderEmpty) {
dstHeader.detHeader.frameNumber = currentFrameIndex;
// no packet to get bnum
dstHeader.detHeader.row = row;
dstHeader.detHeader.column = column;
dstHeader.detHeader.detType = static_cast<uint8_t>(generalData->detType);
dstHeader.detHeader.version = static_cast<uint8_t>(SLS_DETECTOR_HEADER_VERSION);
dstHeader.detHeader.detType =
static_cast<uint8_t>(generalData->detType);
dstHeader.detHeader.version =
static_cast<uint8_t>(SLS_DETECTOR_HEADER_VERSION);
}
if (!EOA) {
++currentFrameIndex;
@ -433,7 +445,12 @@ size_t Listener::HandleFuturePacket(bool EOA, uint32_t numpackets, uint64_t fnum
return imageSize;
}
void Listener::CopyPacket(char* dst, char* src, uint32_t dataSize, uint32_t detHeaderSize, uint32_t correctedDataSize, uint32_t &numpackets, bool &isHeaderEmpty, bool standardHeader, sls_receiver_header& dstHeader, sls_detector_header * srcDetHeader, uint32_t pnum, uint64_t bnum) {
void Listener::CopyPacket(char *dst, char *src, uint32_t dataSize,
uint32_t detHeaderSize, uint32_t correctedDataSize,
uint32_t &numpackets, bool &isHeaderEmpty,
bool standardHeader, sls_receiver_header &dstHeader,
sls_detector_header *srcDetHeader, uint32_t pnum,
uint64_t bnum) {
// copy packet data
switch (generalData->detType) {
@ -449,7 +466,8 @@ void Listener::CopyPacket(char* dst, char* src, uint32_t dataSize, uint32_t detH
case CHIPTESTBOARD:
case MOENCH:
if (pnum == (generalData->packetsPerFrame - 1))
memcpy(dst + (pnum * dataSize), &src[detHeaderSize], correctedDataSize);
memcpy(dst + (pnum * dataSize), &src[detHeaderSize],
correctedDataSize);
else
memcpy(dst + (pnum * dataSize), &src[detHeaderSize], dataSize);
break;
@ -458,27 +476,33 @@ void Listener::CopyPacket(char* dst, char* src, uint32_t dataSize, uint32_t detH
break;
}
++numpackets;
dstHeader.packetsMask[(
(pnum < MAX_NUM_PACKETS) ? pnum : MAX_NUM_PACKETS - 1)] = 1;
++numpackets;
dstHeader
.packetsMask[((pnum < MAX_NUM_PACKETS) ? pnum : MAX_NUM_PACKETS - 1)] =
1;
// writer header
if (isHeaderEmpty) {
if (standardHeader) {
memcpy((char *)&dstHeader, (char *)srcDetHeader, sizeof(sls_detector_header));
memcpy((char *)&dstHeader, (char *)srcDetHeader,
sizeof(sls_detector_header));
} else {
dstHeader.detHeader.frameNumber = currentFrameIndex;
dstHeader.detHeader.bunchId = bnum;
dstHeader.detHeader.row = row;
dstHeader.detHeader.column = column;
dstHeader.detHeader.detType = static_cast<uint8_t>(generalData->detType);
dstHeader.detHeader.version = static_cast<uint8_t>(SLS_DETECTOR_HEADER_VERSION);
dstHeader.detHeader.detType =
static_cast<uint8_t>(generalData->detType);
dstHeader.detHeader.version =
static_cast<uint8_t>(SLS_DETECTOR_HEADER_VERSION);
}
isHeaderEmpty = false;
}
}
void Listener::GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum, bool standardHeader, char* packet, sls_detector_header*& header) {
void Listener::GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum,
bool standardHeader, char *packet,
sls_detector_header *&header) {
if (standardHeader) {
header = (sls_detector_header *)(&packet[0]);
fnum = header->frameNumber;
@ -487,14 +511,14 @@ void Listener::GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum,
// set first packet to be odd or even (check required when switching
// from roi to no roi)
if (generalData->detType == GOTTHARD && !startedFlag) {
oddStartingPacket = generalData->SetOddStartingPacket(index, &packet[0]);
oddStartingPacket =
generalData->SetOddStartingPacket(index, &packet[0]);
}
generalData->GetHeaderInfo(index, &packet[0], oddStartingPacket, fnum, pnum, bnum);
generalData->GetHeaderInfo(index, &packet[0], oddStartingPacket, fnum,
pnum, bnum);
}
}
void Listener::PrintFifoStatistics() {
LOG(logDEBUG1) << "numFramesStatistic:" << numFramesStatistic
<< " numPacketsStatistic:" << numPacketsStatistic

24
slsReceiverSoftware/src/Listener.h
View File

@ -47,12 +47,11 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
void SetFrameDiscardPolicy(frameDiscardPolicy value);
void SetSilentMode(bool enable);
void ResetParametersforNewAcquisition();
void CreateUDPSocket(int& actualSize);
void CreateUDPSocket(int &actualSize);
void ShutDownUDPSocket();
/** to set & get actual buffer size */
void CreateDummySocketForUDPSocketBufferSize(int s, int & actualSize);
void CreateDummySocketForUDPSocketBufferSize(int s, int &actualSize);
/**
* Set hard coded (calculated but not from detector) row and column
@ -77,7 +76,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
* pushes dummy buffer into fifo
* and reset running mask by calling StopRunning()
*/
void StopListening(char *buf, size_t& size);
void StopListening(char *buf, size_t &size);
/**
* Listen to the UDP Socket for an image,
@ -85,13 +84,22 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
* @returns number of bytes of relevant data, can be image size or 0 (stop
* acquisition) or -1 to discard image
*/
uint32_t ListenToAnImage(sls_receiver_header & dstHeader, char *dstData);
uint32_t ListenToAnImage(sls_receiver_header &dstHeader, char *dstData);
size_t HandleFuturePacket(bool EOA, uint32_t numpackets, uint64_t fnum, bool isHeaderEmpty, size_t imageSize, sls_receiver_header& rxHeader);
size_t HandleFuturePacket(bool EOA, uint32_t numpackets, uint64_t fnum,
bool isHeaderEmpty, size_t imageSize,
sls_receiver_header &rxHeader);
void CopyPacket(char* dst, char* src, uint32_t dataSize, uint32_t detHeaderSize, uint32_t correctedDataSize, uint32_t &numpackets, bool &isHeaderEmpty, bool standardHeader, sls_receiver_header& rxHeader, sls_detector_header* detHeader, uint32_t pnum, uint64_t bnum);
void CopyPacket(char *dst, char *src, uint32_t dataSize,
uint32_t detHeaderSize, uint32_t correctedDataSize,
uint32_t &numpackets, bool &isHeaderEmpty,
bool standardHeader, sls_receiver_header &rxHeader,
sls_detector_header *detHeader, uint32_t pnum,
uint64_t bnum);
void GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum, bool standardHeader, char* packet, sls_detector_header*& header);
void GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum,
bool standardHeader, char *packet,
sls_detector_header *&header);
void PrintFifoStatistics();

171
slsReceiverSoftware/src/MasterAttributes.cpp
View File

@ -3,7 +3,6 @@
#include "MasterAttributes.h"
#include <time.h>
namespace sls {
void MasterAttributes::GetBinaryAttributes(
@ -33,8 +32,7 @@ void MasterAttributes::GetBinaryAttributes(
GetCtbBinaryAttributes(w);
break;
default:
throw RuntimeError(
"Unknown Detector type to get master attributes");
throw RuntimeError("Unknown Detector type to get master attributes");
}
GetFinalBinaryAttributes(w);
w->EndObject();
@ -66,8 +64,7 @@ void MasterAttributes::WriteHDF5Attributes(H5::H5File *fd, H5::Group *group) {
WriteCtbHDF5Attributes(fd, group);
break;
default:
throw RuntimeError(
"Unknown Detector type to get master attributes");
throw RuntimeError("Unknown Detector type to get master attributes");
}
WriteFinalHDF5Attributes(fd, group);
}
@ -169,14 +166,15 @@ void MasterAttributes::GetFinalBinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
char c[1024]{};
// version
{
double version = BINARY_WRITER_VERSION;
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::Attribute attribute =
fd->createAttribute("Version", H5::PredType::NATIVE_DOUBLE, dataspace);
H5::Attribute attribute = fd->createAttribute(
"Version", H5::PredType::NATIVE_DOUBLE, dataspace);
attribute.write(H5::PredType::NATIVE_DOUBLE, &version);
}
// timestamp
@ -211,22 +209,22 @@ void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd, H5::Group *grou
// geometry x
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Geometry in x axis",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Geometry in x axis", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&geometry.x, H5::PredType::NATIVE_INT);
}
// geometry y
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Geometry in y axis",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Geometry in y axis", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&geometry.y, H5::PredType::NATIVE_INT);
}
// Image Size
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Image Size", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Image Size", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&imageSize, H5::PredType::NATIVE_INT);
H5::DataSpace dataspaceAttr = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 256);
@ -239,22 +237,22 @@ void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd, H5::Group *grou
// npixels x
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Number of pixels in x axis",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Number of pixels in x axis", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&nPixels.x, H5::PredType::NATIVE_INT);
}
// npixels y
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Number of pixels in y axis",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Number of pixels in y axis", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&nPixels.y, H5::PredType::NATIVE_INT);
}
// Maximum frames per file
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Maximum frames per file",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Maximum frames per file", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&maxFramesPerFile, H5::PredType::NATIVE_INT);
}
// Frame Discard Policy
@ -262,15 +260,15 @@ void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd, H5::Group *grou
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 256);
H5::DataSet dataset = group->createDataSet("Frame Discard Policy",
strdatatype, dataspace);
strdatatype, dataspace);
strcpy_safe(c, ToString(frameDiscardMode));
dataset.write(c, strdatatype);
}
// Frame Padding
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Frame Padding",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Frame Padding", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&framePadding, H5::PredType::NATIVE_INT);
}
// Scan Parameters
@ -285,47 +283,48 @@ void MasterAttributes::WriteCommonHDF5Attributes(H5::H5File *fd, H5::Group *grou
// Total Frames
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Total Frames",
H5::PredType::STD_U64LE, dataspace);
H5::DataSet dataset = group->createDataSet(
"Total Frames", H5::PredType::STD_U64LE, dataspace);
dataset.write(&totalFrames, H5::PredType::STD_U64LE);
}
// Receiver Roi xmin
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("receiver roi xmin",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"receiver roi xmin", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&receiverRoi.xmin, H5::PredType::NATIVE_INT);
}
// Receiver Roi xmax
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("receiver roi xmax",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"receiver roi xmax", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&receiverRoi.xmax, H5::PredType::NATIVE_INT);
}
// Receiver Roi ymin
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("receiver roi ymin",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"receiver roi ymin", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&receiverRoi.ymin, H5::PredType::NATIVE_INT);
}
// Receiver Roi ymax
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("receiver roi ymax",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"receiver roi ymax", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&receiverRoi.ymax, H5::PredType::NATIVE_INT);
}
}
void MasterAttributes::WriteFinalHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteFinalHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
char c[1024]{};
// Total Frames in file
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Frames in File",
H5::PredType::STD_U64LE, dataspace);
H5::DataSet dataset = group->createDataSet(
"Frames in File", H5::PredType::STD_U64LE, dataspace);
dataset.write(&framesInFile, H5::PredType::STD_U64LE);
}
// additional json header
@ -334,7 +333,7 @@ void MasterAttributes::WriteFinalHDF5Attributes(H5::H5File *fd, H5::Group *group
H5::StrType strdatatype(H5::PredType::C_S1, json.length());
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Additional JSON Header",
strdatatype, dataspace);
strdatatype, dataspace);
strcpy_safe(c, ToString(additionalJsonHeader));
dataset.write(c, strdatatype);
}
@ -362,8 +361,8 @@ void MasterAttributes::WriteHDF5Period(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5DynamicRange(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Dynamic Range", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Dynamic Range", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&dynamicRange, H5::PredType::NATIVE_INT);
H5::DataSpace dataspaceAttr = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 256);
@ -375,8 +374,8 @@ void MasterAttributes::WriteHDF5DynamicRange(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5TenGiga(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Ten Giga Enable",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Ten Giga Enable", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&tenGiga, H5::PredType::NATIVE_INT);
}
@ -384,38 +383,40 @@ void MasterAttributes::WriteHDF5ROI(H5::H5File *fd, H5::Group *group) {
// Roi xmin
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("roi xmin", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"roi xmin", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&detectorRoi.xmin, H5::PredType::NATIVE_INT);
}
// Roi xmax
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("roi xmax", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"roi xmax", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&detectorRoi.xmax, H5::PredType::NATIVE_INT);
}
}
void MasterAttributes::WriteHDF5NumUDPInterfaces(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5NumUDPInterfaces(H5::H5File *fd,
H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Number of UDP Interfaces",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Number of UDP Interfaces", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&numUDPInterfaces, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5ReadNRows(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Number of rows", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Number of rows", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&readNRows, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5ThresholdEnergy(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5ThresholdEnergy(H5::H5File *fd,
H5::Group *group) {
char c[1024]{};
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Threshold Energy",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Threshold Energy", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&thresholdEnergyeV, H5::PredType::NATIVE_INT);
H5::DataSpace dataspaceAttr = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 256);
@ -425,7 +426,8 @@ void MasterAttributes::WriteHDF5ThresholdEnergy(H5::H5File *fd, H5::Group *group
attribute.write(strdatatype, c);
}
void MasterAttributes::WriteHDF5ThresholdEnergies(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5ThresholdEnergies(H5::H5File *fd,
H5::Group *group) {
char c[1024]{};
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 1024);
@ -462,7 +464,8 @@ void MasterAttributes::WriteHDF5SubQuad(H5::H5File *fd, H5::Group *group) {
dataset.write(&quad, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5RateCorrections(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5RateCorrections(H5::H5File *fd,
H5::Group *group) {
char c[1024]{};
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::StrType strdatatype(H5::PredType::C_S1, 1024);
@ -474,8 +477,8 @@ void MasterAttributes::WriteHDF5RateCorrections(H5::H5File *fd, H5::Group *group
void MasterAttributes::WriteHDF5CounterMask(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Counter Mask", H5::PredType::STD_U32LE, dataspace);
H5::DataSet dataset = group->createDataSet(
"Counter Mask", H5::PredType::STD_U32LE, dataspace);
dataset.write(&counterMask, H5::PredType::STD_U32LE);
}
@ -491,7 +494,8 @@ void MasterAttributes::WriteHDF5ExptimeArray(H5::H5File *fd, H5::Group *group) {
}
}
void MasterAttributes::WriteHDF5GateDelayArray(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5GateDelayArray(H5::H5File *fd,
H5::Group *group) {
for (int i = 0; i != 3; ++i) {
char c[1024]{};
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
@ -529,43 +533,45 @@ void MasterAttributes::WriteHDF5AdcMask(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5AnalogFlag(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Analog Flag", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Analog Flag", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&analog, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5AnalogSamples(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5AnalogSamples(H5::H5File *fd,
H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Analog Samples", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Analog Samples", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&analogSamples, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5DigitalFlag(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Digital Flag", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Digital Flag", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&digital, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5DigitalSamples(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteHDF5DigitalSamples(H5::H5File *fd,
H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Digital Samples",
H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Digital Samples", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&digitalSamples, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5DbitOffset(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset =
group->createDataSet("Dbit Offset", H5::PredType::NATIVE_INT, dataspace);
H5::DataSet dataset = group->createDataSet(
"Dbit Offset", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&dbitoffset, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5DbitList(H5::H5File *fd, H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet("Dbit Bitset List",
H5::PredType::STD_U64LE, dataspace);
H5::DataSet dataset = group->createDataSet(
"Dbit Bitset List", H5::PredType::STD_U64LE, dataspace);
dataset.write(&dbitlist, H5::PredType::STD_U64LE);
}
#endif
@ -586,7 +592,8 @@ void MasterAttributes::GetGotthardBinaryAttributes(
};
#ifdef HDF5C
void MasterAttributes::WriteGotthardHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteGotthardHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5ROI(fd, group);
@ -606,7 +613,8 @@ void MasterAttributes::GetJungfrauBinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteJungfrauHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteJungfrauHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5NumUDPInterfaces(fd, group);
@ -639,7 +647,8 @@ void MasterAttributes::GetEigerBinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteEigerHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteEigerHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5DynamicRange(fd, group);
MasterAttributes::WriteHDF5TenGiga(fd, group);
MasterAttributes::WriteHDF5Exptime(fd, group);
@ -678,7 +687,8 @@ void MasterAttributes::GetMythen3BinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteMythen3HDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteMythen3HDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5DynamicRange(fd, group);
MasterAttributes::WriteHDF5TenGiga(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
@ -701,7 +711,8 @@ void MasterAttributes::GetGotthard2BinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteGotthard2HDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteGotthard2HDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5BurstMode(fd, group);
@ -723,7 +734,8 @@ void MasterAttributes::GetMoenchBinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteMoenchHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteMoenchHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5TenGiga(fd, group);
@ -757,7 +769,8 @@ void MasterAttributes::GetCtbBinaryAttributes(
}
#ifdef HDF5C
void MasterAttributes::WriteCtbHDF5Attributes(H5::H5File *fd, H5::Group *group) {
void MasterAttributes::WriteCtbHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5TenGiga(fd, group);

5
slsReceiverSoftware/src/MasterAttributes.h
View File

@ -7,21 +7,18 @@
#include "sls/logger.h"
#include "sls/sls_detector_defs.h"
#include <chrono>
#include <rapidjson/prettywriter.h>
#include <rapidjson/stringbuffer.h>
#include <chrono>
#ifdef HDF5C
#include "H5Cpp.h"
#endif
namespace sls {
using ns = std::chrono::nanoseconds;
class MasterAttributes {
public:
// (before acquisition)

55
slsReceiverSoftware/src/MasterFileUtility.cpp
View File

@ -24,9 +24,9 @@ std::string CreateMasterBinaryFile(const std::string &filePath,
if (!overWriteEnable)
mode = "wx";
FILE *fd = fopen(fileName.c_str(), mode.c_str());
if(!fd) {
if (!fd) {
throw RuntimeError("Could not create/overwrite binary master file " +
fileName);
fileName);
}
rapidjson::StringBuffer s;
@ -62,15 +62,16 @@ void LinkHDF5FileInMaster(std::string &masterFileName,
// open master file
H5::H5File masterfd(masterFileName.c_str(), H5F_ACC_RDWR,
H5::FileCreatPropList::DEFAULT, flist);
H5::FileCreatPropList::DEFAULT, flist);
// open data file
fd = make_unique<H5::H5File>(dataFilename.c_str(), H5F_ACC_RDONLY,
H5::FileCreatPropList::DEFAULT, flist);
H5::FileCreatPropList::DEFAULT, flist);
// create link for data dataset
H5::DataSet dset = fd->openDataSet(DATASET_NAME);
std::string linkname = std::string("/entry/data/") + std::string(DATASET_NAME);
std::string linkname =
std::string("/entry/data/") + std::string(DATASET_NAME);
if (H5Lcreate_external(dataFilename.c_str(), DATASET_NAME,
masterfd.getLocId(), linkname.c_str(),
H5P_DEFAULT, H5P_DEFAULT) < 0) {
@ -129,7 +130,7 @@ std::string CreateMasterHDF5File(const std::string &filePath,
createFlags = H5F_ACC_TRUNC;
}
fd = make_unique<H5::H5File>(fileName.c_str(), createFlags,
H5::FileCreatPropList::DEFAULT, flist);
H5::FileCreatPropList::DEFAULT, flist);
// attributes - version
double dValue = HDF5_WRITER_VERSION;
@ -152,8 +153,7 @@ std::string CreateMasterHDF5File(const std::string &filePath,
error.printErrorStack();
if (fd != nullptr)
fd->close();
throw RuntimeError(
"Could not create/overwrite master HDF5 handles");
throw RuntimeError("Could not create/overwrite master HDF5 handles");
}
if (!silentMode) {
LOG(logINFO) << "Master File: " << fileName;
@ -165,13 +165,12 @@ std::string CreateVirtualHDF5File(
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 maxFramesPerFile,
const uint32_t nPixelsX, const uint32_t nPixelsY,
const uint32_t dynamicRange, const uint64_t numImagesCaught,
const int numModX, const int numModY, const H5::DataType dataType,
const std::vector<std::string> parameterNames,
const std::vector<H5::DataType> parameterDataTypes, std::mutex *hdf5LibMutex,
bool gotthard25um) {
const uint32_t maxFramesPerFile, const uint32_t nPixelsX,
const uint32_t nPixelsY, const uint32_t dynamicRange,
const uint64_t numImagesCaught, const int numModX, const int numModY,
const H5::DataType dataType, const std::vector<std::string> parameterNames,
const std::vector<H5::DataType> parameterDataTypes,
std::mutex *hdf5LibMutex, bool gotthard25um) {
// virtual file name
std::ostringstream osfn;
@ -195,10 +194,10 @@ std::string CreateVirtualHDF5File(
fapl.setFcloseDegree(H5F_CLOSE_STRONG);
if (!overWriteEnable)
fd = make_unique<H5::H5File>(fileName.c_str(), H5F_ACC_EXCL,
H5::FileCreatPropList::DEFAULT, fapl);
H5::FileCreatPropList::DEFAULT, fapl);
else
fd = make_unique<H5::H5File>(fileName.c_str(), H5F_ACC_TRUNC,
H5::FileCreatPropList::DEFAULT, fapl);
H5::FileCreatPropList::DEFAULT, fapl);
// attributes - version
double dValue = HDF5_WRITER_VERSION;
@ -209,8 +208,9 @@ std::string CreateVirtualHDF5File(
// dataspace
hsize_t vdsDims[DATA_RANK] = {numImagesCaught, numModY * nDimy,
numModZ * nDimz};
hsize_t vdsDimsPara[VDS_PARA_RANK] = {numImagesCaught, numModY * numModZ};
numModZ * nDimz};
hsize_t vdsDimsPara[VDS_PARA_RANK] = {numImagesCaught,
numModY * numModZ};
H5::DataSpace vdsDataSpace(DATA_RANK, vdsDims, nullptr);
H5::DataSpace vdsDataSpacePara(VDS_PARA_RANK, vdsDimsPara, nullptr);
@ -290,17 +290,19 @@ std::string CreateVirtualHDF5File(
H5::DataSpace srcDataSpace(DATA_RANK, srcDims, srcDimsMax);
hsize_t srcDimsPara[PARA_RANK] = {nDimx};
hsize_t srcDimsMaxPara[PARA_RANK] = {H5S_UNLIMITED};
H5::DataSpace srcDataSpacePara(PARA_RANK, srcDimsPara, srcDimsMaxPara);
H5::DataSpace srcDataSpacePara(PARA_RANK, srcDimsPara,
srcDimsMaxPara);
// temporary fixfor corner case bug:
// (framescaught not multiple of framesperfile,
// (framescaught not multiple of framesperfile,
// virtual parameter datasets error loading (bad scalar value))
if (nDimx != maxFramesPerFile) {
hsize_t count[1] = {nDimx};
hsize_t start[1] = {0};
srcDataSpacePara.selectHyperslab(H5S_SELECT_SET, count, start, strideBetweenBlocksPara, blockSizePara);
srcDataSpacePara.selectHyperslab(
H5S_SELECT_SET, count, start, strideBetweenBlocksPara,
blockSizePara);
}
// mapping of property list
plist.setVirtual(vdsDataSpace, relative_srcFileName.c_str(),
DATASET_NAME, srcDataSpace);
@ -325,8 +327,8 @@ std::string CreateVirtualHDF5File(
framesSaved += nDimx;
}
// datasets
H5::DataSet vdsDataSet(fd->createDataSet(DATASET_NAME, dataType,
vdsDataSpace, plist));
H5::DataSet vdsDataSet(
fd->createDataSet(DATASET_NAME, dataType, vdsDataSpace, plist));
for (unsigned int p = 0; p < paraSize; ++p) {
H5::DataSet vdsDataSetPara(fd->createDataSet(
@ -340,8 +342,7 @@ std::string CreateVirtualHDF5File(
if (fd) {
fd->close();
}
throw RuntimeError(
"Could not create/overwrite virtual HDF5 handles");
throw RuntimeError("Could not create/overwrite virtual HDF5 handles");
}
if (!silentMode) {
LOG(logINFO) << "Virtual File: " << fileName;

16
slsReceiverSoftware/src/MasterFileUtility.h
View File

@ -10,9 +10,6 @@ namespace sls {
namespace masterFileUtility {
std::string CreateMasterBinaryFile(const std::string &filePath,
const std::string &fileNamePrefix,
const uint64_t fileIndex,
@ -37,13 +34,12 @@ std::string CreateVirtualHDF5File(
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 maxFramesPerFile,
const uint32_t nPixelsX, const uint32_t nPixelsY,
const uint32_t dynamicRange, const uint64_t numImagesCaught,
const int numModX, const int numModY, const H5::DataType dataType,
const std::vector<std::string> parameterNames,
const std::vector<H5::DataType> parameterDataTypes, std::mutex *hdf5LibMutex,
bool gotthard25um);
const uint32_t maxFramesPerFile, const uint32_t nPixelsX,
const uint32_t nPixelsY, const uint32_t dynamicRange,
const uint64_t numImagesCaught, const int numModX, const int numModY,
const H5::DataType dataType, const std::vector<std::string> parameterNames,
const std::vector<H5::DataType> parameterDataTypes,
std::mutex *hdf5LibMutex, bool gotthard25um);
#endif
} // namespace masterFileUtility

12
slsReceiverSoftware/src/MultiReceiverApp.cpp
View File

@ -54,15 +54,16 @@ void printHelp() {
int StartAcq(const std::string &filePath, const std::string &fileName,
uint64_t fileIndex, size_t imageSize, void *objectPointer) {
LOG(sls::logINFOBLUE) << "#### StartAcq: filePath:" << filePath
<< " fileName:" << fileName << " fileIndex:" << fileIndex
<< " imageSize:" << imageSize << " ####";
<< " fileName:" << fileName
<< " fileIndex:" << fileIndex
<< " imageSize:" << imageSize << " ####";
return 0;
}
/** Acquisition Finished Call back */
void AcquisitionFinished(uint64_t framesCaught, void *objectPointer) {
LOG(sls::logINFOBLUE) << "#### AcquisitionFinished: framesCaught:"
<< framesCaught << " ####";
<< framesCaught << " ####";
}
/**
@ -70,7 +71,7 @@ void AcquisitionFinished(uint64_t framesCaught, void *objectPointer) {
* Prints in different colors(for each receiver process) the different headers
* for each image call back.
*/
void GetData(slsDetectorDefs::sls_receiver_header& header, char *dataPointer,
void GetData(slsDetectorDefs::sls_receiver_header &header, char *dataPointer,
size_t imageSize, void *objectPointer) {
slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
@ -101,7 +102,8 @@ void GetData(slsDetectorDefs::sls_receiver_header& header, char *dataPointer,
* @param modifiedImageSize new data size in bytes after the callback.
* This will be the size written/streamed. (only smaller value is allowed).
*/
void GetData(slsDetectorDefs::sls_receiver_header& header, char *dataPointer, size_t &modifiedImageSize, void *objectPointer) {
void GetData(slsDetectorDefs::sls_receiver_header &header, char *dataPointer,
size_t &modifiedImageSize, void *objectPointer) {
slsDetectorDefs::sls_detector_header detectorHeader = header.detHeader;
PRINT_IN_COLOR(

12
slsReceiverSoftware/src/Receiver.cpp
View File

@ -128,9 +128,11 @@ int64_t Receiver::getReceiverVersion() {
return tcpipInterface->getReceiverVersion();
}
void Receiver::registerCallBackStartAcquisition(
int (*func)(const std::string &, const std::string &, uint64_t, size_t, void *),
void *arg) {
void Receiver::registerCallBackStartAcquisition(int (*func)(const std::string &,
const std::string &,
uint64_t, size_t,
void *),
void *arg) {
tcpipInterface->registerCallBackStartAcquisition(func, arg);
}
@ -141,12 +143,12 @@ void Receiver::registerCallBackAcquisitionFinished(void (*func)(uint64_t,
}
void Receiver::registerCallBackRawDataReady(
void (*func)(sls_receiver_header&, char *, size_t, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t, void *), void *arg) {
tcpipInterface->registerCallBackRawDataReady(func, arg);
}
void Receiver::registerCallBackRawDataModifyReady(
void (*func)(sls_receiver_header&, char *, size_t &, void *), void *arg) {
void (*func)(sls_receiver_header &, char *, size_t &, void *), void *arg) {
tcpipInterface->registerCallBackRawDataModifyReady(func, arg);
}

4
slsReceiverSoftware/src/ThreadObject.cpp
View File

@ -25,8 +25,8 @@ ThreadObject::ThreadObject(int index, std::string type)
try {
threadObject = std::thread(&ThreadObject::RunningThread, this);
} catch (...) {
throw RuntimeError("Could not create " + type +
" thread with index " + std::to_string(index));
throw RuntimeError("Could not create " + type + " thread with index " +
std::to_string(index));
}
}

21
slsReceiverSoftware/src/receiver_defs.h
View File

@ -36,20 +36,22 @@ namespace sls {
// binary
#define FILE_BUFFER_SIZE (16 * 1024 * 1024) // 16mb
// fifo
// fifo
struct image_structure {
size_t size;
size_t firstIndex;
slsDetectorDefs::sls_receiver_header header;
char data[];
size_t size;
size_t firstIndex;
slsDetectorDefs::sls_receiver_header header;
char data[];
};
#define IMAGE_STRUCTURE_HEADER_SIZE (sizeof(size_t) + sizeof(size_t) + sizeof(slsDetectorDefs::sls_receiver_header))
#define IMAGE_STRUCTURE_HEADER_SIZE \
(sizeof(size_t) + sizeof(size_t) + \
sizeof(slsDetectorDefs::sls_receiver_header))
// hdf5
#define MAX_CHUNKED_IMAGES (1)
#define DATA_RANK (3)
#define PARA_RANK (1)
#define VDS_PARA_RANK (2)
#define DATA_RANK (3)
#define PARA_RANK (1)
#define VDS_PARA_RANK (2)
// parameters to calculate fifo depth
#define SAMPLE_TIME_IN_NS (100000000) // 100ms
@ -64,7 +66,6 @@ struct image_structure {
#define STREAMER_PRIORITY (10)
#define TCP_PRIORITY (10)
#ifdef HDF5C
#define DATASET_NAME "/data"
#endif