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

rxr chrono

Browse Source
This commit is contained in:
maliakal_d
2020-08-05 12:07:45 +02:00
parent 6db5954d21
commit 7b6f4d0b5b
4 changed files with 123 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -8,6 +8,7 @@
#include "versionAPI.h" #include "versionAPI.h"
#include <array> #include <array>
#include <chrono>
#include <cstdlib> #include <cstdlib>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
@ -19,6 +20,7 @@
#include <unistd.h> #include <unistd.h>
#include <vector> #include <vector>
using ns = std::chrono::nanoseconds;
using sls::RuntimeError; using sls::RuntimeError;
using sls::SocketError; using sls::SocketError;
using Interface = sls::ServerInterface; using Interface = sls::ServerInterface;
@ -381,12 +383,13 @@ int ClientInterface::setup_receiver(Interface &socket) {
} }
} }
if (myDetectorType != MYTHEN3) { 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) { if (myDetectorType == EIGER) {
impl()->setSubExpTime(arg.subExpTimeNs); impl()->setSubExpTime(std::chrono::nanoseconds(arg.subExpTimeNs));
impl()->setSubPeriod(arg.subExpTimeNs + arg.subDeadTimeNs); impl()->setSubPeriod(std::chrono::nanoseconds(arg.subExpTimeNs) +
std::chrono::nanoseconds(arg.subDeadTimeNs));
impl()->setActivate(static_cast<bool>(arg.activate)); impl()->setActivate(static_cast<bool>(arg.activate));
try { try {
impl()->setQuad(arg.quad == 0 ? false : true); impl()->setQuad(arg.quad == 0 ? false : true);
@ -445,12 +448,12 @@ int ClientInterface::setup_receiver(Interface &socket) {
} }
if (myDetectorType == MYTHEN3) { if (myDetectorType == MYTHEN3) {
impl()->setCounterMask(arg.countermask); impl()->setCounterMask(arg.countermask);
impl()->setAcquisitionTime1(arg.expTime1Ns); impl()->setAcquisitionTime1(std::chrono::nanoseconds(arg.expTime1Ns));
impl()->setAcquisitionTime2(arg.expTime2Ns); impl()->setAcquisitionTime2(std::chrono::nanoseconds(arg.expTime2Ns));
impl()->setAcquisitionTime3(arg.expTime3Ns); impl()->setAcquisitionTime3(std::chrono::nanoseconds(arg.expTime3Ns));
impl()->setGateDelay1(arg.gateDelay1Ns); impl()->setGateDelay1(std::chrono::nanoseconds(arg.gateDelay1Ns));
impl()->setGateDelay2(arg.gateDelay2Ns); impl()->setGateDelay2(std::chrono::nanoseconds(arg.gateDelay2Ns));
impl()->setGateDelay3(arg.gateDelay3Ns); impl()->setGateDelay3(std::chrono::nanoseconds(arg.gateDelay3Ns));
impl()->setNumberOfGates(arg.gates); impl()->setNumberOfGates(arg.gates);
} }
if (myDetectorType == GOTTHARD2) { if (myDetectorType == GOTTHARD2) {
@ -618,9 +621,9 @@ int ClientInterface::set_exptime(Interface &socket) {
int64_t args[2]{-1, -1}; int64_t args[2]{-1, -1};
socket.Receive(args); socket.Receive(args);
int gateIndex = static_cast<int>(args[0]); int gateIndex = static_cast<int>(args[0]);
int64_t value = args[1]; ns value = std::chrono::nanoseconds(args[1]);
LOG(logDEBUG1) << "Setting exptime to " << value LOG(logDEBUG1) << "Setting exptime to " << sls::ToString(value)
<< "ns (gateIndex: " << gateIndex << ")"; << " (gateIndex: " << gateIndex << ")";
switch (gateIndex) { switch (gateIndex) {
case -1: case -1:
if (myDetectorType == MYTHEN3) { if (myDetectorType == MYTHEN3) {
@ -657,27 +660,27 @@ int ClientInterface::set_exptime(Interface &socket) {
} }
int ClientInterface::set_period(Interface &socket) { int ClientInterface::set_period(Interface &socket) {
auto value = socket.Receive<int64_t>(); auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
LOG(logDEBUG1) << "Setting period to " << value << "ns"; LOG(logDEBUG1) << "Setting period to " << sls::ToString(value);
impl()->setAcquisitionPeriod(value); impl()->setAcquisitionPeriod(value);
return socket.Send(OK); return socket.Send(OK);
} }
int ClientInterface::set_subexptime(Interface &socket) { int ClientInterface::set_subexptime(Interface &socket) {
auto value = socket.Receive<int64_t>(); auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
LOG(logDEBUG1) << "Setting period to " << value << "ns"; LOG(logDEBUG1) << "Setting period to " << sls::ToString(value);
uint64_t subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime(); ns subdeadtime = impl()->getSubPeriod() - impl()->getSubExpTime();
impl()->setSubExpTime(value); impl()->setSubExpTime(value);
impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime); impl()->setSubPeriod(impl()->getSubExpTime() + subdeadtime);
return socket.Send(OK); return socket.Send(OK);
} }
int ClientInterface::set_subdeadtime(Interface &socket) { int ClientInterface::set_subdeadtime(Interface &socket) {
auto value = socket.Receive<int64_t>(); auto value = std::chrono::nanoseconds(socket.Receive<int64_t>());
LOG(logDEBUG1) << "Setting sub deadtime to " << value << "ns"; LOG(logDEBUG1) << "Setting sub deadtime to " << sls::ToString(value);
impl()->setSubPeriod(value + impl()->getSubExpTime()); impl()->setSubPeriod(value + impl()->getSubExpTime());
LOG(logDEBUG1) << "Setting sub period to " << impl()->getSubPeriod() LOG(logDEBUG1) << "Setting sub period to "
<< "ns"; << sls::ToString(impl()->getSubPeriod());
return socket.Send(OK); return socket.Send(OK);
} }
@ -1554,9 +1557,9 @@ int ClientInterface::set_gate_delay(Interface &socket) {
int64_t args[2]{-1, -1}; int64_t args[2]{-1, -1};
socket.Receive(args); socket.Receive(args);
int gateIndex = static_cast<int>(args[0]); int gateIndex = static_cast<int>(args[0]);
int64_t value = args[1]; auto value = std::chrono::nanoseconds(args[1]);
LOG(logDEBUG1) << "Setting gate delay to " << value LOG(logDEBUG1) << "Setting gate delay to " << sls::ToString(value)
<< "ns (gateIndex: " << gateIndex << ")"; << " (gateIndex: " << gateIndex << ")";
if (myDetectorType != MYTHEN3) { if (myDetectorType != MYTHEN3) {
functionNotImplemented(); functionNotImplemented();
} }

97
slsReceiverSoftware/src/Implementation.cpp
View File

@ -98,16 +98,16 @@ void Implementation::InitializeMembers() {
numberOfGates = 0; numberOfGates = 0;
timingMode = AUTO_TIMING; timingMode = AUTO_TIMING;
burstMode = BURST_INTERNAL; burstMode = BURST_INTERNAL;
acquisitionPeriod = SAMPLE_TIME_IN_NS; acquisitionPeriod = std::chrono::nanoseconds(SAMPLE_TIME_IN_NS);
acquisitionTime = 0; acquisitionTime = std::chrono::nanoseconds(0);
acquisitionTime1 = 0; acquisitionTime1 = std::chrono::nanoseconds(0);
acquisitionTime2 = 0; acquisitionTime2 = std::chrono::nanoseconds(0);
acquisitionTime3 = 0; acquisitionTime3 = std::chrono::nanoseconds(0);
gateDelay1 = 0; gateDelay1 = std::chrono::nanoseconds(0);
gateDelay2 = 0; gateDelay2 = std::chrono::nanoseconds(0);
gateDelay3 = 0; gateDelay3 = std::chrono::nanoseconds(0);
subExpTime = 0; subExpTime = std::chrono::nanoseconds(0);
subPeriod = 0; subPeriod = std::chrono::nanoseconds(0);
numberOfAnalogSamples = 0; numberOfAnalogSamples = 0;
numberOfDigitalSamples = 0; numberOfDigitalSamples = 0;
counterMask = 0; counterMask = 0;
@ -835,12 +835,12 @@ void Implementation::SetupWriter() {
xy(generalData->nPixelsX, generalData->nPixelsY); xy(generalData->nPixelsX, generalData->nPixelsY);
masterAttributes->maxFramesPerFile = framesPerFile; masterAttributes->maxFramesPerFile = framesPerFile;
masterAttributes->totalFrames = numberOfTotalFrames; masterAttributes->totalFrames = numberOfTotalFrames;
masterAttributes->exptime = std::chrono::nanoseconds(acquisitionTime); masterAttributes->exptime = acquisitionTime;
masterAttributes->period = std::chrono::nanoseconds(acquisitionPeriod); masterAttributes->period = acquisitionPeriod;
masterAttributes->dynamicRange = dynamicRange; masterAttributes->dynamicRange = dynamicRange;
masterAttributes->tenGiga = tengigaEnable; masterAttributes->tenGiga = tengigaEnable;
masterAttributes->subExptime = std::chrono::nanoseconds(subExpTime); masterAttributes->subExptime = subExpTime;
masterAttributes->subPeriod = std::chrono::nanoseconds(subPeriod); masterAttributes->subPeriod = subPeriod;
masterAttributes->quad = quadEnable; masterAttributes->quad = quadEnable;
masterAttributes->ratecorr = rateCorrections; masterAttributes->ratecorr = rateCorrections;
masterAttributes->adcmask = masterAttributes->adcmask =
@ -858,12 +858,12 @@ void Implementation::SetupWriter() {
} }
masterAttributes->roi = roi; masterAttributes->roi = roi;
masterAttributes->counterMask = counterMask; masterAttributes->counterMask = counterMask;
masterAttributes->exptime1 = std::chrono::nanoseconds(acquisitionTime1); masterAttributes->exptime1 = acquisitionTime1;
masterAttributes->exptime2 = std::chrono::nanoseconds(acquisitionTime2); masterAttributes->exptime2 = acquisitionTime2;
masterAttributes->exptime3 = std::chrono::nanoseconds(acquisitionTime3); masterAttributes->exptime3 = acquisitionTime3;
masterAttributes->gateDelay1 = std::chrono::nanoseconds(gateDelay1); masterAttributes->gateDelay1 = gateDelay1;
masterAttributes->gateDelay2 = std::chrono::nanoseconds(gateDelay2); masterAttributes->gateDelay2 = gateDelay2;
masterAttributes->gateDelay3 = std::chrono::nanoseconds(gateDelay3); masterAttributes->gateDelay3 = gateDelay3;
masterAttributes->gates = numberOfGates; masterAttributes->gates = numberOfGates;
try { try {
@ -1298,81 +1298,74 @@ void Implementation::setBurstMode(const slsDetectorDefs::burstMode i) {
updateTotalNumberOfFrames(); updateTotalNumberOfFrames();
} }
uint64_t Implementation::getAcquisitionPeriod() const { ns Implementation::getAcquisitionPeriod() const { return acquisitionPeriod; }
return acquisitionPeriod;
}
void Implementation::setAcquisitionPeriod(const uint64_t i) { void Implementation::setAcquisitionPeriod(const ns i) {
acquisitionPeriod = i; acquisitionPeriod = i;
LOG(logINFO) << "Acquisition Period: " << (double)acquisitionPeriod / (1E9) LOG(logINFO) << "Acquisition Period: " << sls::ToString(acquisitionPeriod);
<< "s";
} }
uint64_t Implementation::getAcquisitionTime() const { return acquisitionTime; } ns Implementation::getAcquisitionTime() const { return acquisitionTime; }
void Implementation::updateAcquisitionTime() { void Implementation::updateAcquisitionTime() {
if (acquisitionTime1 == acquisitionTime2 && if (acquisitionTime1 == acquisitionTime2 &&
acquisitionTime2 == acquisitionTime3) { acquisitionTime2 == acquisitionTime3) {
acquisitionTime = acquisitionTime1; acquisitionTime = acquisitionTime1;
} else { } else {
acquisitionTime = -1; acquisitionTime = std::chrono::nanoseconds(0);
} }
} }
void Implementation::setAcquisitionTime(const uint64_t i) { void Implementation::setAcquisitionTime(const ns i) {
acquisitionTime = i; acquisitionTime = i;
LOG(logINFO) << "Acquisition Time: " << (double)acquisitionTime / (1E9) LOG(logINFO) << "Acquisition Time: " << sls::ToString(acquisitionTime);
<< "s";
} }
void Implementation::setAcquisitionTime1(const uint64_t i) { void Implementation::setAcquisitionTime1(const ns i) {
acquisitionTime1 = i; acquisitionTime1 = i;
LOG(logINFO) << "Acquisition Time1: " << (double)acquisitionTime1 / (1E9) LOG(logINFO) << "Acquisition Time1: " << sls::ToString(acquisitionTime1);
<< "s";
updateAcquisitionTime(); updateAcquisitionTime();
} }
void Implementation::setAcquisitionTime2(const uint64_t i) { void Implementation::setAcquisitionTime2(const ns i) {
acquisitionTime2 = i; acquisitionTime2 = i;
LOG(logINFO) << "Acquisition Time2: " << (double)acquisitionTime2 / (1E9) LOG(logINFO) << "Acquisition Time2: " << sls::ToString(acquisitionTime2);
<< "s";
updateAcquisitionTime(); updateAcquisitionTime();
} }
void Implementation::setAcquisitionTime3(const uint64_t i) { void Implementation::setAcquisitionTime3(const ns i) {
acquisitionTime3 = i; acquisitionTime3 = i;
LOG(logINFO) << "Acquisition Time3: " << (double)acquisitionTime3 / (1E9) LOG(logINFO) << "Acquisition Time3: " << sls::ToString(acquisitionTime3);
<< "s";
updateAcquisitionTime(); updateAcquisitionTime();
} }
void Implementation::setGateDelay1(const uint64_t i) { void Implementation::setGateDelay1(const ns i) {
gateDelay1 = 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; 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; 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; 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; subPeriod = i;
LOG(logINFO) << "Sub Period: " << (double)subPeriod / (1E9) << "s"; LOG(logINFO) << "Sub Period: " << sls::ToString(subPeriod);
} }
uint32_t Implementation::getNumberofAnalogSamples() const { uint32_t Implementation::getNumberofAnalogSamples() const {

56
slsReceiverSoftware/src/Implementation.h
View File

@ -11,10 +11,12 @@ class Fifo;
class slsDetectorDefs; class slsDetectorDefs;
#include <atomic> #include <atomic>
#include <chrono>
#include <exception> #include <exception>
#include <map> #include <map>
#include <memory> #include <memory>
#include <vector> #include <vector>
using ns = std::chrono::nanoseconds;
class Implementation : private virtual slsDetectorDefs { class Implementation : private virtual slsDetectorDefs {
public: public:
@ -156,30 +158,30 @@ class Implementation : private virtual slsDetectorDefs {
burstMode getBurstMode() const; burstMode getBurstMode() const;
/** [Gottthard2] */ /** [Gottthard2] */
void setBurstMode(const burstMode i); void setBurstMode(const burstMode i);
uint64_t getAcquisitionTime() const; ns getAcquisitionTime() const;
void setAcquisitionTime(const uint64_t i); void setAcquisitionTime(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void updateAcquisitionTime(); void updateAcquisitionTime();
/** [Mythen3] */ /** [Mythen3] */
void setAcquisitionTime1(const uint64_t i); void setAcquisitionTime1(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void setAcquisitionTime2(const uint64_t i); void setAcquisitionTime2(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void setAcquisitionTime3(const uint64_t i); void setAcquisitionTime3(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void setGateDelay1(const uint64_t i); void setGateDelay1(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void setGateDelay2(const uint64_t i); void setGateDelay2(const ns i);
/** [Mythen3] */ /** [Mythen3] */
void setGateDelay3(const uint64_t i); void setGateDelay3(const ns i);
uint64_t getAcquisitionPeriod() const; ns getAcquisitionPeriod() const;
void setAcquisitionPeriod(const uint64_t i); void setAcquisitionPeriod(const ns i);
uint64_t getSubExpTime() const; ns getSubExpTime() const;
/* [Eiger] */ /* [Eiger] */
void setSubExpTime(const uint64_t i); void setSubExpTime(const ns i);
uint64_t getSubPeriod() const; ns getSubPeriod() const;
/* [Eiger] */ /* [Eiger] */
void setSubPeriod(const uint64_t i); void setSubPeriod(const ns i);
uint32_t getNumberofAnalogSamples() const; uint32_t getNumberofAnalogSamples() const;
/**[Ctb][Moench] */ /**[Ctb][Moench] */
void setNumberofAnalogSamples(const uint32_t i); void setNumberofAnalogSamples(const uint32_t i);
@ -225,7 +227,7 @@ class Implementation : private virtual slsDetectorDefs {
void setTenGigaADCEnableMask(const uint32_t mask); void setTenGigaADCEnableMask(const uint32_t mask);
std::vector<int> getDbitList() const; std::vector<int> getDbitList() const;
/* [Ctb] */ /* [Ctb] */
void setDbitList(const std::vector<int>& v); void setDbitList(const std::vector<int> &v);
int getDbitOffset() const; int getDbitOffset() const;
/* [Ctb] */ /* [Ctb] */
void setDbitOffset(const int s); void setDbitOffset(const int s);
@ -318,18 +320,18 @@ class Implementation : private virtual slsDetectorDefs {
int numberOfGates; int numberOfGates;
timingMode timingMode; timingMode timingMode;
burstMode burstMode; burstMode burstMode;
uint64_t acquisitionPeriod; ns acquisitionPeriod;
uint64_t acquisitionTime; ns acquisitionTime;
uint64_t acquisitionTime1; ns acquisitionTime1;
uint64_t acquisitionTime2; ns acquisitionTime2;
uint64_t acquisitionTime3; ns acquisitionTime3;
uint64_t gateDelay1; ns gateDelay1;
uint64_t gateDelay2; ns gateDelay2;
uint64_t gateDelay3; ns gateDelay3;
uint64_t subExpTime; ns subExpTime;
uint64_t subPeriod; ns subPeriod;
uint64_t numberOfAnalogSamples; uint32_t numberOfAnalogSamples;
uint64_t numberOfDigitalSamples; uint32_t numberOfDigitalSamples;
uint32_t counterMask; uint32_t counterMask;
uint32_t dynamicRange; uint32_t dynamicRange;
ROI roi; ROI roi;

30
slsSupportLib/src/ToString.cpp
View File

@ -42,10 +42,14 @@ std::string ToString(const slsDetectorDefs::rxParameters &r) {
<< "bursts:" << r.bursts << std::endl << "bursts:" << r.bursts << std::endl
<< "analogSamples:" << r.analogSamples << std::endl << "analogSamples:" << r.analogSamples << std::endl
<< "digitalSamples:" << r.digitalSamples << std::endl << "digitalSamples:" << r.digitalSamples << std::endl
<< "expTimeNs:" << r.expTimeNs << std::endl << "expTime:" << ToString(std::chrono::nanoseconds(r.expTimeNs))
<< "periodNs:" << r.periodNs << std::endl << std::endl
<< "subExpTimeNs:" << r.subExpTimeNs << std::endl << "period:" << ToString(std::chrono::nanoseconds(r.periodNs))
<< "subDeadTimeNs:" << r.subDeadTimeNs << std::endl << 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 << "activate:" << r.activate << std::endl
<< "quad:" << r.quad << std::endl << "quad:" << r.quad << std::endl
<< "dynamicRange:" << r.dynamicRange << 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 << "roi.xmax:" << r.roi.xmax << std::endl
<< "countermask:" << r.countermask << std::endl << "countermask:" << r.countermask << std::endl
<< "burstType:" << r.burstType << std::endl << "burstType:" << r.burstType << std::endl
<< "exptime1:" << r.expTime1Ns << std::endl << "exptime1:" << ToString(std::chrono::nanoseconds(r.expTime1Ns))
<< "exptime2:" << r.expTime2Ns << std::endl << std::endl
<< "exptime3:" << r.expTime3Ns << std::endl << "exptime2:" << ToString(std::chrono::nanoseconds(r.expTime2Ns))
<< "gateDelay1:" << r.gateDelay1Ns << std::endl << std::endl
<< "gateDelay2:" << r.gateDelay2Ns << std::endl << "exptime3:" << ToString(std::chrono::nanoseconds(r.expTime3Ns))
<< "gateDelay3:" << r.gateDelay3Ns << std::endl << 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 << "gates:" << r.gates << std::endl
<< ']'; << ']';
return oss.str(); return oss.str();