detectors/slsDetectorPackage
24
1
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2026-02-18 19:48:42 +01: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
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 Padd partial frames in the receiver
""" """
return self._api.getReceiverPartialFramesPadding() return self._api.getPartialFramesPadding()
@frame_padding.setter @frame_padding.setter
def frame_padding(self, padding): def frame_padding(self, padding):
self._api.setReceiverPartialFramesPadding(padding) self._api.setPartialFramesPadding(padding)
def free_shared_memory(self): def free_shared_memory(self):
""" """

417
python/src/Detector.h
View File

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

17
slsDetectorSoftware/src/multiSlsDetector.cpp
View File

@@ -2912,14 +2912,17 @@ multiSlsDetector::setReceiverFramesDiscardPolicy(frameDiscardPolicy f, int detPo
return sls::minusOneIfDifferent(r); return sls::minusOneIfDifferent(r);
} }
int multiSlsDetector::setReceiverPartialFramesPadding(int f, int detPos) { int multiSlsDetector::setPartialFramesPadding(bool padding, int detPos) {
// single if (detPos >= 0)
if (detPos >= 0) { return detectors[detPos]->setPartialFramesPadding(padding);
return detectors[detPos]->setReceiverPartialFramesPadding(f); auto r = parallelCall(&slsDetector::setPartialFramesPadding, padding);
} return sls::minusOneIfDifferent(r);
}
// multi int multiSlsDetector::getPartialFramesPadding(int detPos) const {
auto r = parallelCall(&slsDetector::setReceiverPartialFramesPadding, f); if (detPos >= 0)
return detectors[detPos]->getPartialFramesPadding();
auto r = parallelCall(&slsDetector::getPartialFramesPadding);
return sls::minusOneIfDifferent(r); 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") { else if (cmd == "r_padding") {
if (action == PUT_ACTION) { if (action == PUT_ACTION) {
if (sscanf(args[1], "%d", &ival)) { if (sscanf(args[1], "%d", &ival)) {
myDet->setReceiverPartialFramesPadding(ival, detPos); myDet->setPartialFramesPadding(ival, detPos);
} else } else
return std::string("could not scan receiver padding enable\n"); return std::string("could not scan receiver padding enable\n");
} }
memset(answer, 0, 100); memset(answer, 0, 100);
sprintf(answer, "%d", myDet->setReceiverPartialFramesPadding(-1, detPos)); sprintf(answer, "%d", myDet->getPartialFramesPadding(detPos));
return std::string(answer); 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) { 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) { int slsDetectorUsers::setReceiverFramesPerFile(int f, int detPos) {

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

@@ -13,11 +13,14 @@ struct Data {
using namespace sls; using namespace sls;
constexpr int shm_id = 10;
TEST_CASE("Create SharedMemory read and write", "[detector]") { TEST_CASE("Create SharedMemory read and write", "[detector]") {
SharedMemory<Data> shm(0, -1); SharedMemory<Data> shm(shm_id, -1);
shm.CreateSharedMemory(); shm.CreateSharedMemory();
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0"); CHECK(shm.GetName() ==
std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
shm()->x = 3; shm()->x = 3;
shm()->y = 5.7; shm()->y = 5.7;
@@ -36,12 +39,12 @@ TEST_CASE("Create SharedMemory read and write", "[detector]") {
TEST_CASE("Open existing SharedMemory and read", "[detector]") { TEST_CASE("Open existing SharedMemory and read", "[detector]") {
{ {
SharedMemory<double> shm(0, -1); SharedMemory<double> shm(shm_id, -1);
shm.CreateSharedMemory(); shm.CreateSharedMemory();
*shm() = 5.3; *shm() = 5.3;
} }
SharedMemory<double> shm2(0, -1); SharedMemory<double> shm2(shm_id, -1);
shm2.OpenSharedMemory(); shm2.OpenSharedMemory();
CHECK(*shm2() == 5.3); 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", TEST_CASE("Creating a second shared memory with the same name throws",
"[detector]") { "[detector]") {
SharedMemory<double> shm0(0, -1); SharedMemory<double> shm0(shm_id, -1);
SharedMemory<double> shm1(0, -1); SharedMemory<double> shm1(shm_id, -1);
shm0.CreateSharedMemory(); shm0.CreateSharedMemory();
CHECK_THROWS(shm1.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]") { TEST_CASE("Open two shared memories to the same place", "[detector]") {
//Create the first shared memory //Create the first shared memory
SharedMemory<Data> shm(0, -1); SharedMemory<Data> shm(shm_id, -1);
shm.CreateSharedMemory(); shm.CreateSharedMemory();
shm()->x = 5; shm()->x = 5;
CHECK(shm()->x == 5); CHECK(shm()->x == 5);
//Open the second shared memory with the same name //Open the second shared memory with the same name
SharedMemory<Data> shm2(0, -1); SharedMemory<Data> shm2(shm_id, -1);
shm2.OpenSharedMemory(); shm2.OpenSharedMemory();
CHECK(shm2()->x == 5); CHECK(shm2()->x == 5);
CHECK(shm.GetName() == shm2.GetName()); 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]") { TEST_CASE("Move SharedMemory", "[detector]") {
SharedMemory<Data> shm(0,-1); SharedMemory<Data> shm(shm_id, -1);
CHECK(shm.GetName() == "/slsDetectorPackage_multi_0"); CHECK(shm.GetName() ==
std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
shm.CreateSharedMemory(); shm.CreateSharedMemory();
shm()->x = 9; shm()->x = 9;
CHECK(shm.size()== sizeof(Data)); 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! shm2 = std::move(shm); //shm is now a moved from object!
CHECK(shm2()->x == 9); CHECK(shm2()->x == 9);
CHECK(shm() == nullptr); CHECK(shm() == nullptr);
CHECK(shm.size() == 0); CHECK(shm.size() == 0);
CHECK(shm2.GetName() == "/slsDetectorPackage_multi_0"); CHECK(shm2.GetName() == std::string("/slsDetectorPackage_multi_") +
std::to_string(shm_id));
shm2.RemoveSharedMemory(); shm2.RemoveSharedMemory();
} }
@@ -110,7 +115,7 @@ TEST_CASE("Create several shared memories", "[detector]") {
std::vector<SharedMemory<int>> v; std::vector<SharedMemory<int>> v;
v.reserve(N); v.reserve(N);
for (int i = 0; i != N; ++i) { for (int i = 0; i != N; ++i) {
v.emplace_back(i, -1); v.emplace_back(shm_id+i, -1);
CHECK(v[i].IsExisting() == false); CHECK(v[i].IsExisting() == false);
v[i].CreateSharedMemory(); v[i].CreateSharedMemory();
*v[i]() = i; *v[i]() = i;
@@ -119,7 +124,8 @@ TEST_CASE("Create several shared memories", "[detector]") {
for (int i = 0; i != N; ++i) { for (int i = 0; i != N; ++i) {
CHECK(*v[i]() == 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) { 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]") { SCENARIO("Multi detector operation", "[detector]") {
multiSlsDetector::freeSharedMemory(0, -1); multiSlsDetector::freeSharedMemory(20, -1);
GIVEN("An empty multi detector") { GIVEN("An empty multi detector") {
multiSlsDetector m(0); multiSlsDetector m(20);
THEN("the size is zero") { THEN("the size is zero") {
CHECK(m.getNumberOfDetectors() == 0); CHECK(m.getNumberOfDetectors() == 0);
CHECK(m.getDataBytes() == 0); CHECK(m.getDataBytes() == 0);
@@ -23,7 +23,7 @@ SCENARIO("Multi detector operation", "[detector]") {
WHEN("we add a detector") { WHEN("we add a detector") {
m.addSlsDetector(sls::make_unique<slsDetector>( m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 0, 0)); slsDetectorDefs::detectorType::EIGER, 20, 0));
THEN("the size and number of detector changes") { THEN("the size and number of detector changes") {
CHECK(m.getNumberOfDetectors() == 1); CHECK(m.getNumberOfDetectors() == 1);
CHECK(m.getTotalNumberOfChannels() == 256 * 1024); CHECK(m.getTotalNumberOfChannels() == 256 * 1024);
@@ -31,7 +31,7 @@ SCENARIO("Multi detector operation", "[detector]") {
WHEN("we add another detector") { WHEN("we add another detector") {
m.addSlsDetector(sls::make_unique<slsDetector>( m.addSlsDetector(sls::make_unique<slsDetector>(
slsDetectorDefs::detectorType::EIGER, 0, 1)); slsDetectorDefs::detectorType::EIGER, 20, 1));
THEN("the size and number of detector changes") { THEN("the size and number of detector changes") {
CHECK(m.getNumberOfDetectors() == 2); CHECK(m.getNumberOfDetectors() == 2);
CHECK(m.getTotalNumberOfChannels() == 2 * 256 * 1024); CHECK(m.getTotalNumberOfChannels() == 2 * 256 * 1024);
@@ -61,3 +61,24 @@ SCENARIO("Multi detector operation", "[detector]") {
m.freeSharedMemory(); 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]") { TEST_CASE("Set and get trimen", "[detector]") {
// Free shared memory to be sure that we start in a clean state // 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 // 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); CHECK(d.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER);
// At the beginning there should be no trimen set // 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]") { TEST_CASE("Set additional JSON header", "[detector]") {
slsDetector::freeSharedMemory(0, 0); slsDetector::freeSharedMemory(20, 20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0); slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
auto header = d.getAdditionalJsonHeader(); auto header = d.getAdditionalJsonHeader();
CHECK(header.empty()); CHECK(header.empty());
@@ -102,8 +102,8 @@ TEST_CASE("Set additional JSON header", "[detector]") {
TEST_CASE("Set ROI", "[detector]") { TEST_CASE("Set ROI", "[detector]") {
using ROI = slsDetectorDefs::ROI; using ROI = slsDetectorDefs::ROI;
slsDetector::freeSharedMemory(0, 0); slsDetector::freeSharedMemory(20,20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0); slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
int n{0}; int n{0};
d.getROI(n); d.getROI(n);
@@ -133,8 +133,8 @@ TEST_CASE("Set ROI", "[detector]") {
TEST_CASE("Set multiple ROIs", "[detector]") { TEST_CASE("Set multiple ROIs", "[detector]") {
using ROI = slsDetectorDefs::ROI; using ROI = slsDetectorDefs::ROI;
slsDetector::freeSharedMemory(0, 0); slsDetector::freeSharedMemory(20, 20);
slsDetector d(slsDetectorDefs::detectorType::EIGER, 0, 0); slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
// set one ROI // set one ROI
constexpr int n = 3; constexpr int n = 3;
@@ -176,4 +176,19 @@ TEST_CASE("Set multiple ROIs", "[detector]") {
CHECK(res[2].ymax == 800); CHECK(res[2].ymax == 800);
d.freeSharedMemory(); 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();
} }