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

Merge pull request #340 from slsdetectorgroup/eiger2udp

Browse Source 
Eiger2udp
This commit is contained in:
Dhanya Thattil 2022-01-24 16:40:52 +01:00 committed by GitHub
commit 379d08dd03
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 473 additions and 530 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
RELEASE.txt
View File

@ -21,6 +21,9 @@ This document describes the differences between v6.1.0 and v6.0.0.
- Fixed minor warnings (will fix commandline print of excess packets for missing packets)
- ctb slow adcs and any other adcs (other than temp) goes to the control Server
- number of udp interfaces is 2 for Eiger (CHANGE IN API??)
- added module id for virtual servers into the udp header
- refactoring (rxr)
- fixed patsetbit and patsetmask for moench
- changed default vref of adc9257 to 2V for moench (from 1.33V)

BIN
slsDetectorServers/ctbDetectorServer/bin/ctbDetectorServer_developer
View File

Binary file not shown.

2
slsDetectorServers/ctbDetectorServer/slsDetectorFunctionList.c
View File

@ -1492,6 +1492,8 @@ enum timingMode getTiming() {
/* configure mac */
int getNumberofUDPInterfaces() { return 1; }
void calcChecksum(udp_header *udp) {
int count = IP_HEADER_SIZE;
long int sum = 0;

BIN
slsDetectorServers/eigerDetectorServer/bin/eigerDetectorServer_developer
View File

Binary file not shown.

9
slsDetectorServers/eigerDetectorServer/slsDetectorFunctionList.c
View File

@ -88,6 +88,7 @@ int eiger_virtual_read_n_rows = 256;
int eiger_virtual_interrupt_subframe = 0;
int eiger_virtual_left_datastream = 1;
int eiger_virtual_right_datastream = 1;
int eiger_virtual_module_id = 0;
#endif
int defaultDacValues[NDAC] = DEFAULT_DAC_VALS;
@ -304,10 +305,9 @@ u_int32_t getDetectorIP() {
void initControlServer() {
LOG(logINFOBLUE, ("Configuring Control server\n"));
if (!updateFlag && initError == OK) {
#ifndef VIRTUAL
int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
#else
getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
#ifdef VIRTUAL
eiger_virtual_module_id = modid;
#endif
if (initError == FAIL) {
return;
@ -1500,6 +1500,7 @@ enum timingMode getTiming() {
}
/* configure mac */
int getNumberofUDPInterfaces() { return 2; }
int getNumberofDestinations(int *retval) {
#ifdef VIRTUAL
@ -2407,6 +2408,7 @@ void *start_timer(void *arg) {
header->version = SLS_DETECTOR_HEADER_VERSION;
header->frameNumber = frameNr + iframes;
header->packetNumber = i;
header->modId = eiger_virtual_module_id;
header->row = row;
header->column = colLeft;
@ -2417,6 +2419,7 @@ void *start_timer(void *arg) {
header->version = SLS_DETECTOR_HEADER_VERSION;
header->frameNumber = frameNr + iframes;
header->packetNumber = i;
header->modId = eiger_virtual_module_id;
header->row = row;
header->column = colRight;
if (eiger_virtual_quad_mode) {

BIN
slsDetectorServers/gotthard2DetectorServer/bin/gotthard2DetectorServer_developer
View File

Binary file not shown.

43
slsDetectorServers/gotthard2DetectorServer/slsDetectorFunctionList.c
View File

@ -41,6 +41,7 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
int64_t virtual_currentFrameNumber = 2;
int virtual_moduleid = 0;
#endif
enum detectorSettings thisSettings = UNINITIALIZED;
@ -101,8 +102,9 @@ void basictests() {
}
// does check only if flag is 0 (by default), set by command line
if ((!debugflag) && (!updateFlag) &&
((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) || (checkType() == FAIL) ||
(testFpga() == FAIL) || (testBus() == FAIL))) {
((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) ||
(checkType() == FAIL) || (testFpga() == FAIL) ||
(testBus() == FAIL))) {
sprintf(initErrorMessage,
"Could not pass basic tests of FPGA and bus. Dangerous to "
"continue. (Firmware version:0x%llx) \n",
@ -480,6 +482,9 @@ void setupDetector() {
// set module id in register
int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
#ifdef VIRTUAL
virtual_moduleid = modid;
#endif
if (initError == FAIL) {
return;
}
@ -2083,40 +2088,56 @@ int setReadoutSpeed(int val) {
case G2_108MHZ:
LOG(logINFOBLUE, ("Setting readout speed to 108 MHz\n"));
if (setClockDivider(READOUT_C0, SPEED_108_CLKDIV_0) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set readout clk 0 to %d\n", SPEED_108_CLKDIV_0));
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
"set readout clk 0 to %d\n",
SPEED_108_CLKDIV_0));
return FAIL;
}
if (setClockDivider(READOUT_C1, SPEED_108_CLKDIV_1) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set readout clk 1 to %d\n", SPEED_108_CLKDIV_1));
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
"set readout clk 1 to %d\n",
SPEED_108_CLKDIV_1));
return FAIL;
}
if (setPhase(READOUT_C1, SPEED_108_CLKPHASE_DEG_1, 1) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set clk phase 1 %d deg\n", SPEED_108_CLKPHASE_DEG_1));
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
"set clk phase 1 %d deg\n",
SPEED_108_CLKPHASE_DEG_1));
return FAIL;
}
setDBITPipeline(SPEED_144_DBIT_PIPELINE);
if (getDBITPipeline() != SPEED_144_DBIT_PIPELINE) {
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to set dbitpipeline to %d \n", SPEED_144_DBIT_PIPELINE));
LOG(logERROR, ("Could not set readout speed to 108 MHz. Failed to "
"set dbitpipeline to %d \n",
SPEED_144_DBIT_PIPELINE));
return FAIL;
}
break;
case G2_144MHZ:
LOG(logINFOBLUE, ("Setting readout speed to 144 MHz\n"));
if (setClockDivider(READOUT_C0, SPEED_144_CLKDIV_0) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set readout clk 0 to %d\n", SPEED_144_CLKDIV_0));
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
"set readout clk 0 to %d\n",
SPEED_144_CLKDIV_0));
return FAIL;
}
if (setClockDivider(READOUT_C1, SPEED_144_CLKDIV_1) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set readout clk 1 to %d\n", SPEED_144_CLKDIV_1));
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
"set readout clk 1 to %d\n",
SPEED_144_CLKDIV_1));
return FAIL;
}
if (setPhase(READOUT_C1, SPEED_144_CLKPHASE_DEG_1, 1) == FAIL) {
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set clk phase 1 %d deg\n", SPEED_144_CLKPHASE_DEG_1));
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
"set clk phase 1 %d deg\n",
SPEED_144_CLKPHASE_DEG_1));
return FAIL;
}
setDBITPipeline(SPEED_144_DBIT_PIPELINE);
if (getDBITPipeline() != SPEED_144_DBIT_PIPELINE) {
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to set dbitpipeline to %d \n", SPEED_144_DBIT_PIPELINE));
LOG(logERROR, ("Could not set readout speed to 144 MHz. Failed to "
"set dbitpipeline to %d \n",
SPEED_144_DBIT_PIPELINE));
return FAIL;
}
break;
@ -3005,7 +3026,7 @@ void *start_timer(void *arg) {
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = virtual_currentFrameNumber;
header->packetNumber = 0;
header->modId = 0;
header->modId = virtual_moduleid;
header->row = detPos[X];
header->column = detPos[Y];
// fill data

BIN
slsDetectorServers/gotthardDetectorServer/bin/gotthardDetectorServer_developer
View File

Binary file not shown.

2
slsDetectorServers/gotthardDetectorServer/slsDetectorFunctionList.c
View File

@ -1299,6 +1299,8 @@ int getExtSignal(int signalIndex) {
/* configure mac */
int getNumberofUDPInterfaces() { return 1; }
void calcChecksum(mac_conf *mac, int sourceip, int destip) {
mac->ip.ip_ver = 0x4;
mac->ip.ip_ihl = 0x5;

BIN
slsDetectorServers/jungfrauDetectorServer/bin/jungfrauDetectorServer_developer
View File

Binary file not shown.

BIN
slsDetectorServers/moenchDetectorServer/bin/moenchDetectorServer_developer
View File

Binary file not shown.

2
slsDetectorServers/moenchDetectorServer/slsDetectorFunctionList.c
View File

@ -1157,6 +1157,8 @@ enum timingMode getTiming() {
/* configure mac */
int getNumberofUDPInterfaces() { return 1; }
void calcChecksum(udp_header *udp) {
int count = IP_HEADER_SIZE;
long int sum = 0;

BIN
slsDetectorServers/mythen3DetectorServer/bin/mythen3DetectorServer_developer
View File

Binary file not shown.

8
slsDetectorServers/mythen3DetectorServer/slsDetectorFunctionList.c
View File

@ -42,6 +42,7 @@ char initErrorMessage[MAX_STR_LENGTH];
#ifdef VIRTUAL
pthread_t pthread_virtual_tid;
int64_t virtual_currentFrameNumber = 2;
int virtual_moduleid = 0;
#endif
enum detectorSettings thisSettings = UNINITIALIZED;
@ -448,6 +449,9 @@ void setupDetector() {
// set module id in register
int modid = getModuleIdInFile(&initError, initErrorMessage, ID_FILE);
#ifdef VIRTUAL
virtual_moduleid = modid;
#endif
if (initError == FAIL) {
return;
}
@ -1719,6 +1723,8 @@ int getExtSignal(int signalIndex) {
}
}
int getNumberofUDPInterfaces() { return 1; }
int configureMAC() {
uint32_t srcip = udpDetails[0].srcip;
@ -2280,7 +2286,7 @@ void *start_timer(void *arg) {
header->version = SLS_DETECTOR_HEADER_VERSION - 1;
header->frameNumber = virtual_currentFrameNumber;
header->packetNumber = i;
header->modId = 0;
header->modId = virtual_moduleid;
header->row = detPos[X];
header->column = detPos[Y];

2
slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h
View File

@ -387,8 +387,8 @@ void calcChecksum(mac_conf *mac, int sourceip, int destip);
#endif
#if defined(JUNGFRAUD) || defined(GOTTHARD2D)
void setNumberofUDPInterfaces(int val);
int getNumberofUDPInterfaces();
#endif
int getNumberofUDPInterfaces();
#if defined(JUNGFRAUD) || defined(EIGERD)
int getNumberofDestinations(int *retval);

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

@ -4725,19 +4725,22 @@ void calculate_and_set_position() {
LOG(logERROR, (mess));
return;
}
int maxy = maxydet;
// position does not change for gotthard2 (2 interfaces)
#ifdef JUNGFRAUD
maxy *= getNumberofUDPInterfaces();
// calculating new position
int modulePorts[2] = {1, 1};
// position does change for eiger and jungfrau (2 interfaces)
#if defined(EIGERD)
modulePorts[1] = getNumberofUDPInterfaces(); // horz
#elif defined(JUNGFRAUD)
modulePorts[0] = getNumberofUDPInterfaces(); // vert
#endif
int maxy = maxydet * modulePorts[0];
int pos[2] = {0, 0};
// row
pos[0] = (detectorId % maxy);
// col for horiz. udp ports
pos[1] = (detectorId / maxy);
#ifdef EIGERD
pos[1] *= 2;
#endif
pos[1] = (detectorId / maxy) * modulePorts[1];
LOG(logDEBUG, ("Setting Positions (%d,%d)\n", pos[0], pos[1]));
if (setDetectorPosition(pos) == FAIL) {
ret = FAIL;
@ -5320,7 +5323,16 @@ int set_num_interfaces(int file_des) {
LOG(logINFO, ("Setting number of interfaces: %d\n", arg));
#if !defined(JUNGFRAUD) && !defined(GOTTHARD2D)
functionNotImplemented();
// fixed number of udp interfaces
int num_interfaces = getNumberofUDPInterfaces();
if (arg != num_interfaces) {
ret = FAIL;
sprintf(mess,
"Could not set number of interfaces. Invalid value: %d. Must "
"be %d\n",
arg, num_interfaces);
LOG(logERROR, (mess));
}
#else
// only set
if (Server_VerifyLock() == OK) {
@ -5380,12 +5392,9 @@ int get_num_interfaces(int file_des) {
int retval = -1;
LOG(logDEBUG1, ("Getting number of udp interfaces\n"));
#if !defined(JUNGFRAUD) && !defined(GOTTHARD2D)
retval = 1;
#else
// get only
retval = getNumberofUDPInterfaces();
#endif
LOG(logDEBUG1, ("Number of udp interfaces retval: %u\n", retval));
return Server_SendResult(file_des, INT32, &retval, sizeof(retval));
}
@ -6883,11 +6892,7 @@ int get_receiver_parameters(int file_des) {
// sending real detector parameters
// udp interfaces
#if defined(JUNGFRAUD) || defined(GOTTHARD2D)
i32 = getNumberofUDPInterfaces();
#else
i32 = 1;
#endif
n += sendData(file_des, &i32, sizeof(i32), INT32);
if (n < 0)
return printSocketReadError();

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) {
int num_sockets_per_detector = 1;
switch (getDetectorType().squash()) {
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;
}
int num_sockets_per_detector = pimpl->getNumberofUDPInterfaces({}).tsquash(
"Number of UDP Interfaces is not consistent among modules");
std::vector<int> res;
res.reserve(size());
for (int idet = 0; idet < size(); ++idet) {

54
slsDetectorSoftware/src/DetectorImpl.cpp
View File

@ -245,6 +245,15 @@ void DetectorImpl::setHostname(const std::vector<std::string> &name) {
addModule(hostname);
}
updateDetectorSize();
// update zmq port (especially for eiger)
int numInterfaces = modules[0]->getNumberofUDPInterfaces();
if (numInterfaces == 2) {
for (size_t i = 0; i < modules.size(); ++i) {
modules[i]->setClientStreamingPort(DEFAULT_ZMQ_CL_PORTNO +
i * numInterfaces);
}
}
}
void DetectorImpl::addModule(const std::string &hostname) {
@ -402,31 +411,25 @@ int DetectorImpl::createReceivingDataSockets() {
}
LOG(logINFO) << "Going to create data sockets";
size_t numSockets = modules.size();
size_t numSocketsPerModule = 1;
if (shm()->detType == EIGER) {
numSocketsPerModule = 2;
size_t numUDPInterfaces =
Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash(1);
// gotthard2 second interface is only for veto debugging (not in gui)
if (shm()->detType == GOTTHARD2) {
numUDPInterfaces = 1;
}
// gotthard2 second interface is only for veto debugging
else if (shm()->detType != GOTTHARD2) {
if (Parallel(&Module::getNumberofUDPInterfacesFromShm, {}).squash() ==
2) {
numSocketsPerModule = 2;
}
}
numSockets *= numSocketsPerModule;
size_t numSockets = modules.size() * numUDPInterfaces;
for (size_t iSocket = 0; iSocket < numSockets; ++iSocket) {
uint32_t portnum =
(modules[iSocket / numSocketsPerModule]->getClientStreamingPort());
portnum += (iSocket % numSocketsPerModule);
(modules[iSocket / numUDPInterfaces]->getClientStreamingPort());
portnum += (iSocket % numUDPInterfaces);
try {
zmqSocket.push_back(sls::make_unique<ZmqSocket>(
modules[iSocket / numSocketsPerModule]
->getClientStreamingIP()
.str()
.c_str(),
portnum));
zmqSocket.push_back(
sls::make_unique<ZmqSocket>(modules[iSocket / numUDPInterfaces]
->getClientStreamingIP()
.str()
.c_str(),
portnum));
// set high water mark
int hwm = shm()->zmqHwm;
if (hwm >= 0) {
@ -460,13 +463,9 @@ void DetectorImpl::readFrameFromReceiver() {
int nDetPixelsX = 0;
int nDetPixelsY = 0;
bool quadEnable = false;
// to flip image
bool eiger = false;
bool numInterfaces = 1;
// gotthard2 second interface is veto debugging
if (shm()->detType != GOTTHARD2) {
numInterfaces = Parallel(&Module::getNumberofUDPInterfacesFromShm, {})
.squash(); // cannot pick up from zmq
}
std::vector<bool> runningList(zmqSocket.size());
std::vector<bool> connectList(zmqSocket.size());
numZmqRunning = 0;
@ -542,10 +541,9 @@ void DetectorImpl::readFrameFromReceiver() {
// shape
nPixelsX = zHeader.npixelsx;
nPixelsY = zHeader.npixelsy;
// module shape
// module shape (port)
nX = zHeader.ndetx;
nY = zHeader.ndety;
nY *= numInterfaces;
nDetPixelsX = nX * nPixelsX;
nDetPixelsY = nY * nPixelsY;
// det type

4
slsDetectorSoftware/src/Module.cpp
View File

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

5
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -317,10 +317,7 @@ int ClientInterface::setup_receiver(Interface &socket) {
// basic setup
setDetectorType(arg.detType);
{
int msize[2] = {arg.numberOfModule.x, arg.numberOfModule.y};
impl()->setDetectorSize(msize);
}
impl()->setDetectorSize(arg.numberOfModule);
impl()->setModulePositionId(arg.moduleIndex);
impl()->setDetectorHostname(arg.hostname);

17
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -17,11 +17,12 @@
const std::string DataStreamer::TypeName = "DataStreamer";
DataStreamer::DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi,
bool fr, int *nm, bool *qe, uint64_t *tot)
bool fr, slsDetectorDefs::xy nm, bool *qe,
uint64_t *tot)
: ThreadObject(ind, TypeName), fifo(f), dynamicRange(dr), roi(r),
fileIndex(fi), flipRows(fr), quadEnable(qe), totalNumFrames(tot) {
numMods[0] = nm[0];
numMods[1] = nm[1];
numMods.x = nm.x;
numMods.y = nm.y;
LOG(logDEBUG) << "DataStreamer " << ind << " created";
}
@ -62,9 +63,9 @@ void DataStreamer::RecordFirstIndex(uint64_t fnum, char *buf) {
void DataStreamer::SetGeneralData(GeneralData *g) { generalData = g; }
void DataStreamer::SetNumberofModules(int *nm) {
numMods[0] = nm[0];
numMods[1] = nm[1];
void DataStreamer::SetNumberofModules(xy nm) {
numMods.x = nm.x;
numMods.y = nm.y;
}
void DataStreamer::SetFlipRows(bool fd) { flipRows = fd; }
@ -219,8 +220,8 @@ int DataStreamer::SendHeader(sls_receiver_header *rheader, uint32_t size,
zHeader.dynamicRange = *dynamicRange;
zHeader.fileIndex = *fileIndex;
zHeader.ndetx = numMods[0];
zHeader.ndety = numMods[1];
zHeader.ndetx = numMods.x;
zHeader.ndety = numMods.y;
zHeader.npixelsx = nx;
zHeader.npixelsy = ny;
zHeader.imageSize = size;

10
slsReceiverSoftware/src/DataStreamer.h
View File

@ -33,12 +33,12 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
* @param r roi
* @param fi pointer to file index
* @param fr flip rows
* @param nm pointer to number of modules in each dimension
* @param nm number of modules in each dimension
* @param qe pointer to quad Enable
* @param tot pointer to total number of frames
*/
DataStreamer(int ind, Fifo *f, uint32_t *dr, ROI *r, uint64_t *fi, bool fr,
int *nm, bool *qe, uint64_t *tot);
xy nm, bool *qe, uint64_t *tot);
/**
* Destructor
@ -65,9 +65,9 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
/**
* Set number of detectors
* @param nm number of modules in both dimensions
* @param nm number of modules/ports in both dimensions
*/
void SetNumberofModules(int *nm);
void SetNumberofModules(xy nm);
/**
* Set Flipped rows
@ -196,7 +196,7 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
char *completeBuffer{nullptr};
/** Number of Modules in X and Y dimension */
int numMods[2];
xy numMods{1, 1};
/** Quad Enable */
bool *quadEnable;

566
slsReceiverSoftware/src/GeneralData.h
View File

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

208
slsReceiverSoftware/src/Implementation.cpp
View File

@ -64,7 +64,7 @@ void Implementation::SetThreadPriorities() {
void Implementation::SetupFifoStructure() {
fifo.clear();
for (int i = 0; i < numThreads; ++i) {
for (int i = 0; i < numUDPInterfaces; ++i) {
uint32_t datasize = generalData->imageSize;
// veto data size
if (detType == GOTTHARD2 && i != 0) {
@ -97,7 +97,7 @@ void Implementation::SetupFifoStructure() {
(double)(1024 * 1024)
<< " 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:
break;
}
numThreads = generalData->threadsPerReceiver;
numUDPInterfaces = generalData->numUDPInterfaces;
fifoDepth = generalData->defaultFifoDepth;
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
framesPerFile = generalData->maxFramesPerFile;
@ -161,7 +161,7 @@ void Implementation::setDetectorType(const detectorType d) {
SetupFifoStructure();
// create threads
for (int i = 0; i < numThreads; ++i) {
for (int i = 0; i < numUDPInterfaces; ++i) {
try {
auto fifo_ptr = fifo[i].get();
@ -170,6 +170,10 @@ void Implementation::setDetectorType(const detectorType d) {
&udpSocketBufferSize, &actualUDPSocketBufferSize,
&framesPerFile, &frameDiscardMode, &activated,
&detectorDataStream[i], &silentMode));
int ctbAnalogDataBytes = 0;
if (detType == CHIPTESTBOARD) {
ctbAnalogDataBytes = generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &activated, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs, &streamingStartFnum,
@ -194,35 +198,35 @@ void Implementation::setDetectorType(const detectorType d) {
LOG(logDEBUG) << " Detector type set to " << sls::ToString(d);
}
int *Implementation::getDetectorSize() const { return (int *)numMods; }
slsDetectorDefs::xy Implementation::getDetectorSize() const {
return numModules;
}
slsDetectorDefs::xy Implementation::GetPortGeometry() {
xy portGeometry{1, 1};
if (detType == EIGER)
portGeometry.x = numUDPInterfaces;
else // (jungfrau and gotthard2)
portGeometry.y = numUDPInterfaces;
return portGeometry;
}
void Implementation::setDetectorSize(const slsDetectorDefs::xy size) {
xy portGeometry = GetPortGeometry();
void Implementation::setDetectorSize(const int *size) {
std::string log_message = "Detector Size (ports): (";
for (int i = 0; i < MAX_DIMENSIONS; ++i) {
// x dir (colums) each udp port
if (detType == EIGER && i == X)
numMods[i] = size[i] * 2;
// y dir (rows) each udp port
else if (numUDPInterfaces == 2 && i == Y)
numMods[i] = size[i] * 2;
else
numMods[i] = size[i];
log_message += std::to_string(numMods[i]);
if (i < MAX_DIMENSIONS - 1)
log_message += ", ";
}
log_message += ")";
int nm[2] = {numMods[0], numMods[1]};
numModules.x = portGeometry.x * size.x;
numModules.y = portGeometry.y * size.y;
xy nm{numModules.x, numModules.y};
if (quadEnable) {
nm[0] = 1;
nm[1] = 2;
nm.x = 1;
nm.y = 2;
}
for (const auto &it : dataStreamer) {
it->SetNumberofModules(nm);
}
LOG(logINFO) << log_message;
LOG(logINFO) << "Detector Size (ports): " << sls::ToString(numModules);
}
int Implementation::getModulePositionId() const { return modulePos; }
@ -232,19 +236,18 @@ void Implementation::setModulePositionId(const int id) {
LOG(logINFO) << "Module Position Id:" << modulePos;
// update zmq port
streamingPort =
DEFAULT_ZMQ_RX_PORTNO + (modulePos * (detType == EIGER ? 2 : 1));
xy portGeometry = GetPortGeometry();
streamingPort = DEFAULT_ZMQ_RX_PORTNO + modulePos * portGeometry.x;
for (const auto &it : dataProcessor)
it->SetupFileWriter(fileWriteEnable, masterFileWriteEnable,
fileFormatType, modulePos, &hdf5Lib);
assert(numMods[1] != 0);
assert(numModules.y != 0);
for (unsigned int i = 0; i < listener.size(); ++i) {
uint16_t row = 0, col = 0;
row =
(modulePos % numMods[1]) * ((numUDPInterfaces == 2) ? 2 : 1); // row
col = (modulePos / numMods[1]) * ((detType == EIGER) ? 2 : 1) +
i; // col for horiz. udp ports
row = (modulePos % numModules.y) * portGeometry.y;
col = (modulePos / numModules.y) * portGeometry.x + i;
listener[i]->SetHardCodedPosition(row, col);
}
}
@ -308,7 +311,7 @@ std::array<pid_t, NUM_RX_THREAD_IDS> Implementation::getThreadIds() const {
} else {
retval[id++] = 0;
}
if (numThreads == 2) {
if (numUDPInterfaces == 2) {
retval[id++] = listener[1]->GetThreadId();
retval[id++] = dataProcessor[1]->GetThreadId();
if (dataStreamEnable) {
@ -474,8 +477,8 @@ double Implementation::getProgress() const {
}
std::vector<int64_t> Implementation::getNumMissingPackets() const {
std::vector<int64_t> mp(numThreads);
for (int i = 0; i < numThreads; ++i) {
std::vector<int64_t> mp(numUDPInterfaces);
for (int i = 0; i < numUDPInterfaces; ++i) {
int np = generalData->packetsPerFrame;
uint64_t totnp = np;
// ReadNRows
@ -562,11 +565,12 @@ void Implementation::stopReceiver() {
if (modulePos == 0) {
// more than 1 file, create virtual file
if (dataProcessor[0]->GetFilesInAcquisition() > 1 ||
(numMods[X] * numMods[Y]) > 1) {
(numModules.x * numModules.y) > 1) {
dataProcessor[0]->CreateVirtualFile(
filePath, fileName, fileIndex, overwriteEnable, silentMode,
modulePos, numThreads, framesPerFile, numberOfTotalFrames,
dynamicRange, numMods[X], numMods[Y], &hdf5Lib);
modulePos, numUDPInterfaces, framesPerFile,
numberOfTotalFrames, dynamicRange, numModules.x,
numModules.y, &hdf5Lib);
}
// link file in master
dataProcessor[0]->LinkDataInMasterFile(silentMode);
@ -598,7 +602,7 @@ void Implementation::stopReceiver() {
auto mp = getNumMissingPackets();
// print summary
uint64_t tot = 0;
for (int i = 0; i < numThreads; i++) {
for (int i = 0; i < numUDPInterfaces; i++) {
int nf = dataProcessor[i]->GetNumCompleteFramesCaught();
tot += nf;
std::string mpMessage = std::to_string(mp[i]);
@ -629,7 +633,7 @@ void Implementation::stopReceiver() {
// callback
if (acquisitionFinishedCallBack) {
try {
acquisitionFinishedCallBack((tot / numThreads),
acquisitionFinishedCallBack((tot / numUDPInterfaces),
pAcquisitionFinished);
} catch (const std::exception &e) {
// change status
@ -810,7 +814,7 @@ void Implementation::SetupWriter() {
for (unsigned int i = 0; i < dataProcessor.size(); ++i) {
dataProcessor[i]->CreateFirstFiles(
masterAttributes.get(), filePath, fileName, fileIndex,
overwriteEnable, silentMode, modulePos, numThreads,
overwriteEnable, silentMode, modulePos, numUDPInterfaces,
udpPortNum[i], framesPerFile, numberOfTotalFrames, dynamicRange,
detectorDataStream[i]);
}
@ -849,16 +853,19 @@ int Implementation::getNumberofUDPInterfaces() const {
return numUDPInterfaces;
}
// not Eiger
void Implementation::setNumberofUDPInterfaces(const int n) {
if (detType == EIGER) {
throw sls::RuntimeError(
"Cannot set number of UDP interfaces for Eiger");
}
if (numUDPInterfaces != n) {
// reduce number of detectors in y dir (rows) if it had 2 interfaces
// before
if (numUDPInterfaces == 2)
numMods[Y] /= 2;
numUDPInterfaces = n;
// reduce number of detectors to size with 1 interface
xy portGeometry = GetPortGeometry();
numModules.x /= portGeometry.x;
numModules.y /= portGeometry.y;
// clear all threads and fifos
listener.clear();
@ -868,14 +875,14 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
// set local variables
generalData->SetNumberofInterfaces(n);
numThreads = generalData->threadsPerReceiver;
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
numUDPInterfaces = n;
// fifo
udpSocketBufferSize = generalData->defaultUdpSocketBufferSize;
SetupFifoStructure();
// create threads
for (int i = 0; i < numThreads; ++i) {
for (int i = 0; i < numUDPInterfaces; ++i) {
// listener and dataprocessor threads
try {
auto fifo_ptr = fifo[i].get();
@ -886,6 +893,11 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
&detectorDataStream[i], &silentMode));
listener[i]->SetGeneralData(generalData);
int ctbAnalogDataBytes = 0;
if (detType == CHIPTESTBOARD) {
ctbAnalogDataBytes =
generalData->GetNumberOfAnalogDatabytes();
}
dataProcessor.push_back(sls::make_unique<DataProcessor>(
i, detType, fifo_ptr, &activated, &dataStreamEnable,
&streamingFrequency, &streamingTimerInMs,
@ -903,18 +915,18 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
if (dataStreamEnable) {
try {
bool flip = flipRows;
int nm[2] = {numMods[0], numMods[1]};
xy nm{numModules.x, numModules.y};
if (quadEnable) {
flip = (i == 1 ? true : false);
nm[0] = 1;
nm[1] = 2;
nm.x = 1;
nm.y = 2;
}
dataStreamer.push_back(sls::make_unique<DataStreamer>(
i, fifo[i].get(), &dynamicRange, &roi, &fileIndex, flip,
(int *)nm, &quadEnable, &numberOfTotalFrames));
nm, &quadEnable, &numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(
&numThreads, streamingPort, streamingSrcIP,
&numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader);
@ -934,7 +946,7 @@ void Implementation::setNumberofUDPInterfaces(const int n) {
SetThreadPriorities();
// update (from 1 to 2 interface) & also for printout
setDetectorSize(numMods);
setDetectorSize(numModules);
// update row and column in dataprocessor
setModulePositionId(modulePos);
@ -994,7 +1006,8 @@ void Implementation::setUDPSocketBufferSize(const int s) {
// 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 && (int)listSize != numUDPInterfaces) {
if ((detType == JUNGFRAU || detType == GOTTHARD2) &&
(int)listSize != numUDPInterfaces) {
throw sls::RuntimeError(
"Number of Interfaces " + std::to_string(numUDPInterfaces) +
" do not match listener size " + std::to_string(listSize));
@ -1029,21 +1042,21 @@ void Implementation::setDataStreamEnable(const bool enable) {
dataStreamer.clear();
if (enable) {
for (int i = 0; i < numThreads; ++i) {
for (int i = 0; i < numUDPInterfaces; ++i) {
try {
bool flip = flipRows;
int nm[2] = {numMods[0], numMods[1]};
xy nm{numModules.x, numModules.y};
if (quadEnable) {
flip = (i == 1 ? true : false);
nm[0] = 1;
nm[1] = 2;
nm.x = 1;
nm.y = 2;
}
dataStreamer.push_back(sls::make_unique<DataStreamer>(
i, fifo[i].get(), &dynamicRange, &roi, &fileIndex, flip,
(int *)nm, &quadEnable, &numberOfTotalFrames));
nm, &quadEnable, &numberOfTotalFrames));
dataStreamer[i]->SetGeneralData(generalData);
dataStreamer[i]->CreateZmqSockets(
&numThreads, streamingPort, streamingSrcIP,
&numUDPInterfaces, streamingPort, streamingSrcIP,
streamingHwm);
dataStreamer[i]->SetAdditionalJsonHeader(
additionalJsonHeader);
@ -1348,11 +1361,7 @@ void Implementation::setNumberofAnalogSamples(const uint32_t i) {
if (numberOfAnalogSamples != i) {
numberOfAnalogSamples = i;
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetNumberOfAnalogSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Analog Samples: " << numberOfAnalogSamples;
@ -1367,11 +1376,7 @@ void Implementation::setNumberofDigitalSamples(const uint32_t i) {
if (numberOfDigitalSamples != i) {
numberOfDigitalSamples = i;
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetNumberOfDigitalSamples(i);
SetupFifoStructure();
}
LOG(logINFO) << "Number of Digital Samples: " << numberOfDigitalSamples;
@ -1389,8 +1394,7 @@ void Implementation::setCounterMask(const uint32_t i) {
". Expected 1-3.");
}
counterMask = i;
generalData->SetNumberofCounters(ncounters, dynamicRange,
tengigaEnable);
generalData->SetNumberofCounters(ncounters);
SetupFifoStructure();
}
LOG(logINFO) << "Counter mask: " << sls::ToStringHex(counterMask);
@ -1405,14 +1409,7 @@ void Implementation::setDynamicRange(const uint32_t i) {
dynamicRange = i;
if (detType == EIGER || detType == MYTHEN3) {
if (detType == EIGER) {
generalData->SetDynamicRange(i, tengigaEnable);
} else {
int ncounters = __builtin_popcount(counterMask);
generalData->SetNumberofCounters(ncounters, i, tengigaEnable);
}
generalData->SetDynamicRange(i);
fifoDepth = generalData->defaultFifoDepth;
SetupFifoStructure();
}
@ -1442,25 +1439,8 @@ bool Implementation::getTenGigaEnable() const { return tengigaEnable; }
void Implementation::setTenGigaEnable(const bool b) {
if (tengigaEnable != b) {
tengigaEnable = b;
int ncounters = __builtin_popcount(counterMask);
// side effects
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;
}
generalData->SetTenGigaEnable(b);
SetupFifoStructure();
}
LOG(logINFO) << "Ten Giga: " << (tengigaEnable ? "enabled" : "disabled");
@ -1494,14 +1474,15 @@ void Implementation::setQuad(const bool b) {
quadEnable = b;
if (!quadEnable) {
xy nm{numModules.x, numModules.y};
for (const auto &it : dataStreamer) {
it->SetNumberofModules(numMods);
it->SetNumberofModules(nm);
it->SetFlipRows(flipRows);
}
} else {
int size[2] = {1, 2};
xy nm{1, 2};
for (const auto &it : dataStreamer) {
it->SetNumberofModules(size);
it->SetNumberofModules(nm);
}
if (dataStreamer.size() == 2) {
dataStreamer[0]->SetFlipRows(false);
@ -1563,11 +1544,7 @@ void Implementation::setReadoutMode(const readoutMode f) {
if (readoutType != f) {
readoutType = f;
// side effects
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetReadoutMode(f);
SetupFifoStructure();
}
LOG(logINFO) << "Readout Mode: " << sls::ToString(f);
@ -1581,11 +1558,8 @@ uint32_t Implementation::getADCEnableMask() const {
void Implementation::setADCEnableMask(uint32_t mask) {
if (adcEnableMaskOneGiga != mask) {
adcEnableMaskOneGiga = mask;
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetOneGigaAdcEnableMask(mask);
SetupFifoStructure();
}
LOG(logINFO) << "ADC Enable Mask for 1Gb mode: 0x" << std::hex
@ -1601,11 +1575,7 @@ void Implementation::setTenGigaADCEnableMask(uint32_t mask) {
if (adcEnableMaskTenGiga != mask) {
adcEnableMaskTenGiga = mask;
ctbAnalogDataBytes = generalData->setImageSize(
tengigaEnable ? adcEnableMaskTenGiga : adcEnableMaskOneGiga,
numberOfAnalogSamples, numberOfDigitalSamples, tengigaEnable,
readoutType);
generalData->SetTenGigaAdcEnableMask(mask);
SetupFifoStructure();
}
LOG(logINFO) << "ADC Enable Mask for 10Gb mode: 0x" << std::hex

9
slsReceiverSoftware/src/Implementation.h
View File

@ -33,8 +33,8 @@ class Implementation : private virtual slsDetectorDefs {
* ************************************************/
void setDetectorType(const detectorType d);
int *getDetectorSize() const;
void setDetectorSize(const int *size);
xy getDetectorSize() const;
void setDetectorSize(const xy size);
int getModulePositionId() const;
void setModulePositionId(const int id);
std::string getDetectorHostname() const;
@ -266,6 +266,7 @@ class Implementation : private virtual slsDetectorDefs {
void SetThreadPriorities();
void SetupFifoStructure();
xy GetPortGeometry();
void ResetParametersforNewAcquisition();
void CreateUDPSockets();
void SetupWriter();
@ -278,9 +279,8 @@ class Implementation : private virtual slsDetectorDefs {
* ************************************************/
// config parameters
int numThreads{1};
detectorType detType{GENERIC};
int numMods[MAX_DIMENSIONS] = {0, 0};
xy numModules{1, 1};
int modulePos{0};
std::string detHostname;
bool silentMode{false};
@ -361,7 +361,6 @@ class Implementation : private virtual slsDetectorDefs {
uint32_t adcEnableMaskTenGiga{BIT32_MASK};
std::vector<int> ctbDbitList;
int ctbDbitOffset{0};
int ctbAnalogDataBytes{0};
// callbacks
int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,

4
slsSupportLib/include/sls/versionAPI.h
View File

@ -5,11 +5,11 @@
#define APILIB 0x211125
#define APIRECEIVER 0x211124
#define APIGUI 0x211124
#define APIEIGER 0x220124
#define APICTB 0x220124
#define APIGOTTHARD 0x220124
#define APIGOTTHARD2 0x220124
#define APIJUNGFRAU 0x220124
#define APIMYTHEN3 0x220124
#define APIMOENCH 0x220124
#define APIEIGER 0x220124