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

gotthard2 with veto data on second interface

Browse Source
This commit is contained in:
maliakal_d
2020-05-13 17:50:18 +02:00
parent e730c124e3
commit eea67014b7
17 changed files with 455 additions and 379 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -394,7 +394,7 @@ int ClientInterface::setup_receiver(Interface &socket) {
}
impl()->setUDPPortNumber(arg.udp_dstport);
impl()->setUDPPortNumber2(arg.udp_dstport2);
if (myDetectorType == JUNGFRAU) {
if (myDetectorType == JUNGFRAU || myDetectorType == GOTTHARD2) {
try {
impl()->setNumberofUDPInterfaces(arg.udpInterfaces);
} catch (const RuntimeError &e) {
@ -1531,7 +1531,7 @@ sls::MacAddr ClientInterface::setUdpIp2(sls::IpAddr arg) {
int ClientInterface::set_udp_ip2(Interface &socket) {
auto arg = socket.Receive<sls::IpAddr>();
verifyIdle(socket);
if (myDetectorType != JUNGFRAU) {
if (myDetectorType != JUNGFRAU && myDetectorType != GOTTHARD2) {
throw RuntimeError(
"UDP Destination IP2 not implemented for this detector");
}
@ -1552,7 +1552,8 @@ int ClientInterface::set_udp_port(Interface &socket) {
int ClientInterface::set_udp_port2(Interface &socket) {
auto arg = socket.Receive<int>();
verifyIdle(socket);
if (myDetectorType != JUNGFRAU && myDetectorType != EIGER) {
if (myDetectorType != JUNGFRAU && myDetectorType != EIGER &&
myDetectorType != GOTTHARD2) {
throw RuntimeError(
"UDP Destination Port2 not implemented for this detector");
}
@ -1565,7 +1566,7 @@ int ClientInterface::set_num_interfaces(Interface &socket) {
auto arg = socket.Receive<int>();
arg = (arg > 1 ? 2 : 1);
verifyIdle(socket);
if (myDetectorType != JUNGFRAU) {
if (myDetectorType != JUNGFRAU && myDetectorType != GOTTHARD2) {
throw RuntimeError(
"Number of interfaces not implemented for this detector");
}

4
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -74,7 +74,6 @@ void DataProcessor::RecordFirstIndex(uint64_t fnum) {
void DataProcessor::SetGeneralData(GeneralData *g) {
generalData = g;
generalData->Print();
if (file != nullptr) {
if (file->GetFileType() == HDF5) {
file->SetNumberofPixels(generalData->nPixelsX,
@ -352,6 +351,9 @@ void DataProcessor::PadMissingPackets(char *buf) {
sls_bitset pmask = header->packetsMask;
uint32_t dsize = generalData->dataSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
dsize = generalData->vetoDataSize;
}
uint32_t fifohsize = generalData->fifoBufferHeaderSize;
uint32_t corrected_dsize =
dsize - ((pperFrame * dsize) - generalData->imageSize);

12
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -41,10 +41,8 @@ void DataStreamer::ResetParametersforNewAcquisition(const std::string &fname) {
delete[] completeBuffer;
completeBuffer = nullptr;
}
if (roi->xmin != -1) {
if (generalData->myDetectorType == GOTTHARD) {
adcConfigured = generalData->GetAdcConfigured(index, *roi);
}
if (generalData->myDetectorType == GOTTHARD && roi->xmin != -1) {
adcConfigured = generalData->GetAdcConfigured(index, *roi);
completeBuffer = new char[generalData->imageSizeComplete];
memset(completeBuffer, 0, generalData->imageSizeComplete);
}
@ -57,10 +55,7 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum) {
LOG(logDEBUG1) << index << " First Index: " << firstIndex;
}
void DataStreamer::SetGeneralData(GeneralData *g) {
generalData = g;
generalData->Print();
}
void DataStreamer::SetGeneralData(GeneralData *g) { generalData = g; }
void DataStreamer::SetNumberofDetectors(int *nd) {
numDet[0] = nd[0];
@ -147,7 +142,6 @@ void DataStreamer::ProcessAnImage(char *buf) {
// shortframe gotthard
if (completeBuffer) {
// disregarding the size modified from callback (always using
// imageSizeComplete
// instead of buf (32 bit) because gui needs imagesizecomplete and

150
slsReceiverSoftware/src/GeneralData.h
View File

@ -17,86 +17,41 @@
class GeneralData {
public:
/** DetectorType */
slsDetectorDefs::detectorType myDetectorType;
/** Number of Pixels in x axis */
uint32_t nPixelsX;
/** Number of Pixels in y axis */
uint32_t nPixelsY;
/** Size of header in Packet */
uint32_t headerSizeinPacket;
slsDetectorDefs::detectorType myDetectorType{slsDetectorDefs::GENERIC};
uint32_t nPixelsX{0};
uint32_t nPixelsY{0};
uint32_t headerSizeinPacket{0};
/** Size of just data in 1 packet (in bytes) */
uint32_t dataSize;
/** Size of 1 packet (in bytes) */
uint32_t packetSize;
uint32_t dataSize{0};
uint32_t packetSize{0};
/** Number of packets in an image (for each listening UDP port) */
uint32_t packetsPerFrame;
uint32_t packetsPerFrame{0};
/** Image size (in bytes, for each listening UDP port) */
uint32_t imageSize;
/** Frame Number Mask */
uint64_t frameIndexMask;
/** Frame Index Offset */
uint32_t frameIndexOffset;
/** Packet Index Mask */
uint32_t packetIndexMask;
/** Packet Index Offset */
uint32_t packetIndexOffset;
/** Max Frames per binary file */
uint32_t maxFramesPerFile;
uint32_t imageSize{0};
uint64_t frameIndexMask{0};
uint32_t frameIndexOffset{0};
uint32_t packetIndexMask{0};
uint32_t packetIndexOffset{0};
uint32_t maxFramesPerFile{0};
/** Header size of data saved into fifo buffer at a time*/
uint32_t fifoBufferHeaderSize;
/** Default Fifo depth */
uint32_t defaultFifoDepth;
/** Threads per receiver */
uint32_t threadsPerReceiver;
/** Size of a header packet */
uint32_t headerPacketSize;
/** Streaming (for ROI - mainly short Gotthard) - Number of Pixels in x axis
*/
uint32_t nPixelsXComplete;
/** Streaming (for ROI - mainly short Gotthard) - Number of Pixels in y axis
*/
uint32_t nPixelsYComplete;
uint32_t fifoBufferHeaderSize{0};
uint32_t defaultFifoDepth{0};
uint32_t threadsPerReceiver{1};
uint32_t headerPacketSize{0};
/** Streaming (for ROI - mainly short Gotthard) */
uint32_t nPixelsXComplete{0};
/** Streaming (for ROI - mainly short Gotthard) */
uint32_t nPixelsYComplete{0};
/** Streaming (for ROI - mainly short Gotthard) - Image size (in bytes) */
uint32_t imageSizeComplete;
uint32_t imageSizeComplete{0};
/** if standard header implemented in firmware */
bool standardheader;
bool standardheader{false};
uint32_t defaultUdpSocketBufferSize{RECEIVE_SOCKET_BUFFER_SIZE};
uint32_t vetoDataSize{0};
uint32_t vetoPacketSize{0};
uint32_t vetoImageSize{0};
/** default udp socket buffer size */
uint32_t defaultUdpSocketBufferSize;
/** Cosntructor */
GeneralData()
: myDetectorType(slsDetectorDefs::GENERIC), nPixelsX(0), nPixelsY(0),
headerSizeinPacket(0), dataSize(0), packetSize(0), packetsPerFrame(0),
imageSize(0), frameIndexMask(0), frameIndexOffset(0),
packetIndexMask(0), packetIndexOffset(0), maxFramesPerFile(0),
fifoBufferHeaderSize(0), defaultFifoDepth(0), threadsPerReceiver(1),
headerPacketSize(0), nPixelsXComplete(0), nPixelsYComplete(0),
imageSizeComplete(0), standardheader(false),
defaultUdpSocketBufferSize(RECEIVE_SOCKET_BUFFER_SIZE){};
/** Destructor */
GeneralData(){};
virtual ~GeneralData(){};
/**
@ -203,35 +158,6 @@ class GeneralData {
LOG(logERROR) << "SetNumberofCounters is a generic function that "
"should be overloaded by a derived class";
}
/**
* Print all variables
*/
virtual void Print(TLogLevel level = logDEBUG1) const {
LOG(level) << "\n\nDetector Data Variables:";
LOG(level) << "myDetectorType: " << sls::ToString(myDetectorType);
LOG(level) << "Pixels X: " << nPixelsX;
LOG(level) << "Pixels Y: " << nPixelsY;
LOG(level) << "Header Size in Packet: " << headerSizeinPacket;
LOG(level) << "Data Size: " << dataSize;
LOG(level) << "Packet Size: " << packetSize;
LOG(level) << "Packets per Frame: " << packetsPerFrame;
LOG(level) << "Image Size: " << imageSize;
LOG(level) << "Frame Index Mask: " << frameIndexMask;
LOG(level) << "Frame Index Offset: " << frameIndexOffset;
LOG(level) << "Packet Index Mask: " << packetIndexMask;
LOG(level) << "Packet Index Offset: " << packetIndexOffset;
LOG(level) << "Max Frames Per File: " << maxFramesPerFile;
LOG(level) << "Fifo Buffer Header Size: " << fifoBufferHeaderSize;
LOG(level) << "Default Fifo Depth: " << defaultFifoDepth;
LOG(level) << "Threads Per Receiver: " << threadsPerReceiver;
LOG(level) << "Header Packet Size: " << headerPacketSize;
LOG(level) << "Complete Pixels X: " << nPixelsXComplete;
LOG(level) << "Complete Pixels Y: " << nPixelsYComplete;
LOG(level) << "Complete Image Size: " << imageSizeComplete;
LOG(level) << "Standard Header: " << standardheader;
LOG(level) << "UDP Socket Buffer Size: " << defaultUdpSocketBufferSize;
};
};
class GotthardData : public GeneralData {
@ -475,7 +401,7 @@ class JungfrauData : public GeneralData {
threadsPerReceiver = 1;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
}
}
};
};
class Mythen3Data : public GeneralData {
@ -561,6 +487,24 @@ class Gotthard2Data : public GeneralData {
defaultFifoDepth = 50000;
standardheader = true;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
vetoDataSize = 160;
vetoPacketSize = headerSizeinPacket + vetoDataSize;
vetoImageSize = vetoDataSize * packetsPerFrame;
};
/**
* set number of interfaces
* @param number of interfaces
*/
void SetNumberofInterfaces(const int n) {
// 2 interfaces (+veto)
if (n == 2) {
threadsPerReceiver = 2;
}
// 1 interface (data only)
else {
threadsPerReceiver = 1;
}
};
};

22
slsReceiverSoftware/src/Implementation.cpp
View File

@ -178,13 +178,16 @@ void Implementation::SetupFifoStructure() {
fifo.clear();
for (int i = 0; i < numThreads; ++i) {
uint32_t datasize = generalData->imageSize;
// veto data size
if (myDetectorType == GOTTHARD2 && i != 0) {
datasize = generalData->vetoImageSize;
}
// create fifo structure
try {
fifo.push_back(sls::make_unique<Fifo>(
i,
(generalData->imageSize) + (generalData->fifoBufferHeaderSize),
fifoDepth));
i, datasize + (generalData->fifoBufferHeaderSize), fifoDepth));
} catch (...) {
fifo.clear();
fifoDepth = 0;
@ -199,14 +202,15 @@ void Implementation::SetupFifoStructure() {
dataProcessor[i]->SetFifo(fifo[i].get());
if (dataStreamer.size())
dataStreamer[i]->SetFifo(fifo[i].get());
LOG(logINFO) << "Memory Allocated for Fifo " << i << ": "
<< (double)(((size_t)(datasize) +
(size_t)(generalData->fifoBufferHeaderSize)) *
(size_t)fifoDepth) /
(double)(1024 * 1024)
<< " MB";
}
LOG(logINFO) << "Memory Allocated Per Fifo: "
<< (double)(((size_t)(generalData->imageSize) +
(size_t)(generalData->fifoBufferHeaderSize)) *
(size_t)fifoDepth) /
(double)(1024 * 1024)
<< " MB";
LOG(logINFO) << numThreads << " Fifo structure(s) reconstructed";
}

59
slsReceiverSoftware/src/Listener.cpp
View File

@ -63,10 +63,14 @@ void Listener::ResetParametersforNewAcquisition() {
currentFrameIndex = 0;
lastCaughtFrameIndex = 0;
carryOverFlag = false;
carryOverPacket = sls::make_unique<char[]>(generalData->packetSize);
memset(carryOverPacket.get(), 0, generalData->packetSize);
listeningPacket = sls::make_unique<char[]>(generalData->packetSize);
memset(carryOverPacket.get(), 0, generalData->packetSize);
uint32_t packetSize = generalData->packetSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
packetSize = generalData->vetoPacketSize;
}
carryOverPacket = sls::make_unique<char[]>(packetSize);
memset(carryOverPacket.get(), 0, packetSize);
listeningPacket = sls::make_unique<char[]>(packetSize);
memset(carryOverPacket.get(), 0, packetSize);
numPacketsStatistic = 0;
numFramesStatistic = 0;
@ -89,10 +93,7 @@ void Listener::RecordFirstIndex(uint64_t fnum) {
}
}
void Listener::SetGeneralData(GeneralData *g) {
generalData = g;
generalData->Print();
}
void Listener::SetGeneralData(GeneralData *g) { generalData = g; }
void Listener::CreateUDPSockets() {
if (!(*activated)) {
@ -108,10 +109,16 @@ void Listener::CreateUDPSockets() {
}
ShutDownUDPSocket();
uint32_t packetSize = generalData->packetSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
packetSize = generalData->vetoPacketSize;
}
// InterfaceNameToIp(eth).str().c_str()
try {
udpSocket = sls::make_unique<sls::UdpRxSocket>(
*udpPortNumber, generalData->packetSize,
*udpPortNumber, packetSize,
((*eth).length() ? sls::InterfaceNameToIp(*eth).str().c_str()
: nullptr),
*udpSocketBufferSize);
@ -152,9 +159,14 @@ void Listener::CreateDummySocketForUDPSocketBufferSize(int64_t s) {
(*eth) = "";
}
uint32_t packetSize = generalData->packetSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
packetSize = generalData->vetoPacketSize;
}
// create dummy socket
try {
sls::UdpRxSocket g(*udpPortNumber, generalData->packetSize,
sls::UdpRxSocket g(*udpPortNumber, packetSize,
((*eth).length()
? sls::InterfaceNameToIp(*eth).str().c_str()
: nullptr),
@ -260,19 +272,24 @@ uint32_t Listener::ListenToAnImage(char *buf) {
uint32_t pnum = 0;
uint32_t numpackets = 0;
uint32_t dsize = generalData->dataSize;
uint32_t hsize = generalData->headerSizeinPacket; //(includes empty header)
uint32_t imageSize = generalData->imageSize;
uint32_t packetSize = generalData->packetSize;
if (myDetectorType == GOTTHARD2 && index != 0) {
dsize = generalData->vetoDataSize;
imageSize = generalData->vetoImageSize;
packetSize = generalData->vetoPacketSize;
}
uint32_t hsize = generalData->headerSizeinPacket;
uint32_t fifohsize = generalData->fifoBufferHeaderSize;
uint32_t pperFrame = generalData->packetsPerFrame;
bool isHeaderEmpty = true;
sls_detector_header *old_header = nullptr;
sls_receiver_header *new_header = nullptr;
bool standardheader = generalData->standardheader;
uint32_t corrected_dsize =
dsize - ((pperFrame * dsize) - generalData->imageSize);
uint32_t corrected_dsize = dsize - ((pperFrame * dsize) - imageSize);
// reset to -1
memset(buf, 0, fifohsize);
/*memset(buf + fifohsize, 0xFF, generalData->imageSize);*/
new_header = (sls_receiver_header *)(buf + FIFO_HEADER_NUMBYTES);
// deactivated (eiger)
@ -294,7 +311,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
new_header->detHeader.column = column;
new_header->detHeader.detType = (uint8_t)generalData->myDetectorType;
new_header->detHeader.version = (uint8_t)SLS_DETECTOR_HEADER_VERSION;
return generalData->imageSize;
return imageSize;
}
// look for carry over
@ -338,7 +355,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
new_header->detHeader.row = row;
new_header->detHeader.column = column;
}
return generalData->imageSize;
return imageSize;
}
// copy packet
@ -427,8 +444,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
new_header->detHeader.row = row;
new_header->detHeader.column = column;
}
return generalData
->imageSize; // empty packet now, but not empty image
return imageSize; // empty packet now, but not empty image
}
// update parameters
@ -489,8 +505,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
// detectors)
if (fnum != currentFrameIndex) {
carryOverFlag = true;
memcpy(carryOverPacket.get(), &listeningPacket[0],
generalData->packetSize);
memcpy(carryOverPacket.get(), &listeningPacket[0], packetSize);
switch (*frameDiscardMode) {
case DISCARD_EMPTY_FRAMES:
@ -508,7 +523,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
new_header->detHeader.row = row;
new_header->detHeader.column = column;
}
return generalData->imageSize;
return imageSize;
}
// copy packet
@ -568,7 +583,7 @@ uint32_t Listener::ListenToAnImage(char *buf) {
// complete image
new_header->detHeader.packetNumber = numpackets; // number of packets caught
return generalData->imageSize;
return imageSize;
}
void Listener::PrintFifoStatistics() {