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

Dev/remove gotthard i (#1108)

Browse Source 
* slsSupportLib done, at receiver rooting out in implementation

* removed from receiver and client

* removed everywhere except gui, python and client(commands.yaml and Detector.h)

* updated python

* fixed autocomplete to print what the issue is if there is one with ToString when running the autocomplete script to generate fixed.json. updated readme.md in generator folder

* formatting

* removed enums for dacs

* udpating autocomplete and generating commands

* removed gotthard from docs and release notes

* removed dac test

* bug from removing g1

* fixed virtual test for xilinx, was minor. so in this PR

* gui done

* binary in merge fix

* formatting and removing enums

* updated fixed and dump.json

* bash autocomplete

* updated doc on command line generation

* removing increments in dac enums for backward compatibility. Not required

* removed ROI from rxParameters  (only in g1), not needed to be backward compatible

* removed the phase shift option from det server staruip
This commit is contained in:
maliakal_d
2025-03-10 14:24:33 +01:00
committed by GitHub
parent fa504e6675
commit 297c3752e3
103 changed files with 20090 additions and 27262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -44,7 +44,7 @@ ClientInterface::~ClientInterface() {
}
ClientInterface::ClientInterface(uint16_t portNumber)
: detType(GOTTHARD), portNumber(portNumber), server(portNumber) {
: detType(GENERIC), portNumber(portNumber), server(portNumber) {
validatePortNumber(portNumber);
functionTable();
parentThreadId = gettid();
@ -120,7 +120,6 @@ int ClientInterface::functionTable(){
flist[F_GET_LAST_RECEIVER_CLIENT_IP] = &ClientInterface::get_last_client_ip;
flist[F_GET_RECEIVER_VERSION] = &ClientInterface::get_version;
flist[F_SETUP_RECEIVER] = &ClientInterface::setup_receiver;
flist[F_RECEIVER_SET_DETECTOR_ROI] = &ClientInterface::set_detector_roi;
flist[F_RECEIVER_SET_NUM_FRAMES] = &ClientInterface::set_num_frames;
flist[F_SET_RECEIVER_NUM_TRIGGERS] = &ClientInterface::set_num_triggers;
flist[F_SET_RECEIVER_NUM_BURSTS] = &ClientInterface::set_num_bursts;
@ -413,9 +412,6 @@ int ClientInterface::setup_receiver(Interface &socket) {
if (detType == CHIPTESTBOARD) {
impl()->setADCEnableMask(arg.adcMask);
}
if (detType == GOTTHARD) {
impl()->setDetectorROI(arg.roi);
}
if (detType == MYTHEN3) {
impl()->setCounterMask(arg.countermask);
impl()->setAcquisitionTime1(
@ -443,7 +439,6 @@ int ClientInterface::setup_receiver(Interface &socket) {
void ClientInterface::setDetectorType(detectorType arg) {
switch (arg) {
case GOTTHARD:
case EIGER:
case CHIPTESTBOARD:
case XILINX_CHIPTESTBOARD:
@ -482,22 +477,6 @@ void ClientInterface::setDetectorType(detectorType arg) {
impl()->setThreadIds(parentThreadId, tcpThreadId);
}
int ClientInterface::set_detector_roi(Interface &socket) {
auto arg = socket.Receive<ROI>();
LOG(logDEBUG1) << "Set Detector ROI: " << ToString(arg);
if (detType != GOTTHARD)
functionNotImplemented();
verifyIdle(socket);
try {
impl()->setDetectorROI(arg);
} catch (const std::exception &e) {
throw RuntimeError("Could not set ROI [" + std::string(e.what()) + ']');
}
return socket.Send(OK);
}
int ClientInterface::set_num_frames(Interface &socket) {
auto value = socket.Receive<int64_t>();
if (value <= 0) {

1
slsReceiverSoftware/src/ClientInterface.h
View File

@ -63,7 +63,6 @@ class ClientInterface : private virtual slsDetectorDefs {
int get_version(ServerInterface &socket);
int setup_receiver(ServerInterface &socket);
void setDetectorType(detectorType arg);
int set_detector_roi(ServerInterface &socket);
int set_num_frames(ServerInterface &socket);
int set_num_triggers(ServerInterface &socket);
int set_num_bursts(ServerInterface &socket);

15
slsReceiverSoftware/src/DataProcessor.cpp
View File

@ -213,9 +213,8 @@ std::string DataProcessor::CreateVirtualFile(
"Skipping virtual hdf5 file since rx_roi is enabled.");
}
bool gotthard25um = ((generalData->detType == GOTTHARD ||
generalData->detType == GOTTHARD2) &&
(numModX * numModY) == 2);
bool gotthard25um =
(generalData->detType == GOTTHARD2 && (numModX * numModY) == 2);
// 0 for infinite files
uint32_t framesPerFile =
@ -505,16 +504,6 @@ void DataProcessor::PadMissingPackets(sls_receiver_header header, char *data) {
// missing packet
switch (generalData->detType) {
// for gotthard, 1st packet: 4 bytes fnum, CACA + CACA, 639*2 bytes
// data
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data +
// 640*2 bytes data !!
case GOTTHARD:
if (pnum == 0u)
memset(data + (pnum * dsize), 0xFF, dsize - 2);
else
memset(data + (pnum * dsize), 0xFF, dsize + 2);
break;
case CHIPTESTBOARD:
case XILINX_CHIPTESTBOARD:
if (pnum == (pperFrame - 1))

56
slsReceiverSoftware/src/DataStreamer.cpp
View File

@ -22,10 +22,7 @@ DataStreamer::DataStreamer(int index) : ThreadObject(index, TypeName) {
LOG(logDEBUG) << "DataStreamer " << index << " created";
}
DataStreamer::~DataStreamer() {
CloseZmqSocket();
delete[] completeBuffer;
}
DataStreamer::~DataStreamer() { CloseZmqSocket(); }
void DataStreamer::SetFifo(Fifo *f) { fifo = f; }
@ -62,19 +59,7 @@ void DataStreamer::ResetParametersforNewAcquisition(const std::string &fname) {
StopRunning();
startedFlag = false;
firstIndex = 0;
fileNametoStream = fname;
if (completeBuffer) {
delete[] completeBuffer;
completeBuffer = nullptr;
}
if (generalData->detType == GOTTHARD &&
generalData->detectorRoi.xmin != -1) {
adcConfigured =
generalData->GetAdcConfigured(index, generalData->detectorRoi);
completeBuffer = new char[generalData->imageSizeComplete];
memset(completeBuffer, 0, generalData->imageSizeComplete);
}
}
void DataStreamer::RecordFirstIndex(uint64_t fnum, size_t firstImageIndex) {
@ -160,40 +145,15 @@ void DataStreamer::ProcessAnImage(sls_detector_header header, size_t size,
uint64_t fnum = header.frameNumber;
LOG(logDEBUG1) << "DataStreamer " << index << ": fnum:" << fnum;
// shortframe gotthard
if (completeBuffer) {
// disregarding the size modified from callback (always using
// imageSizeComplete instead of size because gui needs
// imagesizecomplete and listener writes imagesize to size
if (!SendDataHeader(header, generalData->imageSizeComplete,
generalData->nPixelsXComplete,
generalData->nPixelsYComplete)) {
LOG(logERROR) << "Could not send zmq header for fnum " << fnum
<< " and streamer " << index;
}
memcpy(completeBuffer + ((generalData->imageSize) * adcConfigured),
data, size);
if (!zmqSocket->SendData(completeBuffer,
generalData->imageSizeComplete)) {
LOG(logERROR) << "Could not send zmq data for fnum " << fnum
<< " and streamer " << index;
}
if (!SendDataHeader(header, size, generalData->nPixelsX,
generalData->nPixelsY)) {
LOG(logERROR) << "Could not send zmq header for fnum " << fnum
<< " and streamer " << index;
}
// normal
else {
if (!SendDataHeader(header, size, generalData->nPixelsX,
generalData->nPixelsY)) {
LOG(logERROR) << "Could not send zmq header for fnum " << fnum
<< " and streamer " << index;
}
if (!zmqSocket->SendData(data, size)) {
LOG(logERROR) << "Could not send zmq data for fnum " << fnum
<< " and streamer " << index;
}
if (!zmqSocket->SendData(data, size)) {
LOG(logERROR) << "Could not send zmq data for fnum " << fnum
<< " and streamer " << index;
}
}

3
slsReceiverSoftware/src/DataStreamer.h
View File

@ -88,7 +88,6 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
const GeneralData *generalData{nullptr};
Fifo *fifo{nullptr};
ZmqSocket *zmqSocket{nullptr};
int adcConfigured{-1};
uint64_t fileIndex{0};
bool flipRows{false};
std::map<std::string, std::string> additionalJsonHeader;
@ -107,8 +106,6 @@ class DataStreamer : private virtual slsDetectorDefs, public ThreadObject {
bool startedFlag{false};
uint64_t firstIndex{0};
std::string fileNametoStream;
/** Complete buffer used for detectorRoi, eg. shortGotthard */
char *completeBuffer{nullptr};
xy numPorts{1, 1};
bool quadEnable{false};

166
slsReceiverSoftware/src/GeneralData.h
View File

@ -40,13 +40,6 @@ class GeneralData {
uint32_t fifoDepth{0};
int numUDPInterfaces{1};
uint32_t headerPacketSize{0};
/** Streaming (for ROI - mainly short Gotthard) */
uint32_t nPixelsXComplete{0};
/** Streaming (for ROI - mainly short Gotthard) */
uint32_t nPixelsYComplete{0};
/** Streaming (for ROI - mainly short Gotthard) - Image size (in bytes) */
uint32_t imageSizeComplete{0};
/** if standard header implemented in firmware */
bool standardheader{false};
uint32_t udpSocketBufferSize{RECEIVE_SOCKET_BUFFER_SIZE};
uint32_t vetoDataSize{0};
@ -62,7 +55,6 @@ class GeneralData {
slsDetectorDefs::readoutMode readoutType{slsDetectorDefs::ANALOG_ONLY};
uint32_t adcEnableMaskOneGiga{BIT32_MASK};
uint32_t adcEnableMaskTenGiga{BIT32_MASK};
slsDetectorDefs::ROI detectorRoi{};
uint32_t counterMask{0};
uint32_t transceiverMask{0};
slsDetectorDefs::frameDiscardPolicy frameDiscardMode{
@ -84,14 +76,12 @@ class GeneralData {
* Get Header Infomation (frame number, packet number)
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @param oddStartingPacket odd starting packet (gotthard)
* @param frameNumber frame number
* @param packetNumber packet number
* @param bunchId bunch Id
*/
virtual void GetHeaderInfo(int index, char *packetData,
bool oddStartingPacket, uint64_t &frameNumber,
uint32_t &packetNumber,
uint64_t &frameNumber, uint32_t &packetNumber,
uint64_t &bunchId) const {
frameNumber = ((uint32_t)(*((uint32_t *)(packetData))));
frameNumber++;
@ -100,16 +90,6 @@ class GeneralData {
bunchId = -1;
}
virtual void SetDetectorROI(slsDetectorDefs::ROI i) {
ThrowGenericError("SetDetectorROI");
};
/**@returns adc configured */
virtual int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
ThrowGenericError("GetAdcConfigured");
return 0;
};
virtual void SetDynamicRange(int dr) {
ThrowGenericError("SetDynamicRange");
};
@ -118,11 +98,6 @@ class GeneralData {
ThrowGenericError("SetTenGigaEnable");
};
virtual bool SetOddStartingPacket(int index, char *packetData) {
ThrowGenericError("SetOddStartingPacket");
return false;
};
virtual void SetNumberofInterfaces(const int n) {
ThrowGenericError("SetNumberofInterfaces");
};
@ -175,139 +150,6 @@ class GeneralData {
};
};
class GotthardData : public GeneralData {
private:
const int nChan = 128;
const int nChipsPerAdc = 2;
public:
GotthardData() {
detType = slsDetectorDefs::GOTTHARD;
nPixelsY = 1;
headerSizeinPacket = 6;
framesPerFile = MAX_FRAMES_PER_FILE;
UpdateImageSize();
};
/**
* Get Header Infomation (frame number, packet number)
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @param oddStartingPacket odd starting packet (gotthard)
* @param frameNumber frame number
* @param packetNumber packet number
* @param bunchId bunch Id
*/
void GetHeaderInfo(int index, char *packetData, bool oddStartingPacket,
uint64_t &frameNumber, uint32_t &packetNumber,
uint64_t &bunchId) const {
if (nPixelsX == 1280) {
frameNumber = *reinterpret_cast<uint32_t *>(packetData);
if (oddStartingPacket)
frameNumber++;
packetNumber = frameNumber & packetIndexMask;
frameNumber = (frameNumber & frameIndexMask) >> frameIndexOffset;
} else {
frameNumber = *reinterpret_cast<uint32_t *>(packetData);
packetNumber = 0;
}
bunchId = -1;
}
/** @returns adc configured */
int GetAdcConfigured(int index, slsDetectorDefs::ROI i) const {
int adc = -1;
// single adc
if (i.xmin != -1) {
// gotthard can have only one adc per detector enabled (or all)
// adc = mid value/numchans also for only 1 roi
adc = ((((i.xmax) + (i.xmin)) / 2) / (nChan * nChipsPerAdc));
if ((adc < 0) || (adc > 4)) {
LOG(logWARNING) << index
<< ": Deleting ROI. "
"Adc value should be between 0 and 4";
adc = -1;
}
}
LOG(logINFO) << "Adc Configured: " << adc;
return adc;
};
/**
* 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
*/
bool SetOddStartingPacket(int index, char *packetData) {
bool oddStartingPacket = true;
// care only if no roi
if (nPixelsX == 1280) {
uint32_t fnum = ((uint32_t)(*((uint32_t *)(packetData))));
uint32_t firstData = ((uint32_t)(*((uint32_t *)(packetData + 4))));
// first packet
if (firstData == 0xCACACACA) {
// packet number should be 0, but is 1 => so odd starting packet
if (fnum & packetIndexMask) {
oddStartingPacket = true;
} else {
oddStartingPacket = false;
}
}
// second packet
else {
// packet number should be 1, but is 0 => so odd starting packet
if (!(fnum & packetIndexMask)) {
oddStartingPacket = true;
} else {
oddStartingPacket = false;
}
}
}
return oddStartingPacket;
};
void SetDetectorROI(slsDetectorDefs::ROI i) {
detectorRoi = i;
UpdateImageSize();
};
private:
void UpdateImageSize() {
// all adcs
if (detectorRoi.xmin == -1) {
nPixelsX = 1280;
dataSize = 1280;
packetsPerFrame = 2;
frameIndexMask = 0xFFFFFFFE;
frameIndexOffset = 1;
packetIndexMask = 1;
framesPerFile = MAX_FRAMES_PER_FILE;
nPixelsXComplete = 0;
nPixelsYComplete = 0;
imageSizeComplete = 0;
fifoDepth = 50000;
} else {
nPixelsX = 256;
dataSize = 512;
packetsPerFrame = 1;
frameIndexMask = 0xFFFFFFFF;
frameIndexOffset = 0;
packetIndexMask = 0;
framesPerFile = SHORT_MAX_FRAMES_PER_FILE;
nPixelsXComplete = 1280;
nPixelsYComplete = 1;
imageSizeComplete = 1280 * 2;
fifoDepth = 75000;
}
imageSize = int(nPixelsX * nPixelsY * GetPixelDepth());
packetSize = headerSizeinPacket + dataSize;
packetsPerFrame = imageSize / dataSize;
};
};
class EigerData : public GeneralData {
public:
@ -502,14 +344,12 @@ class Gotthard2Data : public GeneralData {
* Get Header Infomation (frame number, packet number) for veto packets
* @param index thread index for debugging purposes
* @param packetData pointer to data
* @param oddStartingPacket odd starting packet (gotthard)
* @param frameNumber frame number
* @param packetNumber packet number
* @param bunchId bunch Id
*/
void GetHeaderInfo(int index, char *packetData, bool oddStartingPacket,
uint64_t &frameNumber, uint32_t &packetNumber,
uint64_t &bunchId) const {
void GetHeaderInfo(int index, char *packetData, uint64_t &frameNumber,
uint32_t &packetNumber, uint64_t &bunchId) const {
frameNumber = *reinterpret_cast<uint64_t *>(packetData);
bunchId = *reinterpret_cast<uint64_t *>(packetData + 8);
packetNumber = 0;

21
slsReceiverSoftware/src/Implementation.cpp
View File

@ -111,7 +111,6 @@ void Implementation::SetupFifoStructure() {
void Implementation::setDetectorType(const detectorType d) {
switch (d) {
case GOTTHARD:
case EIGER:
case JUNGFRAU:
case MOENCH:
@ -131,9 +130,6 @@ void Implementation::setDetectorType(const detectorType d) {
// set detector specific variables
switch (d) {
case GOTTHARD:
generalData = new GotthardData();
break;
case EIGER:
generalData = new EigerData();
break;
@ -1007,7 +1003,6 @@ void Implementation::StartMasterWriter() {
generalData->readoutType == DIGITAL_AND_TRANSCEIVER)
? 1
: 0;
masterAttributes.detectorRoi = generalData->detectorRoi;
masterAttributes.counterMask = generalData->counterMask;
masterAttributes.exptimeArray[0] = acquisitionTime1;
masterAttributes.exptimeArray[1] = acquisitionTime2;
@ -1600,22 +1595,6 @@ void Implementation::setDynamicRange(const uint32_t i) {
LOG(logINFO) << "Dynamic Range: " << generalData->dynamicRange;
}
slsDetectorDefs::ROI Implementation::getROI() const {
return generalData->detectorRoi;
}
void Implementation::setDetectorROI(slsDetectorDefs::ROI arg) {
if (generalData->detectorRoi.xmin != arg.xmin ||
generalData->detectorRoi.xmax != arg.xmax) {
// only for gotthard
generalData->SetDetectorROI(arg);
SetupFifoStructure();
}
LOG(logINFO) << "Detector ROI: " << ToString(generalData->detectorRoi);
LOG(logINFO) << "Packets per Frame: " << (generalData->packetsPerFrame);
}
bool Implementation::getTenGigaEnable() const {
return generalData->tengigaEnable;
}

3
slsReceiverSoftware/src/Implementation.h
View File

@ -211,9 +211,6 @@ class Implementation : private virtual slsDetectorDefs {
void setCounterMask(const uint32_t i);
uint32_t getDynamicRange() const;
void setDynamicRange(const uint32_t i);
ROI getROI() const;
/* [Gotthard] */
void setDetectorROI(ROI arg);
bool getTenGigaEnable() const;
/* [Eiger][Ctb] */
void setTenGigaEnable(const bool b);

20
slsReceiverSoftware/src/Listener.cpp
View File

@ -350,8 +350,6 @@ uint32_t Listener::ListenToAnImage(sls_receiver_header &dstHeader,
carryOverFlag = false;
}
// until last packet isHeaderEmpty to account for gotthard short frame, else
// never entering this loop)
while (numpackets < pperFrame) {
// listen to new packet
if (!udpSocketAlive || !udpSocket->ReceivePacket(&listeningPacket[0])) {
@ -463,15 +461,6 @@ void Listener::CopyPacket(char *dst, char *src, uint32_t dataSize,
// copy packet data
switch (generalData->detType) {
// for gotthard,
// 1st packet: 4 bytes fnum, CACA + CACA, 639*2 bytes data
// 2nd packet: 4 bytes fnum, previous 1*2 bytes data + 640*2 bytes data
case GOTTHARD:
if (!pnum)
memcpy(dst, &src[detHeaderSize + 2], dataSize - 2);
else
memcpy(dst + dataSize - 2, &src[detHeaderSize - 2], dataSize + 2);
break;
case CHIPTESTBOARD:
case XILINX_CHIPTESTBOARD:
if (pnum == (generalData->packetsPerFrame - 1))
@ -517,14 +506,7 @@ void Listener::GetPacketIndices(uint64_t &fnum, uint32_t &pnum, uint64_t &bnum,
fnum = header->frameNumber;
pnum = header->packetNumber;
} else {
// set first packet to be odd or even (check required when switching
// from roi to no roi)
if (generalData->detType == GOTTHARD && !startedFlag) {
oddStartingPacket =
generalData->SetOddStartingPacket(index, &packet[0]);
}
generalData->GetHeaderInfo(index, &packet[0], oddStartingPacket, fnum,
pnum, bnum);
generalData->GetHeaderInfo(index, &packet[0], fnum, pnum, bnum);
}
}

6
slsReceiverSoftware/src/Listener.h
View File

@ -156,12 +156,6 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject {
// for print progress during acquisition*/
uint32_t numPacketsStatistic{0};
uint32_t numFramesStatistic{0};
/**
* starting packet number is odd or even, accordingly increment frame number
* to get first packet number as 0
* (pecific to gotthard, can vary between modules, hence defined here) */
bool oddStartingPacket{true};
};
} // namespace sls

47
slsReceiverSoftware/src/MasterAttributes.cpp
View File

@ -10,9 +10,6 @@ void MasterAttributes::GetBinaryAttributes(
w->StartObject();
GetCommonBinaryAttributes(w);
switch (detType) {
case slsDetectorDefs::GOTTHARD:
GetGotthardBinaryAttributes(w);
break;
case slsDetectorDefs::JUNGFRAU:
GetJungfrauBinaryAttributes(w);
break;
@ -45,9 +42,6 @@ void MasterAttributes::GetBinaryAttributes(
void MasterAttributes::WriteHDF5Attributes(H5::H5File *fd, H5::Group *group) {
WriteCommonHDF5Attributes(fd, group);
switch (detType) {
case slsDetectorDefs::GOTTHARD:
WriteGotthardHDF5Attributes(fd, group);
break;
case slsDetectorDefs::JUNGFRAU:
WriteJungfrauHDF5Attributes(fd, group);
break;
@ -385,23 +379,6 @@ void MasterAttributes::WriteHDF5TenGiga(H5::H5File *fd, H5::Group *group) {
dataset.write(&tenGiga, H5::PredType::NATIVE_INT);
}
void MasterAttributes::WriteHDF5ROI(H5::H5File *fd, H5::Group *group) {
// Roi xmin
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet(
"roi xmin", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&detectorRoi.xmin, H5::PredType::NATIVE_INT);
}
// Roi xmax
{
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
H5::DataSet dataset = group->createDataSet(
"roi xmax", H5::PredType::NATIVE_INT, dataspace);
dataset.write(&detectorRoi.xmax, H5::PredType::NATIVE_INT);
}
}
void MasterAttributes::WriteHDF5NumUDPInterfaces(H5::H5File *fd,
H5::Group *group) {
H5::DataSpace dataspace = H5::DataSpace(H5S_SCALAR);
@ -606,30 +583,6 @@ void MasterAttributes::WriteHDF5TransceiverSamples(H5::H5File *fd,
}
#endif
void MasterAttributes::GetGotthardBinaryAttributes(
rapidjson::PrettyWriter<rapidjson::StringBuffer> *w) {
w->Key("Exptime");
w->String(ToString(exptime).c_str());
w->Key("Period");
w->String(ToString(period).c_str());
w->Key("Detector Roi");
w->StartObject();
w->Key("xmin");
w->Uint(detectorRoi.xmin);
w->Key("xmax");
w->Uint(detectorRoi.xmax);
w->EndObject();
};
#ifdef HDF5C
void MasterAttributes::WriteGotthardHDF5Attributes(H5::H5File *fd,
H5::Group *group) {
MasterAttributes::WriteHDF5Exptime(fd, group);
MasterAttributes::WriteHDF5Period(fd, group);
MasterAttributes::WriteHDF5ROI(fd, group);
}
#endif
void MasterAttributes::GetJungfrauBinaryAttributes(
rapidjson::PrettyWriter<rapidjson::StringBuffer> *w) {
w->Key("Exptime");

8
slsReceiverSoftware/src/MasterAttributes.h
View File

@ -56,7 +56,6 @@ class MasterAttributes {
uint32_t transceiverMask{0};
uint32_t transceiver{0};
uint32_t transceiverSamples{0};
slsDetectorDefs::ROI detectorRoi{};
slsDetectorDefs::ROI receiverRoi{};
uint32_t counterMask{0};
std::array<ns, 3> exptimeArray{};
@ -85,7 +84,6 @@ class MasterAttributes {
void WriteHDF5Period(H5::H5File *fd, H5::Group *group);
void WriteHDF5DynamicRange(H5::H5File *fd, H5::Group *group);
void WriteHDF5TenGiga(H5::H5File *fd, H5::Group *group);
void WriteHDF5ROI(H5::H5File *fd, H5::Group *group);
void WriteHDF5NumUDPInterfaces(H5::H5File *fd, H5::Group *group);
void WriteHDF5ReadNRows(H5::H5File *fd, H5::Group *group);
void WriteHDF5ThresholdEnergy(H5::H5File *fd, H5::Group *group);
@ -111,12 +109,6 @@ class MasterAttributes {
void WriteHDF5TransceiverSamples(H5::H5File *fd, H5::Group *group);
#endif
void GetGotthardBinaryAttributes(
rapidjson::PrettyWriter<rapidjson::StringBuffer> *w);
#ifdef HDF5C
void WriteGotthardHDF5Attributes(H5::H5File *fd, H5::Group *group);
#endif
void GetJungfrauBinaryAttributes(
rapidjson::PrettyWriter<rapidjson::StringBuffer> *w);
#ifdef HDF5C

3
slsReceiverSoftware/src/receiver_defs.h
View File

@ -57,9 +57,6 @@ struct image_structure {
// parameters to calculate fifo depth
#define SAMPLE_TIME_IN_NS (100000000) // 100ms
// to differentiate between gotthard and short gotthard
#define GOTTHARD_PACKET_SIZE (1286)
#define DUMMY_PACKET_VALUE (0xFFFFFFFF)
#define LISTENER_PRIORITY (90)

27
slsReceiverSoftware/tests/test-GeneralData.cpp
View File

@ -53,30 +53,3 @@
// CHECK(bunchId == 0xf012fb20010f195b);
// CHECK(subFrameNumber == -1);
// }
// TEST_CASE("Parse header gotthard data", "[receiver]") {
// GotthardData data;
// struct packet {
// uint32_t frameNumber;
// unsigned char data[GOTTHARD_PACKET_SIZE];
// } __attribute__((packed));
// packet test_packet;
// test_packet.frameNumber = 25698u;
// int index = 0;
// char *packetData = reinterpret_cast<char *>(&test_packet);
// uint32_t dynamicRange{0};
// bool oddStartingPacket{0};
// uint64_t frameNumber{0};
// uint32_t packetNumber{0};
// uint32_t subFrameNumber{0};
// uint64_t bunchId{0};
// data.GetHeaderInfo(index, packetData, dynamicRange, oddStartingPacket,
// frameNumber, packetNumber, subFrameNumber, bunchId);
// CHECK(frameNumber == test_packet.frameNumber/2);
// CHECK(subFrameNumber == -1);
// CHECK(bunchId == -1);
// }