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

partial frames

Browse Source
This commit is contained in:
Erik Frojdh 2019-04-11 12:14:52 +02:00
parent d00fd70d6d
commit dce7dcbfd4
12 changed files with 1269 additions and 904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
python/sls_detector/detector.py
View File

@ -417,11 +417,11 @@ class Detector:
"""
Padd partial frames in the receiver
"""
return self._api.getReceiverPartialFramesPadding()
return self._api.getPartialFramesPadding()
@frame_padding.setter
def frame_padding(self, padding):
self._api.setReceiverPartialFramesPadding(padding)
self._api.setPartialFramesPadding(padding)
def free_shared_memory(self):
"""

417
python/src/Detector.h
View File

@ -16,39 +16,38 @@
class Detector {
public:
Detector(int i)
: det(i), multi_detector_id(i) {
//Disable output from std::cout
Detector(int i) : det(i), multi_detector_id(i) {
// Disable output from std::cout
// std::cout.setstate(std::ios_base::failbit);
}
int getMultiDetectorId() { return multi_detector_id; }
//get image size as [nrow, ncols] return as a pair of ints
// get image size as [nrow, ncols] return as a pair of ints
std::pair<int, int> getImageSize() {
std::pair<int, int> image_size{0, 0};
image_size.first = det.getMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::Y);
image_size.second = det.getMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::X);
image_size.first = det.getMaxNumberOfChannelsPerDetector(
slsDetectorDefs::dimension::Y);
image_size.second = det.getMaxNumberOfChannelsPerDetector(
slsDetectorDefs::dimension::X);
return image_size;
}
void setImageSize(const int rows, const int cols) {
det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::Y, rows);
det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::X, cols);
det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::Y,
rows);
det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::X,
cols);
}
//blocking command, acquire set number of frames
// blocking command, acquire set number of frames
void acquire() { det.acquire(); }
//for Eiger check status of the module
//true active false deactivated
bool getActive(int i) {
return det.activate(-1, i);
}
//activate or deactivate a module
void setActive(int i, bool value) {
det.activate(value, i);
}
// for Eiger check status of the module
// true active false deactivated
bool getActive(int i) { return det.activate(-1, i); }
// activate or deactivate a module
void setActive(int i, bool value) { det.activate(value, i); }
int getFramesCaughtByReceiver() {
return det.getFramesCaughtByReceiver();
@ -66,24 +65,17 @@ class Detector {
det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER, num);
}
int getNumberOfStorageCells() {
return det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER, -1);
return det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER,
-1);
}
void setStoragecellStart(int cell) {
det.setStoragecellStart(cell);
}
void setStoragecellStart(int cell) { det.setStoragecellStart(cell); }
int getStoragecellStart() {
return det.setStoragecellStart();
}
int getStoragecellStart() { return det.setStoragecellStart(); }
int getReceiverFifoDepth() {
return det.setReceiverFifoDepth();
}
int getReceiverFifoDepth() { return det.setReceiverFifoDepth(); }
void resetFramesCaught() {
det.resetFramesCaught();
}
void resetFramesCaught() { det.resetFramesCaught(); }
int getReceiverCurrentFrameIndex() {
return det.getReceiverCurrentFrameIndex();
@ -105,20 +97,18 @@ class Detector {
det.setReceiverUDPIP(ip, det_id);
}
std::string getReceiverUDPMAC(int det_id = -1){
std::string getReceiverUDPMAC(int det_id = -1) {
return det.getReceiverUDPMAC(det_id);
}
void setReceiverUDPMAC(std::string mac, int det_id = -1){
void setReceiverUDPMAC(std::string mac, int det_id = -1) {
det.setReceiverUDPMAC(mac, det_id);
}
void startReceiver() { det.startReceiver(); }
void stopReceiver() { det.stopReceiver(); }
bool getTenGigabitEthernet() {
return det.enableTenGigabitEthernet();
}
bool getTenGigabitEthernet() { return det.enableTenGigabitEthernet(); }
void setTenGigabitEthernet(bool value) {
det.enableTenGigabitEthernet(value);
}
@ -126,43 +116,29 @@ class Detector {
void setFileFormat(const std::string &format);
std::string getFileFormat();
std::string checkOnline() {
return det.checkOnline();
}
std::string checkOnline() { return det.checkOnline(); }
bool getReceiverOnline() {
return det.setReceiverOnline();
}
void setReceiverOnline(const bool status) {
det.setReceiverOnline(status);
}
bool getReceiverOnline() { return det.setReceiverOnline(); }
void setReceiverOnline(const bool status) { det.setReceiverOnline(status); }
bool getOnline() {
return det.setOnline();
}
void setOnline(const bool status) {
det.setOnline(status);
}
bool getOnline() { return det.setOnline(); }
void setOnline(const bool status) { det.setOnline(status); }
bool isChipPowered() {
return det.powerChip();
}
void powerChip(const bool value) {
det.powerChip(value);
}
bool isChipPowered() { return det.powerChip(); }
void powerChip(const bool value) { det.powerChip(value); }
//read register from readout system, used for low level control
// read register from readout system, used for low level control
uint32_t readRegister(const uint32_t addr) {
return det.readRegister(addr);
}
//directly write to register in readout system
// directly write to register in readout system
void writeRegister(const uint32_t addr, const uint32_t value) {
det.writeRegister(addr, value);
}
//directly write to the ADC register
//should this also be unsigned? Probably...
// directly write to the ADC register
// should this also be unsigned? Probably...
void writeAdcRegister(const int addr, const int value) {
det.writeAdcRegister(addr, value);
}
@ -174,20 +150,12 @@ class Detector {
det.clearBit(reg_addr, bit_number);
}
bool getAcquiringFlag() {
return det.getAcquiringFlag();
}
bool getAcquiringFlag() { return det.getAcquiringFlag(); }
void setAcquiringFlag(const bool flag) {
det.setAcquiringFlag(flag);
}
void setAcquiringFlag(const bool flag) { det.setAcquiringFlag(flag); }
bool getCounterBit() {
return det.setCounterBit();
}
void setCounterBit(bool b) {
det.setCounterBit(b);
}
bool getCounterBit() { return det.setCounterBit(); }
void setCounterBit(bool b) { det.setCounterBit(b); }
slsDetectorDefs::dacIndex dacNameToEnum(std::string dac_name);
@ -197,9 +165,7 @@ class Detector {
return g;
}
int getNumberOfDetectors() {
return det.getNumberOfDetectors();
}
int getNumberOfDetectors() { return det.getNumberOfDetectors(); }
std::string getRunStatus() {
auto s = det.getRunStatus();
@ -209,36 +175,40 @@ class Detector {
void startAcquisition() { det.startAcquisition(); }
void stopAcquisition() { det.stopAcquisition(); }
std::string getHostname() {
return det.getHostname();
}
std::string getHostname() { return det.getHostname(); }
void setHostname(std::string hostname) {
det.setHostname(hostname.c_str());
}
int getDynamicRange() {
return det.setDynamicRange(-1);
}
void setDynamicRange(const int dr) {
det.setDynamicRange(dr);
}
int getDynamicRange() { return det.setDynamicRange(-1); }
void setDynamicRange(const int dr) { det.setDynamicRange(dr); }
void pulseChip(const int n) { det.pulseChip(n); }
void pulseAllPixels(const int n);
void pulseDiagonal(const int n);
void readConfigurationFile(std::string fname) { det.readConfigurationFile(fname); }
void readParametersFile(std::string fname) { det.retrieveDetectorSetup(fname); }
int64_t getFirmwareVersion() { return det.getId(slsDetectorDefs::DETECTOR_FIRMWARE_VERSION); }
int64_t getServerVersion() { return det.getId(slsDetectorDefs::DETECTOR_SOFTWARE_VERSION); }
int64_t getClientVersion() { return det.getId(slsDetectorDefs::THIS_SOFTWARE_VERSION); }
int64_t getReceiverVersion() { return det.getId(slsDetectorDefs::RECEIVER_VERSION); }
std::vector<int64_t> getDetectorNumber() {
return det.getDetectorNumber();
void readConfigurationFile(std::string fname) {
det.readConfigurationFile(fname);
}
void readParametersFile(std::string fname) {
det.retrieveDetectorSetup(fname);
}
int64_t getFirmwareVersion() {
return det.getId(slsDetectorDefs::DETECTOR_FIRMWARE_VERSION);
}
int64_t getServerVersion() {
return det.getId(slsDetectorDefs::DETECTOR_SOFTWARE_VERSION);
}
int64_t getClientVersion() {
return det.getId(slsDetectorDefs::THIS_SOFTWARE_VERSION);
}
int64_t getReceiverVersion() {
return det.getId(slsDetectorDefs::RECEIVER_VERSION);
}
std::vector<int64_t> getDetectorNumber() { return det.getDetectorNumber(); }
int getReadoutClockSpeed() {
return det.setSpeed(slsDetectorDefs::CLOCK_DIVIDER, -1);
@ -256,18 +226,12 @@ class Detector {
void setDbitPhase(const int value) {
det.setSpeed(slsDetectorDefs::DBIT_PHASE, value);
}
int getDbitPhase() {
return det.setSpeed(slsDetectorDefs::DBIT_PHASE, -1);
}
int getDbitPhase() { return det.setSpeed(slsDetectorDefs::DBIT_PHASE, -1); }
void setDbitClock(const int value) {
det.setSpeed(slsDetectorDefs::DBIT_CLOCK, value);
}
int getDbitClock() {
return det.setSpeed(slsDetectorDefs::DBIT_CLOCK, -1);
}
std::vector<int> getReceiverPort() const {
return det.getReceiverPort();
}
int getDbitClock() { return det.setSpeed(slsDetectorDefs::DBIT_CLOCK, -1); }
std::vector<int> getReceiverPort() const { return det.getReceiverPort(); }
void setReceiverPort(int det_id, int value) {
det.setReceiverPort(value, det_id);
@ -297,51 +261,39 @@ class Detector {
}
/*** Frame and file settings ***/
void setFileName(std::string fname) {
det.setFileName(fname);
}
std::string getFileName() {
return det.getFileName();
}
void setFilePath(std::string path) {
det.setFilePath(path);
}
void setFilePath(std::string path, int i) {
det.setFilePath(path, i);
}
std::string getFilePath() {
return det.getFilePath();
}
std::string getFilePath(int i) {
return det.getFilePath(i);
}
void setFileName(std::string fname) { det.setFileName(fname); }
std::string getFileName() { return det.getFileName(); }
void setFilePath(std::string path) { det.setFilePath(path); }
void setFilePath(std::string path, int i) { det.setFilePath(path, i); }
std::string getFilePath() { return det.getFilePath(); }
std::string getFilePath(int i) { return det.getFilePath(i); }
std::string getUserDetails() {
return det.getUserDetails();
}
std::string getUserDetails() { return det.getUserDetails(); }
void setFramesPerFile(const int n_frames) {
det.setFramesPerFile(n_frames);
}
int getFramesPerFile() {
return det.setFramesPerFile();
}
int getFramesPerFile() { return det.setFramesPerFile(); }
std::string getReceiverFrameDiscardPolicy() {
return det.getReceiverFrameDiscardPolicy(det.setReceiverFramesDiscardPolicy());
return det.getReceiverFrameDiscardPolicy(
det.setReceiverFramesDiscardPolicy());
}
void setReceiverFramesDiscardPolicy(std::string f) {
auto fdp = det.getReceiverFrameDiscardPolicy(f);
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);
}
bool getReceiverPartialFramesPadding() {
return det.setReceiverPartialFramesPadding();
void setPartialFramesPadding(bool padding) {
det.setPartialFramesPadding(padding);
}
bool getPartialFramesPadding() { return det.getPartialFramesPadding(); }
std::vector<double> getMeasuredPeriod() {
std::vector<double> mp;
for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
@ -374,24 +326,16 @@ class Detector {
return false;
}
void setReceiverPartialFramesPadding(bool padding) {
det.setReceiverPartialFramesPadding(padding);
}
/*** END Frame and file settings ***/
void loadTrimbitFile(std::string fname, const int idet) {
det.loadSettingsFile(fname, idet);
}
//Eiger: set the energies where the detector is trimmed
void setTrimEnergies(std::vector<int> energy) {
det.setTrimEn(energy);
}
// Eiger: set the energies where the detector is trimmed
void setTrimEnergies(std::vector<int> energy) { det.setTrimEn(energy); }
std::vector<int> getTrimEnergies() {
return det.getTrimEn();
}
std::vector<int> getTrimEnergies() { return det.getTrimEn(); }
/*** Temperature control functions for Jungfrau ***/
void setThresholdTemperature(float t) {
@ -399,34 +343,23 @@ class Detector {
}
float getThresholdTemperature() {
return static_cast<double>(det.setThresholdTemperature(-1, -1)) / 1000.0;
return static_cast<double>(det.setThresholdTemperature(-1, -1)) /
1000.0;
}
void setTemperatureControl(bool v) {
det.setTemperatureControl(v);
}
bool getTemperatureControl() {
return det.setTemperatureControl();
}
void setTemperatureControl(bool v) { det.setTemperatureControl(v); }
bool getTemperatureControl() { return det.setTemperatureControl(); }
bool getTemperatureEvent() {
return det.setTemperatureEvent();
}
void resetTemperatureEvent() {
det.setTemperatureEvent(0);
}
bool getTemperatureEvent() { return det.setTemperatureEvent(); }
void resetTemperatureEvent() { det.setTemperatureEvent(0); }
/*** END Temperature control functions for Jungfrau ***/
void setThresholdEnergy(const int eV) {
det.setThresholdEnergy(eV);
}
void setThresholdEnergy(const int eV) { det.setThresholdEnergy(eV); }
std::string getSettingsDir() { return det.getSettingsDir(); }
void setSettingsDir(std::string dir) { det.setSettingsDir(dir); }
int getThresholdEnergy() {
return det.getThresholdEnergy();
}
int getThresholdEnergy() { return det.getThresholdEnergy(); }
std::string getSettings() {
return det.getDetectorSettings(det.getSettings());
@ -436,8 +369,8 @@ class Detector {
det.setSettings(det.getDetectorSettings(s));
}
//name to enum translation on the c++ side
//should we instead expose the enum to Python?
// name to enum translation on the c++ side
// should we instead expose the enum to Python?
int getDac(std::string dac_name, const int mod_id) {
int val = -1;
auto dac = dacNameToEnum(dac_name);
@ -460,19 +393,19 @@ class Detector {
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
int getDacFromIndex(const int index, const int mod_id) {
int val = -1;
auto dac = static_cast<slsDetectorDefs::dacIndex>(0);
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
int setDacFromIndex(const int index, const int mod_id, int value) {
auto dac = static_cast<slsDetectorDefs::dacIndex>(0);
return det.setDAC(value, dac, 0, mod_id);
}
//Calling multi do we have a need to lock/unlock a single det?
// Calling multi do we have a need to lock/unlock a single det?
bool getServerLock() { return det.lockServer(-1); }
void setServerLock(const bool value) { det.lockServer(value); }
bool getReceiverLock() { return det.lockReceiver(-1); }
@ -485,10 +418,10 @@ class Detector {
std::vector<std::string> getReadoutFlags();
//note singular
// note singular
void setReadoutFlag(const std::string flag_name);
//name to enum transltion of dac
// name to enum transltion of dac
int getDacVthreshold() {
int val = -1;
auto dac = slsDetectorDefs::dacIndex::THRESHOLD;
@ -500,20 +433,16 @@ class Detector {
det.setDAC(val, dac, 0, -1);
}
void setFileIndex(const int i) {
det.setFileIndex(i);
}
void setFileIndex(const int i) { det.setFileIndex(i); }
int getFileIndex() {
return det.getFileIndex();
}
int getFileIndex() { return det.getFileIndex(); }
//time in ns
// time in ns
void setExposureTime(const int64_t t) {
det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
}
//time in ns
// time in ns
int64_t getExposureTime() {
return det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, -1);
}
@ -523,8 +452,9 @@ class Detector {
}
int64_t getSubExposureTime() {
//time in ns
return det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, -1);
// time in ns
return det.setTimer(
slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, -1);
}
void setSubExposureDeadTime(const int64_t t) {
@ -532,7 +462,7 @@ class Detector {
}
int64_t getSubExposureDeadTime() {
//time in ns
// time in ns
return det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME, -1);
}
@ -545,10 +475,12 @@ class Detector {
}
void setNumberOfMeasurements(const int n_measurements) {
det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER, n_measurements);
det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER,
n_measurements);
}
int getNumberOfMeasurements() {
return det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER, -1);
return det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER,
-1);
}
int getNumberOfGates() {
@ -558,19 +490,20 @@ class Detector {
det.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, t);
}
//time in ns
// time in ns
int64_t getDelay() {
return det.setTimer(slsDetectorDefs::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) {
det.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, t);
}
//time in ns
// time in ns
int64_t getPeriod() {
return det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, -1);
}
//time in ns
// time in ns
void setPeriod(const int64_t t) {
det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, t);
}
@ -584,15 +517,14 @@ class Detector {
}
std::string getTimingMode() {
return det.externalCommunicationType(det.setExternalCommunicationMode());
return det.externalCommunicationType(
det.setExternalCommunicationMode());
}
void setTimingMode(const std::string mode) {
det.setExternalCommunicationMode(det.externalCommunicationType(mode));
}
void freeSharedMemory() {
det.freeSharedMemory();
}
void freeSharedMemory() { det.freeSharedMemory(); }
std::vector<std::string> getDetectorType() {
std::vector<std::string> detector_type;
@ -602,27 +534,15 @@ class Detector {
return detector_type;
}
void setFileWrite(bool value) {
det.setFileWrite(value);
}
bool getFileWrite() {
return det.getFileWrite();
}
void setFileWrite(bool value) { det.setFileWrite(value); }
bool getFileWrite() { return det.getFileWrite(); }
void setFileOverWrite(bool value) {
det.setFileOverWrite(value);
}
void setFileOverWrite(bool value) { det.setFileOverWrite(value); }
bool getFileOverWrite() {
return det.getFileOverWrite();
}
bool getFileOverWrite() { return det.getFileOverWrite(); }
void setAllTrimbits(int tb) {
det.setAllTrimbits(tb);
}
int getAllTrimbits() {
return det.setAllTrimbits(-1);
}
void setAllTrimbits(int tb) { det.setAllTrimbits(tb); }
int getAllTrimbits() { return det.setAllTrimbits(-1); }
bool getRxDataStreamStatus() {
return det.enableDataStreamingFromReceiver();
}
@ -631,8 +551,8 @@ class Detector {
det.enableDataStreamingFromReceiver(state);
}
//Get a network parameter for all detectors, looping over individual detectors
//return a vector of strings
// Get a network parameter for all detectors, looping over individual
// detectors return a vector of strings
std::vector<int> getReceiverStreamingPort() {
std::vector<int> vec;
vec.reserve(det.getNumberOfDetectors());
@ -671,9 +591,11 @@ class Detector {
det.setReceiverUDPPort2(port, det_id);
}
// //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.
// void setDetectorNetworkParameter(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);
// if (det_id == -1) {
// det.setDetectorNetworkParameter(p, par);
@ -684,58 +606,64 @@ class Detector {
void configureNetworkParameters() { det.configureMAC(); }
std::string getLastClientIP() {
return det.getLastClientIP();
}
std::string getLastClientIP() { return det.getLastClientIP(); }
std::string getReceiverLastClientIP() {
return det.getReceiverLastClientIP();
}
//get frame delay of module (det_id) in ns
// get frame delay of module (det_id) in ns
int getDelayFrame(int det_id) {
auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, -1, det_id);
auto r = det.setDetectorNetworkParameter(
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, -1,
det_id);
return r;
}
//set frame delay of module (det_id) in ns
// set frame delay of module (det_id) in ns
void setDelayFrame(int det_id, int delay) {
// auto delay_str = std::to_string(delay);
det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME, delay, det_id);
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(int det_id) {
auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, -1, det_id);
auto r = det.setDetectorNetworkParameter(
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, -1,
det_id);
return r;
}
//set delay left of module (det_id) in ns
// set delay left of module (det_id) in ns
void setDelayLeft(int det_id, int delay) {
// auto delay_str = std::to_string(delay);
det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT, delay, det_id);
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) {
auto r = det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, -1, det_id);
auto r = det.setDetectorNetworkParameter(
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, -1,
det_id);
return r;
}
//set delay right of module (det_id) in ns
// set delay right of module (det_id) in ns
void setDelayRight(int det_id, int delay) {
// auto delay_str = std::to_string(delay);
det.setDetectorNetworkParameter(slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, delay, det_id);
det.setDetectorNetworkParameter(
slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT, delay,
det_id);
}
//Check if detector if filling in gap pixels in module
//return true if so, currently only in developer
bool getGapPixels() {
return det.enableGapPixels(-1);
}
// Check if detector if filling in gap pixels in module
// return true if so, currently only in developer
bool getGapPixels() { return det.enableGapPixels(-1); }
//Set to true to have the detector filling in gap pixels
//false to disable, currently only in developer
void setGapPixels(bool val) {
det.enableGapPixels(val);
}
// Set to true to have the detector filling in gap pixels
// false to disable, currently only in developer
void setGapPixels(bool val) { det.enableGapPixels(val); }
slsDetectorDefs::networkParameter networkNameToEnum(std::string par_name);
@ -756,7 +684,8 @@ void Detector::setFileFormat(const std::string &format) {
}
std::string Detector::getFileFormat() {
auto format = det.setFileFormat(slsDetectorDefs::fileFormat::GET_FILE_FORMAT, -1);
auto format =
det.setFileFormat(slsDetectorDefs::fileFormat::GET_FILE_FORMAT, -1);
switch (format) {
case slsDetectorDefs::fileFormat::BINARY:
return "binary";
@ -769,7 +698,8 @@ std::string Detector::getFileFormat() {
}
}
slsDetectorDefs::networkParameter Detector::networkNameToEnum(std::string par_name) {
slsDetectorDefs::networkParameter
Detector::networkNameToEnum(std::string par_name) {
if (par_name == "detectormac") {
return slsDetectorDefs::networkParameter::DETECTOR_MAC;
@ -788,7 +718,8 @@ slsDetectorDefs::networkParameter Detector::networkNameToEnum(std::string par_na
} else if (par_name == "rx_udpsocksize") {
return slsDetectorDefs::networkParameter::RECEIVER_UDP_SCKT_BUF_SIZE;
} else if (par_name == "rx_realudpsocksize") {
return slsDetectorDefs::networkParameter::RECEIVER_REAL_UDP_SCKT_BUF_SIZE;
return slsDetectorDefs::networkParameter::
RECEIVER_REAL_UDP_SCKT_BUF_SIZE;
} else if (par_name == "rx_jsonaddheader") {
return slsDetectorDefs::networkParameter::ADDITIONAL_JSON_HEADER;
} else if (par_name == "delay_left") {
@ -815,7 +746,7 @@ slsDetectorDefs::networkParameter Detector::networkNameToEnum(std::string par_na
// slsDetectorDefs::fileFormat Detector::file///
slsDetectorDefs::dacIndex Detector::dacNameToEnum(std::string dac_name) {
//to avoid uninitialised
// to avoid uninitialised
slsDetectorDefs::dacIndex dac = slsDetectorDefs::dacIndex::E_SvP;
if (dac_name == "vsvp") {
@ -969,7 +900,7 @@ std::vector<std::string> Detector::getReadoutFlags() {
return flags;
}
//note singular
// note singular
void Detector::setReadoutFlag(const std::string flag_name) {
if (flag_name == "none")
det.setReadOutFlags(slsDetectorDefs::readOutFlags::NORMAL_READOUT);

4
python/src/main.cpp
View File

@ -212,8 +212,8 @@ PYBIND11_MODULE(_sls_detector, m)
.def("getReceiverFrameDiscardPolicy", &Detector::getReceiverFrameDiscardPolicy)
.def("setReceiverFramesDiscardPolicy", &Detector::setReceiverFramesDiscardPolicy)
.def("setReceiverPartialFramesPadding", &Detector::setReceiverPartialFramesPadding)
.def("getReceiverPartialFramesPadding", &Detector::getReceiverPartialFramesPadding)
.def("setPartialFramesPadding", &Detector::setPartialFramesPadding)
.def("getPartialFramesPadding", &Detector::getPartialFramesPadding)
.def("getUserDetails", &Detector::getUserDetails)
.def("isClientAndDetectorCompatible", &Detector::isClientAndDetectorCompatible)

4
slsDetectorSoftware/include/multiSlsDetector.h
View File

@ -1622,7 +1622,9 @@ class multiSlsDetector : public virtual slsDetectorDefs {
* @param detPos -1 for all detectors in list or specific detector position
* @returns partial frames padding enable in receiver
*/
int setReceiverPartialFramesPadding(int f = -1, int detPos = -1);
int setPartialFramesPadding(bool padding, int detPos = -1);
int getPartialFramesPadding(int detPos = -1) const;
/**
* Returns file format

3
slsDetectorSoftware/include/slsDetector.h
View File

@ -1480,7 +1480,8 @@ class slsDetector : public virtual slsDetectorDefs{
* @param f partial frames padding enable
* @returns partial frames padding enable in receiver
*/
int setReceiverPartialFramesPadding(int f = -1);
bool setPartialFramesPadding(bool padding);
bool getPartialFramesPadding() const;
/**
* Returns file format

17
slsDetectorSoftware/src/multiSlsDetector.cpp
View File

@ -2912,14 +2912,17 @@ multiSlsDetector::setReceiverFramesDiscardPolicy(frameDiscardPolicy f, int detPo
return sls::minusOneIfDifferent(r);
}
int multiSlsDetector::setReceiverPartialFramesPadding(int f, int detPos) {
// single
if (detPos >= 0) {
return detectors[detPos]->setReceiverPartialFramesPadding(f);
}
int multiSlsDetector::setPartialFramesPadding(bool padding, int detPos) {
if (detPos >= 0)
return detectors[detPos]->setPartialFramesPadding(padding);
auto r = parallelCall(&slsDetector::setPartialFramesPadding, padding);
return sls::minusOneIfDifferent(r);
}
// multi
auto r = parallelCall(&slsDetector::setReceiverPartialFramesPadding, f);
int multiSlsDetector::getPartialFramesPadding(int detPos) const {
if (detPos >= 0)
return detectors[detPos]->getPartialFramesPadding();
auto r = parallelCall(&slsDetector::getPartialFramesPadding);
return sls::minusOneIfDifferent(r);
}

1621
slsDetectorSoftware/src/slsDetector.cpp
View File

File diff suppressed because it is too large Load Diff

4
slsDetectorSoftware/src/slsDetectorCommand.cpp
View File

@ -5086,12 +5086,12 @@ std::string slsDetectorCommand::cmdReceiver(int narg, char *args[], int action,
else if (cmd == "r_padding") {
if (action == PUT_ACTION) {
if (sscanf(args[1], "%d", &ival)) {
myDet->setReceiverPartialFramesPadding(ival, detPos);
myDet->setPartialFramesPadding(ival, detPos);
} else
return std::string("could not scan receiver padding enable\n");
}
memset(answer, 0, 100);
sprintf(answer, "%d", myDet->setReceiverPartialFramesPadding(-1, detPos));
sprintf(answer, "%d", myDet->getPartialFramesPadding(detPos));
return std::string(answer);
}

5
slsDetectorSoftware/src/slsDetectorUsers.cpp
View File

@ -359,7 +359,10 @@ int slsDetectorUsers::setReceiverFramesDiscardPolicy(int f, int detPos) {
}
int slsDetectorUsers::setReceiverPartialFramesPadding(int f, int detPos) {
return detector.setReceiverPartialFramesPadding(f, detPos);
if (f>=0)
return detector.setPartialFramesPadding(f, detPos);
else
return detector.getPartialFramesPadding(detPos);
}
int slsDetectorUsers::setReceiverFramesPerFile(int f, int detPos) {

34
slsDetectorSoftware/tests/test-SharedMemory.cpp
View File

@ -13,11 +13,14 @@ struct Data {
using namespace sls;
constexpr int shm_id = 10;
TEST_CASE("Create SharedMemory read and write", "[detector]") {
SharedMemory<Data> shm(0, -1);
SharedMemory<Data> shm(shm_id, -1);
shm.CreateSharedMemory();
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0");
CHECK(shm.GetName() ==
std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
shm()->x = 3;
shm()->y = 5.7;
@ -36,12 +39,12 @@ TEST_CASE("Create SharedMemory read and write", "[detector]") {
TEST_CASE("Open existing SharedMemory and read", "[detector]") {
{
SharedMemory<double> shm(0, -1);
SharedMemory<double> shm(shm_id, -1);
shm.CreateSharedMemory();
*shm() = 5.3;
}
SharedMemory<double> shm2(0, -1);
SharedMemory<double> shm2(shm_id, -1);
shm2.OpenSharedMemory();
CHECK(*shm2() == 5.3);
@ -51,8 +54,8 @@ TEST_CASE("Open existing SharedMemory and read", "[detector]") {
TEST_CASE("Creating a second shared memory with the same name throws",
"[detector]") {
SharedMemory<double> shm0(0, -1);
SharedMemory<double> shm1(0, -1);
SharedMemory<double> shm0(shm_id, -1);
SharedMemory<double> shm1(shm_id, -1);
shm0.CreateSharedMemory();
CHECK_THROWS(shm1.CreateSharedMemory());
@ -62,13 +65,13 @@ TEST_CASE("Creating a second shared memory with the same name throws",
TEST_CASE("Open two shared memories to the same place", "[detector]") {
//Create the first shared memory
SharedMemory<Data> shm(0, -1);
SharedMemory<Data> shm(shm_id, -1);
shm.CreateSharedMemory();
shm()->x = 5;
CHECK(shm()->x == 5);
//Open the second shared memory with the same name
SharedMemory<Data> shm2(0, -1);
SharedMemory<Data> shm2(shm_id, -1);
shm2.OpenSharedMemory();
CHECK(shm2()->x == 5);
CHECK(shm.GetName() == shm2.GetName());
@ -86,21 +89,23 @@ TEST_CASE("Open two shared memories to the same place", "[detector]") {
TEST_CASE("Move SharedMemory", "[detector]") {
SharedMemory<Data> shm(0,-1);
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0");
SharedMemory<Data> shm(shm_id, -1);
CHECK(shm.GetName() ==
std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
shm.CreateSharedMemory();
shm()->x = 9;
CHECK(shm.size()== sizeof(Data));
SharedMemory<Data> shm2(1,-1);
SharedMemory<Data> shm2(shm_id+1, -1);
shm2 = std::move(shm); //shm is now a moved from object!
CHECK(shm2()->x == 9);
CHECK(shm() == nullptr);
CHECK(shm.size() == 0);
CHECK(shm2.GetName() == "/slsDetectorPackage_multi_0");
CHECK(shm2.GetName() == std::string("/slsDetectorPackage_multi_") +
std::to_string(shm_id));
shm2.RemoveSharedMemory();
}
@ -110,7 +115,7 @@ TEST_CASE("Create several shared memories", "[detector]") {
std::vector<SharedMemory<int>> v;
v.reserve(N);
for (int i = 0; i != N; ++i) {
v.emplace_back(i, -1);
v.emplace_back(shm_id+i, -1);
CHECK(v[i].IsExisting() == false);
v[i].CreateSharedMemory();
*v[i]() = i;
@ -119,7 +124,8 @@ TEST_CASE("Create several shared memories", "[detector]") {
for (int i = 0; i != N; ++i) {
CHECK(*v[i]() == i);
CHECK(v[i].GetName() == std::string("/slsDetectorPackage_multi_")+std::to_string(i));
CHECK(v[i].GetName() == std::string("/slsDetectorPackage_multi_") +
std::to_string(i + shm_id));
}
for (int i = 0; i != N; ++i) {

29
slsDetectorSoftware/tests/test-multiSlsDetector.cpp
View File

@ -11,10 +11,10 @@ using namespace sls;
SCENARIO("Multi detector operation", "[detector]") {
multiSlsDetector::freeSharedMemory(0, -1);
multiSlsDetector::freeSharedMemory(20, -1);
GIVEN("An empty multi detector") {
multiSlsDetector m(0);
multiSlsDetector m(20);
THEN("the size is zero") {
CHECK(m.getNumberOfDetectors() == 0);
CHECK(m.getDataBytes() == 0);
@ -23,7 +23,7 @@ SCENARIO("Multi detector operation", "[detector]") {
WHEN("we add a detector") {
m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 0, 0));
slsDetectorDefs::detectorType::EIGER, 20, 0));
THEN("the size and number of detector changes") {
CHECK(m.getNumberOfDetectors() == 1);
CHECK(m.getTotalNumberOfChannels() == 256 * 1024);
@ -31,7 +31,7 @@ SCENARIO("Multi detector operation", "[detector]") {
WHEN("we add another detector") {
m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 0, 1));
slsDetectorDefs::detectorType::EIGER, 20, 1));
THEN("the size and number of detector changes") {
CHECK(m.getNumberOfDetectors() == 2);
CHECK(m.getTotalNumberOfChannels() == 2 * 256 * 1024);
@ -61,3 +61,24 @@ SCENARIO("Multi detector operation", "[detector]") {
m.freeSharedMemory();
}
}
TEST_CASE("Set and get partialFramesPadding", "[detector]"){
multiSlsDetector::freeSharedMemory(20, -1);
multiSlsDetector m(20);
m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 20, 0));
m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 20, 1));
m.setPartialFramesPadding(0);
CHECK(m.getPartialFramesPadding() == 0);
m.setPartialFramesPadding(1);
CHECK(m.getPartialFramesPadding() == 1);
m.setPartialFramesPadding(0, 0);
CHECK(m.getPartialFramesPadding() == -1);
m.freeSharedMemory();
}

31
slsDetectorSoftware/tests/test-slsDetector.cpp
View File

@ -11,10 +11,10 @@ using namespace sls;
TEST_CASE("Set and get trimen", "[detector]") {
// Free shared memory to be sure that we start in a clean state
slsDetector::freeSharedMemory(0, 0);
slsDetector::freeSharedMemory(20, 20);
// Create a detector and check that the type is set correctly
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
CHECK(d.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER);
// At the beginning there should be no trimen set
@ -48,8 +48,8 @@ TEST_CASE("Set and get trimen", "[detector]") {
}
TEST_CASE("Set additional JSON header", "[detector]") {
slsDetector::freeSharedMemory(0, 0);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0);
slsDetector::freeSharedMemory(20, 20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
auto header = d.getAdditionalJsonHeader();
CHECK(header.empty());
@ -102,8 +102,8 @@ TEST_CASE("Set additional JSON header", "[detector]") {
TEST_CASE("Set ROI", "[detector]") {
using ROI = slsDetectorDefs::ROI;
slsDetector::freeSharedMemory(0, 0);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0);
slsDetector::freeSharedMemory(20,20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
int n{0};
d.getROI(n);
@ -133,8 +133,8 @@ TEST_CASE("Set ROI", "[detector]") {
TEST_CASE("Set multiple ROIs", "[detector]") {
using ROI = slsDetectorDefs::ROI;
slsDetector::freeSharedMemory(0, 0);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0);
slsDetector::freeSharedMemory(20, 20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
// set one ROI
constexpr int n = 3;
@ -176,4 +176,19 @@ TEST_CASE("Set multiple ROIs", "[detector]") {
CHECK(res[2].ymax == 800);
d.freeSharedMemory();
}
TEST_CASE("Padding and discard policy", "[detector][new]"){
slsDetector::freeSharedMemory(20, 20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
//
d.setPartialFramesPadding(false);
CHECK(d.getPartialFramesPadding() == false);
d.setPartialFramesPadding(true);
CHECK(d.getPartialFramesPadding() == true);
d.freeSharedMemory();
}