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

working

Browse Source
This commit is contained in:
Erik Frojdh 2019-03-15 13:50:50 +01:00
parent 73af4a744f
commit c93b78c74f
5 changed files with 123 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
python/_sls_detector.cpython-37m-x86_64-linux-gnu.so
View File

Binary file not shown.

246
python/src/Detector.h
View File

@ -10,9 +10,9 @@
#include "error_defs.h" #include "error_defs.h"
#include "multiSlsDetector.h" #include "multiSlsDetector.h"
#include "slsDetector.h" #include "slsDetector.h"
#include "slsDetectorUtils.h" // #include "slsDetectorUtils.h"
#include "sls_detector_defs.h" #include "sls_detector_defs.h"
#include "sls_receiver_defs.h" // #include "sls_receiver_defs.h"
class Detector { class Detector {
public: public:
@ -42,20 +42,20 @@ class Detector {
//for Eiger check status of the module //for Eiger check status of the module
//true active false deactivated //true active false deactivated
bool getActive(const int i) const { bool getActive(int i){
return getSlsDetector(i)->activate(); return det.activate(-1, i);
} }
//activate or deactivate a module //activate or deactivate a module
void setActive(const int i, const bool value) { void setActive(int i, bool value) {
getSlsDetector(i)->activate(value); det.activate(value, i);
} }
int getFramesCaughtByReceiver() { int getFramesCaughtByReceiver() {
return det.getFramesCaughtByReceiver(); return det.getFramesCaughtByReceiver();
// return det.getFramesCaughtByReceiver(); // return det.getFramesCaughtByReceiver();
} }
int getFramesCaughtByReceiver(int i) const { int getFramesCaughtByReceiver(int i) {
return getSlsDetector(i)->getFramesCaughtByReceiver(); return det.getFramesCaughtByReceiver(i);
} }
void setReceiverFifoDepth(int n_frames){ void setReceiverFifoDepth(int n_frames){
@ -64,10 +64,10 @@ class Detector {
void setNumberOfStorageCells(const int64_t num) { void setNumberOfStorageCells(const int64_t num) {
det.setTimer(slsReceiverDefs::timerIndex::STORAGE_CELL_NUMBER, num); det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER, num);
} }
int getNumberOfStorageCells(){ int getNumberOfStorageCells(){
return det.setTimer(slsReceiverDefs::timerIndex::STORAGE_CELL_NUMBER, -1); return det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER, -1);
} }
void setStoragecellStart(int cell){ void setStoragecellStart(int cell){
@ -91,12 +91,6 @@ class Detector {
return det.getReceiverCurrentFrameIndex(); return det.getReceiverCurrentFrameIndex();
} }
bool getThreadedProcessing() {
return det.setThreadedProcessing();
}
void setThreadedProcessing(const bool value) {
det.setThreadedProcessing(value);
}
void startReceiver() { det.startReceiver(); } void startReceiver() { det.startReceiver(); }
void stopReceiver() { det.stopReceiver(); } void stopReceiver() { det.stopReceiver(); }
@ -238,8 +232,8 @@ class Detector {
int64_t getClientVersion() { return det.getId(slsDetectorDefs::THIS_SOFTWARE_VERSION); } int64_t getClientVersion() { return det.getId(slsDetectorDefs::THIS_SOFTWARE_VERSION); }
int64_t getReceiverVersion() { return det.getId(slsDetectorDefs::RECEIVER_VERSION); } int64_t getReceiverVersion() { return det.getId(slsDetectorDefs::RECEIVER_VERSION); }
int getDetectorNumber(int i) const { int getDetectorNumber(int i) {
return getSlsDetector(i)->getId(slsDetectorDefs::DETECTOR_SERIAL_NUMBER); return det.getId(slsDetectorDefs::DETECTOR_SERIAL_NUMBER, i);
} }
int getReadoutClockSpeed() { int getReadoutClockSpeed() {
@ -267,35 +261,35 @@ class Detector {
int getDbitClock() { int getDbitClock() {
return det.setSpeed(slsDetectorDefs::DBIT_CLOCK, -1); return det.setSpeed(slsDetectorDefs::DBIT_CLOCK, -1);
} }
int getRxTcpport(int i) const { int getReceiverPort(int det_id){
return getSlsDetector(i)->setPort(slsDetectorDefs::portType::DATA_PORT); return det.setReceiverPort(-1, det_id);
} }
void setRxTcpport(const int i, const int value) { void setReceiverPort(int det_id, int value) {
getSlsDetector(i)->setPort(slsDetectorDefs::portType::DATA_PORT, value); det.setReceiverPort(value, det_id);
} }
void setRateCorrection(std::vector<double> tau) { void setRateCorrection(std::vector<double> tau) {
for (int i = 0; i < det.getNumberOfDetectors(); ++i) for (int i = 0; i < det.getNumberOfDetectors(); ++i)
getSlsDetector(i)->setRateCorrection(tau[i]); det.setRateCorrection(tau[i], i);
} }
std::vector<double> getRateCorrection(); std::vector<double> getRateCorrection();
bool getFlippedDataX(int i) const { bool getFlippedDataX(int i){
return getSlsDetector(i)->getFlippedData(slsDetectorDefs::dimension::X); return det.getFlippedData(slsDetectorDefs::dimension::X, i);
} }
bool getFlippedDataY(int i) const { bool getFlippedDataY(int i){
return getSlsDetector(i)->getFlippedData(slsDetectorDefs::dimension::Y); return det.getFlippedData(slsDetectorDefs::dimension::Y, i);
} }
void setFlippedDataX(int i, bool value) { void setFlippedDataX(int i, bool value) {
getSlsDetector(i)->setFlippedData(slsDetectorDefs::dimension::X, value); det.setFlippedData(slsDetectorDefs::dimension::X, value, i);
} }
void setFlippedDataY(int i, bool value) { void setFlippedDataY(int i, bool value) {
getSlsDetector(i)->setFlippedData(slsDetectorDefs::dimension::Y, value); det.setFlippedData(slsDetectorDefs::dimension::Y, value, i);
} }
/*** Frame and file settings ***/ /*** Frame and file settings ***/
@ -308,14 +302,14 @@ class Detector {
void setFilePath(std::string path) { void setFilePath(std::string path) {
det.setFilePath(path); det.setFilePath(path);
} }
void setFilePath(std::string path, const int i) { void setFilePath(std::string path, int i) {
getSlsDetector(i)->setFilePath(path); det.setFilePath(path, i);
} }
std::string getFilePath() { std::string getFilePath() {
return det.getFilePath(); return det.getFilePath();
} }
std::string getFilePath(int i) const { std::string getFilePath(int i){
return getSlsDetector(i)->getFilePath(); return det.getFilePath(i);
} }
std::string getUserDetails() { std::string getUserDetails() {
@ -334,7 +328,7 @@ class Detector {
} }
void setReceiverFramesDiscardPolicy(std::string f) { void setReceiverFramesDiscardPolicy(std::string f) {
auto fdp = det.getReceiverFrameDiscardPolicy(f); auto fdp = det.getReceiverFrameDiscardPolicy(f);
if (fdp == slsReceiverDefs::GET_FRAME_DISCARD_POLICY) { if (fdp == slsDetectorDefs::GET_FRAME_DISCARD_POLICY) {
throw std::invalid_argument("Coult not decode policy: nodiscard, discardempty, discardpartial"); throw std::invalid_argument("Coult not decode policy: nodiscard, discardempty, discardpartial");
} }
det.setReceiverFramesDiscardPolicy(fdp); det.setReceiverFramesDiscardPolicy(fdp);
@ -347,7 +341,7 @@ class Detector {
std::vector<double> getMeasuredPeriod() { std::vector<double> getMeasuredPeriod() {
std::vector<double> mp; std::vector<double> mp;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) { for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
auto t = det.getTimeLeft(slsReceiverDefs::MEASURED_PERIOD, i); auto t = det.getTimeLeft(slsDetectorDefs::MEASURED_PERIOD, i);
mp.push_back(static_cast<double>(t) * 1E-9); mp.push_back(static_cast<double>(t) * 1E-9);
} }
return mp; return mp;
@ -355,21 +349,21 @@ class Detector {
std::vector<double> getMeasuredSubPeriod() { std::vector<double> getMeasuredSubPeriod() {
std::vector<double> mp; std::vector<double> mp;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) { for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
auto t = det.getTimeLeft(slsReceiverDefs::MEASURED_SUBPERIOD, i); auto t = det.getTimeLeft(slsDetectorDefs::MEASURED_SUBPERIOD, i);
mp.push_back(static_cast<double>(t) * 1E-9); mp.push_back(static_cast<double>(t) * 1E-9);
} }
return mp; return mp;
} }
bool isClientAndDetecorCompatible() { bool isClientAndDetecorCompatible() {
auto r = det.checkVersionCompatibility(slsDetectorDefs::CONTROL_PORT); auto r = det.checkDetectorVersionCompatibility(slsDetectorDefs::CONTROL_PORT);
if (r == 0) if (r == 0)
return true; return true;
else else
return false; return false;
} }
bool isClientAndReceiverCompatible() { bool isClientAndReceiverCompatible() {
auto r = det.checkVersionCompatibility(slsDetectorDefs::DATA_PORT); auto r = det.checkReceiverVersionCompatibility(slsDetectorDefs::DATA_PORT);
if (r == 0) if (r == 0)
return true; return true;
else else
@ -446,36 +440,36 @@ class Detector {
//name to enum translation on the c++ side //name to enum translation on the c++ side
//should we instead expose the enum to Python? //should we instead expose the enum to Python?
dacs_t getDac(std::string dac_name, const int mod_id) { int getDac(std::string dac_name, const int mod_id) {
dacs_t val = -1; int val = -1;
auto dac = dacNameToEnum(dac_name); auto dac = dacNameToEnum(dac_name);
return det.setDAC(val, dac, 0, mod_id); return det.setDAC(val, dac, 0, mod_id);
} }
void setDac(std::string dac_name, const int mod_id, dacs_t val) { void setDac(std::string dac_name, const int mod_id, int val) {
auto dac = dacNameToEnum(dac_name); auto dac = dacNameToEnum(dac_name);
det.setDAC(val, dac, 0, mod_id); det.setDAC(val, dac, 0, mod_id);
} }
dacs_t getDac_mV(std::string dac_name, const int mod_id) { int getDac_mV(std::string dac_name, const int mod_id) {
dacs_t val = -1; int val = -1;
auto dac = dacNameToEnum(dac_name); auto dac = dacNameToEnum(dac_name);
return det.setDAC(val, dac, 1, mod_id); return det.setDAC(val, dac, 1, mod_id);
} }
void setDac_mV(std::string dac_name, const int mod_id, dacs_t value) { void setDac_mV(std::string dac_name, const int mod_id, int value) {
auto dac = dacNameToEnum(dac_name); auto dac = dacNameToEnum(dac_name);
det.setDAC(value, dac, 1, mod_id); det.setDAC(value, dac, 1, mod_id);
} }
//Intended for the JungfrauCTB should we name dacs instead //Intended for the JungfrauCTB should we name dacs instead
dacs_t getDacFromIndex(const int index, const int mod_id) { int getDacFromIndex(const int index, const int mod_id) {
dacs_t val = -1; int val = -1;
auto dac = static_cast<slsDetectorDefs::dacIndex>(0); auto dac = static_cast<slsDetectorDefs::dacIndex>(0);
return det.setDAC(val, dac, 0, mod_id); return det.setDAC(val, dac, 0, mod_id);
} }
//Intended for the JungfrauCTB should we name dacs instead //Intended for the JungfrauCTB should we name dacs instead
dacs_t setDacFromIndex(const int index, const int mod_id, dacs_t value) { int setDacFromIndex(const int index, const int mod_id, int value) {
auto dac = static_cast<slsDetectorDefs::dacIndex>(0); auto dac = static_cast<slsDetectorDefs::dacIndex>(0);
return det.setDAC(value, dac, 0, mod_id); return det.setDAC(value, dac, 0, mod_id);
} }
@ -486,7 +480,7 @@ class Detector {
bool getReceiverLock() { return det.lockReceiver(-1); } bool getReceiverLock() { return det.lockReceiver(-1); }
void setReceiverLock(const bool value) { det.lockReceiver(value); } void setReceiverLock(const bool value) { det.lockReceiver(value); }
dacs_t getAdc(std::string adc_name, int mod_id) { int getAdc(std::string adc_name, int mod_id) {
auto adc = dacNameToEnum(adc_name); auto adc = dacNameToEnum(adc_name);
return det.getADC(adc, mod_id); return det.getADC(adc, mod_id);
} }
@ -497,13 +491,13 @@ class Detector {
void setReadoutFlag(const std::string flag_name); void setReadoutFlag(const std::string flag_name);
//name to enum transltion of dac //name to enum transltion of dac
dacs_t getDacVthreshold() { int getDacVthreshold() {
dacs_t val = -1; int val = -1;
auto dac = slsDetectorDefs::dacIndex::THRESHOLD; auto dac = slsDetectorDefs::dacIndex::THRESHOLD;
return det.setDAC(val, dac, 0, -1); return det.setDAC(val, dac, 0, -1);
} }
void setDacVthreshold(const dacs_t val) { void setDacVthreshold(const int val) {
auto dac = slsDetectorDefs::dacIndex::THRESHOLD; auto dac = slsDetectorDefs::dacIndex::THRESHOLD;
det.setDAC(val, dac, 0, -1); det.setDAC(val, dac, 0, -1);
} }
@ -518,88 +512,77 @@ class Detector {
//time in ns //time in ns
void setExposureTime(const int64_t t) { void setExposureTime(const int64_t t) {
det.setTimer(slsReceiverDefs::timerIndex::ACQUISITION_TIME, t); det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
} }
//time in ns //time in ns
int64_t getExposureTime() { int64_t getExposureTime() {
return det.setTimer(slsReceiverDefs::timerIndex::ACQUISITION_TIME, -1); return det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, -1);
} }
void setSubExposureTime(const int64_t t) { void setSubExposureTime(const int64_t t) {
det.setTimer(slsReceiverDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, t); det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, t);
} }
int64_t getSubExposureTime() { int64_t getSubExposureTime() {
//time in ns //time in ns
return det.setTimer(slsReceiverDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, -1); return det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, -1);
} }
void setSubExposureDeadTime(const int64_t t) { void setSubExposureDeadTime(const int64_t t) {
det.setTimer(slsReceiverDefs::timerIndex::SUBFRAME_DEADTIME, t); det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME, t);
} }
int64_t getSubExposureDeadTime() { int64_t getSubExposureDeadTime() {
//time in ns //time in ns
return det.setTimer(slsReceiverDefs::timerIndex::SUBFRAME_DEADTIME, -1); return det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME, -1);
} }
int64_t getCycles() { int64_t getCycles() {
return det.setTimer(slsReceiverDefs::timerIndex::CYCLES_NUMBER, -1); return det.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, -1);
} }
void setCycles(const int64_t n_cycles) { void setCycles(const int64_t n_cycles) {
det.setTimer(slsReceiverDefs::timerIndex::CYCLES_NUMBER, n_cycles); det.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, n_cycles);
}
int64_t getJCTBSamples() {
return det.setTimer(slsReceiverDefs::timerIndex::SAMPLES_JCTB, -1);
} }
void setJCTBSamples(const int64_t n_samples) {
det.setTimer(slsReceiverDefs::timerIndex::SAMPLES_JCTB, n_samples);
}
void setNumberOfMeasurements(const int n_measurements) { void setNumberOfMeasurements(const int n_measurements) {
det.setTimer(slsReceiverDefs::timerIndex::MEASUREMENTS_NUMBER, n_measurements); det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER, n_measurements);
} }
int getNumberOfMeasurements() { int getNumberOfMeasurements() {
return det.setTimer(slsReceiverDefs::timerIndex::MEASUREMENTS_NUMBER, -1); return det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER, -1);
} }
int getNumberOfGates() { int getNumberOfGates() {
return det.setTimer(slsReceiverDefs::timerIndex::GATES_NUMBER, -1); return det.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, -1);
} }
void setNumberOfGates(const int t) { void setNumberOfGates(const int t) {
det.setTimer(slsReceiverDefs::timerIndex::GATES_NUMBER, t); det.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, t);
}
int getNumberOfProbes() {
return det.setTimer(slsReceiverDefs::timerIndex::PROBES_NUMBER, -1);
}
void setNumberOfProbes(const int t) {
det.setTimer(slsReceiverDefs::timerIndex::PROBES_NUMBER, t);
} }
//time in ns //time in ns
int64_t getDelay() { int64_t getDelay() {
return det.setTimer(slsReceiverDefs::timerIndex::DELAY_AFTER_TRIGGER, -1); return det.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, -1);
} }
//time in ns //time in ns
void setDelay(const int64_t t) { void setDelay(const int64_t t) {
det.setTimer(slsReceiverDefs::timerIndex::DELAY_AFTER_TRIGGER, t); det.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, t);
} }
//time in ns //time in ns
int64_t getPeriod() { int64_t getPeriod() {
return det.setTimer(slsReceiverDefs::timerIndex::FRAME_PERIOD, -1); return det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, -1);
} }
//time in ns //time in ns
void setPeriod(const int64_t t) { void setPeriod(const int64_t t) {
det.setTimer(slsReceiverDefs::timerIndex::FRAME_PERIOD, t); det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, t);
} }
int64_t getNumberOfFrames() { int64_t getNumberOfFrames() {
return det.setTimer(slsReceiverDefs::timerIndex::FRAME_NUMBER, -1); return det.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, -1);
} }
void setNumberOfFrames(const int64_t nframes) { void setNumberOfFrames(const int64_t nframes) {
det.setTimer(slsReceiverDefs::timerIndex::FRAME_NUMBER, nframes); det.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, nframes);
} }
std::string getTimingMode() { std::string getTimingMode() {
@ -616,7 +599,7 @@ class Detector {
std::vector<std::string> getDetectorType() { std::vector<std::string> getDetectorType() {
std::vector<std::string> detector_type; std::vector<std::string> detector_type;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) { for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
detector_type.push_back(det.sgetDetectorsType(i)); detector_type.push_back(det.getDetectorTypeAsString(i));
} }
return detector_type; return detector_type;
} }
@ -652,27 +635,27 @@ class Detector {
det.enableDataStreamingFromReceiver(state); det.enableDataStreamingFromReceiver(state);
} }
//Get a network parameter for all detectors, looping over individual detectors // //Get a network parameter for all detectors, looping over individual detectors
//return a vector of strings // //return a vector of strings
std::vector<std::string> getNetworkParameter(std::string par_name) { // std::vector<std::string> getDetectorNetworkParameter(std::string par_name) {
auto p = networkNameToEnum(par_name); // auto p = networkNameToEnum(par_name);
std::vector<std::string> par; // std::vector<std::string> par;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) { // for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
par.push_back(getSlsDetector(i)->getNetworkParameter(p)); // par.push_back(det.setDetectorNetworkParameter(p, -1, i));
} // }
return par; // return par;
} // }
//Set network parameter for all modules if det_id == -1 otherwise the module // //Set network parameter for all modules if det_id == -1 otherwise the module
//specified with det_id. // //specified with det_id.
void setNetworkParameter(std::string par_name, std::string par, const int det_id) { // void setDetectorNetworkParameter(std::string par_name, std::string par, const int det_id) {
auto p = networkNameToEnum(par_name); // auto p = networkNameToEnum(par_name);
if (det_id == -1) { // if (det_id == -1) {
det.setNetworkParameter(p, par); // det.setDetectorNetworkParameter(p, par);
} else { // } else {
getSlsDetector(det_id)->setNetworkParameter(p, par); // det.setDetectorNetworkParameter(p, par, det_id);
} // }
} // }
void configureNetworkParameters() { det.configureMAC(); } void configureNetworkParameters() { det.configureMAC(); }
@ -684,37 +667,37 @@ class Detector {
} }
//get frame delay of module (det_id) in ns //get frame delay of module (det_id) in ns
int getDelayFrame(const int det_id) { int getDelayFrame(int det_id) {
auto r = getSlsDetector(det_id)->getNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME); auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, -1, det_id);
return std::stoi(r); return r;
} }
//set frame delay of module (det_id) in ns //set frame delay of module (det_id) in ns
void setDelayFrame(const int det_id, const int delay) { void setDelayFrame(int det_id, int delay) {
auto delay_str = std::to_string(delay); // auto delay_str = std::to_string(delay);
getSlsDetector(det_id)->setNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, delay_str); det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, delay, det_id);
} }
//get delay left of module (det_id) in ns //get delay left of module (det_id) in ns
int getDelayLeft(const int det_id) { int getDelayLeft(int det_id) {
auto r = getSlsDetector(det_id)->getNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT); auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, -1, det_id);
return std::stoi(r); return r;
} }
//set delay left of module (det_id) in ns //set delay left of module (det_id) in ns
void setDelayLeft(const int det_id, const int delay) { void setDelayLeft(int det_id, int delay) {
auto delay_str = std::to_string(delay); // auto delay_str = std::to_string(delay);
getSlsDetector(det_id)->setNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, delay_str); det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, delay, det_id);
} }
//get delay right of module (det_id) in ns //get delay right of module (det_id) in ns
int getDelayRight(const int det_id) { int getDelayRight(const int det_id) {
auto r = getSlsDetector(det_id)->getNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT); auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, -1, det_id);
return std::stoi(r); return r;
} }
//set delay right of module (det_id) in ns //set delay right of module (det_id) in ns
void setDelayRight(const int det_id, const int delay) { void setDelayRight(int det_id, int delay) {
auto delay_str = std::to_string(delay); // auto delay_str = std::to_string(delay);
getSlsDetector(det_id)->setNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, delay_str); det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, delay, det_id);
} }
//Check if detector if filling in gap pixels in module //Check if detector if filling in gap pixels in module
@ -737,30 +720,21 @@ class Detector {
int multi_detector_id = 0; int multi_detector_id = 0;
}; };
slsDetector *Detector::getSlsDetector(int i) const {
//Get a pointer to an slsDetector
//throw an exception to avoid accessing
//a null pointer
auto d = det(i);
if (d)
return d;
else
throw std::runtime_error("Could not get detector: " + std::to_string(i));
}
void Detector::setFileFormat(const std::string& format){ void Detector::setFileFormat(const std::string& format){
if (format == "binary"){ if (format == "binary"){
det.setFileFormat(slsReceiverDefs::fileFormat::BINARY); det.setFileFormat(slsDetectorDefs::fileFormat::BINARY);
}else if(format == "ascii"){ }else if(format == "ascii"){
det.setFileFormat(slsReceiverDefs::fileFormat::ASCII); det.setFileFormat(slsDetectorDefs::fileFormat::ASCII);
}else if(format == "hdf5"){ }else if(format == "hdf5"){
det.setFileFormat(slsReceiverDefs::fileFormat::HDF5); det.setFileFormat(slsDetectorDefs::fileFormat::HDF5);
} }
} }
std::string Detector::getFileFormat(){ std::string Detector::getFileFormat(){
auto format = det.setFileFormat(); auto format = det.setFileFormat(slsDetectorDefs::fileFormat::GET_FILE_FORMAT, -1);
switch (format) switch (format)
{ {
case slsDetectorDefs::fileFormat::BINARY: case slsDetectorDefs::fileFormat::BINARY:
@ -890,7 +864,7 @@ slsDetectorDefs::dacIndex Detector::dacNameToEnum(std::string dac_name) {
} else if (dac_name == "temp_fpgafr") { } else if (dac_name == "temp_fpgafr") {
dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGA3; dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGA3;
} else if (dac_name == "vhighvoltage") { } else if (dac_name == "vhighvoltage") {
dac = slsDetectorDefs::dacIndex::HV_NEW; dac = slsDetectorDefs::dacIndex::HIGH_VOLTAGE;
} else if (dac_name == "vb_comp") { } else if (dac_name == "vb_comp") {
dac = static_cast<slsDetectorDefs::dacIndex>(0); dac = static_cast<slsDetectorDefs::dacIndex>(0);
} else if (dac_name == "vdd_prot") { } else if (dac_name == "vdd_prot") {
@ -1004,10 +978,8 @@ void Detector::setReadoutFlag(const std::string flag_name) {
std::vector<double> Detector::getRateCorrection() { std::vector<double> Detector::getRateCorrection() {
std::vector<double> rate_corr; std::vector<double> rate_corr;
double tmp = 0;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) { for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
getSlsDetector(i)->getRateCorrection(tmp); rate_corr.push_back(det.getRateCorrection(i));
rate_corr.push_back(tmp);
} }
return rate_corr; return rate_corr;
} }

19
python/src/main.cpp
View File

@ -104,8 +104,8 @@ PYBIND11_MODULE(_sls_detector, m)
.def("getReceiverOnline", &Detector::getReceiverOnline) .def("getReceiverOnline", &Detector::getReceiverOnline)
.def("setReceiverOnline", &Detector::setReceiverOnline) .def("setReceiverOnline", &Detector::setReceiverOnline)
.def("getRxTcpport", &Detector::getRxTcpport) .def("getReceiverPort", &Detector::getReceiverPort)
.def("setRxTcpport", &Detector::setRxTcpport) .def("setReceiverPort", &Detector::setReceiverPort)
.def("isChipPowered", &Detector::isChipPowered) .def("isChipPowered", &Detector::isChipPowered)
.def("powerChip", &Detector::powerChip) .def("powerChip", &Detector::powerChip)
@ -132,9 +132,9 @@ PYBIND11_MODULE(_sls_detector, m)
.def("stopReceiver", &Detector::stopReceiver) .def("stopReceiver", &Detector::stopReceiver)
.def("getFilePath", (std::string(Detector::*)()) & Detector::getFilePath, "Using multiSlsDetector") .def("getFilePath", (std::string(Detector::*)()) & Detector::getFilePath, "Using multiSlsDetector")
.def("getFilePath", (std::string(Detector::*)(const int)const) & Detector::getFilePath, "File path for individual detector") .def("getFilePath", (std::string(Detector::*)(int)) & Detector::getFilePath, "File path for individual detector")
.def("setFilePath", (void (Detector::*)(std::string)) & Detector::setFilePath) .def("setFilePath", (void (Detector::*)(std::string)) & Detector::setFilePath)
.def("setFilePath", (void (Detector::*)(std::string, const int)) & Detector::setFilePath) .def("setFilePath", (void (Detector::*)(std::string, int)) & Detector::setFilePath)
.def("setFileName", &Detector::setFileName) .def("setFileName", &Detector::setFileName)
.def("getFileName", &Detector::getFileName) .def("getFileName", &Detector::getFileName)
@ -158,8 +158,7 @@ PYBIND11_MODULE(_sls_detector, m)
.def("setNumberOfGates", &Detector::setNumberOfGates) .def("setNumberOfGates", &Detector::setNumberOfGates)
.def("getDelay", &Detector::getDelay) .def("getDelay", &Detector::getDelay)
.def("setDelay", &Detector::setDelay) .def("setDelay", &Detector::setDelay)
.def("getJCTBSamples", &Detector::getJCTBSamples)
.def("setJCTBSamples", &Detector::setJCTBSamples)
.def("setStoragecellStart", &Detector::setStoragecellStart) .def("setStoragecellStart", &Detector::setStoragecellStart)
.def("getStoragecellStart", &Detector::getStoragecellStart) .def("getStoragecellStart", &Detector::getStoragecellStart)
@ -181,8 +180,8 @@ PYBIND11_MODULE(_sls_detector, m)
.def("getRxDataStreamStatus", &Detector::getRxDataStreamStatus) .def("getRxDataStreamStatus", &Detector::getRxDataStreamStatus)
.def("setRxDataStreamStatus", &Detector::setRxDataStreamStatus) .def("setRxDataStreamStatus", &Detector::setRxDataStreamStatus)
.def("getNetworkParameter", &Detector::getNetworkParameter) // .def("getDetectorNetworkParameter", &Detector::getDetectorNetworkParameter)
.def("setNetworkParameter", &Detector::setNetworkParameter) // .def("setDetectorNetworkParameter", &Detector::setDetectorNetworkParameter)
.def("configureNetworkParameters", &Detector::configureNetworkParameters) .def("configureNetworkParameters", &Detector::configureNetworkParameters)
.def("getDelayFrame", &Detector::getDelayFrame) .def("getDelayFrame", &Detector::getDelayFrame)
.def("setDelayFrame", &Detector::setDelayFrame) .def("setDelayFrame", &Detector::setDelayFrame)
@ -221,7 +220,7 @@ PYBIND11_MODULE(_sls_detector, m)
//Overloaded calls //Overloaded calls
.def("getFramesCaughtByReceiver", (int (Detector::*)() ) & Detector::getFramesCaughtByReceiver) .def("getFramesCaughtByReceiver", (int (Detector::*)() ) & Detector::getFramesCaughtByReceiver)
.def("getFramesCaughtByReceiver", (int (Detector::*)(int) const) & Detector::getFramesCaughtByReceiver) .def("getFramesCaughtByReceiver", (int (Detector::*)(int)) & Detector::getFramesCaughtByReceiver)
.def("resetFramesCaught", &Detector::resetFramesCaught) .def("resetFramesCaught", &Detector::resetFramesCaught)
.def("getReceiverCurrentFrameIndex", &Detector::getReceiverCurrentFrameIndex) .def("getReceiverCurrentFrameIndex", &Detector::getReceiverCurrentFrameIndex)
@ -251,8 +250,6 @@ PYBIND11_MODULE(_sls_detector, m)
.def("getActive", &Detector::getActive) .def("getActive", &Detector::getActive)
.def("setActive", &Detector::setActive) .def("setActive", &Detector::setActive)
.def("getThreadedProcessing", &Detector::getThreadedProcessing)
.def("setThreadedProcessing", &Detector::setThreadedProcessing)
.def("getTenGigabitEthernet", &Detector::getTenGigabitEthernet) .def("getTenGigabitEthernet", &Detector::getTenGigabitEthernet)
.def("setTenGigabitEthernet", &Detector::setTenGigabitEthernet) .def("setTenGigabitEthernet", &Detector::setTenGigabitEthernet)

6
slsDetectorSoftware/multiSlsDetector/multiSlsDetector.cpp
View File

@ -1857,14 +1857,14 @@ std::string multiSlsDetector::getReceiverStreamingIP(int detPos) {
return sls::concatenateIfDifferent(r); return sls::concatenateIfDifferent(r);
} }
int multiSlsDetector::setDetectorNetworkParameter(networkParameter index, int delay, int detPos) { int multiSlsDetector::setDetectorNetworkParameter(networkParameter index, int value, int detPos) {
// single // single
if (detPos >= 0) { if (detPos >= 0) {
return detectors[detPos]->setDetectorNetworkParameter(index, delay); return detectors[detPos]->setDetectorNetworkParameter(index, value);
} }
// multi // multi
auto r = parallelCall(&slsDetector::setDetectorNetworkParameter, index, delay); auto r = parallelCall(&slsDetector::setDetectorNetworkParameter, index, value);
return sls::minusOneIfDifferent(r); return sls::minusOneIfDifferent(r);
} }

6
slsDetectorSoftware/sharedMemory/SharedMemory.h
View File

@ -195,7 +195,7 @@ class SharedMemory {
/** /**
* Maximum length of name as from man pages * Maximum length of name as from man pages
*/ */
static const int NAME_MAX = 255; static const int name_max_length = 255;
/** /**
*Using the call operator to access the pointer *Using the call operator to access the pointer
@ -236,8 +236,8 @@ class SharedMemory {
ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath; ss << SHM_MULTI_PREFIX << multiId << SHM_SLS_PREFIX << slsId << sEnvPath;
std::string temp = ss.str(); std::string temp = ss.str();
if (temp.length() > NAME_MAX) { if (temp.length() > name_max_length) {
std::string msg = "Shared memory initialization failed. " + temp + " has " + std::to_string(temp.length()) + " characters. \n" + "Maximum is " + std::to_string(NAME_MAX) + ". Change the environment variable " + SHM_ENV_NAME; std::string msg = "Shared memory initialization failed. " + temp + " has " + std::to_string(temp.length()) + " characters. \n" + "Maximum is " + std::to_string(name_max_length) + ". Change the environment variable " + SHM_ENV_NAME;
FILE_LOG(logERROR) << msg; FILE_LOG(logERROR) << msg;
throw SharedMemoryError(msg); throw SharedMemoryError(msg);
} }