mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-04-21 11:20:04 +02:00
Dhanya Thattil
GitHub
commit
04d6644753
@ -8,6 +8,7 @@
|
||||
#include "versionAPI.h"
|
||||
|
||||
#include <array>
|
||||
#include <chrono>
|
||||
#include <cstdlib>
|
||||
#include <fstream>
|
||||
#include <iostream>
|
||||
@ -19,6 +20,7 @@
|
||||
#include <unistd.h>
|
||||
#include <vector>
|
||||
|
||||
using ns = std::chrono::nanoseconds;
|
||||
using sls::RuntimeError;
|
||||
using sls::SocketError;
|
||||
using Interface = sls::ServerInterface;
|
||||
@ -381,12 +383,13 @@ int ClientInterface::setup_receiver(Interface &socket) {
|
||||
}
|
||||
}
|
||||
if (myDetectorType != MYTHEN3) {
|
||||
impl()->setAcquisitionTime(arg.expTimeNs);
|
||||
impl()->setAcquisitionTime(std::chrono::nanoseconds(arg.expTimeNs));
|
||||
}
|
||||
impl()->setAcquisitionPeriod(arg.periodNs);
|
||||
impl()->setAcquisitionPeriod(std::chrono::nanoseconds(arg.periodNs));
|
||||
if (myDetectorType == EIGER) {
|
||||
impl()->setSubExpTime(arg.subExpTimeNs);
|
||||
impl()->setSubPeriod(arg.subExpTimeNs + arg.subDeadTimeNs);
|
||||
impl()->setSubExpTime(std::chrono::nanoseconds(arg.subExpTimeNs));
|
||||
impl()->setSubPeriod(std::chrono::nanoseconds(arg.subExpTimeNs) +
|
||||
std::chrono::nanoseconds(arg.subDeadTimeNs));
|
||||
impl()->setActivate(static_cast<bool>(arg.activate));
|
||||
try {
|
||||
impl()->setQuad(arg.quad == 0 ? false : true);
|
||||
@ -445,12 +448,12 @@ int ClientInterface::setup_receiver(Interface &socket) {
|
||||
}
|
||||
if (myDetectorType == MYTHEN3) {
|
||||
impl()->setCounterMask(arg.countermask);
|
||||
impl()->setAcquisitionTime1(arg.expTime1Ns);
|
||||
impl()->setAcquisitionTime2(arg.expTime2Ns);
|
||||
impl()->setAcquisitionTime3(arg.expTime3Ns);
|
||||
impl()->setGateDelay1(arg.gateDelay1Ns);
|
||||
impl()->setGateDelay2(arg.gateDelay2Ns);
|
||||
impl()->setGateDelay3(arg.gateDelay3Ns);
|
||||
impl()->setAcquisitionTime1(std::chrono::nanoseconds(arg.expTime1Ns));
|
||||
impl()->setAcquisitionTime2(std::chrono::nanoseconds(arg.expTime2Ns));
|
||||
impl()->setAcquisitionTime3(std::chrono::nanoseconds(arg.expTime3Ns));
|
||||
impl()->setGateDelay1(std::chrono::nanoseconds(arg.gateDelay1Ns));
|
||||
impl()->setGateDelay2(std::chrono::nanoseconds(arg.gateDelay2Ns));
|
||||
impl()->setGateDelay3(std::chrono::nanoseconds(arg.gateDelay3Ns));
|
||||
impl()->setNumberOfGates(arg.gates);
|
||||
}
|
||||
if (myDetectorType == GOTTHARD2) {
|
||||
@ -618,9 +621,9 @@ int ClientInterface::set_exptime(Interface &socket) {
|
||||
int64_t args[2]{-1, -1};
|
||||
socket.Receive(args);
|
||||
int gateIndex = static_cast<int>(args[0]);
|
||||
int64_t value = args[1];
|
||||
LOG(logDEBUG1) << "Setting exptime to " << value
|
||||
<< "ns (gateIndex: " << gateIndex << ")";
|
||||
ns value = std::chrono::nanoseconds(args[1]);
|
||||
LOG(logDEBUG1) << "Setting exptime to " << sls::ToString(value)
|
||||
<< " (gateIndex: " << gateIndex << ")";
|
||||
switch (gateIndex) {
|
||||
case -1:
|
||||
if (myDetectorType == MYTHEN3) {
|
||||
@ -657,27 +660,27 @@ int ClientInterface::set_exptime(Interface &socket) {
|
||||
}
|
||||
|
||||
int ClientInterface::set_period(Interface &socket) {
|
||||
auto value = socket.Receive<int64_t>();
|
||||
LOG(logDEBUG1) << "Setting period to " << value << "ns";
|
||||
auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
|
||||
LOG(logDEBUG1) << "Setting period to " << sls::ToString(value);
|
||||
impl()->setAcquisitionPeriod(value);
|
||||
return socket.Send(OK);
|
||||
}
|
||||
|
||||
int ClientInterface::set_subexptime(Interface &socket) {
|
||||
auto value = socket.Receive<int64_t>();
|
||||
LOG(logDEBUG1) << "Setting period to " << value << "ns";
|
||||
uint64_t subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
|
||||
auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
|
||||
LOG(logDEBUG1) << "Setting period to " << sls::ToString(value);
|
||||
ns subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
|
||||
impl()->setSubExpTime(value);
|
||||
impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime);
|
||||
return socket.Send(OK);
|
||||
}
|
||||
|
||||
int ClientInterface::set_subdeadtime(Interface &socket) {
|
||||
auto value = socket.Receive<int64_t>();
|
||||
LOG(logDEBUG1) << "Setting sub deadtime to " << value << "ns";
|
||||
auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
|
||||
LOG(logDEBUG1) << "Setting sub deadtime to " << sls::ToString(value);
|
||||
impl()->setSubPeriod(value + impl()->getSubExpTime());
|
||||
LOG(logDEBUG1) << "Setting sub period to " << impl()->getSubPeriod()
|
||||
<< "ns";
|
||||
LOG(logDEBUG1) << "Setting sub period to "
|
||||
<< sls::ToString(impl()->getSubPeriod());
|
||||
return socket.Send(OK);
|
||||
}
|
||||
|
||||
@ -782,7 +785,7 @@ int ClientInterface::set_file_dir(Interface &socket) {
|
||||
}
|
||||
if (fpath[0] != '/')
|
||||
throw RuntimeError("Receiver path needs to be absolute path");
|
||||
|
||||
|
||||
LOG(logDEBUG1) << "Setting file path: " << fpath;
|
||||
impl()->setFilePath(fpath);
|
||||
return socket.Send(OK);
|
||||
@ -1554,9 +1557,9 @@ int ClientInterface::set_gate_delay(Interface &socket) {
|
||||
int64_t args[2]{-1, -1};
|
||||
socket.Receive(args);
|
||||
int gateIndex = static_cast<int>(args[0]);
|
||||
int64_t value = args[1];
|
||||
LOG(logDEBUG1) << "Setting gate delay to " << value
|
||||
<< "ns (gateIndex: " << gateIndex << ")";
|
||||
auto value = std::chrono::nanoseconds(args[1]);
|
||||
LOG(logDEBUG1) << "Setting gate delay to " << sls::ToString(value)
|
||||
<< " (gateIndex: " << gateIndex << ")";
|
||||
if (myDetectorType != MYTHEN3) {
|
||||
functionNotImplemented();
|
||||
}
|
||||
|
||||
@ -23,121 +23,12 @@
|
||||
/** cosntructor & destructor */
|
||||
|
||||
Implementation::Implementation(const detectorType d) {
|
||||
InitializeMembers();
|
||||
setDetectorType(d);
|
||||
}
|
||||
|
||||
Implementation::~Implementation() { DeleteMembers(); }
|
||||
|
||||
void Implementation::DeleteMembers() {
|
||||
Implementation::~Implementation() {
|
||||
delete generalData;
|
||||
generalData = nullptr;
|
||||
additionalJsonHeader.clear();
|
||||
listener.clear();
|
||||
dataProcessor.clear();
|
||||
dataStreamer.clear();
|
||||
fifo.clear();
|
||||
eth.clear();
|
||||
udpPortNum.clear();
|
||||
rateCorrections.clear();
|
||||
ctbDbitList.clear();
|
||||
}
|
||||
|
||||
void Implementation::InitializeMembers() {
|
||||
// config parameters
|
||||
numThreads = 1;
|
||||
myDetectorType = GENERIC;
|
||||
for (int i = 0; i < MAX_DIMENSIONS; ++i)
|
||||
numDet[i] = 0;
|
||||
modulePos = 0;
|
||||
detHostname = "";
|
||||
silentMode = false;
|
||||
fifoDepth = 0;
|
||||
frameDiscardMode = NO_DISCARD;
|
||||
framePadding = true;
|
||||
|
||||
// file parameters
|
||||
fileFormatType = BINARY;
|
||||
filePath = "/";
|
||||
fileName = "run";
|
||||
fileIndex = 0;
|
||||
fileWriteEnable = true;
|
||||
masterFileWriteEnable = true;
|
||||
overwriteEnable = true;
|
||||
framesPerFile = 0;
|
||||
|
||||
// acquisition
|
||||
status = IDLE;
|
||||
stoppedFlag = false;
|
||||
|
||||
// network configuration (UDP)
|
||||
numUDPInterfaces = 1;
|
||||
eth.resize(MAX_NUMBER_OF_LISTENING_THREADS);
|
||||
udpPortNum.resize(MAX_NUMBER_OF_LISTENING_THREADS);
|
||||
for (int i = 0; i < MAX_NUMBER_OF_LISTENING_THREADS; ++i) {
|
||||
eth[i] = "";
|
||||
udpPortNum[i] = DEFAULT_UDP_PORTNO + i;
|
||||
}
|
||||
udpSocketBufferSize = 0;
|
||||
actualUDPSocketBufferSize = 0;
|
||||
|
||||
// zmq parameters
|
||||
dataStreamEnable = false;
|
||||
streamingFrequency = 1;
|
||||
streamingTimerInMs = DEFAULT_STREAMING_TIMER_IN_MS;
|
||||
streamingStartFnum = 0;
|
||||
streamingPort = 0;
|
||||
streamingSrcIP = sls::IpAddr{};
|
||||
|
||||
// detector parameters
|
||||
numberOfTotalFrames = 0;
|
||||
numberOfFrames = 1;
|
||||
numberOfTriggers = 1;
|
||||
numberOfBursts = 1;
|
||||
numberOfAdditionalStorageCells = 0;
|
||||
numberOfGates = 0;
|
||||
timingMode = AUTO_TIMING;
|
||||
burstMode = BURST_INTERNAL;
|
||||
acquisitionPeriod = SAMPLE_TIME_IN_NS;
|
||||
acquisitionTime = 0;
|
||||
acquisitionTime1 = 0;
|
||||
acquisitionTime2 = 0;
|
||||
acquisitionTime3 = 0;
|
||||
gateDelay1 = 0;
|
||||
gateDelay2 = 0;
|
||||
gateDelay3 = 0;
|
||||
subExpTime = 0;
|
||||
subPeriod = 0;
|
||||
numberOfAnalogSamples = 0;
|
||||
numberOfDigitalSamples = 0;
|
||||
counterMask = 0;
|
||||
dynamicRange = 16;
|
||||
roi.xmin = -1;
|
||||
roi.xmax = -1;
|
||||
tengigaEnable = false;
|
||||
flippedDataX = 0;
|
||||
quadEnable = false;
|
||||
activated = true;
|
||||
deactivatedPaddingEnable = true;
|
||||
numLinesReadout = MAX_EIGER_ROWS_PER_READOUT;
|
||||
readoutType = ANALOG_ONLY;
|
||||
adcEnableMaskOneGiga = BIT32_MASK;
|
||||
adcEnableMaskTenGiga = BIT32_MASK;
|
||||
|
||||
ctbDbitOffset = 0;
|
||||
ctbAnalogDataBytes = 0;
|
||||
|
||||
// callbacks
|
||||
startAcquisitionCallBack = nullptr;
|
||||
pStartAcquisition = nullptr;
|
||||
acquisitionFinishedCallBack = nullptr;
|
||||
pAcquisitionFinished = nullptr;
|
||||
rawDataReadyCallBack = nullptr;
|
||||
rawDataModifyReadyCallBack = nullptr;
|
||||
pRawDataReady = nullptr;
|
||||
|
||||
// class objects
|
||||
generalData = nullptr;
|
||||
}
|
||||
|
||||
void Implementation::SetLocalNetworkParameters() {
|
||||
@ -835,12 +726,12 @@ void Implementation::SetupWriter() {
|
||||
xy(generalData->nPixelsX, generalData->nPixelsY);
|
||||
masterAttributes->maxFramesPerFile = framesPerFile;
|
||||
masterAttributes->totalFrames = numberOfTotalFrames;
|
||||
masterAttributes->exptime = std::chrono::nanoseconds(acquisitionTime);
|
||||
masterAttributes->period = std::chrono::nanoseconds(acquisitionPeriod);
|
||||
masterAttributes->exptime = acquisitionTime;
|
||||
masterAttributes->period = acquisitionPeriod;
|
||||
masterAttributes->dynamicRange = dynamicRange;
|
||||
masterAttributes->tenGiga = tengigaEnable;
|
||||
masterAttributes->subExptime = std::chrono::nanoseconds(subExpTime);
|
||||
masterAttributes->subPeriod = std::chrono::nanoseconds(subPeriod);
|
||||
masterAttributes->subExptime = subExpTime;
|
||||
masterAttributes->subPeriod = subPeriod;
|
||||
masterAttributes->quad = quadEnable;
|
||||
masterAttributes->ratecorr = rateCorrections;
|
||||
masterAttributes->adcmask =
|
||||
@ -858,12 +749,12 @@ void Implementation::SetupWriter() {
|
||||
}
|
||||
masterAttributes->roi = roi;
|
||||
masterAttributes->counterMask = counterMask;
|
||||
masterAttributes->exptime1 = std::chrono::nanoseconds(acquisitionTime1);
|
||||
masterAttributes->exptime2 = std::chrono::nanoseconds(acquisitionTime2);
|
||||
masterAttributes->exptime3 = std::chrono::nanoseconds(acquisitionTime3);
|
||||
masterAttributes->gateDelay1 = std::chrono::nanoseconds(gateDelay1);
|
||||
masterAttributes->gateDelay2 = std::chrono::nanoseconds(gateDelay2);
|
||||
masterAttributes->gateDelay3 = std::chrono::nanoseconds(gateDelay3);
|
||||
masterAttributes->exptime1 = acquisitionTime1;
|
||||
masterAttributes->exptime2 = acquisitionTime2;
|
||||
masterAttributes->exptime3 = acquisitionTime3;
|
||||
masterAttributes->gateDelay1 = gateDelay1;
|
||||
masterAttributes->gateDelay2 = gateDelay2;
|
||||
masterAttributes->gateDelay3 = gateDelay3;
|
||||
masterAttributes->gates = numberOfGates;
|
||||
|
||||
try {
|
||||
@ -1298,81 +1189,74 @@ void Implementation::setBurstMode(const slsDetectorDefs::burstMode i) {
|
||||
updateTotalNumberOfFrames();
|
||||
}
|
||||
|
||||
uint64_t Implementation::getAcquisitionPeriod() const {
|
||||
return acquisitionPeriod;
|
||||
}
|
||||
ns Implementation::getAcquisitionPeriod() const { return acquisitionPeriod; }
|
||||
|
||||
void Implementation::setAcquisitionPeriod(const uint64_t i) {
|
||||
void Implementation::setAcquisitionPeriod(const ns i) {
|
||||
acquisitionPeriod = i;
|
||||
LOG(logINFO) << "Acquisition Period: " << (double)acquisitionPeriod / (1E9)
|
||||
<< "s";
|
||||
LOG(logINFO) << "Acquisition Period: " << sls::ToString(acquisitionPeriod);
|
||||
}
|
||||
|
||||
uint64_t Implementation::getAcquisitionTime() const { return acquisitionTime; }
|
||||
ns Implementation::getAcquisitionTime() const { return acquisitionTime; }
|
||||
|
||||
void Implementation::updateAcquisitionTime() {
|
||||
if (acquisitionTime1 == acquisitionTime2 &&
|
||||
acquisitionTime2 == acquisitionTime3) {
|
||||
acquisitionTime = acquisitionTime1;
|
||||
} else {
|
||||
acquisitionTime = -1;
|
||||
acquisitionTime = std::chrono::nanoseconds(0);
|
||||
}
|
||||
}
|
||||
|
||||
void Implementation::setAcquisitionTime(const uint64_t i) {
|
||||
void Implementation::setAcquisitionTime(const ns i) {
|
||||
acquisitionTime = i;
|
||||
LOG(logINFO) << "Acquisition Time: " << (double)acquisitionTime / (1E9)
|
||||
<< "s";
|
||||
LOG(logINFO) << "Acquisition Time: " << sls::ToString(acquisitionTime);
|
||||
}
|
||||
|
||||
void Implementation::setAcquisitionTime1(const uint64_t i) {
|
||||
void Implementation::setAcquisitionTime1(const ns i) {
|
||||
acquisitionTime1 = i;
|
||||
LOG(logINFO) << "Acquisition Time1: " << (double)acquisitionTime1 / (1E9)
|
||||
<< "s";
|
||||
LOG(logINFO) << "Acquisition Time1: " << sls::ToString(acquisitionTime1);
|
||||
updateAcquisitionTime();
|
||||
}
|
||||
|
||||
void Implementation::setAcquisitionTime2(const uint64_t i) {
|
||||
void Implementation::setAcquisitionTime2(const ns i) {
|
||||
acquisitionTime2 = i;
|
||||
LOG(logINFO) << "Acquisition Time2: " << (double)acquisitionTime2 / (1E9)
|
||||
<< "s";
|
||||
LOG(logINFO) << "Acquisition Time2: " << sls::ToString(acquisitionTime2);
|
||||
updateAcquisitionTime();
|
||||
}
|
||||
|
||||
void Implementation::setAcquisitionTime3(const uint64_t i) {
|
||||
void Implementation::setAcquisitionTime3(const ns i) {
|
||||
acquisitionTime3 = i;
|
||||
LOG(logINFO) << "Acquisition Time3: " << (double)acquisitionTime3 / (1E9)
|
||||
<< "s";
|
||||
LOG(logINFO) << "Acquisition Time3: " << sls::ToString(acquisitionTime3);
|
||||
updateAcquisitionTime();
|
||||
}
|
||||
|
||||
void Implementation::setGateDelay1(const uint64_t i) {
|
||||
void Implementation::setGateDelay1(const ns i) {
|
||||
gateDelay1 = i;
|
||||
LOG(logINFO) << "Gate Delay1: " << (double)gateDelay1 / (1E9) << "s";
|
||||
LOG(logINFO) << "Gate Delay1: " << sls::ToString(gateDelay1);
|
||||
}
|
||||
|
||||
void Implementation::setGateDelay2(const uint64_t i) {
|
||||
void Implementation::setGateDelay2(const ns i) {
|
||||
gateDelay2 = i;
|
||||
LOG(logINFO) << "Gate Delay2: " << (double)gateDelay2 / (1E9) << "s";
|
||||
LOG(logINFO) << "Gate Delay2: " << sls::ToString(gateDelay2);
|
||||
}
|
||||
|
||||
void Implementation::setGateDelay3(const uint64_t i) {
|
||||
void Implementation::setGateDelay3(const ns i) {
|
||||
gateDelay3 = i;
|
||||
LOG(logINFO) << "Gate Delay3: " << (double)gateDelay3 / (1E9) << "s";
|
||||
LOG(logINFO) << "Gate Delay3: " << sls::ToString(gateDelay3);
|
||||
}
|
||||
|
||||
uint64_t Implementation::getSubExpTime() const { return subExpTime; }
|
||||
ns Implementation::getSubExpTime() const { return subExpTime; }
|
||||
|
||||
void Implementation::setSubExpTime(const uint64_t i) {
|
||||
void Implementation::setSubExpTime(const ns i) {
|
||||
subExpTime = i;
|
||||
LOG(logINFO) << "Sub Exposure Time: " << (double)subExpTime / (1E9) << "s";
|
||||
LOG(logINFO) << "Sub Exposure Time: " << sls::ToString(subExpTime);
|
||||
}
|
||||
|
||||
uint64_t Implementation::getSubPeriod() const { return subPeriod; }
|
||||
ns Implementation::getSubPeriod() const { return subPeriod; }
|
||||
|
||||
void Implementation::setSubPeriod(const uint64_t i) {
|
||||
void Implementation::setSubPeriod(const ns i) {
|
||||
subPeriod = i;
|
||||
LOG(logINFO) << "Sub Period: " << (double)subPeriod / (1E9) << "s";
|
||||
LOG(logINFO) << "Sub Period: " << sls::ToString(subPeriod);
|
||||
}
|
||||
|
||||
uint32_t Implementation::getNumberofAnalogSamples() const {
|
||||
|
||||
@ -11,10 +11,12 @@ class Fifo;
|
||||
class slsDetectorDefs;
|
||||
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <exception>
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
using ns = std::chrono::nanoseconds;
|
||||
|
||||
class Implementation : private virtual slsDetectorDefs {
|
||||
public:
|
||||
@ -156,30 +158,30 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
burstMode getBurstMode() const;
|
||||
/** [Gottthard2] */
|
||||
void setBurstMode(const burstMode i);
|
||||
uint64_t getAcquisitionTime() const;
|
||||
void setAcquisitionTime(const uint64_t i);
|
||||
ns getAcquisitionTime() const;
|
||||
void setAcquisitionTime(const ns i);
|
||||
/** [Mythen3] */
|
||||
void updateAcquisitionTime();
|
||||
/** [Mythen3] */
|
||||
void setAcquisitionTime1(const uint64_t i);
|
||||
void setAcquisitionTime1(const ns i);
|
||||
/** [Mythen3] */
|
||||
void setAcquisitionTime2(const uint64_t i);
|
||||
void setAcquisitionTime2(const ns i);
|
||||
/** [Mythen3] */
|
||||
void setAcquisitionTime3(const uint64_t i);
|
||||
void setAcquisitionTime3(const ns i);
|
||||
/** [Mythen3] */
|
||||
void setGateDelay1(const uint64_t i);
|
||||
void setGateDelay1(const ns i);
|
||||
/** [Mythen3] */
|
||||
void setGateDelay2(const uint64_t i);
|
||||
void setGateDelay2(const ns i);
|
||||
/** [Mythen3] */
|
||||
void setGateDelay3(const uint64_t i);
|
||||
uint64_t getAcquisitionPeriod() const;
|
||||
void setAcquisitionPeriod(const uint64_t i);
|
||||
uint64_t getSubExpTime() const;
|
||||
void setGateDelay3(const ns i);
|
||||
ns getAcquisitionPeriod() const;
|
||||
void setAcquisitionPeriod(const ns i);
|
||||
ns getSubExpTime() const;
|
||||
/* [Eiger] */
|
||||
void setSubExpTime(const uint64_t i);
|
||||
uint64_t getSubPeriod() const;
|
||||
void setSubExpTime(const ns i);
|
||||
ns getSubPeriod() const;
|
||||
/* [Eiger] */
|
||||
void setSubPeriod(const uint64_t i);
|
||||
void setSubPeriod(const ns i);
|
||||
uint32_t getNumberofAnalogSamples() const;
|
||||
/**[Ctb][Moench] */
|
||||
void setNumberofAnalogSamples(const uint32_t i);
|
||||
@ -225,7 +227,7 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
void setTenGigaADCEnableMask(const uint32_t mask);
|
||||
std::vector<int> getDbitList() const;
|
||||
/* [Ctb] */
|
||||
void setDbitList(const std::vector<int>& v);
|
||||
void setDbitList(const std::vector<int> &v);
|
||||
int getDbitOffset() const;
|
||||
/* [Ctb] */
|
||||
void setDbitOffset(const int s);
|
||||
@ -249,8 +251,6 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
void *arg);
|
||||
|
||||
private:
|
||||
void DeleteMembers();
|
||||
void InitializeMembers();
|
||||
void SetLocalNetworkParameters();
|
||||
void SetThreadPriorities();
|
||||
void SetupFifoStructure();
|
||||
@ -267,89 +267,89 @@ class Implementation : private virtual slsDetectorDefs {
|
||||
* ************************************************/
|
||||
|
||||
// config parameters
|
||||
int numThreads;
|
||||
detectorType myDetectorType;
|
||||
int numDet[MAX_DIMENSIONS];
|
||||
int modulePos;
|
||||
int numThreads{1};
|
||||
detectorType myDetectorType{GENERIC};
|
||||
int numDet[MAX_DIMENSIONS] = {0, 0};
|
||||
int modulePos{0};
|
||||
std::string detHostname;
|
||||
bool silentMode;
|
||||
uint32_t fifoDepth;
|
||||
frameDiscardPolicy frameDiscardMode;
|
||||
bool framePadding;
|
||||
bool silentMode{false};
|
||||
uint32_t fifoDepth{0};
|
||||
frameDiscardPolicy frameDiscardMode{NO_DISCARD};
|
||||
bool framePadding{true};
|
||||
pid_t parentThreadId;
|
||||
pid_t tcpThreadId;
|
||||
|
||||
// file parameters
|
||||
fileFormat fileFormatType;
|
||||
std::string filePath;
|
||||
std::string fileName;
|
||||
uint64_t fileIndex;
|
||||
bool fileWriteEnable;
|
||||
bool masterFileWriteEnable;
|
||||
bool overwriteEnable;
|
||||
uint32_t framesPerFile;
|
||||
fileFormat fileFormatType{BINARY};
|
||||
std::string filePath{"/"};
|
||||
std::string fileName{"run"};
|
||||
uint64_t fileIndex{0};
|
||||
bool fileWriteEnable{true};
|
||||
bool masterFileWriteEnable{true};
|
||||
bool overwriteEnable{true};
|
||||
uint32_t framesPerFile{0};
|
||||
|
||||
// acquisition
|
||||
std::atomic<runStatus> status;
|
||||
bool stoppedFlag;
|
||||
std::atomic<runStatus> status{IDLE};
|
||||
bool stoppedFlag{false};
|
||||
|
||||
// network configuration (UDP)
|
||||
int numUDPInterfaces;
|
||||
std::vector<std::string> eth;
|
||||
std::vector<uint32_t> udpPortNum;
|
||||
int64_t udpSocketBufferSize;
|
||||
int64_t actualUDPSocketBufferSize;
|
||||
int numUDPInterfaces{1};
|
||||
std::array<std::string,MAX_NUMBER_OF_LISTENING_THREADS>eth;
|
||||
std::array<uint32_t,MAX_NUMBER_OF_LISTENING_THREADS> udpPortNum{DEFAULT_UDP_PORTNO, DEFAULT_UDP_PORTNO+1};
|
||||
int64_t udpSocketBufferSize{0};
|
||||
int64_t actualUDPSocketBufferSize{0};
|
||||
|
||||
// zmq parameters
|
||||
bool dataStreamEnable;
|
||||
uint32_t streamingFrequency;
|
||||
uint32_t streamingTimerInMs;
|
||||
uint32_t streamingStartFnum;
|
||||
uint32_t streamingPort;
|
||||
sls::IpAddr streamingSrcIP;
|
||||
bool dataStreamEnable{false};
|
||||
uint32_t streamingFrequency{1};
|
||||
uint32_t streamingTimerInMs{DEFAULT_STREAMING_TIMER_IN_MS};
|
||||
uint32_t streamingStartFnum{0};
|
||||
uint32_t streamingPort{0};
|
||||
sls::IpAddr streamingSrcIP = sls::IpAddr{};
|
||||
std::map<std::string, std::string> additionalJsonHeader;
|
||||
|
||||
// detector parameters
|
||||
uint64_t numberOfTotalFrames;
|
||||
uint64_t numberOfFrames;
|
||||
uint64_t numberOfTriggers;
|
||||
uint64_t numberOfBursts;
|
||||
int numberOfAdditionalStorageCells;
|
||||
int numberOfGates;
|
||||
timingMode timingMode;
|
||||
burstMode burstMode;
|
||||
uint64_t acquisitionPeriod;
|
||||
uint64_t acquisitionTime;
|
||||
uint64_t acquisitionTime1;
|
||||
uint64_t acquisitionTime2;
|
||||
uint64_t acquisitionTime3;
|
||||
uint64_t gateDelay1;
|
||||
uint64_t gateDelay2;
|
||||
uint64_t gateDelay3;
|
||||
uint64_t subExpTime;
|
||||
uint64_t subPeriod;
|
||||
uint64_t numberOfAnalogSamples;
|
||||
uint64_t numberOfDigitalSamples;
|
||||
uint32_t counterMask;
|
||||
uint32_t dynamicRange;
|
||||
ROI roi;
|
||||
bool tengigaEnable;
|
||||
int flippedDataX;
|
||||
bool quadEnable;
|
||||
bool activated;
|
||||
bool deactivatedPaddingEnable;
|
||||
int numLinesReadout;
|
||||
uint64_t numberOfTotalFrames{0};
|
||||
uint64_t numberOfFrames{1};
|
||||
uint64_t numberOfTriggers{1};
|
||||
uint64_t numberOfBursts{1};
|
||||
int numberOfAdditionalStorageCells{0};
|
||||
int numberOfGates{0};
|
||||
timingMode timingMode{AUTO_TIMING};
|
||||
burstMode burstMode{BURST_INTERNAL};
|
||||
ns acquisitionPeriod = std::chrono::nanoseconds(SAMPLE_TIME_IN_NS);
|
||||
ns acquisitionTime = std::chrono::nanoseconds(0);
|
||||
ns acquisitionTime1 = std::chrono::nanoseconds(0);
|
||||
ns acquisitionTime2 = std::chrono::nanoseconds(0);
|
||||
ns acquisitionTime3 = std::chrono::nanoseconds(0);
|
||||
ns gateDelay1 = std::chrono::nanoseconds(0);
|
||||
ns gateDelay2 = std::chrono::nanoseconds(0);
|
||||
ns gateDelay3 = std::chrono::nanoseconds(0);
|
||||
ns subExpTime = std::chrono::nanoseconds(0);
|
||||
ns subPeriod = std::chrono::nanoseconds(0);
|
||||
uint32_t numberOfAnalogSamples{0};
|
||||
uint32_t numberOfDigitalSamples{0};
|
||||
uint32_t counterMask{0};
|
||||
uint32_t dynamicRange{16};
|
||||
ROI roi{};
|
||||
bool tengigaEnable{false};
|
||||
int flippedDataX{0};
|
||||
bool quadEnable{false};
|
||||
bool activated{true};
|
||||
bool deactivatedPaddingEnable{true};
|
||||
int numLinesReadout{MAX_EIGER_ROWS_PER_READOUT};
|
||||
std::vector<int64_t> rateCorrections;
|
||||
readoutMode readoutType;
|
||||
uint32_t adcEnableMaskOneGiga;
|
||||
uint32_t adcEnableMaskTenGiga;
|
||||
readoutMode readoutType{ANALOG_ONLY};
|
||||
uint32_t adcEnableMaskOneGiga{BIT32_MASK};
|
||||
uint32_t adcEnableMaskTenGiga{BIT32_MASK};
|
||||
std::vector<int> ctbDbitList;
|
||||
int ctbDbitOffset;
|
||||
int ctbAnalogDataBytes;
|
||||
int ctbDbitOffset{0};
|
||||
int ctbAnalogDataBytes{0};
|
||||
|
||||
// callbacks
|
||||
int (*startAcquisitionCallBack)(std::string, std::string, uint64_t,
|
||||
uint32_t, void *);
|
||||
uint32_t, void *){nullptr};
|
||||
void *pStartAcquisition;
|
||||
void (*acquisitionFinishedCallBack)(uint64_t, void *);
|
||||
void *pAcquisitionFinished;
|
||||
|
||||
@ -42,10 +42,14 @@ std::string ToString(const slsDetectorDefs::rxParameters &r) {
|
||||
<< "bursts:" << r.bursts << std::endl
|
||||
<< "analogSamples:" << r.analogSamples << std::endl
|
||||
<< "digitalSamples:" << r.digitalSamples << std::endl
|
||||
<< "expTimeNs:" << r.expTimeNs << std::endl
|
||||
<< "periodNs:" << r.periodNs << std::endl
|
||||
<< "subExpTimeNs:" << r.subExpTimeNs << std::endl
|
||||
<< "subDeadTimeNs:" << r.subDeadTimeNs << std::endl
|
||||
<< "expTime:" << ToString(std::chrono::nanoseconds(r.expTimeNs))
|
||||
<< std::endl
|
||||
<< "period:" << ToString(std::chrono::nanoseconds(r.periodNs))
|
||||
<< std::endl
|
||||
<< "subExpTime:" << ToString(std::chrono::nanoseconds(r.subExpTimeNs))
|
||||
<< std::endl
|
||||
<< "subDeadTime:" << ToString(std::chrono::nanoseconds(r.subDeadTimeNs))
|
||||
<< std::endl
|
||||
<< "activate:" << r.activate << std::endl
|
||||
<< "quad:" << r.quad << std::endl
|
||||
<< "dynamicRange:" << r.dynamicRange << std::endl
|
||||
@ -58,12 +62,18 @@ std::string ToString(const slsDetectorDefs::rxParameters &r) {
|
||||
<< "roi.xmax:" << r.roi.xmax << std::endl
|
||||
<< "countermask:" << r.countermask << std::endl
|
||||
<< "burstType:" << r.burstType << std::endl
|
||||
<< "exptime1:" << r.expTime1Ns << std::endl
|
||||
<< "exptime2:" << r.expTime2Ns << std::endl
|
||||
<< "exptime3:" << r.expTime3Ns << std::endl
|
||||
<< "gateDelay1:" << r.gateDelay1Ns << std::endl
|
||||
<< "gateDelay2:" << r.gateDelay2Ns << std::endl
|
||||
<< "gateDelay3:" << r.gateDelay3Ns << std::endl
|
||||
<< "exptime1:" << ToString(std::chrono::nanoseconds(r.expTime1Ns))
|
||||
<< std::endl
|
||||
<< "exptime2:" << ToString(std::chrono::nanoseconds(r.expTime2Ns))
|
||||
<< std::endl
|
||||
<< "exptime3:" << ToString(std::chrono::nanoseconds(r.expTime3Ns))
|
||||
<< std::endl
|
||||
<< "gateDelay1:" << ToString(std::chrono::nanoseconds(r.gateDelay1Ns))
|
||||
<< std::endl
|
||||
<< "gateDelay2:" << ToString(std::chrono::nanoseconds(r.gateDelay2Ns))
|
||||
<< std::endl
|
||||
<< "gateDelay3:" << ToString(std::chrono::nanoseconds(r.gateDelay3Ns))
|
||||
<< std::endl
|
||||
<< "gates:" << r.gates << std::endl
|
||||
<< ']';
|
||||
return oss.str();
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user