detectors/slsDetectorPackage
24
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-12-31 08:31:18 +01:00
Code Issues Actions Packages Releases Activity

Rxpointers (#504)

Browse Source 
* gui message doesnt show if it has a '>' symbol in error msg

* minor refactoring for readability (size_t calc fifo size)

* refactoring listening udp socket code: activated and datastream dont create udp sockets anyway, rc<=- should be discarded in any case

* wip

* refactoring memory structure access

* wip: bugfix write header + data to binary

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* portRoi no roi effecto on progress

* fail at receiver progress, wip

* segfaults for char pointer in struct

* reference to header to get header and data

* refactoring

* use const defined for size of header of fifo

* updated release notes

* remove pointer in callback for sls_receiver_header pointer

* rx same name arguments in constructors

* rx: same name arguments in constructor

* rx: removing the '_' suffix in class data members

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* diff undo for clang later

* wip

* Wip

* const string&
This commit is contained in:
Dhanya Thattil
2022-08-05 09:08:18 +02:00
committed by GitHub
parent 9ac8dab8af
commit 89e293cb5a
14 changed files with 491 additions and 514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

431
slsReceiverSoftware/src/Implementation.cpp
View File

@@ -66,20 +66,20 @@ void Implementation::SetThreadPriorities() {
void Implementation::SetupFifoStructure() {
fifo.clear();
for (int i = 0; i < numUDPInterfaces; ++i) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
size_t datasize = generalData->imageSize;
// veto data size
if (detType == GOTTHARD2 && i != 0) {
if (generalData->detType == GOTTHARD2 && i != 0) {
datasize = generalData->vetoImageSize;
}
datasize += IMAGE_STRUCTURE_HEADER_SIZE;
// create fifo structure
try {
fifo.push_back(sls::make_unique<Fifo>(i, datasize, fifoDepth));
fifo.push_back(sls::make_unique<Fifo>(i, datasize, generalData->fifoDepth));
} catch (...) {
fifo.clear();
fifoDepth = 0;
generalData->fifoDepth = 0;
throw RuntimeError(
"Could not allocate memory for fifo structure " +
std::to_string(i) + ". FifoDepth is now 0.");
@@ -93,11 +93,11 @@ void Implementation::SetupFifoStructure() {
dataStreamer[i]->SetFifo(fifo[i].get());
LOG(logINFO) << "Memory Allocated for Fifo " << i << ": "
<< (double)(datasize * (size_t)fifoDepth) /
<< (double)(datasize * (size_t)generalData->fifoDepth) /
(double)(1024 * 1024)
<< " MB";
}
LOG(logINFO) << numUDPInterfaces << " Fifo structure(s) reconstructed";
LOG(logINFO) << generalData->numUDPInterfaces << " Fifo structure(s) reconstructed";
}
/**************************************************
@@ -108,8 +108,7 @@ void Implementation::SetupFifoStructure() {
void Implementation::setDetectorType(const detectorType d) {
detType = d;
switch (detType) {
switch (d) {
case GOTTHARD:
case EIGER:
case JUNGFRAU:
@@ -128,7 +127,7 @@ void Implementation::setDetectorType(const detectorType d) {
generalData = nullptr;
// set detector specific variables
switch (detType) {
switch (d) {
case GOTTHARD:
generalData = new GotthardData();
break;
@@ -154,40 +153,18 @@ void Implementation::setDetectorType(const detectorType d) {
break;
}
framesPerFile = generalData->maxFramesPerFile;
fifoDepth = generalData->defaultFifoDepth;
numUDPInterfaces = generalData->numUDPInterfaces;
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
dynamicRange = generalData->dynamicRange;
tengigaEnable = generalData->tengigaEnable;
numberOfAnalogSamples = generalData->nAnalogSamples;
numberOfDigitalSamples = generalData->nDigitalSamples;
readoutType = generalData->readoutType;
adcEnableMaskOneGiga = generalData->adcEnableMaskOneGiga;
adcEnableMaskTenGiga = generalData->adcEnableMaskTenGiga;
detectorRoi = generalData->roi;
counterMask = generalData->counterMask;
SetLocalNetworkParameters();
SetupFifoStructure();
// create threads
for (int i = 0; i < numUDPInterfaces; ++i) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
try {
auto fifo_ptr = fifo[i].get();
listener.push_back(sls::make_unique<Listener>(
i, fifo_ptr, &status, &udpPortNum[i], &eth[i],
&udpSocketBufferSize, &actualUDPSocketBufferSize,
&framesPerFile, &frameDiscardMode, &silentMode));
int ctbAnalogDataBytes = 0;
if (detType == CHIPTESTBOARD) {
ctbAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &dataStreamEnable, &streamingFrequency,
&streamingTimerInMs, &streamingStartFnum, &framePadding,
&ctbDbitList, &ctbDbitOffset, &ctbAnalogDataBytes));
i, &status));
SetupListener(i);
dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
SetupDataProcessor(i);
} catch (...) {
listener.clear();
dataProcessor.clear();
@@ -197,31 +174,59 @@ void Implementation::setDetectorType(const detectorType d) {
}
}
// set up writer and callbacks
for (int i = 0; i != (int)listener.size(); ++i) {
listener[i]->SetGeneralData(generalData);
listener[i]->SetActivate(activated);
listener[i]->SetDetectorDatastream(detectorDataStream[i]);
}
for (const auto &it : dataProcessor) {
it->SetGeneralData(generalData);
it->SetActivate(activated);
}
SetThreadPriorities();
LOG(logDEBUG) << " Detector type set to " << ToString(d);
}
void Implementation::SetupListener(int i) {
listener[i]->SetFifo(fifo[i].get());
listener[i]->SetGeneralData(generalData);
listener[i]->SetUdpPortNumber(udpPortNum[i]);
listener[i]->SetEthernetInterface(eth[i]);
listener[i]->SetActivate(activated);
listener[i]->SetNoRoi(portRois[i].noRoi());
listener[i]->SetDetectorDatastream(detectorDataStream[i]);
listener[i]->SetFrameDiscardPolicy(frameDiscardMode);
listener[i]->SetSilentMode(silentMode);
}
void Implementation::SetupDataProcessor(int i) {
dataProcessor[i]->SetFifo(fifo[i].get());
dataProcessor[i]->SetGeneralData(generalData);
dataProcessor[i]->SetActivate(activated);
dataProcessor[i]->SetReceiverROI(portRois[i]);
dataProcessor[i]->SetDataStreamEnable(dataStreamEnable);
dataProcessor[i]->SetStreamingFrequency(streamingFrequency);
dataProcessor[i]->SetStreamingTimerInMs(streamingTimerInMs);
dataProcessor[i]->SetStreamingStartFnum(streamingStartFnum);
dataProcessor[i]->SetFramePadding(framePadding);
dataProcessor[i]->SetCtbDbitList(ctbDbitList);
dataProcessor[i]->SetCtbDbitOffset(ctbDbitOffset);
}
void Implementation::SetupDataStreamer(int i) {
dataStreamer[i]->SetFifo(fifo[i].get());
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(streamingPort, streamingSrcIP, streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(additionalJsonHeader);
dataStreamer[i]->SetFileIndex(fileIndex);
dataStreamer[i]->SetFlipRows(flipRows);
dataStreamer[i]->SetNumberofPorts(numPorts);
dataStreamer[i]->SetQuadEnable(quadEnable);
dataStreamer[i]->SetNumberofTotalFrames(numberOfTotalFrames);
}
slsDetectorDefs::xy Implementation::getDetectorSize() const {
return numModules;
}
const slsDetectorDefs::xy Implementation::GetPortGeometry() const {
xy portGeometry{1, 1};
if (detType == EIGER)
portGeometry.x = numUDPInterfaces;
else if (detType == JUNGFRAU)
portGeometry.y = numUDPInterfaces;
if (generalData->detType == EIGER)
portGeometry.x = generalData->numUDPInterfaces;
else if (generalData->detType == JUNGFRAU)
portGeometry.y = generalData->numUDPInterfaces;
return portGeometry;
}
@@ -283,14 +288,16 @@ bool Implementation::getSilentMode() const { return silentMode; }
void Implementation::setSilentMode(const bool i) {
silentMode = i;
for (const auto &it : listener)
it->SetSilentMode(silentMode);
LOG(logINFO) << "Silent Mode: " << i;
}
uint32_t Implementation::getFifoDepth() const { return fifoDepth; }
uint32_t Implementation::getFifoDepth() const { return generalData->fifoDepth; }
void Implementation::setFifoDepth(const uint32_t i) {
if (fifoDepth != i) {
fifoDepth = i;
if (generalData->fifoDepth != i) {
generalData->fifoDepth = i;
SetupFifoStructure();
}
LOG(logINFO) << "Fifo Depth: " << i;
@@ -303,6 +310,8 @@ Implementation::getFrameDiscardPolicy() const {
void Implementation::setFrameDiscardPolicy(const frameDiscardPolicy i) {
frameDiscardMode = i;
for (const auto &it : listener)
it->SetFrameDiscardPolicy(frameDiscardMode);
LOG(logINFO) << "Frame Discard Policy: " << ToString(frameDiscardMode);
}
@@ -310,6 +319,8 @@ bool Implementation::getFramePaddingEnable() const { return framePadding; }
void Implementation::setFramePaddingEnable(const bool i) {
framePadding = i;
for (const auto &it : dataProcessor)
it->SetFramePadding(framePadding);
LOG(logINFO) << "Frame Padding: " << framePadding;
}
@@ -330,7 +341,7 @@ std::array<pid_t, NUM_RX_THREAD_IDS> Implementation::getThreadIds() const {
} else {
retval[id++] = 0;
}
if (numUDPInterfaces == 2) {
if (generalData->numUDPInterfaces == 2) {
retval[id++] = listener[1]->GetThreadId();
retval[id++] = dataProcessor[1]->GetThreadId();
if (dataStreamEnable) {
@@ -354,9 +365,9 @@ void Implementation::setArping(const bool i,
arping.StopThread();
} else {
// setup interface
for (int i = 0; i != numUDPInterfaces; ++i) {
for (int i = 0; i != generalData->numUDPInterfaces; ++i) {
// ignore eiger with 2 interfaces (only udp port)
if (i == 1 && (numUDPInterfaces == 1 || detType == EIGER)) {
if (i == 1 && (generalData->numUDPInterfaces == 1 || generalData->detType == EIGER)) {
break;
}
arping.SetInterfacesAndIps(i, eth[i], ips[i]);
@@ -373,13 +384,13 @@ slsDetectorDefs::ROI Implementation::getReceiverROI() const {
void Implementation::setReceiverROI(const slsDetectorDefs::ROI arg) {
receiverRoi = arg;
if (numUDPInterfaces == 1 || detType == slsDetectorDefs::GOTTHARD2) {
if (generalData->numUDPInterfaces == 1 || generalData->detType == slsDetectorDefs::GOTTHARD2) {
portRois[0] = arg;
} else {
slsDetectorDefs::xy nPortDim(generalData->nPixelsX,
generalData->nPixelsY);
for (int iPort = 0; iPort != numUDPInterfaces; ++iPort) {
for (int iPort = 0; iPort != generalData->numUDPInterfaces; ++iPort) {
// default init = complete roi
slsDetectorDefs::ROI portRoi{};
@@ -443,7 +454,7 @@ 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 (numUDPInterfaces == 2 && detType != slsDetectorDefs::GOTTHARD2) {
if (generalData->numUDPInterfaces == 2 && generalData->detType != slsDetectorDefs::GOTTHARD2) {
LOG(logINFO) << "port rois: " << ToString(portRois);
}
}
@@ -504,6 +515,8 @@ uint64_t Implementation::getFileIndex() const { return fileIndex; }
void Implementation::setFileIndex(const uint64_t i) {
fileIndex = i;
for (const auto &it : dataStreamer)
it->SetFileIndex(fileIndex);
LOG(logINFO) << "File Index: " << fileIndex;
}
@@ -539,11 +552,11 @@ void Implementation::setOverwriteEnable(const bool b) {
<< (overwriteEnable ? "enabled" : "disabled");
}
uint32_t Implementation::getFramesPerFile() const { return framesPerFile; }
uint32_t Implementation::getFramesPerFile() const { return generalData->framesPerFile; }
void Implementation::setFramesPerFile(const uint32_t i) {
framesPerFile = i;
LOG(logINFO) << "Frames per file: " << framesPerFile;
generalData->framesPerFile = i;
LOG(logINFO) << "Frames per file: " << generalData->framesPerFile;
}
/**************************************************
@@ -554,7 +567,7 @@ void Implementation::setFramesPerFile(const uint32_t i) {
slsDetectorDefs::runStatus Implementation::getStatus() const { return status; }
std::vector<int64_t> Implementation::getFramesCaught() const {
std::vector<int64_t> numFramesCaught(numUDPInterfaces);
std::vector<int64_t> numFramesCaught(generalData->numUDPInterfaces);
int index = 0;
for (const auto &it : listener) {
if (it->GetStartedFlag()) {
@@ -566,7 +579,7 @@ std::vector<int64_t> Implementation::getFramesCaught() const {
}
std::vector<int64_t> Implementation::getCurrentFrameIndex() const {
std::vector<int64_t> frameIndex(numUDPInterfaces);
std::vector<int64_t> frameIndex(generalData->numUDPInterfaces);
int index = 0;
for (const auto &it : listener) {
if (it->GetStartedFlag()) {
@@ -611,8 +624,8 @@ double Implementation::getProgress() const {
}
std::vector<int64_t> Implementation::getNumMissingPackets() const {
std::vector<int64_t> mp(numUDPInterfaces);
for (int i = 0; i < numUDPInterfaces; ++i) {
std::vector<int64_t> mp(generalData->numUDPInterfaces);
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
int np = generalData->packetsPerFrame;
uint64_t totnp = np;
// ReadNRows
@@ -716,7 +729,7 @@ void Implementation::stopReceiver() {
auto mp = getNumMissingPackets();
// print summary
uint64_t tot = 0;
for (int i = 0; i < numUDPInterfaces; i++) {
for (int i = 0; i < generalData->numUDPInterfaces; i++) {
int nf = listener[i]->GetNumCompleteFramesCaught();
tot += nf;
std::string mpMessage = std::to_string(mp[i]);
@@ -750,7 +763,7 @@ void Implementation::stopReceiver() {
// callback
if (acquisitionFinishedCallBack) {
try {
acquisitionFinishedCallBack((tot / numUDPInterfaces),
acquisitionFinishedCallBack((tot / generalData->numUDPInterfaces),
pAcquisitionFinished);
} catch (const std::exception &e) {
// change status
@@ -836,7 +849,7 @@ void Implementation::ResetParametersforNewAcquisition() {
void Implementation::CreateUDPSockets() {
try {
for (unsigned int i = 0; i < listener.size(); ++i) {
listener[i]->CreateUDPSockets();
listener[i]->CreateUDPSocket(actualUDPSocketBufferSize);
}
} catch (const RuntimeError &e) {
shutDownUDPSockets();
@@ -848,10 +861,12 @@ void Implementation::CreateUDPSockets() {
void Implementation::SetupWriter() {
try {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
std::ostringstream os;
os << filePath << "/" << fileName << "_d" << (modulePos * generalData->numUDPInterfaces + i);
std::string fileNamePrefix = os.str();
dataProcessor[i]->CreateFirstFiles(
filePath, fileName, fileIndex, overwriteEnable, silentMode,
modulePos, numUDPInterfaces, udpPortNum[i], framesPerFile,
numberOfTotalFrames, dynamicRange, detectorDataStream[i]);
fileNamePrefix, fileIndex, overwriteEnable, silentMode,
udpPortNum[i], numberOfTotalFrames, detectorDataStream[i]);
}
} catch (const RuntimeError &e) {
shutDownUDPSockets();
@@ -867,13 +882,13 @@ void Implementation::StartMasterWriter() {
// master file
if (masterFileWriteEnable) {
MasterAttributes masterAttributes;
masterAttributes.detType = detType;
masterAttributes.detType = generalData->detType;
masterAttributes.timingMode = timingMode;
masterAttributes.geometry = numPorts;
masterAttributes.imageSize = generalData->imageSize;
masterAttributes.nPixels =
xy(generalData->nPixelsX, generalData->nPixelsY);
masterAttributes.maxFramesPerFile = framesPerFile;
masterAttributes.maxFramesPerFile = generalData->framesPerFile;
masterAttributes.frameDiscardMode = frameDiscardMode;
masterAttributes.framePadding = framePadding;
masterAttributes.scanParams = scanParams;
@@ -883,9 +898,9 @@ void Implementation::StartMasterWriter() {
masterAttributes.exptime = acquisitionTime;
masterAttributes.period = acquisitionPeriod;
masterAttributes.burstMode = burstMode;
masterAttributes.numUDPInterfaces = numUDPInterfaces;
masterAttributes.dynamicRange = dynamicRange;
masterAttributes.tenGiga = tengigaEnable;
masterAttributes.numUDPInterfaces = generalData->numUDPInterfaces;
masterAttributes.dynamicRange = generalData->dynamicRange;
masterAttributes.tenGiga = generalData->tengigaEnable;
masterAttributes.thresholdEnergyeV = thresholdEnergyeV;
masterAttributes.thresholdAllEnergyeV = thresholdAllEnergyeV;
masterAttributes.subExptime = subExpTime;
@@ -894,24 +909,24 @@ void Implementation::StartMasterWriter() {
masterAttributes.readNRows = readNRows;
masterAttributes.ratecorr = rateCorrections;
masterAttributes.adcmask =
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga;
masterAttributes.analog = (readoutType == ANALOG_ONLY ||
readoutType == ANALOG_AND_DIGITAL)
generalData->tengigaEnable ? generalData->adcEnableMaskTenGiga : generalData->adcEnableMaskOneGiga;
masterAttributes.analog = (generalData->readoutType == ANALOG_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.analogSamples = numberOfAnalogSamples;
masterAttributes.digital = (readoutType == DIGITAL_ONLY ||
readoutType == ANALOG_AND_DIGITAL)
masterAttributes.analogSamples = generalData->nAnalogSamples;
masterAttributes.digital = (generalData->readoutType == DIGITAL_ONLY ||
generalData->readoutType == ANALOG_AND_DIGITAL)
? 1
: 0;
masterAttributes.digitalSamples = numberOfDigitalSamples;
masterAttributes.digitalSamples = generalData->nDigitalSamples;
masterAttributes.dbitoffset = ctbDbitOffset;
masterAttributes.dbitlist = 0;
for (auto &i : ctbDbitList) {
masterAttributes.dbitlist |= (1 << i);
}
masterAttributes.detectorRoi = detectorRoi;
masterAttributes.counterMask = counterMask;
masterAttributes.detectorRoi = generalData->detectorRoi;
masterAttributes.counterMask = generalData->counterMask;
masterAttributes.exptimeArray[0] = acquisitionTime1;
masterAttributes.exptimeArray[1] = acquisitionTime2;
masterAttributes.exptimeArray[2] = acquisitionTime3;
@@ -935,9 +950,8 @@ void Implementation::StartMasterWriter() {
virtualFileName =
dataProcessor[0]->CreateVirtualFile(
filePath, fileName, fileIndex, overwriteEnable,
silentMode, modulePos, numUDPInterfaces, framesPerFile,
numberOfTotalFrames, numPorts.x, numPorts.y,
dynamicRange, &hdf5LibMutex);
silentMode, modulePos, numberOfTotalFrames, numPorts.x, numPorts.y,
&hdf5LibMutex);
}
// link file in master
if (masterFileWriteEnable) {
@@ -976,17 +990,17 @@ void Implementation::StartRunning() {
* *
* ************************************************/
int Implementation::getNumberofUDPInterfaces() const {
return numUDPInterfaces;
return generalData->numUDPInterfaces;
}
// not Eiger
void Implementation::setNumberofUDPInterfaces(const int n) {
if (detType == EIGER) {
if (generalData->detType == EIGER) {
throw RuntimeError(
"Cannot set number of UDP interfaces for Eiger");
}
if (numUDPInterfaces != n) {
if (generalData->numUDPInterfaces != n) {
// clear all threads and fifos
listener.clear();
dataProcessor.clear();
@@ -995,41 +1009,22 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
// set local variables
generalData->SetNumberofInterfaces(n);
numUDPInterfaces = n;
generalData->numUDPInterfaces = n;
// fifo
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
SetupFifoStructure();
// recalculate port rois
setReceiverROI(receiverRoi);
// create threads
for (int i = 0; i < numUDPInterfaces; ++i) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
// listener and dataprocessor threads
try {
auto fifo_ptr = fifo[i].get();
listener.push_back(sls::make_unique<Listener>(
i, fifo_ptr, &status, &udpPortNum[i], &eth[i],
&udpSocketBufferSize, &actualUDPSocketBufferSize,
&framesPerFile, &frameDiscardMode, &silentMode));
listener[i]->SetGeneralData(generalData);
listener[i]->SetActivate(activated);
listener[i]->SetNoRoi(portRois[i].noRoi());
listener[i]->SetDetectorDatastream(detectorDataStream[i]);
int ctbAnalogDataBytes = 0;
if (detType == CHIPTESTBOARD) {
ctbAnalogDataBytes =
generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs,
&streamingStartFnum, &framePadding, &ctbDbitList,
&ctbDbitOffset, &ctbAnalogDataBytes));
dataProcessor[i]->SetGeneralData(generalData);
dataProcessor[i]->SetActivate(activated);
dataProcessor[i]->SetReceiverROI(portRois[i]);
i, &status));
SetupListener(i);
dataProcessor.push_back(sls::make_unique<DataProcessor>(i));
SetupDataProcessor(i);
} catch (...) {
listener.clear();
dataProcessor.clear();
@@ -1037,27 +1032,18 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
"Could not create listener/dataprocessor threads (index:" +
std::to_string(i) + ")");
}
// streamer threads
if (dataStreamEnable) {
try {
bool flip = flipRows;
if (quadEnable) {
flip = (i == 1 ? true : false);
}
dataStreamer.push_back(sls::make_unique<DataStreamer>(
i, fifo[i].get(), &dynamicRange, &detectorRoi,
&fileIndex, flip, numPorts, &quadEnable,
&numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(
&numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader);
dataStreamer.push_back(sls::make_unique<DataStreamer>(i));
SetupDataStreamer(i);
} catch (...) {
if (dataStreamEnable) {
dataStreamer.clear();
dataStreamEnable = false;
for (const auto &it : dataProcessor)
it->SetDataStreamEnable(dataStreamEnable);
}
throw RuntimeError(
"Could not create datastreamer threads (index:" +
@@ -1089,13 +1075,14 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
setUDPSocketBufferSize(0);
}
LOG(logINFO) << "Number of Interfaces: " << numUDPInterfaces;
LOG(logINFO) << "Number of Interfaces: " << generalData->numUDPInterfaces;
}
std::string Implementation::getEthernetInterface() const { return eth[0]; }
void Implementation::setEthernetInterface(const std::string &c) {
eth[0] = c;
listener[0]->SetEthernetInterface(c);
LOG(logINFO) << "Ethernet Interface: " << eth[0];
}
@@ -1103,6 +1090,9 @@ std::string Implementation::getEthernetInterface2() const { return eth[1]; }
void Implementation::setEthernetInterface2(const std::string &c) {
eth[1] = c;
if (listener.size() > 1) {
listener[1]->SetEthernetInterface(c);
}
LOG(logINFO) << "Ethernet Interface 2: " << eth[1];
}
@@ -1110,6 +1100,7 @@ uint32_t Implementation::getUDPPortNumber() const { return udpPortNum[0]; }
void Implementation::setUDPPortNumber(const uint32_t i) {
udpPortNum[0] = i;
listener[0]->SetUdpPortNumber(i);
LOG(logINFO) << "UDP Port Number[0]: " << udpPortNum[0];
}
@@ -1117,32 +1108,27 @@ uint32_t Implementation::getUDPPortNumber2() const { return udpPortNum[1]; }
void Implementation::setUDPPortNumber2(const uint32_t i) {
udpPortNum[1] = i;
if (listener.size() > 1) {
listener[1]->SetUdpPortNumber(i);
}
LOG(logINFO) << "UDP Port Number[1]: " << udpPortNum[1];
}
int Implementation::getUDPSocketBufferSize() const {
return udpSocketBufferSize;
return generalData->udpSocketBufferSize;
}
void Implementation::setUDPSocketBufferSize(const int s) {
// custom setup is not 0 (must complain if set up didnt work)
// testing default setup at startup, argument is 0 to use default values
int size = (s == 0) ? udpSocketBufferSize : s;
size_t listSize = listener.size();
if ((detType == JUNGFRAU || detType == GOTTHARD2) &&
(int)listSize != numUDPInterfaces) {
if ((generalData->detType == JUNGFRAU || generalData->detType == GOTTHARD2) &&
(int)listSize != generalData->numUDPInterfaces) {
throw RuntimeError(
"Number of Interfaces " + std::to_string(numUDPInterfaces) +
"Number of Interfaces " + std::to_string(generalData->numUDPInterfaces) +
" do not match listener size " + std::to_string(listSize));
}
for (auto &l : listener) {
l->CreateDummySocketForUDPSocketBufferSize(size);
}
// custom and didnt set, throw error
if (s != 0 && udpSocketBufferSize != s) {
throw RuntimeError("Could not set udp socket buffer size. (No "
"CAP_NET_ADMIN privileges?)");
l->CreateDummySocketForUDPSocketBufferSize(s, actualUDPSocketBufferSize);
}
}
@@ -1165,31 +1151,23 @@ void Implementation::setDataStreamEnable(const bool enable) {
dataStreamer.clear();
if (enable) {
for (int i = 0; i < numUDPInterfaces; ++i) {
for (int i = 0; i < generalData->numUDPInterfaces; ++i) {
try {
bool flip = flipRows;
if (quadEnable) {
flip = (i == 1 ? true : false);
}
dataStreamer.push_back(sls::make_unique<DataStreamer>(
i, fifo[i].get(), &dynamicRange, &detectorRoi,
&fileIndex, flip, numPorts, &quadEnable,
&numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(
&numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader);
dataStreamer.push_back(sls::make_unique<DataStreamer>(i));
SetupDataStreamer(i);
} catch (...) {
dataStreamer.clear();
dataStreamEnable = false;
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);
}
LOG(logINFO) << "Data Send to Gui: " << dataStreamEnable;
}
@@ -1200,6 +1178,8 @@ uint32_t Implementation::getStreamingFrequency() const {
void Implementation::setStreamingFrequency(const uint32_t freq) {
streamingFrequency = freq;
for (const auto &it : dataProcessor)
it->SetStreamingFrequency(streamingFrequency);
LOG(logINFO) << "Streaming Frequency: " << streamingFrequency;
}
@@ -1209,6 +1189,8 @@ uint32_t Implementation::getStreamingTimer() const {
void Implementation::setStreamingTimer(const uint32_t time_in_ms) {
streamingTimerInMs = time_in_ms;
for (const auto &it : dataProcessor)
it->SetStreamingTimerInMs(streamingTimerInMs);
LOG(logINFO) << "Streamer Timer: " << streamingTimerInMs;
}
@@ -1218,6 +1200,8 @@ uint32_t Implementation::getStreamingStartingFrameNumber() const {
void Implementation::setStreamingStartingFrameNumber(const uint32_t fnum) {
streamingStartFnum = fnum;
for (const auto &it : dataProcessor)
it->SetStreamingStartFnum(streamingStartFnum);
LOG(logINFO) << "Streaming Start Frame num: " << streamingStartFnum;
}
@@ -1313,7 +1297,7 @@ void Implementation::updateTotalNumberOfFrames() {
int64_t repeats = numberOfTriggers;
int64_t numFrames = numberOfFrames;
// gotthard2
if (detType == GOTTHARD2) {
if (generalData->detType == GOTTHARD2) {
// auto
if (timingMode == AUTO_TIMING) {
// burst mode, repeats = #bursts
@@ -1336,6 +1320,8 @@ void Implementation::updateTotalNumberOfFrames() {
}
numberOfTotalFrames =
numFrames * repeats * (int64_t)(numberOfAdditionalStorageCells + 1);
for (const auto &it : dataStreamer)
it->SetNumberofTotalFrames(numberOfTotalFrames);
if (numberOfTotalFrames == 0) {
throw RuntimeError("Invalid total number of frames to receive: 0");
}
@@ -1475,91 +1461,77 @@ void Implementation::setSubPeriod(const ns i) {
}
uint32_t Implementation::getNumberofAnalogSamples() const {
return numberOfAnalogSamples;
return generalData->nAnalogSamples;
}
void Implementation::setNumberofAnalogSamples(const uint32_t i) {
if (numberOfAnalogSamples != i) {
numberOfAnalogSamples = i;
if ( generalData->nAnalogSamples != i) {
generalData->SetNumberOfAnalogSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Analog Samples: " << numberOfAnalogSamples;
LOG(logINFO) << "Number of Analog Samples: " << generalData->nAnalogSamples;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getNumberofDigitalSamples() const {
return numberOfDigitalSamples;
return generalData->nDigitalSamples;
}
void Implementation::setNumberofDigitalSamples(const uint32_t i) {
if (numberOfDigitalSamples != i) {
numberOfDigitalSamples = i;
if ( generalData->nDigitalSamples != i) {
generalData->SetNumberOfDigitalSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Digital Samples: " << numberOfDigitalSamples;
LOG(logINFO) << "Number of Digital Samples: " << generalData->nDigitalSamples;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getCounterMask() const { return counterMask; }
uint32_t Implementation::getCounterMask() const { return generalData->counterMask; }
void Implementation::setCounterMask(const uint32_t i) {
if (counterMask != i) {
if (generalData->counterMask != i) {
generalData->SetCounterMask(i);
counterMask = i;
SetupFifoStructure();
}
LOG(logINFO) << "Counter mask: " << ToStringHex(counterMask);
int ncounters = __builtin_popcount(counterMask);
LOG(logINFO) << "Counter mask: " << ToStringHex(generalData->counterMask);
int ncounters = __builtin_popcount(generalData->counterMask);
LOG(logINFO) << "Number of counters: " << ncounters;
}
uint32_t Implementation::getDynamicRange() const { return dynamicRange; }
uint32_t Implementation::getDynamicRange() const { return generalData->dynamicRange; }
void Implementation::setDynamicRange(const uint32_t i) {
if (dynamicRange != i) {
dynamicRange = i;
if (detType == EIGER || detType == MYTHEN3) {
if (generalData->dynamicRange != i) {
if (generalData->detType == EIGER || generalData->detType == MYTHEN3) {
generalData->SetDynamicRange(i);
fifoDepth = generalData->defaultFifoDepth;
SetupFifoStructure();
}
}
LOG(logINFO) << "Dynamic Range: " << dynamicRange;
LOG(logINFO) << "Dynamic Range: " << generalData->dynamicRange;
}
slsDetectorDefs::ROI Implementation::getROI() const { return detectorRoi; }
slsDetectorDefs::ROI Implementation::getROI() const { return generalData->detectorRoi; }
void Implementation::setDetectorROI(slsDetectorDefs::ROI arg) {
if (detectorRoi.xmin != arg.xmin || detectorRoi.xmax != arg.xmax) {
detectorRoi.xmin = arg.xmin;
detectorRoi.xmax = arg.xmax;
if (generalData->detectorRoi.xmin != arg.xmin || generalData->detectorRoi.xmax != arg.xmax) {
// only for gotthard
generalData->SetDetectorROI(arg);
framesPerFile = generalData->maxFramesPerFile;
SetupFifoStructure();
}
LOG(logINFO) << "Detector ROI: " << ToString(detectorRoi);
LOG(logINFO) << "Detector ROI: " << ToString(generalData->detectorRoi);
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
bool Implementation::getTenGigaEnable() const { return tengigaEnable; }
bool Implementation::getTenGigaEnable() const { return generalData->tengigaEnable; }
void Implementation::setTenGigaEnable(const bool b) {
if (tengigaEnable != b) {
tengigaEnable = b;
if ( generalData->tengigaEnable != b) {
generalData->SetTenGigaEnable(b);
SetupFifoStructure();
// datastream can be disabled/enabled only for Eiger 10GbE
if (detType == EIGER) {
if (generalData->detType == EIGER) {
if (!b) {
detectorDataStream[LEFT] = 1;
detectorDataStream[RIGHT] = 1;
@@ -1573,7 +1545,7 @@ void Implementation::setTenGigaEnable(const bool b) {
<< ToString(detectorDataStream[RIGHT]) << "]";
}
}
LOG(logINFO) << "Ten Giga: " << (tengigaEnable ? "enabled" : "disabled");
LOG(logINFO) << "Ten Giga: " << ( generalData->tengigaEnable ? "enabled" : "disabled");
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
@@ -1581,19 +1553,8 @@ bool Implementation::getFlipRows() const { return flipRows; }
void Implementation::setFlipRows(bool enable) {
flipRows = enable;
if (!quadEnable) {
for (const auto &it : dataStreamer) {
it->SetFlipRows(flipRows);
}
}
// quad
else {
if (dataStreamer.size() == 2) {
dataStreamer[0]->SetFlipRows(false);
dataStreamer[1]->SetFlipRows(true);
}
}
for (const auto &it : dataStreamer)
it->SetFlipRows(flipRows);
LOG(logINFO) << "Flip Rows: " << flipRows;
}
@@ -1603,15 +1564,9 @@ void Implementation::setQuad(const bool b) {
if (quadEnable != b) {
quadEnable = b;
setDetectorSize(numModules);
if (!quadEnable) {
for (const auto &it : dataStreamer) {
it->SetFlipRows(flipRows);
}
} else {
if (dataStreamer.size() == 2) {
dataStreamer[0]->SetFlipRows(false);
dataStreamer[1]->SetFlipRows(true);
}
for (const auto &it : dataStreamer) {
it->SetQuadEnable(quadEnable);
it->SetFlipRows(flipRows);
}
}
LOG(logINFO) << "Quad Enable: " << quadEnable;
@@ -1641,7 +1596,7 @@ void Implementation::setDetectorDataStream(const portPosition port,
LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port)
<< " Port): " << ToString(detectorDataStream10GbE[index]);
// update datastream for 10g
if (tengigaEnable) {
if ( generalData->tengigaEnable) {
detectorDataStream[index] = detectorDataStream10GbE[index];
LOG(logDEBUG) << "Detector datastream updated ["
<< (index == 0 ? "Left" : "Right")
@@ -1673,59 +1628,63 @@ void Implementation::setRateCorrections(const std::vector<int64_t> &t) {
}
slsDetectorDefs::readoutMode Implementation::getReadoutMode() const {
return readoutType;
return generalData->readoutType;
}
void Implementation::setReadoutMode(const readoutMode f) {
if (readoutType != f) {
readoutType = f;
if (generalData->readoutType != f) {
generalData->SetReadoutMode(f);
SetupFifoStructure();
}
LOG(logINFO) << "Readout Mode: " << ToString(f);
LOG(logINFO) << "Readout Mode: " << ToString(generalData->readoutType);
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getADCEnableMask() const {
return adcEnableMaskOneGiga;
return generalData->adcEnableMaskOneGiga;
}
void Implementation::setADCEnableMask(uint32_t mask) {
if (adcEnableMaskOneGiga != mask) {
adcEnableMaskOneGiga = mask;
if (generalData->adcEnableMaskOneGiga != mask) {
generalData->SetOneGigaAdcEnableMask(mask);
SetupFifoStructure();
}
LOG(logINFO) << "ADC Enable Mask for 1Gb mode: 0x" << std::hex
<< adcEnableMaskOneGiga << std::dec;
<< generalData->adcEnableMaskOneGiga << std::dec;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
uint32_t Implementation::getTenGigaADCEnableMask() const {
return adcEnableMaskTenGiga;
return generalData->adcEnableMaskTenGiga;
}
void Implementation::setTenGigaADCEnableMask(uint32_t mask) {
if (adcEnableMaskTenGiga != mask) {
adcEnableMaskTenGiga = mask;
if (generalData->adcEnableMaskTenGiga != mask) {
generalData->SetTenGigaAdcEnableMask(mask);
SetupFifoStructure();
}
LOG(logINFO) << "ADC Enable Mask for 10Gb mode: 0x" << std::hex
<< adcEnableMaskTenGiga << std::dec;
<< generalData->adcEnableMaskTenGiga << std::dec;
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
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);
}
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;
}
/**************************************************
* *