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

updated client and rxr, not tested

Browse Source
This commit is contained in:
maliakal_d 2022-01-06 18:46:14 +01:00
parent 1e309b67ef
commit 79affe1ea4
7 changed files with 329 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c
View File

@ -4727,13 +4727,12 @@ void calculate_and_set_position() {
} }
// calculating new position // calculating new position
int numInterfaces = getNumberofUDPInterfaces();
int modulePorts[2] = {1, 1}; int modulePorts[2] = {1, 1};
// position does change for eiger and jungfrau (2 interfaces) // position does change for eiger and jungfrau (2 interfaces)
#if defined(EIGERD) #if defined(EIGERD)
modulePorts[1] = numInterfaces; // horz modulePorts[1] = getNumberofUDPInterfaces(); // horz
#elif defined(JUNGFRAUD) #elif defined(JUNGFRAUD)
modulePorts[0] = numInterfaces; // vert modulePorts[0] = getNumberofUDPInterfaces(); // vert
#endif #endif
int maxy = maxydet * modulePorts[0]; int maxy = maxydet * modulePorts[0];
int pos[2] = {0, 0}; int pos[2] = {0, 0};

16
slsDetectorSoftware/src/Detector.cpp
View File

@ -2306,20 +2306,8 @@ Result<uint64_t> Detector::getRxCurrentFrameIndex(Positions pos) const {
} }
std::vector<int> Detector::getPortNumbers(int start_port) { std::vector<int> Detector::getPortNumbers(int start_port) {
int num_sockets_per_detector = 1; int num_sockets_per_detector = pimpl->getNumberofUDPInterfaces({}).tsquash(
switch (getDetectorType().squash()) { "Number of UDP Interfaces is not consistent among modules");
case defs::EIGER:
num_sockets_per_detector *= 2;
break;
case defs::JUNGFRAU:
case defs::GOTTHARD2:
if (pimpl->getNumberofUDPInterfaces({}).squash() == 2) {
num_sockets_per_detector *= 2;
}
break;
default:
break;
}
std::vector<int> res; std::vector<int> res;
res.reserve(size()); res.reserve(size());
for (int idet = 0; idet < size(); ++idet) { for (int idet = 0; idet < size(); ++idet) {

51
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@ -284,6 +284,8 @@ void DetectorImpl::addModule(const std::string &hostname) {
.tsquash("Inconsistent detector types."); .tsquash("Inconsistent detector types.");
// for moench and ctb // for moench and ctb
modules[pos]->updateNumberOfChannels(); modules[pos]->updateNumberOfChannels();
modules[pos]->getNumberofUDPInterfaces();
} }
void DetectorImpl::updateDetectorSize() { void DetectorImpl::updateDetectorSize() {
@ -402,27 +404,21 @@ int DetectorImpl::createReceivingDataSockets() {
} }
LOG(logINFO) << "Going to create data sockets"; LOG(logINFO) << "Going to create data sockets";
size_t numSockets = modules.size(); size_t numUDPInterfaces =
size_t numSocketsPerModule = 1; Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash(1);
if (shm()->detType == EIGER) { // gotthard2 second interface is only for veto debugging (not in gui)
numSocketsPerModule = 2; if (shm()->detType == GOTTHARD2) {
numUDPInterfaces = 1;
} }
// gotthard2 second interface is only for veto debugging size_t numSockets = modules.size() * numUDPInterfaces;
else if (shm()->detType != GOTTHARD2) {
if (Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash() ==
2) {
numSocketsPerModule = 2;
}
}
numSockets *= numSocketsPerModule;
for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) { for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
uint32_t portnum = uint32_t portnum =
(modules[iSocket / numSocketsPerModule]->getClientStreamingPort()); (modules[iSocket / numUDPInterfaces]->getClientStreamingPort());
portnum += (iSocket % numSocketsPerModule); portnum += (iSocket % numUDPInterfaces);
try { try {
zmqSocket.push_back(sls::make_unique<ZmqSocket>( zmqSocket.push_back(
modules[iSocket / numSocketsPerModule] sls::make_unique<ZmqSocket>(modules[iSocket / numUDPInterfaces]
->getClientStreamingIP() ->getClientStreamingIP()
.str() .str()
.c_str(), .c_str(),
@ -460,13 +456,19 @@ void DetectorImpl::readFrameFromReceiver() {
int nDetPixelsX = 0; int nDetPixelsX = 0;
int nDetPixelsY = 0; int nDetPixelsY = 0;
bool quadEnable = false; bool quadEnable = false;
// to flip image
bool eiger = false; bool eiger = false;
bool numInterfaces = 1;
// cannot pick up udp interfaces from zmq
int numInterfaces =
Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash(1);
int module_ports[2] = {1, 1};
// gotthard2 second interface is veto debugging // gotthard2 second interface is veto debugging
if (shm()->detType != GOTTHARD2) { if (shm()->detType == EIGER)
numInterfaces = Parallel(&Module::getNumberofUDPInterfacesFromShm, {}) module_ports[1] = numInterfaces; // horz
.squash(); // cannot pick up from zmq else if (shm()->detType == JUNGFRAU)
} module_ports[0] = numInterfaces; // vert
std::vector<bool> runningList(zmqSocket.size()); std::vector<bool> runningList(zmqSocket.size());
std::vector<bool> connectList(zmqSocket.size()); std::vector<bool> connectList(zmqSocket.size());
numZmqRunning = 0; numZmqRunning = 0;
@ -543,9 +545,10 @@ void DetectorImpl::readFrameFromReceiver() {
nPixelsX = zHeader.npixelsx; nPixelsX = zHeader.npixelsx;
nPixelsY = zHeader.npixelsy; nPixelsY = zHeader.npixelsy;
// module shape // module shape
nX = zHeader.ndetx; nX = zHeader.ndetx *
nY = zHeader.ndety; module_ports[1]; // TODO: check if module_ports[1]
nY *= numInterfaces; // needed
nY = zHeader.ndety * module_ports[0];
nDetPixelsX = nX * nPixelsX; nDetPixelsX = nX * nPixelsX;
nDetPixelsY = nY * nPixelsY; nDetPixelsY = nY * nPixelsY;
// det type // det type

4
slsDetectorSoftware/src/Module.cpp
View File

@ -3114,8 +3114,8 @@ void Module::initializeModuleStructure(detectorType type) {
sls::strcpy_safe(shm()->rxHostname, "none"); sls::strcpy_safe(shm()->rxHostname, "none");
shm()->rxTCPPort = DEFAULT_PORTNO + 2; shm()->rxTCPPort = DEFAULT_PORTNO + 2;
shm()->useReceiverFlag = false; shm()->useReceiverFlag = false;
shm()->zmqport = DEFAULT_ZMQ_CL_PORTNO + shm()->zmqport =
(moduleIndex * ((shm()->detType == EIGER) ? 2 : 1)); DEFAULT_ZMQ_CL_PORTNO + moduleIndex * shm()->numUDPInterfaces;
shm()->zmqip = IpAddr{}; shm()->zmqip = IpAddr{};
shm()->numUDPInterfaces = 1; shm()->numUDPInterfaces = 1;
shm()->stoppedFlag = false; shm()->stoppedFlag = false;

559
slsReceiverSoftware/src/GeneralData.h
View File

@ -38,7 +38,7 @@ class GeneralData {
/** Header size of data saved into fifo buffer at a time*/ /** Header size of data saved into fifo buffer at a time*/
uint32_t fifoBufferHeaderSize{0}; uint32_t fifoBufferHeaderSize{0};
uint32_t defaultFifoDepth{0}; uint32_t defaultFifoDepth{0};
uint32_t threadsPerReceiver{1}; uint32_t numUDPInterfaces{1};
uint32_t headerPacketSize{0}; uint32_t headerPacketSize{0};
/** Streaming (for ROI - mainly short Gotthard) */ /** Streaming (for ROI - mainly short Gotthard) */
uint32_t nPixelsXComplete{0}; uint32_t nPixelsXComplete{0};
@ -54,10 +54,27 @@ class GeneralData {
uint32_t vetoImageSize{0}; uint32_t vetoImageSize{0};
uint32_t vetoHsize{0}; uint32_t vetoHsize{0};
uint32_t maxRowsPerReadout{0}; uint32_t maxRowsPerReadout{0};
uint32_t dynamicRange{16};
bool tengigaEnable{false};
uint32_t nAnalogSamples{0};
uint32_t nDigitalSamples{0};
readoutMode readoutType{ANALOG_ONLY};
uint32_t adcEnableMaskOneGiga{BIT32_MASK};
uint32_t adcEnableMaskTenGiga{BIT32_MASK};
slsDetectorDefs::ROI roi{};
GeneralData(){}; GeneralData(){};
virtual ~GeneralData(){}; virtual ~GeneralData(){};
// Returns the pixel depth in byte, 4 bits being 0.5 byte
float GetPixelDepth() { return float(dynamicRange) / 8; }
void ThrowGenericError(std::string msg) {
throw sls::RuntimeError(
msg + std::string("SetROI is a generic function that should be "
"overloaded by a derived class"));
}
/** /**
* Get Header Infomation (frame number, packet number) * Get Header Infomation (frame number, packet number)
* @param index thread index for debugging purposes * @param index thread index for debugging purposes
@ -78,94 +95,65 @@ class GeneralData {
bunchId = -1; bunchId = -1;
} }
/**
* Set ROI
* @param i ROI
*/
virtual void SetROI(slsDetectorDefs::ROI i) { virtual void SetROI(slsDetectorDefs::ROI i) {
LOG(logERROR) << "SetROI is a generic function that should be " ThrowGenericError("SetROI");
"overloaded by a derived class";
}; };
/** /**@returns adc configured */
* Get Adc configured
* @param index thread index for debugging purposes
* @param i
* @returns adc configured
*/
virtual int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const { virtual int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
LOG(logERROR) << "GetAdcConfigured is a generic function that should " ThrowGenericError("GetAdcConfigured");
"be overloaded by a derived class";
return 0; return 0;
}; };
/** virtual void SetDynamicRange(int dr) {
* Setting dynamic range changes member variables ThrowGenericError("SetDynamicRange");
* @param dr dynamic range
* @param tgEnable true if 10GbE is enabled, else false
*/
virtual void SetDynamicRange(int dr, bool tgEnable) {
LOG(logERROR) << "SetDynamicRange is a generic function that should be "
"overloaded by a derived class";
}; };
/** virtual void SetTenGigaEnable(bool tgEnable) {
* Setting ten giga enable changes member variables ThrowGenericError("SetTenGigaEnable");
* @param tgEnable true if 10GbE is enabled, else false
* @param dr dynamic range
*/
virtual void SetTenGigaEnable(bool tgEnable, int dr) {
LOG(logERROR) << "SetTenGigaEnable is a generic function that should "
"be overloaded by a derived class";
}; };
/**
* Set odd starting packet (gotthard)
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @returns true or false for odd starting packet number
*/
virtual bool SetOddStartingPacket(int index, char *packetData) { virtual bool SetOddStartingPacket(int index, char *packetData) {
LOG(logERROR) << "SetOddStartingPacket is a generic function that " ThrowGenericError("SetOddStartingPacket");
"should be overloaded by a derived class";
return false; return false;
}; };
/** virtual void SetNumberofInterfaces(const int n) {
* Set databytes (ctb, moench) ThrowGenericError("SetNumberofInterfaces");
* @param a adc enable mask };
* @param as analog number of samples
* @param ds digital number of samples virtual void SetNumberofCounters(const int n) {
* @param t tengiga enable ThrowGenericError("SetNumberofCounters");
* @param f readout flags };
* @returns analog data bytes
*/ virtual int GetNumberOfAnalogDatabytes() {
virtual int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t, ThrowGenericError("GetNumberOfAnalogDatabytes");
slsDetectorDefs::readoutMode f) {
LOG(logERROR) << "setImageSize is a generic function that should be "
"overloaded by a derived class";
return 0; return 0;
}; };
/** virtual void SetNumberOfAnalogSamples(int n) {
* set number of interfaces (jungfrau) ThrowGenericError("SetNumberOfAnalogSamples");
* @param n number of interfaces };
*/
virtual void SetNumberofInterfaces(const int n) {
LOG(logERROR) << "SetNumberofInterfaces is a generic function that "
"should be overloaded by a derived class";
}
/** virtual void SetNumberOfDigitalSamples(int n) {
* set number of counters (mythen3) ThrowGenericError("SetNumberOfDigitalSamples");
* @param n number of counters };
* @param dr dynamic range
* @param tgEnable ten giga enable virtual void SetOneGigaAdcEnableMask(int n) {
*/ ThrowGenericError("SetOneGigaAdcEnableMask");
virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) { };
LOG(logERROR) << "SetNumberofCounters is a generic function that "
"should be overloaded by a derived class"; virtual void SetTenGigaAdcEnableMask(int n) {
} ThrowGenericError("SetTenGigaAdcEnableMask");
};
virtual void SetReadoutMode(slsDetectorDefs::readoutMode r) {
ThrowGenericError("SetReadoutMode");
};
virtual void SetTenGigaEnable(bool tg) {
ThrowGenericError("SetTenGigaEnable");
};
}; };
class GotthardData : public GeneralData { class GotthardData : public GeneralData {
@ -175,23 +163,15 @@ class GotthardData : public GeneralData {
const int nChipsPerAdc = 2; const int nChipsPerAdc = 2;
public: public:
/** Constructor */
GotthardData() { GotthardData() {
myDetectorType = slsDetectorDefs::GOTTHARD; myDetectorType = slsDetectorDefs::GOTTHARD;
nPixelsX = 1280;
nPixelsY = 1; nPixelsY = 1;
headerSizeinPacket = 4; headerSizeinPacket = 6;
dataSize = 1280;
packetSize = GOTTHARD_PACKET_SIZE;
packetsPerFrame = 2;
imageSize = dataSize * packetsPerFrame;
frameIndexMask = 0xFFFFFFFE;
frameIndexOffset = 1;
packetIndexMask = 1;
maxFramesPerFile = MAX_FRAMES_PER_FILE; maxFramesPerFile = MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 50000; defaultFifoDepth = 50000;
UpdateImageSize();
}; };
/** /**
@ -219,56 +199,7 @@ class GotthardData : public GeneralData {
bunchId = -1; bunchId = -1;
} }
/** /** @returns adc configured */
* Set ROI
* @param i ROI
*/
void SetROI(slsDetectorDefs::ROI i) {
// all adcs
if (i.xmin == -1) {
nPixelsX = 1280;
dataSize = 1280;
packetSize = GOTTHARD_PACKET_SIZE;
packetsPerFrame = 2;
imageSize = dataSize * packetsPerFrame;
frameIndexMask = 0xFFFFFFFE;
frameIndexOffset = 1;
packetIndexMask = 1;
maxFramesPerFile = MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = FIFO_HEADER_NUMBYTES +
sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 50000;
nPixelsXComplete = 0;
nPixelsYComplete = 0;
imageSizeComplete = 0;
}
// single adc
else {
nPixelsX = 256;
dataSize = 512;
packetSize = 518;
packetsPerFrame = 1;
imageSize = dataSize * packetsPerFrame;
frameIndexMask = 0xFFFFFFFF;
frameIndexOffset = 0;
packetIndexMask = 0;
maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = FIFO_HEADER_NUMBYTES +
sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 75000;
nPixelsXComplete = 1280;
nPixelsYComplete = 1;
imageSizeComplete = 1280 * 2;
}
};
/**
* Get Adc configured
* @param index thread index for debugging purposes
* @param i ROI
* @returns adc configured
*/
int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const { int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
int adc = -1; int adc = -1;
// single adc // single adc
@ -320,99 +251,114 @@ class GotthardData : public GeneralData {
} }
return oddStartingPacket; return oddStartingPacket;
}; };
void SetROI(slsDetectorDefs::ROI i) {
roi = i;
UpdateImageSize();
};
private:
void UpdateImageSize() {
// all adcs
if (roi.xmin == -1) {
nPixelsX = 1280;
dataSize = 1280;
packetsPerFrame = 2;
frameIndexMask = 0xFFFFFFFE;
frameIndexOffset = 1;
packetIndexMask = 1;
maxFramesPerFile = MAX_FRAMES_PER_FILE;
nPixelsXComplete = 0;
nPixelsYComplete = 0;
imageSizeComplete = 0;
defaultFifoDepth = 50000;
} else {
nPixelsX = 256;
dataSize = 512;
packetsPerFrame = 1;
frameIndexMask = 0xFFFFFFFF;
frameIndexOffset = 0;
packetIndexMask = 0;
maxFramesPerFile = SHORT_MAX_FRAMES_PER_FILE;
nPixelsXComplete = 1280;
nPixelsYComplete = 1;
imageSizeComplete = 1280 * 2;
defaultFifoDepth = 75000;
}
imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = imageSize / dataSize;
};
}; };
class EigerData : public GeneralData { class EigerData : public GeneralData {
public: public:
/** Constructor */
EigerData() { EigerData() {
myDetectorType = slsDetectorDefs::EIGER; myDetectorType = slsDetectorDefs::EIGER;
nPixelsX = (256 * 2);
nPixelsY = 256;
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = 1024;
packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = 256;
imageSize = dataSize * packetsPerFrame;
maxFramesPerFile = EIGER_MAX_FRAMES_PER_FILE; maxFramesPerFile = EIGER_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 1000; numUDPInterfaces = 2;
threadsPerReceiver = 2;
headerPacketSize = 40; headerPacketSize = 40;
standardheader = true; standardheader = true;
maxRowsPerReadout = 256; maxRowsPerReadout = 256;
UpdateImageSize();
}; };
/** void SetDynamicRange(int dr) {
* Setting dynamic range changes member variables dynamicRange = dr;
* @param dr dynamic range UpdateImageSize();
* @param tgEnable true if 10GbE is enabled, else false
*/
void SetDynamicRange(int dr, bool tgEnable) {
packetsPerFrame = (tgEnable ? 4 : 16) * dr;
imageSize = dataSize * packetsPerFrame;
defaultFifoDepth = (dr == 32 ? 100 : 1000);
} }
/** void SetTenGigaEnable(bool tgEnable) {
* Setting ten giga enable changes member variables tengigaEnable = tgEnable;
* @param tgEnable true if 10GbE is enabled, else false UpdateImageSize();
* @param dr dynamic range };
*/
void SetTenGigaEnable(bool tgEnable, int dr) { private:
dataSize = (tgEnable ? 4096 : 1024); void UpdateImageSize() {
nPixelsX = (256 * 4) / numUDPInterfaces;
nPixelsY = 256;
dataSize = (tengigaEnable ? 4096 : 1024);
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = (tgEnable ? 4 : 16) * dr; imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
imageSize = dataSize * packetsPerFrame; packetsPerFrame = imageSize / dataSize;
defaultFifoDepth = (dynamicRange == 32 ? 100 : 1000);
}; };
}; };
class JungfrauData : public GeneralData { class JungfrauData : public GeneralData {
public: public:
/** Constructor */
JungfrauData() { JungfrauData() {
myDetectorType = slsDetectorDefs::JUNGFRAU; myDetectorType = slsDetectorDefs::JUNGFRAU;
nPixelsX = (256 * 4);
nPixelsY = 512;
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = 8192; dataSize = 8192;
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = 128;
imageSize = dataSize * packetsPerFrame;
maxFramesPerFile = JFRAU_MAX_FRAMES_PER_FILE; maxFramesPerFile = JFRAU_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 2500; defaultFifoDepth = 2500;
standardheader = true; standardheader = true;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
maxRowsPerReadout = 512; maxRowsPerReadout = 512;
UpdateImageSize();
}; };
/**
* set number of interfaces (jungfrau)
* @param n number of interfaces
*/
void SetNumberofInterfaces(const int n) { void SetNumberofInterfaces(const int n) {
// 2 interfaces numUDPInterfaces = n;
if (n == 2) { UpdateImageSize();
nPixelsY = 256; };
packetsPerFrame = 64;
imageSize = dataSize * packetsPerFrame;
threadsPerReceiver = 2;
defaultUdpSocketBufferSize = (500 * 1024 * 1024);
} private:
// 1 interface void UpdateImageSize() {
else { nPixelsX = (256 * 4);
nPixelsY = 512; nPixelsY = (256 * 2) / numUDPInterfaces;
packetsPerFrame = 128; imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
imageSize = dataSize * packetsPerFrame; packetsPerFrame = imageSize / dataSize;
threadsPerReceiver = 1; defaultUdpSocketBufferSize = (1000 * 1024 * 1024) / numUDPInterfaces;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
}
}; };
}; };
@ -422,39 +368,44 @@ class Mythen3Data : public GeneralData {
const int NCHAN = 1280; const int NCHAN = 1280;
public: public:
/** Constructor */
Mythen3Data() { Mythen3Data() {
myDetectorType = slsDetectorDefs::MYTHEN3; myDetectorType = slsDetectorDefs::MYTHEN3;
ncounters = 3; ncounters = 3;
nPixelsX = (NCHAN * ncounters); // max 1280 channels x 3 counters
nPixelsY = 1; nPixelsY = 1;
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = 7680;
packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = 2;
imageSize = dataSize * packetsPerFrame;
maxFramesPerFile = MYTHEN3_MAX_FRAMES_PER_FILE; maxFramesPerFile = MYTHEN3_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 50000; defaultFifoDepth = 50000;
standardheader = true; standardheader = true;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024); defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
UpdateImageSize();
}; };
/** void SetDynamicRange(int dr) {
* set number of counters (mythen3) dynamicRange = dr;
* @param n number of counters UpdateImageSize();
* @param dr dynamic range };
* @param tgEnable ten giga enable
*/ void SetTenGigaEnable(bool tg) {
virtual void SetNumberofCounters(const int n, const int dr, bool tgEnable) { tengigaEnable = tg;
UpdateImageSize();
};
virtual void SetNumberofCounters(const int n) {
ncounters = n; ncounters = n;
nPixelsX = NCHAN * ncounters; UpdateImageSize();
};
private:
void UpdateImageSize() {
nPixelsX = (NCHAN * ncounters); // max 1280 channels x 3 counters
LOG(logINFO) << "nPixelsX: " << nPixelsX; LOG(logINFO) << "nPixelsX: " << nPixelsX;
imageSize = nPixelsX * nPixelsY * ((double)dr / 8.00); imageSize = nPixelsX * nPixelsY * GetPixelDepth();
// 10g // 10g
if (tgEnable) { if (tengigaEnable) {
if (dr == 32 && n > 1) { if (dynamicRange == 32 && ncounters > 1) {
packetsPerFrame = 2; packetsPerFrame = 2;
} else { } else {
packetsPerFrame = 1; packetsPerFrame = 1;
@ -463,7 +414,7 @@ class Mythen3Data : public GeneralData {
} }
// 1g // 1g
else { else {
if (n == 3) { if (ncounters == 3) {
dataSize = 768; dataSize = 768;
} else { } else {
dataSize = 1280; dataSize = 1280;
@ -479,41 +430,26 @@ class Mythen3Data : public GeneralData {
class Gotthard2Data : public GeneralData { class Gotthard2Data : public GeneralData {
public: public:
/** Constructor */
Gotthard2Data() { Gotthard2Data() {
myDetectorType = slsDetectorDefs::GOTTHARD2; myDetectorType = slsDetectorDefs::GOTTHARD2;
nPixelsX = 128 * 10; nPixelsX = 128 * 10;
nPixelsY = 1; nPixelsY = 1;
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = 2560; // 1280 channels * 2 bytes dataSize = 2560; // 1280 channels * 2 bytes
packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = 1; packetsPerFrame = 1;
imageSize = dataSize * packetsPerFrame;
maxFramesPerFile = GOTTHARD2_MAX_FRAMES_PER_FILE; maxFramesPerFile = GOTTHARD2_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 50000; defaultFifoDepth = 50000;
standardheader = true; standardheader = true;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024);
vetoDataSize = 160; vetoDataSize = 160;
vetoImageSize = vetoDataSize * packetsPerFrame;
vetoHsize = 16; vetoHsize = 16;
vetoPacketSize = vetoHsize + vetoDataSize; UpdateImageSize();
}; };
/**
* set number of interfaces
* @param n number of interfaces
*/
void SetNumberofInterfaces(const int n) { void SetNumberofInterfaces(const int n) {
// 2 interfaces (+veto) numUDPInterfaces = n;
if (n == 2) { UpdateImageSize();
threadsPerReceiver = 2;
}
// 1 interface (data only)
else {
threadsPerReceiver = 1;
}
}; };
/** /**
@ -532,14 +468,23 @@ class Gotthard2Data : public GeneralData {
bunchId = *reinterpret_cast<uint64_t *>(packetData + 8); bunchId = *reinterpret_cast<uint64_t *>(packetData + 8);
packetNumber = 0; packetNumber = 0;
}; };
private:
void UpdateImageSize() {
packetSize = headerSizeinPacket + dataSize;
imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
packetsPerFrame = imageSize / dataSize;
vetoPacketSize = vetoHsize + vetoDataSize;
vetoImageSize = vetoDataSize * packetsPerFrame;
defaultUdpSocketBufferSize = (1000 * 1024 * 1024) / numUDPInterfaces;
};
}; };
class ChipTestBoardData : public GeneralData { class ChipTestBoardData : public GeneralData {
private: private:
/** Number of digital channels */
const int NCHAN_DIGITAL = 64; const int NCHAN_DIGITAL = 64;
/** Number of bytes per analog channel */
const int NUM_BYTES_PER_ANALOG_CHANNEL = 2; const int NUM_BYTES_PER_ANALOG_CHANNEL = 2;
int nAnalogBytes = 0;
public: public:
/** Constructor */ /** Constructor */
@ -548,118 +493,136 @@ class ChipTestBoardData : public GeneralData {
nPixelsX = 36; // total number of channels nPixelsX = 36; // total number of channels
nPixelsY = 1; // number of samples nPixelsY = 1; // number of samples
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = UDP_PACKET_DATA_BYTES;
packetSize = headerSizeinPacket + dataSize;
// packetsPerFrame = 1;
imageSize = nPixelsX * nPixelsY * 2;
frameIndexMask = 0xFFFFFF; // 10g frameIndexMask = 0xFFFFFF; // 10g
frameIndexOffset = 8; // 10g frameIndexOffset = 8; // 10g
packetIndexMask = 0xFF; // 10g packetIndexMask = 0xFF; // 10g
packetsPerFrame =
ceil((double)imageSize / (double)UDP_PACKET_DATA_BYTES);
maxFramesPerFile = CTB_MAX_FRAMES_PER_FILE; maxFramesPerFile = CTB_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 2500; defaultFifoDepth = 2500;
standardheader = true; standardheader = true;
UpdateImageSize();
}; };
/** public:
* Set databytes int GetNumberOfAnalogDatabytes() { return nAnalogBytes; };
* @param a adc enable mask
* @param as analog number of samples void SetNumberOfAnalogSamples(int n) {
* @param ds digital number of samples nAnalogSamples = n;
* @param t tengiga enable UpdateImageSize();
* @param f readout flags };
* @returns analog data bytes
*/ void SetNumberOfDigitalSamples(int n) {
int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t, nDigitalSamples = n;
slsDetectorDefs::readoutMode f) { UpdateImageSize();
int nachans = 0, ndchans = 0; };
int adatabytes = 0, ddatabytes = 0;
void SetOneGigaAdcEnableMask(int n) {
adcEnableMaskOneGiga = n;
UpdateImageSize();
};
void SetTenGigaAdcEnableMask(int n) {
adcEnableMaskTenGiga = n;
UpdateImageSize();
};
void SetReadoutMode(slsDetectorDefs::readoutMode r) {
readoutType = r;
UpdateImageSize();
};
void SetTenGigaEnable(bool tg) {
tengigaEnable = tg;
UpdateImageSize();
};
private:
void UpdateImageSize() {
nAnalogBytes = 0;
int nDigitalBytes = 0;
int nAnalogChans = 0, nDigitalChans = 0;
// analog channels (normal, analog/digital readout) // analog channels (normal, analog/digital readout)
if (f == slsDetectorDefs::ANALOG_ONLY || if (readoutType == slsDetectorDefs::ANALOG_ONLY ||
f == slsDetectorDefs::ANALOG_AND_DIGITAL) { readoutType == slsDetectorDefs::ANALOG_AND_DIGITAL) {
nachans = __builtin_popcount(a); uint32_t adcEnableMask =
(tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga);
nAnalogChans = __builtin_popcount(adcEnableMask);
adatabytes = nachans * NUM_BYTES_PER_ANALOG_CHANNEL * as; nAnalogBytes =
LOG(logDEBUG1) << " Number of Analog Channels:" << nachans nAnalogChans * NUM_BYTES_PER_ANALOG_CHANNEL * nAnalogSamples;
<< " Databytes: " << adatabytes; LOG(logDEBUG1) << " Number of Analog Channels:" << nAnalogChans
<< " Databytes: " << nAnalogBytes;
} }
// digital channels // digital channels
if (f == slsDetectorDefs::DIGITAL_ONLY || if (readoutType == slsDetectorDefs::DIGITAL_ONLY ||
f == slsDetectorDefs::ANALOG_AND_DIGITAL) { readoutType == slsDetectorDefs::ANALOG_AND_DIGITAL) {
ndchans = NCHAN_DIGITAL; nDigitalChans = NCHAN_DIGITAL;
ddatabytes = (sizeof(uint64_t) * ds); nDigitalBytes = (sizeof(uint64_t) * nDigitalSamples);
LOG(logDEBUG1) << "Number of Digital Channels:" << ndchans LOG(logDEBUG1) << "Number of Digital Channels:" << nDigitalChans
<< " Databytes: " << ddatabytes; << " Databytes: " << nDigitalBytes;
} }
LOG(logDEBUG1) << "Total Number of Channels:" << nachans + ndchans
<< " Databytes: " << adatabytes + ddatabytes;
nPixelsX = nachans + ndchans; nPixelsX = nAnalogChans + nDigitalChans;
nPixelsY = 1; nPixelsY = 1;
LOG(logDEBUG1) << "Total Number of Channels:" << nPixelsX
<< " Databytes: " << nAnalogBytes + nDigitalBytes;
// 10G dataSize = tengigaEnable ? 8144 : UDP_PACKET_DATA_BYTES;
if (t) {
dataSize = 8144;
}
// 1g udp (via fifo readout)
else {
dataSize = UDP_PACKET_DATA_BYTES;
}
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;
imageSize = adatabytes + ddatabytes; imageSize = adatabytes + ddatabytes;
packetsPerFrame = ceil((double)imageSize / (double)dataSize); packetsPerFrame = ceil((double)imageSize / (double)dataSize);
};
return adatabytes;
}
}; };
class MoenchData : public GeneralData { class MoenchData : public GeneralData {
private: private:
/** Number of bytes per analog channel */
const int NUM_BYTES_PER_ANALOG_CHANNEL = 2; const int NUM_BYTES_PER_ANALOG_CHANNEL = 2;
public: public:
/** Constructor */
MoenchData() { MoenchData() {
myDetectorType = slsDetectorDefs::MOENCH; myDetectorType = slsDetectorDefs::MOENCH;
nPixelsX = 32; // total number of channels
nPixelsY = 1; // number of samples nPixelsY = 1; // number of samples
headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header);
dataSize = UDP_PACKET_DATA_BYTES;
packetSize = headerSizeinPacket + dataSize;
// packetsPerFrame = 1;
imageSize = nPixelsX * nPixelsY * 2;
packetsPerFrame =
ceil((double)imageSize / (double)UDP_PACKET_DATA_BYTES);
frameIndexMask = 0xFFFFFF; frameIndexMask = 0xFFFFFF;
maxFramesPerFile = MOENCH_MAX_FRAMES_PER_FILE; maxFramesPerFile = MOENCH_MAX_FRAMES_PER_FILE;
fifoBufferHeaderSize = fifoBufferHeaderSize =
FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header); FIFO_HEADER_NUMBYTES + sizeof(slsDetectorDefs::sls_receiver_header);
defaultFifoDepth = 2500; defaultFifoDepth = 2500;
standardheader = true; standardheader = true;
UpdateImageSize();
}; };
/** void SetNumberOfAnalogSamples(int n) {
* Set databytes nAnalogSamples = n;
* @param a adc enable mask UpdateImageSize();
* @param as analog number of samples };
* @param ds digital number of samples
* @param t tengiga enable void SetOneGigaAdcEnableMask(int n) {
* @param f readout flags adcEnableMaskOneGiga = n;
* @returns analog data bytes UpdateImageSize();
*/ };
int setImageSize(uint32_t a, uint32_t as, uint32_t ds, bool t,
slsDetectorDefs::readoutMode f) { void SetTenGigaAdcEnableMask(int n) {
adcEnableMaskTenGiga = n;
UpdateImageSize();
};
void SetTenGigaEnable(bool tg) {
tengigaEnable = tg;
UpdateImageSize();
};
private:
void UpdateImageSize() {
uint32_t adcEnableMask =
(tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga);
// count number of channels in x, each adc has 25 channels each // count number of channels in x, each adc has 25 channels each
int nchanTop = __builtin_popcount(a & 0xF0F0F0F0) * 25; int nchanTop = __builtin_popcount(adcEnableMask & 0xF0F0F0F0) * 25;
int nchanBot = __builtin_popcount(a & 0x0F0F0F0F) * 25; int nchanBot = __builtin_popcount(adcEnableMask & 0x0F0F0F0F) * 25;
nPixelsX = nchanTop > 0 ? nchanTop : nchanBot; nPixelsX = nchanTop > 0 ? nchanTop : nchanBot;
// if both top and bottom adcs enabled, rows = 2 // if both top and bottom adcs enabled, rows = 2
@ -667,25 +630,15 @@ class MoenchData : public GeneralData {
if (nchanTop > 0 && nchanBot > 0) { if (nchanTop > 0 && nchanBot > 0) {
nrows = 2; nrows = 2;
} }
nPixelsY = as / 25 * nrows; nPixelsY = nAnalogSamples / 25 * nrows;
LOG(logINFO) << "Number of Pixels: [" << nPixelsX << ", " << nPixelsY LOG(logINFO) << "Number of Pixels: [" << nPixelsX << ", " << nPixelsY
<< "]"; << "]";
// 10G dataSize = tengigaEnable ? 8144 : UDP_PACKET_DATA_BYTES;
if (t) {
dataSize = 8144;
}
// 1g udp (via fifo readout)
else {
dataSize = UDP_PACKET_DATA_BYTES;
}
imageSize = nPixelsX * nPixelsY * NUM_BYTES_PER_ANALOG_CHANNEL;
packetSize = headerSizeinPacket + dataSize; packetSize = headerSizeinPacket + dataSize;
imageSize = nPixelsX * nPixelsY * NUM_BYTES_PER_ANALOG_CHANNEL;
packetsPerFrame = ceil((double)imageSize / (double)dataSize); packetsPerFrame = ceil((double)imageSize / (double)dataSize);
LOG(logDEBUG) << "Databytes: " << imageSize; LOG(logDEBUG) << "Databytes: " << imageSize;
};
return imageSize;
}
}; };

105
slsReceiverSoftware/src/Implementation.cpp
View File

@ -64,7 +64,7 @@ void Implementation::SetThreadPriorities() {
void Implementation::SetupFifoStructure() { void Implementation::SetupFifoStructure() {
fifo.clear(); fifo.clear();
for (int i = 0; i < numThreads; ++i) { for (int i = 0; i < numUDPInterfaces; ++i) {
uint32_t datasize = generalData->imageSize; uint32_t datasize = generalData->imageSize;
// veto data size // veto data size
if (detType == GOTTHARD2 && i != 0) { if (detType == GOTTHARD2 && i != 0) {
@ -97,7 +97,7 @@ void Implementation::SetupFifoStructure() {
(double)(1024 * 1024) (double)(1024 * 1024)
<< " MB"; << " MB";
} }
LOG(logINFO) << numThreads << " Fifo structure(s) reconstructed"; LOG(logINFO) << numUDPInterfaces << " Fifo structure(s) reconstructed";
} }
/************************************************** /**************************************************
@ -152,7 +152,7 @@ void Implementation::setDetectorType(const detectorType d) {
default: default:
break; break;
} }
numThreads = generalData->threadsPerReceiver; numUDPInterfaces = generalData->numUDPInterfaces;
fifoDepth = generalData->defaultFifoDepth; fifoDepth = generalData->defaultFifoDepth;
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize; udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
framesPerFile = generalData->maxFramesPerFile; framesPerFile = generalData->maxFramesPerFile;
@ -161,7 +161,7 @@ void Implementation::setDetectorType(const detectorType d) {
SetupFifoStructure(); SetupFifoStructure();
// create threads // create threads
for (int i = 0; i < numThreads; ++i) { for (int i = 0; i < numUDPInterfaces; ++i) {
try { try {
auto fifo_ptr = fifo[i].get(); auto fifo_ptr = fifo[i].get();
@ -170,6 +170,10 @@ void Implementation::setDetectorType(const detectorType d) {
&udpSocketBufferSize, &actualUDPSocketBufferSize, &udpSocketBufferSize, &actualUDPSocketBufferSize,
&framesPerFile, &frameDiscardMode, &activated, &framesPerFile, &frameDiscardMode, &activated,
&detectorDataStream[i], &silentMode)); &detectorDataStream[i], &silentMode));
int ctbAnalogDataBytes = 0;
if (myDetectorType == CHIPTESTBOARD) {
ctbAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>( dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &activated, &dataStreamEnable, i, detType, fifo_ptr, &activated, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs, &streamingStartFnum, &streamingFrequency, &streamingTimerInMs, &streamingStartFnum,
@ -308,7 +312,7 @@ std::array<pid_t, NUM_RX_THREAD_IDS> Implementation::getThreadIds() const {
} else { } else {
retval[id++] = 0; retval[id++] = 0;
} }
if (numThreads == 2) { if (numUDPInterfaces == 2) {
retval[id++] = listener[1]->GetThreadId(); retval[id++] = listener[1]->GetThreadId();
retval[id++] = dataProcessor[1]->GetThreadId(); retval[id++] = dataProcessor[1]->GetThreadId();
if (dataStreamEnable) { if (dataStreamEnable) {
@ -474,8 +478,8 @@ double Implementation::getProgress() const {
} }
std::vector<uint64_t> Implementation::getNumMissingPackets() const { std::vector<uint64_t> Implementation::getNumMissingPackets() const {
std::vector<uint64_t> mp(numThreads); std::vector<uint64_t> mp(numUDPInterfaces);
for (int i = 0; i < numThreads; i++) { for (int i = 0; i < numUDPInterfaces; i++) {
int np = generalData->packetsPerFrame; int np = generalData->packetsPerFrame;
uint64_t totnp = np; uint64_t totnp = np;
// ReadNRows // ReadNRows
@ -565,8 +569,9 @@ void Implementation::stopReceiver() {
(numMods[X] * numMods[Y]) > 1) { (numMods[X] * numMods[Y]) > 1) {
dataProcessor[0]->CreateVirtualFile( dataProcessor[0]->CreateVirtualFile(
filePath, fileName, fileIndex, overwriteEnable, silentMode, filePath, fileName, fileIndex, overwriteEnable, silentMode,
modulePos, numThreads, framesPerFile, numberOfTotalFrames, modulePos, numUDPInterfaces, framesPerFile,
dynamicRange, numMods[X], numMods[Y], &hdf5Lib); numberOfTotalFrames, dynamicRange, numMods[X], numMods[Y],
&hdf5Lib);
} }
// link file in master // link file in master
dataProcessor[0]->LinkDataInMasterFile(silentMode); dataProcessor[0]->LinkDataInMasterFile(silentMode);
@ -603,7 +608,7 @@ void Implementation::stopReceiver() {
} }
// print summary // print summary
uint64_t tot = 0; uint64_t tot = 0;
for (int i = 0; i < numThreads; i++) { for (int i = 0; i < numUDPInterfaces; i++) {
int nf = dataProcessor[i]->GetNumCompleteFramesCaught(); int nf = dataProcessor[i]->GetNumCompleteFramesCaught();
tot += nf; tot += nf;
std::string mpMessage = std::to_string(mp[i]); std::string mpMessage = std::to_string(mp[i]);
@ -634,7 +639,7 @@ void Implementation::stopReceiver() {
// callback // callback
if (acquisitionFinishedCallBack) { if (acquisitionFinishedCallBack) {
try { try {
acquisitionFinishedCallBack((tot / numThreads), acquisitionFinishedCallBack((tot / numUDPInterfaces),
pAcquisitionFinished); pAcquisitionFinished);
} catch (const std::exception &e) { } catch (const std::exception &e) {
// change status // change status
@ -815,7 +820,7 @@ void Implementation::SetupWriter() {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) { for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
dataProcessor[i]->CreateFirstFiles( dataProcessor[i]->CreateFirstFiles(
masterAttributes.get(), filePath, fileName, fileIndex, masterAttributes.get(), filePath, fileName, fileIndex,
overwriteEnable, silentMode, modulePos, numThreads, overwriteEnable, silentMode, modulePos, numUDPInterfaces,
udpPortNum[i], framesPerFile, numberOfTotalFrames, dynamicRange, udpPortNum[i], framesPerFile, numberOfTotalFrames, dynamicRange,
detectorDataStream[i]); detectorDataStream[i]);
} }
@ -873,14 +878,13 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
// set local variables // set local variables
generalData->SetNumberofInterfaces(n); generalData->SetNumberofInterfaces(n);
numThreads = generalData->threadsPerReceiver;
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize; udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
// fifo // fifo
SetupFifoStructure(); SetupFifoStructure();
// create threads // create threads
for (int i = 0; i < numThreads; ++i) { for (int i = 0; i < numUDPInterfaces; ++i) {
// listener and dataprocessor threads // listener and dataprocessor threads
try { try {
auto fifo_ptr = fifo[i].get(); auto fifo_ptr = fifo[i].get();
@ -891,6 +895,11 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
&detectorDataStream[i], &silentMode)); &detectorDataStream[i], &silentMode));
listener[i]->SetGeneralData(generalData); listener[i]->SetGeneralData(generalData);
int ctbAnalogDataBytes = 0;
if (myDetectorType == CHIPTESTBOARD) {
ctbAnalogDataBytes =
generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>( dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &activated, &dataStreamEnable, i, detType, fifo_ptr, &activated, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs, &streamingFrequency, &streamingTimerInMs,
@ -919,7 +928,7 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
(int *)nm, &quadEnable, &numberOfTotalFrames)); (int *)nm, &quadEnable, &numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData); dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets( dataStreamer[i]->CreateZmqSockets(
&numThreads, streamingPort, streamingSrcIP, &numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm); streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader( dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader); additionalJsonHeader);
@ -1034,7 +1043,7 @@ void Implementation::setDataStreamEnable(const bool enable) {
dataStreamer.clear(); dataStreamer.clear();
if (enable) { if (enable) {
for (int i = 0; i < numThreads; ++i) { for (int i = 0; i < numUDPInterfaces; ++i) {
try { try {
bool flip = flipRows; bool flip = flipRows;
int nm[2] = {numMods[0], numMods[1]}; int nm[2] = {numMods[0], numMods[1]};
@ -1048,7 +1057,7 @@ void Implementation::setDataStreamEnable(const bool enable) {
(int *)nm, &quadEnable, &numberOfTotalFrames)); (int *)nm, &quadEnable, &numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData); dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets( dataStreamer[i]->CreateZmqSockets(
&numThreads, streamingPort, streamingSrcIP, &numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm); streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader( dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader); additionalJsonHeader);
@ -1353,11 +1362,7 @@ void Implementation::setNumberofAnalogSamples(const uint32_t i) {
if (numberOfAnalogSamples != i) { if (numberOfAnalogSamples != i) {
numberOfAnalogSamples = i; numberOfAnalogSamples = i;
ctbAnalogDataBytes = generalData->setImageSize( generalData->SetNumberOfAnalogSamples(i);
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "Number of Analog Samples: " << numberOfAnalogSamples; LOG(logINFO) << "Number of Analog Samples: " << numberOfAnalogSamples;
@ -1372,11 +1377,7 @@ void Implementation::setNumberofDigitalSamples(const uint32_t i) {
if (numberOfDigitalSamples != i) { if (numberOfDigitalSamples != i) {
numberOfDigitalSamples = i; numberOfDigitalSamples = i;
ctbAnalogDataBytes = generalData->setImageSize( generalData->SetNumberOfDigitalSamples(i);
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "Number of Digital Samples: " << numberOfDigitalSamples; LOG(logINFO) << "Number of Digital Samples: " << numberOfDigitalSamples;
@ -1394,8 +1395,7 @@ void Implementation::setCounterMask(const uint32_t i) {
". Expected 1-3."); ". Expected 1-3.");
} }
counterMask = i; counterMask = i;
generalData->SetNumberofCounters(ncounters, dynamicRange, generalData->SetNumberofCounters(ncounters);
tengigaEnable);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "Counter mask: " << sls::ToStringHex(counterMask); LOG(logINFO) << "Counter mask: " << sls::ToStringHex(counterMask);
@ -1410,14 +1410,7 @@ void Implementation::setDynamicRange(const uint32_t i) {
dynamicRange = i; dynamicRange = i;
if (detType == EIGER || detType == MYTHEN3) { if (detType == EIGER || detType == MYTHEN3) {
generalData->SetDynamicRange(i);
if (detType == EIGER) {
generalData->SetDynamicRange(i, tengigaEnable);
} else {
int ncounters = __builtin_popcount(counterMask);
generalData->SetNumberofCounters(ncounters, i, tengigaEnable);
}
fifoDepth = generalData->defaultFifoDepth; fifoDepth = generalData->defaultFifoDepth;
SetupFifoStructure(); SetupFifoStructure();
} }
@ -1447,25 +1440,8 @@ bool Implementation::getTenGigaEnable() const { return tengigaEnable; }
void Implementation::setTenGigaEnable(const bool b) { void Implementation::setTenGigaEnable(const bool b) {
if (tengigaEnable != b) { if (tengigaEnable != b) {
tengigaEnable = b; tengigaEnable = b;
int ncounters = __builtin_popcount(counterMask);
// side effects generalData->SetTenGigaEnable(b);
switch (detType) {
case EIGER:
generalData->SetTenGigaEnable(b, dynamicRange);
break;
case MYTHEN3:
generalData->SetNumberofCounters(ncounters, dynamicRange, b);
break;
case MOENCH:
case CHIPTESTBOARD:
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
break;
default:
break;
}
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "Ten Giga: " << (tengigaEnable ? "enabled" : "disabled"); LOG(logINFO) << "Ten Giga: " << (tengigaEnable ? "enabled" : "disabled");
@ -1568,11 +1544,7 @@ void Implementation::setReadoutMode(const readoutMode f) {
if (readoutType != f) { if (readoutType != f) {
readoutType = f; readoutType = f;
// side effects generalData->SetReadoutMode(f);
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "Readout Mode: " << sls::ToString(f); LOG(logINFO) << "Readout Mode: " << sls::ToString(f);
@ -1586,11 +1558,8 @@ uint32_t Implementation::getADCEnableMask() const {
void Implementation::setADCEnableMask(uint32_t mask) { void Implementation::setADCEnableMask(uint32_t mask) {
if (adcEnableMaskOneGiga != mask) { if (adcEnableMaskOneGiga != mask) {
adcEnableMaskOneGiga = mask; adcEnableMaskOneGiga = mask;
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetOneGigaAdcEnableMask(mask);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "ADC Enable Mask for 1Gb mode: 0x" << std::hex LOG(logINFO) << "ADC Enable Mask for 1Gb mode: 0x" << std::hex
@ -1606,11 +1575,7 @@ void Implementation::setTenGigaADCEnableMask(uint32_t mask) {
if (adcEnableMaskTenGiga != mask) { if (adcEnableMaskTenGiga != mask) {
adcEnableMaskTenGiga = mask; adcEnableMaskTenGiga = mask;
ctbAnalogDataBytes = generalData->setImageSize( generalData->SetTenGigaAdcEnableMask(mask);
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
SetupFifoStructure(); SetupFifoStructure();
} }
LOG(logINFO) << "ADC Enable Mask for 10Gb mode: 0x" << std::hex LOG(logINFO) << "ADC Enable Mask for 10Gb mode: 0x" << std::hex

2
slsReceiverSoftware/src/Implementation.h
View File

@ -278,7 +278,6 @@ class Implementation : private virtual slsDetectorDefs {
* ************************************************/ * ************************************************/
// config parameters // config parameters
int numThreads{1};
detectorType detType{GENERIC}; detectorType detType{GENERIC};
int numMods[MAX_DIMENSIONS] = {0, 0}; int numMods[MAX_DIMENSIONS] = {0, 0};
int modulePos{0}; int modulePos{0};
@ -361,7 +360,6 @@ class Implementation : private virtual slsDetectorDefs {
uint32_t adcEnableMaskTenGiga{BIT32_MASK}; uint32_t adcEnableMaskTenGiga{BIT32_MASK};
std::vector<int> ctbDbitList; std::vector<int> ctbDbitList;
int ctbDbitOffset{0}; int ctbDbitOffset{0};
int ctbAnalogDataBytes{0};
// callbacks // callbacks
int (*startAcquisitionCallBack)(std::string, std::string, uint64_t, int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,