merging refactor (replacing)

python/src/Detector.h

@@ -0,0 +1,964 @@
+#ifndef DETECTOR_H
+#define DETECTOR_H
+#include <cstdint>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <stdexcept>
+
+#include "error_defs.h"
+#include "multiSlsDetector.h"
+#include "slsDetector.h"
+// #include "slsDetectorUtils.h"
+#include "sls_detector_defs.h"
+// #include "sls_receiver_defs.h"
+
+class Detector {
+  public:
+    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
+    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);
+        return image_size;
+    }
+
+    void setImageSize(const int rows, const int cols) {
+        det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::Y,
+                                              rows);
+        det.setMaxNumberOfChannelsPerDetector(slsDetectorDefs::dimension::X,
+                                              cols);
+    }
+
+    // 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); }
+
+    int getFramesCaughtByReceiver() {
+        return det.getFramesCaughtByReceiver();
+        // return det.getFramesCaughtByReceiver();
+    }
+    int getFramesCaughtByReceiver(int i) {
+        return det.getFramesCaughtByReceiver(i);
+    }
+
+    void setReceiverFifoDepth(int n_frames) {
+        det.setReceiverFifoDepth(n_frames);
+    }
+
+    void setNumberOfStorageCells(const int64_t num) {
+        det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER, num);
+    }
+    int getNumberOfStorageCells() {
+        return det.setTimer(slsDetectorDefs::timerIndex::STORAGE_CELL_NUMBER,
+                            -1);
+    }
+
+    void setStoragecellStart(int cell) { det.setStoragecellStart(cell); }
+
+    int getStoragecellStart() { return det.setStoragecellStart(); }
+
+    int getReceiverFifoDepth() { return det.setReceiverFifoDepth(); }
+
+    void resetFramesCaught() { det.resetFramesCaught(); }
+
+    int getReceiverCurrentFrameIndex() {
+        return det.getReceiverCurrentFrameIndex();
+    }
+
+    std::string getReceiverHostname(int det_id = -1) const {
+        return det.getReceiverHostname(det_id);
+    }
+
+    void setReceiverHostname(std::string hostname, int det_id = -1) {
+        det.setReceiverHostname(hostname, det_id);
+    }
+
+    std::string getReceiverUDPIP(int det_id = -1) const {
+        return det.getReceiverUDPIP(det_id);
+    }
+
+    void setReceiverUDPIP(std::string ip, int det_id = -1) {
+        det.setReceiverUDPIP(ip, det_id);
+    }
+
+    std::string getReceiverUDPMAC(int det_id = -1) {
+        return det.getReceiverUDPMAC(det_id);
+    }
+
+    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(); }
+    void setTenGigabitEthernet(bool value) {
+        det.enableTenGigabitEthernet(value);
+    }
+
+    void setFileFormat(const std::string &format);
+    std::string getFileFormat();
+
+    std::string checkOnline() { return det.checkOnline(); }
+
+    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 isChipPowered() { return det.powerChip(); }
+    void powerChip(const bool value) { det.powerChip(value); }
+
+    // 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
+    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...
+    void writeAdcRegister(const int addr, const int value) {
+        det.writeAdcRegister(addr, value);
+    }
+
+    void setBitInRegister(const uint32_t reg_addr, const int bit_number) {
+        det.setBit(reg_addr, bit_number);
+    }
+    void clearBitInRegister(const uint32_t reg_addr, const int bit_number) {
+        det.clearBit(reg_addr, bit_number);
+    }
+
+    bool getAcquiringFlag() { return det.getAcquiringFlag(); }
+
+    void setAcquiringFlag(const bool flag) { det.setAcquiringFlag(flag); }
+
+    bool getCounterBit() { return det.setCounterBit(); }
+    void setCounterBit(bool b) { det.setCounterBit(b); }
+
+    slsDetectorDefs::dacIndex dacNameToEnum(std::string dac_name);
+
+    std::pair<int, int> getDetectorGeometry() {
+        std::pair<int, int> g;
+        det.getNumberOfDetectors(g.first, g.second);
+        return g;
+    }
+
+    int getNumberOfDetectors() { return det.getNumberOfDetectors(); }
+
+    std::string getRunStatus() {
+        auto s = det.getRunStatus();
+        return det.runStatusType(s);
+    }
+
+    void startAcquisition() { det.startAcquisition(); }
+    void stopAcquisition() { det.stopAcquisition(); }
+
+    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); }
+
+    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(); }
+
+    int getReadoutClockSpeed() {
+        return det.setSpeed(slsDetectorDefs::CLOCK_DIVIDER, -1);
+    }
+    void setReadoutClockSpeed(const int speed) {
+        det.setSpeed(slsDetectorDefs::CLOCK_DIVIDER, speed);
+    }
+
+    void setDbitPipeline(const int value) {
+        det.setSpeed(slsDetectorDefs::DBIT_PIPELINE, value);
+    }
+    int getDbitPipeline() {
+        return det.setSpeed(slsDetectorDefs::DBIT_PIPELINE, -1);
+    }
+    void setDbitPhase(const int value) {
+        det.setSpeed(slsDetectorDefs::DBIT_PHASE, value);
+    }
+    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(); }
+
+    void setReceiverPort(int det_id, int value) {
+        det.setReceiverPort(value, det_id);
+    }
+
+    void setRateCorrection(std::vector<double> tau) {
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i)
+            det.setRateCorrection(tau[i], i);
+    }
+
+    std::vector<double> getRateCorrection();
+
+    bool getFlippedDataX(int i) {
+        return det.getFlippedData(slsDetectorDefs::dimension::X, i);
+    }
+
+    bool getFlippedDataY(int i) {
+        return det.getFlippedData(slsDetectorDefs::dimension::Y, i);
+    }
+
+    void setFlippedDataX(int i, bool value) {
+        det.setFlippedData(slsDetectorDefs::dimension::X, value, i);
+    }
+
+    void setFlippedDataY(int i, bool value) {
+        det.setFlippedData(slsDetectorDefs::dimension::Y, value, i);
+    }
+
+    /*** 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); }
+
+    std::string getUserDetails() { return det.getUserDetails(); }
+
+    void setFramesPerFile(const int n_frames) {
+        det.setFramesPerFile(n_frames);
+    }
+    int getFramesPerFile() { return det.setFramesPerFile(); }
+
+    std::string getReceiverFrameDiscardPolicy() {
+        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");
+        }
+        det.setReceiverFramesDiscardPolicy(fdp);
+    }
+
+    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) {
+            auto t = det.getTimeLeft(slsDetectorDefs::MEASURED_PERIOD, i);
+            mp.push_back(static_cast<double>(t) * 1E-9);
+        }
+        return mp;
+    }
+    std::vector<double> getMeasuredSubPeriod() {
+        std::vector<double> mp;
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+            auto t = det.getTimeLeft(slsDetectorDefs::MEASURED_SUBPERIOD, i);
+            mp.push_back(static_cast<double>(t) * 1E-9);
+        }
+        return mp;
+    }
+
+    bool isClientAndDetectorCompatible() {
+        auto r = det.checkDetectorVersionCompatibility();
+        if (r == 0)
+            return true;
+        else
+            return false;
+    }
+    bool isClientAndReceiverCompatible() {
+        auto r = det.checkReceiverVersionCompatibility();
+        if (r == 0)
+            return true;
+        else
+            return false;
+    }
+
+    /*** 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); }
+
+    std::vector<int> getTrimEnergies() { return det.getTrimEn(); }
+
+    /*** Temperature control functions for Jungfrau ***/
+    void setThresholdTemperature(float t) {
+        det.setThresholdTemperature(static_cast<int>(t * 1000), -1);
+    }
+
+    float getThresholdTemperature() {
+        return static_cast<double>(det.setThresholdTemperature(-1, -1)) /
+               1000.0;
+    }
+
+    void setTemperatureControl(bool v) { det.setTemperatureControl(v); }
+    bool getTemperatureControl() { return det.setTemperatureControl(); }
+
+    bool getTemperatureEvent() { return det.setTemperatureEvent(); }
+    void resetTemperatureEvent() { det.setTemperatureEvent(0); }
+    /*** END Temperature control functions for Jungfrau ***/
+
+    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(); }
+
+    std::string getSettings() {
+        return det.getDetectorSettings(det.getSettings());
+    }
+
+    void setSettings(std::string s) {
+        det.setSettings(det.getDetectorSettings(s));
+    }
+
+    // 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);
+        return det.setDAC(val, dac, 0, mod_id);
+    }
+
+    void setDac(std::string dac_name, const int mod_id, int val) {
+        auto dac = dacNameToEnum(dac_name);
+        det.setDAC(val, dac, 0, mod_id);
+    }
+
+    int getDac_mV(std::string dac_name, const int mod_id) {
+        int val = -1;
+        auto dac = dacNameToEnum(dac_name);
+        return det.setDAC(val, dac, 1, mod_id);
+    }
+
+    void setDac_mV(std::string dac_name, const int mod_id, int value) {
+        auto dac = dacNameToEnum(dac_name);
+        det.setDAC(value, dac, 1, mod_id);
+    }
+
+    // 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
+    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?
+    bool getServerLock() { return det.lockServer(-1); }
+    void setServerLock(const bool value) { det.lockServer(value); }
+    bool getReceiverLock() { return det.lockReceiver(-1); }
+    void setReceiverLock(const bool value) { det.lockReceiver(value); }
+
+    int getAdc(std::string adc_name, int mod_id) {
+        auto adc = dacNameToEnum(adc_name);
+        return det.getADC(adc, mod_id);
+    }
+
+    std::vector<std::string> getReadoutFlags();
+
+    // note singular
+    void setReadoutFlag(const std::string flag_name);
+
+    // name to enum transltion of dac
+    int getDacVthreshold() {
+        int val = -1;
+        auto dac = slsDetectorDefs::dacIndex::THRESHOLD;
+        return det.setDAC(val, dac, 0, -1);
+    }
+
+    void setDacVthreshold(const int val) {
+        auto dac = slsDetectorDefs::dacIndex::THRESHOLD;
+        det.setDAC(val, dac, 0, -1);
+    }
+
+    void setFileIndex(const int i) { det.setFileIndex(i); }
+
+    int getFileIndex() { return det.getFileIndex(); }
+
+    // time in ns
+    void setExposureTime(const int64_t t) {
+        det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
+    }
+
+    // time in ns
+    int64_t getExposureTime() {
+        return det.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, -1);
+    }
+
+    void setSubExposureTime(const int64_t t) {
+        det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, t);
+    }
+
+    int64_t getSubExposureTime() {
+        // time in ns
+        return det.setTimer(
+            slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, -1);
+    }
+
+    void setSubExposureDeadTime(const int64_t t) {
+        det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME, t);
+    }
+
+    int64_t getSubExposureDeadTime() {
+        // time in ns
+        return det.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_DEADTIME, -1);
+    }
+
+    int64_t getCycles() {
+        return det.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, -1);
+    }
+
+    void setCycles(const int64_t n_cycles) {
+        det.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, n_cycles);
+    }
+
+    void setNumberOfMeasurements(const int n_measurements) {
+        det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER,
+                     n_measurements);
+    }
+    int getNumberOfMeasurements() {
+        return det.setTimer(slsDetectorDefs::timerIndex::MEASUREMENTS_NUMBER,
+                            -1);
+    }
+
+    int getNumberOfGates() {
+        return det.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, -1);
+    }
+    void setNumberOfGates(const int t) {
+        det.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, t);
+    }
+
+    // time in ns
+    int64_t getDelay() {
+        return det.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER,
+                            -1);
+    }
+    // time in ns
+    void setDelay(const int64_t t) {
+        det.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, t);
+    }
+    // time in ns
+    int64_t getPeriod() {
+        return det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, -1);
+    }
+    // time in ns
+    void setPeriod(const int64_t t) {
+        det.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, t);
+    }
+
+    int64_t getNumberOfFrames() {
+        return det.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, -1);
+    }
+
+    void setNumberOfFrames(const int64_t nframes) {
+        det.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, nframes);
+    }
+
+    std::string getTimingMode() {
+        return det.externalCommunicationType(
+            det.setExternalCommunicationMode());
+    }
+    void setTimingMode(const std::string mode) {
+        det.setExternalCommunicationMode(det.externalCommunicationType(mode));
+    }
+
+    void freeSharedMemory() { det.freeSharedMemory(); }
+
+    std::vector<std::string> getDetectorType() {
+        std::vector<std::string> detector_type;
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+            detector_type.push_back(det.getDetectorTypeAsString(i));
+        }
+        return detector_type;
+    }
+
+    void setFileWrite(bool value) { det.setFileWrite(value); }
+    bool getFileWrite() { return det.getFileWrite(); }
+
+    void setFileOverWrite(bool value) { det.setFileOverWrite(value); }
+
+    bool getFileOverWrite() { return det.getFileOverWrite(); }
+
+    void setAllTrimbits(int tb) { det.setAllTrimbits(tb); }
+    int getAllTrimbits() { return det.setAllTrimbits(-1); }
+    bool getRxDataStreamStatus() {
+        return det.enableDataStreamingFromReceiver();
+    }
+
+    void setRxDataStreamStatus(bool state) {
+        det.enableDataStreamingFromReceiver(state);
+    }
+
+    // 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());
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+            vec.push_back(det.getReceiverStreamingPort(i));
+        }
+        return vec;
+    }
+
+    void setReceiverStreamingPort(int value, int det_id) {
+        det.setReceiverDataStreamingOutPort(value, det_id);
+    }
+
+    std::vector<int> getReceiverUDPPort() {
+        std::vector<int> vec;
+        vec.reserve(det.getNumberOfDetectors());
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+            vec.push_back(det.getReceiverUDPPort(i));
+        }
+        return vec;
+    }
+
+    std::vector<int> getReceiverUDPPort2() {
+        std::vector<int> vec;
+        vec.reserve(det.getNumberOfDetectors());
+        for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+            vec.push_back(det.getReceiverUDPPort2(i));
+        }
+        return vec;
+    }
+
+    void setReceiverUDPPort(int port, int det_id) {
+        det.setReceiverUDPPort(port, det_id);
+    }
+    void setReceiverUDPPort2(int port, int det_id) {
+        det.setReceiverUDPPort2(port, det_id);
+    }
+
+    // //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) {
+    //     auto p = networkNameToEnum(par_name);
+    //     if (det_id == -1) {
+    //         det.setDetectorNetworkParameter(p, par);
+    //     } else {
+    //         det.setDetectorNetworkParameter(p, par, det_id);
+    //     }
+    // }
+
+    void configureNetworkParameters() { det.configureMAC(); }
+
+    std::string getLastClientIP() { return det.getLastClientIP(); }
+    std::string getReceiverLastClientIP() {
+        return det.getReceiverLastClientIP();
+    }
+
+    // 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);
+        return r;
+    }
+    // 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);
+    }
+
+    // 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);
+        return r;
+    }
+    // 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);
+    }
+
+    // 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);
+        return r;
+    }
+
+    // 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);
+    }
+
+    // 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); }
+
+    slsDetectorDefs::networkParameter networkNameToEnum(std::string par_name);
+
+  private:
+    multiSlsDetector det;
+    slsDetector *getSlsDetector(int i) const;
+    int multi_detector_id = 0;
+};
+
+void Detector::setFileFormat(const std::string &format) {
+    if (format == "binary") {
+        det.setFileFormat(slsDetectorDefs::fileFormat::BINARY);
+    } else if (format == "ascii") {
+        det.setFileFormat(slsDetectorDefs::fileFormat::ASCII);
+    } else if (format == "hdf5") {
+        det.setFileFormat(slsDetectorDefs::fileFormat::HDF5);
+    }
+}
+
+std::string Detector::getFileFormat() {
+    auto format =
+        det.setFileFormat(slsDetectorDefs::fileFormat::GET_FILE_FORMAT, -1);
+    switch (format) {
+    case slsDetectorDefs::fileFormat::BINARY:
+        return "binary";
+    case slsDetectorDefs::fileFormat::ASCII:
+        return "ascii";
+    case slsDetectorDefs::fileFormat::HDF5:
+        return "hdf5";
+    default:
+        return "unknown";
+    }
+}
+
+slsDetectorDefs::networkParameter
+Detector::networkNameToEnum(std::string par_name) {
+
+    if (par_name == "detectormac") {
+        return slsDetectorDefs::networkParameter::DETECTOR_MAC;
+    } else if (par_name == "detectorip") {
+        return slsDetectorDefs::networkParameter::DETECTOR_IP;
+    } else if (par_name == "rx_hostname") {
+        return slsDetectorDefs::networkParameter::RECEIVER_HOSTNAME;
+    } else if (par_name == "rx_udpip") {
+        return slsDetectorDefs::networkParameter::RECEIVER_UDP_IP;
+    } else if (par_name == "rx_udpport") {
+        return slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT;
+    } else if (par_name == "rx_udpmac") {
+        return slsDetectorDefs::networkParameter::RECEIVER_UDP_MAC;
+    } else if (par_name == "rx_udpport2") {
+        return slsDetectorDefs::networkParameter::RECEIVER_UDP_PORT2;
+    } 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;
+    } else if (par_name == "rx_jsonaddheader") {
+        return slsDetectorDefs::networkParameter::ADDITIONAL_JSON_HEADER;
+    } else if (par_name == "delay_left") {
+        return slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_LEFT;
+    } else if (par_name == "delay_right") {
+        return slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_RIGHT;
+    } else if (par_name == "delay_frame") {
+        return slsDetectorDefs::networkParameter::DETECTOR_TXN_DELAY_FRAME;
+    } else if (par_name == "flow_control_10g") {
+        return slsDetectorDefs::networkParameter::FLOW_CONTROL_10G;
+    } else if (par_name == "client_zmqport") {
+        return slsDetectorDefs::networkParameter::CLIENT_STREAMING_PORT;
+    } else if (par_name == "rx_zmqport") {
+        return slsDetectorDefs::networkParameter::RECEIVER_STREAMING_PORT;
+    } else if (par_name == "rx_zmqip") {
+        return slsDetectorDefs::networkParameter::RECEIVER_STREAMING_SRC_IP;
+    } else if (par_name == "client_zmqip") {
+        return slsDetectorDefs::networkParameter::CLIENT_STREAMING_SRC_IP;
+    }
+
+    throw std::runtime_error("Could not decode network parameter");
+};
+
+// slsDetectorDefs::fileFormat Detector::file///
+
+slsDetectorDefs::dacIndex Detector::dacNameToEnum(std::string dac_name) {
+    // to avoid uninitialised
+    slsDetectorDefs::dacIndex dac = slsDetectorDefs::dacIndex::E_SvP;
+
+    if (dac_name == "vsvp") {
+        dac = slsDetectorDefs::dacIndex::E_SvP;
+    } else if (dac_name == "vtr") {
+        dac = slsDetectorDefs::dacIndex::E_Vtr;
+    } else if (dac_name == "vthreshold") {
+        dac = slsDetectorDefs::dacIndex::THRESHOLD;
+    } else if (dac_name == "vrf") {
+        dac = slsDetectorDefs::dacIndex::E_Vrf;
+    } else if (dac_name == "vrs") {
+        dac = slsDetectorDefs::dacIndex::E_Vrs;
+    } else if (dac_name == "vsvn") {
+        dac = slsDetectorDefs::dacIndex::E_SvN;
+    } else if (dac_name == "vtgstv") {
+        dac = slsDetectorDefs::dacIndex::E_Vtgstv;
+    } else if (dac_name == "vcmp_ll") {
+        dac = slsDetectorDefs::dacIndex::E_Vcmp_ll;
+    } else if (dac_name == "vcmp_lr") {
+        dac = slsDetectorDefs::dacIndex::E_Vcmp_lr;
+    } else if (dac_name == "vcall") {
+        dac = slsDetectorDefs::dacIndex::E_cal;
+    } else if (dac_name == "vcmp_rl") {
+        dac = slsDetectorDefs::dacIndex::E_Vcmp_rl;
+    } else if (dac_name == "rxb_rb") {
+        dac = slsDetectorDefs::dacIndex::E_rxb_rb;
+    } else if (dac_name == "rxb_lb") {
+        dac = slsDetectorDefs::dacIndex::E_rxb_lb;
+    } else if (dac_name == "vcmp_rr") {
+        dac = slsDetectorDefs::dacIndex::E_Vcmp_rr;
+    } else if (dac_name == "vcp") {
+        dac = slsDetectorDefs::dacIndex::E_Vcp;
+    } else if (dac_name == "vcn") {
+        dac = slsDetectorDefs::dacIndex::E_Vcn;
+    } else if (dac_name == "vis") {
+        dac = slsDetectorDefs::dacIndex::E_Vis;
+    } else if (dac_name == "iodelay") {
+        dac = slsDetectorDefs::dacIndex::IO_DELAY;
+    } else if (dac_name == "v_a") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_A;
+    } else if (dac_name == "v_b") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_B;
+    } else if (dac_name == "v_c") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_C;
+    } else if (dac_name == "v_d") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_D;
+    } else if (dac_name == "v_io") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_IO;
+    } else if (dac_name == "v_chip") {
+        dac = slsDetectorDefs::dacIndex::V_POWER_CHIP;
+    } else if (dac_name == "v_limit") {
+        dac = slsDetectorDefs::dacIndex::V_LIMIT;
+    } else if (dac_name == "temp_fpga") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGA;
+    } else if (dac_name == "temp_fpgaext") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGAEXT;
+    } else if (dac_name == "temp_10ge") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_10GE;
+    } else if (dac_name == "temp_dcdc") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_DCDC;
+    } else if (dac_name == "temp_sodl") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_SODL;
+    } else if (dac_name == "temp_sodr") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_SODR;
+    } else if (dac_name == "temp_fpgafl") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGA2;
+    } else if (dac_name == "temp_fpgafr") {
+        dac = slsDetectorDefs::dacIndex::TEMPERATURE_FPGA3;
+    } else if (dac_name == "vhighvoltage") {
+        dac = slsDetectorDefs::dacIndex::HIGH_VOLTAGE;
+    } else if (dac_name == "vb_comp") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(0);
+    } else if (dac_name == "vdd_prot") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(1);
+    } else if (dac_name == "vin_com") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(2);
+    } else if (dac_name == "vref_prech") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(3);
+    } else if (dac_name == "vb_pixbuff") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(4);
+    } else if (dac_name == "vb_ds") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(5);
+    } else if (dac_name == "vref_ds") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(6);
+    } else if (dac_name == "vref_comp") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(7);
+    } else if (dac_name == "dac0") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(0);
+    } else if (dac_name == "dac1") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(1);
+    } else if (dac_name == "dac2") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(2);
+    } else if (dac_name == "dac3") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(3);
+    } else if (dac_name == "dac4") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(4);
+    } else if (dac_name == "dac5") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(5);
+    } else if (dac_name == "dac6") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(6);
+    } else if (dac_name == "dac7") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(7);
+    } else if (dac_name == "dac8") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(8);
+    } else if (dac_name == "dac9") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(9);
+    } else if (dac_name == "dac10") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(10);
+    } else if (dac_name == "dac11") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(11);
+    } else if (dac_name == "dac12") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(12);
+    } else if (dac_name == "dac13") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(13);
+    } else if (dac_name == "dac14") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(14);
+    } else if (dac_name == "dac15") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(15);
+    } else if (dac_name == "dac16") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(16);
+    } else if (dac_name == "dac17") {
+        dac = static_cast<slsDetectorDefs::dacIndex>(17);
+    }
+
+    return dac;
+}
+
+std::vector<std::string> Detector::getReadoutFlags() {
+    std::vector<std::string> flags;
+    auto r = det.setReadOutFlags();
+    if (r & slsDetectorDefs::readOutFlags::STORE_IN_RAM)
+        flags.push_back("storeinram");
+    if (r & slsDetectorDefs::readOutFlags::TOT_MODE)
+        flags.push_back("tot");
+    if (r & slsDetectorDefs::readOutFlags::CONTINOUS_RO)
+        flags.push_back("continous");
+    if (r & slsDetectorDefs::readOutFlags::PARALLEL)
+        flags.push_back("parallel");
+    if (r & slsDetectorDefs::readOutFlags::NONPARALLEL)
+        flags.push_back("nonparallel");
+    if (r & slsDetectorDefs::readOutFlags::SAFE)
+        flags.push_back("safe");
+    if (r & slsDetectorDefs::readOutFlags::DIGITAL_ONLY)
+        flags.push_back("digital");
+    if (r & slsDetectorDefs::readOutFlags::ANALOG_AND_DIGITAL)
+        flags.push_back("analog_digital");
+    if (r & slsDetectorDefs::readOutFlags::NOOVERFLOW)
+        flags.push_back("nooverflow");
+    if (r & slsDetectorDefs::readOutFlags::SHOW_OVERFLOW)
+        flags.push_back("overflow");
+    return flags;
+}
+
+// note singular
+void Detector::setReadoutFlag(const std::string flag_name) {
+    if (flag_name == "none")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::NORMAL_READOUT);
+    else if (flag_name == "storeinram")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::STORE_IN_RAM);
+    else if (flag_name == "tot")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::TOT_MODE);
+    else if (flag_name == "continous")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::CONTINOUS_RO);
+    else if (flag_name == "parallel")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::PARALLEL);
+    else if (flag_name == "nonparallel")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::NONPARALLEL);
+    else if (flag_name == "safe")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::SAFE);
+    else if (flag_name == "digital")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::DIGITAL_ONLY);
+    else if (flag_name == "analog_digital")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::ANALOG_AND_DIGITAL);
+    else if (flag_name == "nooverflow")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::NOOVERFLOW);
+    else if (flag_name == "overflow")
+        det.setReadOutFlags(slsDetectorDefs::readOutFlags::SHOW_OVERFLOW);
+    else
+        throw std::runtime_error("Flag name not recognized");
+}
+
+std::vector<double> Detector::getRateCorrection() {
+    std::vector<double> rate_corr;
+    for (int i = 0; i < det.getNumberOfDetectors(); ++i) {
+        rate_corr.push_back(det.getRateCorrection(i));
+    }
+    return rate_corr;
+}
+
+void Detector::pulseAllPixels(int n) {
+    //  int pulsePixelNMove(int n=0,int x=0,int y=0);
+    //  int pulsePixel(int n=0,int x=0,int y=0);
+
+    for (int j = 0; j < 8; ++j) {
+        det.pulsePixel(0, -255 + j, 0);
+        for (int i = 0; i < 256; ++i) {
+            det.pulsePixelNMove(n, 0, 1);
+        }
+    }
+    return;
+}
+void Detector::pulseDiagonal(int n) {
+    //  int pulsePixelNMove(int n=0,int x=0,int y=0);
+    //  int pulsePixel(int n=0,int x=0,int y=0);
+
+    for (int j = 20; j < 232; j += 16) {
+        det.pulsePixel(0, -255, j);
+        for (int i = 0; i < 8; ++i) {
+            det.pulsePixelNMove(n, 1, 1);
+        }
+    }
+    return;
+}
+
+#endif // DETECTOR_H

python/src/main.cpp

@@ -0,0 +1,297 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "Detector.h"
+#include "mythenFileIO.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_sls_detector, m)
+{
+    m.doc() = R"pbdoc(
+        C/C++ API
+        -----------------------
+        .. warning ::
+
+            This is the compiled c extension. You probably want to look at the
+            interface provided by sls instead.
+
+    )pbdoc";
+
+    py::class_<Detector> DetectorApi(m, "DetectorApi", R"pbdoc(
+    Interface to the multiSlsDetector class through Detector.h These functions
+    are used by the python classes Eiger and Jungfrau and normally it is better
+    to use them than to directly access functions here.
+
+    However it is possible to access these functions...
+
+    ::
+
+        #Using the python class
+        from sls_detector import Eiger
+        d = Eiger()
+        d._api.getThresholdEnergy()
+
+        #creating a DetectorApi object (remember to set online flags)
+        from _sls_detector import DetectorApi
+        api = DetectorApi(0)
+        api.setOnline(True)
+        api.setReceiverOnline(True)
+        api.getNumberOfFrames()
+
+        #But the Pythonic way is almost alway simpler
+        d = Eiger()
+        d.n_frames
+        >> 10
+
+    )pbdoc");
+    DetectorApi
+        .def(py::init<int>())
+        .def("freeSharedMemory", &Detector::freeSharedMemory)
+        .def("getMultiDetectorId", &Detector::getMultiDetectorId)
+        .def("acq", &Detector::acquire)
+        .def("getAcquiringFlag", &Detector::getAcquiringFlag)
+        .def("setAcquiringFlag", &Detector::setAcquiringFlag)
+
+        .def("setAllTrimbits", &Detector::setAllTrimbits)
+        .def("getAllTrimbits", &Detector::getAllTrimbits)
+        .def("setCounterBit", &Detector::setCounterBit)
+        .def("getCounterBit", &Detector::getCounterBit)
+
+        .def("getAdc", &Detector::getAdc)
+        .def("getDac", &Detector::getDac)
+        .def("getDac_mV", &Detector::getDac_mV)
+        .def("setDac", &Detector::setDac)
+        .def("setDac_mV", &Detector::setDac_mV)
+        .def("getDacFromIndex", &Detector::getDacFromIndex)
+        .def("setDacFromIndex", &Detector::setDacFromIndex)
+
+        .def("getDbitPipeline", &Detector::getDbitPipeline)
+        .def("setDbitPipeline", &Detector::setDbitPipeline)
+        .def("getDbitPhase", &Detector::getDbitPhase)
+        .def("setDbitPhase", &Detector::setDbitPhase)
+        .def("getDbitClock", &Detector::getDbitClock)
+        .def("setDbitClock", &Detector::setDbitClock)
+
+        .def("setThresholdEnergy", &Detector::setThresholdEnergy)
+        .def("getThresholdEnergy", &Detector::getThresholdEnergy)
+
+        .def("getSettings", &Detector::getSettings)
+        .def("setSettings", &Detector::setSettings)
+        .def("getSettingsDir", &Detector::getSettingsDir)
+        .def("setSettingsDir", &Detector::setSettingsDir)
+
+        .def("loadTrimbitFile", &Detector::loadTrimbitFile)
+        .def("setTrimEnergies", &Detector::setTrimEnergies)
+        .def("getTrimEnergies", &Detector::getTrimEnergies)
+
+        .def("pulseChip", &Detector::pulseChip)
+        .def("pulseAllPixels", &Detector::pulseAllPixels)
+        .def("pulseDiagonal", &Detector::pulseDiagonal)
+        .def("getRunStatus", &Detector::getRunStatus)
+        .def("readConfigurationFile", &Detector::readConfigurationFile)
+        .def("readParametersFile", &Detector::readParametersFile)
+        .def("checkOnline", &Detector::checkOnline)
+        .def("setReadoutClockSpeed", &Detector::setReadoutClockSpeed)
+        .def("getReadoutClockSpeed", &Detector::getReadoutClockSpeed)
+        .def("getHostname", &Detector::getHostname)
+        .def("setHostname", &Detector::setHostname)
+
+        .def("getOnline", &Detector::getOnline)
+        .def("setOnline", &Detector::setOnline)
+        .def("getReceiverOnline", &Detector::getReceiverOnline)
+        .def("setReceiverOnline", &Detector::setReceiverOnline)
+
+        .def("getReceiverPort", &Detector::getReceiverPort)
+        .def("setReceiverPort", &Detector::setReceiverPort)
+
+        .def("isChipPowered", &Detector::isChipPowered)
+        .def("powerChip", &Detector::powerChip)
+
+        .def("readRegister", &Detector::readRegister)
+        .def("writeRegister", &Detector::writeRegister)
+        .def("writeAdcRegister", &Detector::writeAdcRegister)
+        .def("setBitInRegister", &Detector::setBitInRegister)
+        .def("clearBitInRegister", &Detector::clearBitInRegister)
+
+        .def("setDynamicRange", &Detector::setDynamicRange)
+        .def("getDynamicRange", &Detector::getDynamicRange)
+        .def("getFirmwareVersion", &Detector::getFirmwareVersion)
+        .def("getServerVersion", &Detector::getServerVersion)
+        .def("getClientVersion", &Detector::getClientVersion)
+        .def("getReceiverVersion", &Detector::getReceiverVersion)
+        .def("getDetectorNumber", &Detector::getDetectorNumber)
+        .def("getRateCorrection", &Detector::getRateCorrection)
+        .def("setRateCorrection", &Detector::setRateCorrection)
+
+        .def("startAcquisition", &Detector::startAcquisition)
+        .def("stopAcquisition", &Detector::stopAcquisition)
+        .def("startReceiver", &Detector::startReceiver)
+        .def("stopReceiver", &Detector::stopReceiver)
+
+        .def("getFilePath", (std::string(Detector::*)()) & Detector::getFilePath, "Using multiSlsDetector")
+        .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, int)) & Detector::setFilePath)
+
+        .def("setFileName", &Detector::setFileName)
+        .def("getFileName", &Detector::getFileName)
+        .def("setFileIndex", &Detector::setFileIndex)
+        .def("getFileIndex", &Detector::getFileIndex)
+
+        .def("setExposureTime", &Detector::setExposureTime)
+        .def("getExposureTime", &Detector::getExposureTime)
+        .def("setSubExposureTime", &Detector::setSubExposureTime)
+        .def("getSubExposureTime", &Detector::getSubExposureTime)
+        .def("setPeriod", &Detector::setPeriod)
+        .def("getPeriod", &Detector::getPeriod)
+        .def("setSubExposureDeadTime", &Detector::setSubExposureDeadTime)
+        .def("getSubExposureDeadTime", &Detector::getSubExposureDeadTime)
+
+        .def("getCycles", &Detector::getCycles)
+        .def("setCycles", &Detector::setCycles)
+        .def("setNumberOfMeasurements", &Detector::setNumberOfMeasurements)
+        .def("getNumberOfMeasurements", &Detector::getNumberOfMeasurements)
+        .def("getNumberOfGates", &Detector::getNumberOfGates)
+        .def("setNumberOfGates", &Detector::setNumberOfGates)
+        .def("getDelay", &Detector::getDelay)
+        .def("setDelay", &Detector::setDelay)
+
+
+        .def("setStoragecellStart", &Detector::setStoragecellStart)
+        .def("getStoragecellStart", &Detector::getStoragecellStart)
+        .def("setNumberOfStorageCells", &Detector::setNumberOfStorageCells)
+        .def("getNumberOfStorageCells", &Detector::getNumberOfStorageCells)
+
+        .def("getTimingMode", &Detector::getTimingMode)
+        .def("setTimingMode", &Detector::setTimingMode)
+
+        .def("getDetectorType", &Detector::getDetectorType)
+
+        .def("setThresholdTemperature", &Detector::setThresholdTemperature)
+        .def("getThresholdTemperature", &Detector::getThresholdTemperature)
+        .def("setTemperatureControl", &Detector::setTemperatureControl)
+        .def("getTemperatureControl", &Detector::getTemperatureControl)
+        .def("getTemperatureEvent", &Detector::getTemperatureEvent)
+        .def("resetTemperatureEvent", &Detector::resetTemperatureEvent)
+
+        .def("getRxDataStreamStatus", &Detector::getRxDataStreamStatus)
+        .def("setRxDataStreamStatus", &Detector::setRxDataStreamStatus)
+
+        //Network stuff
+        .def("getReceiverHostname", &Detector::getReceiverHostname)
+        .def("setReceiverHostname", &Detector::setReceiverHostname)
+        .def("getReceiverStreamingPort", &Detector::getReceiverStreamingPort)
+        .def("setReceiverStreamingPort", &Detector::setReceiverStreamingPort)
+        .def("getReceiverUDPPort", &Detector::getReceiverUDPPort)
+        .def("getReceiverUDPPort2", &Detector::getReceiverUDPPort2)
+        .def("setReceiverUDPPort", &Detector::setReceiverUDPPort)
+        .def("setReceiverUDPPort2", &Detector::setReceiverUDPPort2)
+        .def("setReceiverUDPIP", &Detector::setReceiverUDPIP)
+        .def("getReceiverUDPIP", &Detector::getReceiverUDPIP)
+        .def("getReceiverUDPMAC", &Detector::getReceiverUDPMAC)
+        .def("setReceiverUDPMAC", &Detector::setReceiverUDPMAC)
+        
+        .def("getReceiverPort", &Detector::getReceiverPort)
+        .def("setReceiverPort", &Detector::setReceiverPort)
+
+        .def("configureNetworkParameters", &Detector::configureNetworkParameters)
+        .def("getDelayFrame", &Detector::getDelayFrame)
+        .def("setDelayFrame", &Detector::setDelayFrame)
+        .def("getDelayLeft", &Detector::getDelayLeft)
+        .def("setDelayLeft", &Detector::setDelayLeft)
+        .def("getDelayRight", &Detector::getDelayRight)
+        .def("setDelayRight", &Detector::setDelayRight)
+        .def("getLastClientIP", &Detector::getLastClientIP)
+        .def("getReceiverLastClientIP", &Detector::getReceiverLastClientIP)
+
+        .def("setFramesPerFile", &Detector::setFramesPerFile)
+        .def("getFramesPerFile", &Detector::getFramesPerFile)
+        .def("setReceiverFifoDepth", &Detector::setReceiverFifoDepth)
+        .def("getReceiverFifoDepth", &Detector::getReceiverFifoDepth)
+
+        .def("getReceiverFrameDiscardPolicy", &Detector::getReceiverFrameDiscardPolicy)
+        .def("setReceiverFramesDiscardPolicy", &Detector::setReceiverFramesDiscardPolicy)
+        .def("setPartialFramesPadding", &Detector::setPartialFramesPadding)
+        .def("getPartialFramesPadding", &Detector::getPartialFramesPadding)
+
+        .def("getUserDetails", &Detector::getUserDetails)
+        .def("isClientAndDetectorCompatible", &Detector::isClientAndDetectorCompatible)
+        .def("isClientAndReceiverCompatible", &Detector::isClientAndReceiverCompatible)
+        .def("getMeasuredPeriod", &Detector::getMeasuredPeriod)
+        .def("getMeasuredSubPeriod", &Detector::getMeasuredSubPeriod)
+
+
+        .def("setFileWrite", &Detector::setFileWrite)
+        .def("getFileWrite", &Detector::getFileWrite)
+        .def("setFileOverWrite", &Detector::setFileOverWrite)
+        .def("getFileOverWrite", &Detector::getFileOverWrite)
+        .def("getDacVthreshold", &Detector::getDacVthreshold)
+        .def("setDacVthreshold", &Detector::setDacVthreshold)
+        .def("setNumberOfFrames", &Detector::setNumberOfFrames)
+        .def("getNumberOfFrames", &Detector::getNumberOfFrames)
+
+        //Overloaded calls
+        .def("getFramesCaughtByReceiver", (int (Detector::*)() ) & Detector::getFramesCaughtByReceiver)
+        .def("getFramesCaughtByReceiver", (int (Detector::*)(int)) & Detector::getFramesCaughtByReceiver)
+
+
+        .def("resetFramesCaught", &Detector::resetFramesCaught)
+        .def("getReceiverCurrentFrameIndex", &Detector::getReceiverCurrentFrameIndex)
+        .def("getGapPixels", &Detector::getGapPixels)
+        .def("setGapPixels", &Detector::setGapPixels)
+        .def("getFlippedDataX", &Detector::getFlippedDataX)
+        .def("getFlippedDataY", &Detector::getFlippedDataY)
+        .def("setFlippedDataX", &Detector::setFlippedDataX)
+        .def("setFlippedDataY", &Detector::setFlippedDataY)
+
+        .def("getServerLock", &Detector::getServerLock)
+        .def("setServerLock", &Detector::setServerLock)
+        .def("getReceiverLock", &Detector::getReceiverLock)
+        .def("setReceiverLock", &Detector::setReceiverLock)
+
+        .def("getReadoutFlags", &Detector::getReadoutFlags)
+        .def("setReadoutFlag", &Detector::setReadoutFlag)
+
+        .def("setFileFormat", &Detector::setFileFormat)
+        .def("getFileFormat", &Detector::getFileFormat)
+
+        .def("getActive", &Detector::getActive)
+        .def("setActive", &Detector::setActive)
+
+        .def("getTenGigabitEthernet", &Detector::getTenGigabitEthernet)
+        .def("setTenGigabitEthernet", &Detector::setTenGigabitEthernet)
+
+        .def("getImageSize", &Detector::getImageSize)
+        .def("setImageSize", &Detector::setImageSize)
+        .def("getNumberOfDetectors", &Detector::getNumberOfDetectors)
+        .def("getDetectorGeometry", &Detector::getDetectorGeometry);
+
+
+
+//Experimental API to use the multi directly and inherit from to reduce
+//code duplication need to investigate how to handle documentation
+py::class_<multiSlsDetector> multiDetectorApi(m, "multiDetectorApi");
+    multiDetectorApi
+        .def(py::init<int>())
+        .def_property("busy", 
+            py::cpp_function(&multiSlsDetector::getAcquiringFlag),
+            py::cpp_function(&multiSlsDetector::setAcquiringFlag))
+         .def_property_readonly("rx_tcpport", 
+            py::cpp_function(&multiSlsDetector::getReceiverPort))          
+        .def_property_readonly("detectornumber", 
+            py::cpp_function(&multiSlsDetector::getDetectorNumber))  
+        .def("_getReceiverUDPIP", &multiSlsDetector::getReceiverUDPIP)
+        .def("_setReceiverUDPIP", &multiSlsDetector::setReceiverUDPIP)
+            ;
+
+    py::module io = m.def_submodule("io", "Submodule for io");
+    io.def("read_ctb_file", &read_ctb_file, "some");
+
+
+#ifdef VERSION_INFO
+    m.attr("__version__") = VERSION_INFO;
+#else
+    m.attr("__version__") = "dev";
+#endif
+}

python/src/mythenFileIO.h

@@ -0,0 +1,85 @@
+#pragma once
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <vector>
+
+#include <pybind11/numpy.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+namespace py = pybind11;
+
+template <size_t bit_index0, size_t bit_index1>
+std::vector<int> ExtractBits(const std::vector<uint64_t> &data, int dr = 24) {
+    constexpr int mask0 = (1 << bit_index0);
+    constexpr int mask1 = (1 << bit_index1);
+    constexpr int NumStrips = 2;
+    const int NumCompleteSamples = data.size() / dr;
+    const int NumCounters = NumCompleteSamples * NumStrips;
+
+    std::vector<int> result(NumCounters);
+
+    auto ptr = data.data();
+
+    auto strip0 = result.data();
+    auto strip1 = strip0 + NumCompleteSamples;
+
+    for (int j = 0; j != NumCompleteSamples; ++j) {
+        for (int i = 0; i != dr; ++i) {
+            int bit0 = (*ptr & mask0) >> bit_index0;
+            int bit1 = (*ptr++ & mask1) >> bit_index1;
+            *strip0 |= bit0 << i;
+            *strip1 |= bit1 << i;
+        }
+        strip0++;
+        strip1++;
+    }
+    return result;
+}
+
+template <size_t bit_index>
+std::vector<int> ExtractBits(const std::vector<uint64_t> &data, int dr = 24) {
+    constexpr int mask = (1 << bit_index);
+    const int NumCompleteSamples = data.size() / dr;
+    std::vector<int> result(NumCompleteSamples);
+    auto ptr = data.data();
+    for (auto &r : result) {
+        for (int i = 0; i != dr; ++i) {
+            int bit = (*ptr++ & mask) >> bit_index;
+            r |= bit << i;
+        }
+    }
+    return result;
+}
+
+std::vector<uint64_t> ReadFile(const std::string &fname, int offset = 8,
+                               int dr = 24) {
+    const int element_size = static_cast<int>(sizeof(uint64_t));
+    const int byte_offset = element_size * offset;
+    const int expected_size = dr * element_size * 32 * 3;
+    std::ifstream fs(fname, std::ios::binary | std::ios::ate);
+    if (!fs.is_open()) {
+        throw std::runtime_error("File not found: " + std::string(fname));
+    }
+    auto data_size = static_cast<long>(fs.tellg()) - byte_offset;
+    if (data_size != expected_size) {
+        auto diff = data_size - expected_size;
+        std::cout << "WARNING: data size is: " << data_size
+                  << " expected size is: " << expected_size << ", "
+                  << std::abs(diff) << " bytes "
+                  << ((diff < 0) ? "missing" : "too many") << '\n';
+    }
+    std::vector<uint64_t> data(expected_size / element_size);
+    fs.seekg(byte_offset, std::ios::beg);
+    fs.read(reinterpret_cast<char *>(data.data()), expected_size);
+    return data;
+}
+
+py::array_t<uint64_t> read_ctb_file(const std::string &fname, int offset = 8,
+                                    int dr = 24) {
+    auto data = ExtractBits<17, 6>(ReadFile(fname, offset, dr));
+    return py::array(data.size(), data.data());
+}