detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-06-13 05:17: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

55
slsReceiverSoftware/src/ClientInterface.cpp
View File

@ -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();
}

97
slsReceiverSoftware/src/Implementation.cpp
View File

@ -98,16 +98,16 @@ void Implementation::InitializeMembers() {
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;
acquisitionPeriod = std::chrono::nanoseconds(SAMPLE_TIME_IN_NS);
acquisitionTime = std::chrono::nanoseconds(0);
acquisitionTime1 = std::chrono::nanoseconds(0);
acquisitionTime2 = std::chrono::nanoseconds(0);
acquisitionTime3 = std::chrono::nanoseconds(0);
gateDelay1 = std::chrono::nanoseconds(0);
gateDelay2 = std::chrono::nanoseconds(0);
gateDelay3 = std::chrono::nanoseconds(0);
subExpTime = std::chrono::nanoseconds(0);
subPeriod = std::chrono::nanoseconds(0);
numberOfAnalogSamples = 0;
numberOfDigitalSamples = 0;
counterMask = 0;
@ -835,12 +835,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 +858,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 +1298,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 {

56
slsReceiverSoftware/src/Implementation.h
View File

@ -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);
@ -318,18 +320,18 @@ class Implementation : private virtual slsDetectorDefs {
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;
ns acquisitionPeriod;
ns acquisitionTime;
ns acquisitionTime1;
ns acquisitionTime2;
ns acquisitionTime3;
ns gateDelay1;
ns gateDelay2;
ns gateDelay3;
ns subExpTime;
ns subPeriod;
uint32_t numberOfAnalogSamples;
uint32_t numberOfDigitalSamples;
uint32_t counterMask;
uint32_t dynamicRange;
ROI roi;