From 3881e2cd21f57783bfe8220fb20ed21172b905a5 Mon Sep 17 00:00:00 2001 From: Dhanya Thattil Date: Mon, 19 Aug 2019 20:36:42 +0200 Subject: [PATCH] WIP --- slsDetectorSoftware/include/Detector.h | 152 +- slsDetectorSoftware/src/Detector.cpp | 1821 ++++++++++++------------ 2 files changed, 1004 insertions(+), 969 deletions(-) diff --git a/slsDetectorSoftware/include/Detector.h b/slsDetectorSoftware/include/Detector.h index 304159b93..d34b586b4 100644 --- a/slsDetectorSoftware/include/Detector.h +++ b/slsDetectorSoftware/include/Detector.h @@ -196,6 +196,7 @@ class Detector { * If no receiver enabled, you can skip this for normal acquisition (no abort) */ void stopAcquisition();//TODO: cannot do this. for acquire, to stop acquisition, must not also do stop receiver(mutex) + // TODO: stopAcquire?? /** * Clears the acquiring flag. This has to be done manually @@ -218,7 +219,7 @@ class Detector { /** [Eiger] Sends an internal software trigger to the detector */ void sendSoftwareTrigger(Positions pos = {}); -//TODO: remove resetframescaught in receiver + //TODO: remove resetframescaught in receiver /************************************************** @@ -228,11 +229,41 @@ class Detector { * ************************************************/ /** Configures the destination for UDP packets in the detector - * Needed only if you use a custm receiver (not slsReceiver) + * Needed only if you use a custom receiver (not slsReceiver) * as it is already included in setReceiverHostname. */ void configureMAC(Positions pos = {});//TODO: find a reasonable name + /** [Jungfrau] */ + Result getNumberofUDPInterfaces(Positions pos = {}) const; + + /** [Jungfrau] Also restarts client and receiver sockets */ + void setNumberofUDPInterfaces(int n, Positions pos = {}); + + /** [Jungfrau] */ + Result getSelectedUDPInterface(Positions pos = {}) const; + + /** + * [Jungfrau: + * Effective only when number of interfaces is 1. + * Options: 0 (outer, default), 1(inner)] //TODO: enum? + */ + void selectUDPInterface(int interface, Positions pos = {}); + + Result getSourceUDPIP(Positions pos = {}) const; + + /* For Eiger 1G, the detector will replace with its own DHCP IP + * 10G Eiger and other detectors, the source UDP IP must be in the + * same subnet of the destination UDP IP + */ + void setSourceUDPIP(const std::string &ip, Positions pos = {}); + + /** [Jungfrau] bottom half */ + Result getSourceUDPIP2(Positions pos = {}) const; + + /** [Jungfrau] bottom half */ + void setSourceUDPIP2(const std::string &ip, Positions pos = {}); + Result getSourceUDPMAC(Positions pos = {}) const; /* For Eiger 1G, the detector will replace with its own DHCP MAC @@ -240,35 +271,44 @@ class Detector { * Others can be anything (beware of certain bits) */ - void setSourceUDPMAC(const std::string &detectorMAC, Positions pos = {}); + void setSourceUDPMAC(const std::string &mac, Positions pos = {}); - Result getSourceUDPIP(Positions pos = {}) const; + /** [Jungfrau] bottom half */ + Result getSourceUDPMAC2(Positions pos = {}) const; - /* For Eiger 1G, the detector will replace with its own DHCP IP - * 10G Eiger and other detectors, the source UDP IP must be in the - * same subnet of the destination UDP IP - */ - void setSourceUDPIP(const std::string &detectorIP, Positions pos = {}); + /** [Jungfrau] bottom half */ + void setSourceUDPMAC2(const std::string &mac, Positions pos = {}); Result getDestinationUDPIP(Positions pos = {}) const; /** IP of the interface in receiver that the detector sends data to */ - void setDestinationUDPIP(const std::string &udpip, Positions pos = {}); + void setDestinationUDPIP(const std::string &ip, Positions pos = {}); + /** [Jungfrau bottom half] */ + Result getDestinationUDPIP2(Positions pos = {}) const; + + /** [Jungfrau bottom half] */ + void setDestinationUDPIP2(const std::string &ip, Positions pos = {}); + Result getDestinationUDPMAC(Positions pos = {}) const; /** MAC of the interface in receiver that the detector sends data to * Only needed if you use a custom receiver (not slsReceiver) * Must be followed by configuremac. */ - void setDestinationUDPMAC(const std::string &udpmac, Positions pos = {}); + void setDestinationUDPMAC(const std::string &mac, Positions pos = {}); + + /** [Jungfrau bottom half] */ + Result getDestinationUDPMAC2(Positions pos = {}) const; + + /** [Jungfrau bottom half] */ + void setDestinationUDPMAC2(const std::string &mac, Positions pos = {}); Result getDestinationUDPPort(Positions pos = {}) const; - /** - * module_id is -1 for all detectors, ports for each module is calculated (increments) - */ - void setDestinationUDPPort(int udpport, int module_id = -1); + /** module_id is -1 for all detectors, ports for each module is calculated (increments) */ + //TODO if Parallel takes a vector, can send multiple vaues to set in slsdetector.cp + void setDestinationUDPPort(int port, int module_id = -1); /** [Eiger right port][Jungfrau bottom half] */ Result getDestinationUDPPort2(Positions pos = {}) const; @@ -276,10 +316,16 @@ class Detector { /** [Eiger right port][Jungfrau bottom half] * module_id is -1 for all detectors, ports for each module is calculated (increments) */ - void setDestinationUDPPort2(int udpport, int module_id = -1); + void setDestinationUDPPort2(int port, int module_id = -1); Result printRxConfiguration(Positions pos = {}) const; + /** [Eiger][CTB] */ + Result getTenGiga(Positions pos = {}) const; + + /** [Eiger][CTB] */ + void setTenGiga(bool enable, Positions pos = {}); + /** [Eiger, Jungfrau] */ Result getTenGigaGFlowControl(Positions pos = {}) const; @@ -317,48 +363,6 @@ class Detector { */ void setTransmissionDelayRight(int value, Positions pos = {}); - /** [Jungfrau] */ - Result getNumberofUDPInterfaces(Positions pos = {}) const; - - /** [Jungfrau] Also restarts client and receiver sockets */ - void setNumberofUDPInterfaces(int n, Positions pos = {}); - - /** [Jungfrau] */ - Result getSelectedUDPInterface(Positions pos = {}) const; - - /** - * [Jungfrau: - * Effective only when number of interfaces is 1. - * Options: 0 (outer, default), 1(inner)] //TODO: enum? - */ - void selectUDPInterface(int interface, Positions pos = {}); - - /** [Jungfrau] bottom half */ - Result getDetectorMAC2(Positions pos = {}) const; - - /** [Jungfrau] bottom half */ - void setDetectorMAC2(const std::string &detectorMAC, Positions pos = {}); - - /** [Jungfrau] bottom half */ - Result getDetectorIP2(Positions pos = {}) const; - - /** [Jungfrau] bottom half */ - void setDetectorIP2(const std::string &detectorIP, Positions pos = {}); - - /** [Jungfrau bottom half] */ - Result getDestinationUDPIP2(Positions pos = {}) const; - - /** [Jungfrau bottom half] */ - void setDestinationUDPIP2(const std::string &udpip, Positions pos = {}); - - /** [Jungfrau bottom half] */ - Result getDestinationUDPMAC2(Positions pos = {}) const; - - /** [Jungfrau bottom half] */ - void setDestinationUDPMAC2(const std::string &udpmac, Positions pos = {}); - - - /************************************************** * * @@ -426,10 +430,10 @@ class Detector { Result getRxLastClientIP(Positions pos = {}) const; + /************************************************** * * - * FILE, anything concerning file writing or * - * reading goes here * + * FILE * * * * ************************************************/ Result getFileFormat(Positions pos = {}) const; @@ -546,12 +550,6 @@ class Detector { */ void setDynamicRange(int value); - /** [Eiger] */ - Result getTenGiga(Positions pos = {}) const; - - /** [Eiger] */ - void setTenGiga(bool enable, Positions pos = {}); - /** [Eiger] in 32 bit mode */ Result getSubExptime(Positions pos = {}) const; @@ -660,6 +658,9 @@ class Detector { /** [Eiger] */ Result getRxPadDeactivatedMode(Positions pos = {}) const; + /** [Eiger] Pad deactivated modules in receiver */ + void setRxPadDeactivatedMode(bool pad, Positions pos = {}); + /** [Eiger] Advanced */ Result getPartialReset(Positions pos = {}) const; @@ -669,20 +670,17 @@ class Detector { /** [Eiger] Advanced * Pulse Pixel n times at x and y coordinates */ - void pulsePixel(int n, defs:: pixel, Positions pos = {}); + void pulsePixel(int n, defs::xy pixel, Positions pos = {}); /** [Eiger] Advanced * Pulse Pixel n times and move by a relative value of x and y * coordinates */ - void pulsePixelNMove(int n, defs:: pixel, Positions pos = {}); + void pulsePixelNMove(int n, defs::xy pixel, Positions pos = {}); /** [Eiger] Advanced * Pulse chip n times */ void pulseChip(int n, Positions pos = {}); - /** [Eiger] Pad deactivated modules in receiver */ - void setRxPadDeactivatedMode(bool pad, Positions pos = {}); - /** [Eiger] with specific quad hardware */ Result getQuad(Positions pos = {}) const; @@ -941,16 +939,16 @@ class Detector { void setExternalSampling(bool value, Positions pos = {}); /** [CTB] */ - Result> getReceiverDbitList(Positions pos = {}) const; + Result> getRxDbitList(Positions pos = {}) const; /** [CTB] list contains the set of bits (0-63) to save */ - void setReceiverDbitList(std::vector list, Positions pos = {}); + void setRxDbitList(std::vector list, Positions pos = {}); /** [CTB] */ - Result getReceiverDbitOffset(Positions pos = {}) const; + Result getRxDbitOffset(Positions pos = {}) const; /** [CTB] Set number of bytes of digital data to skip in the Receiver */ - void setReceiverDbitOffset(int value, Positions pos = {}); + void setRxDbitOffset(int value, Positions pos = {}); /** * [CTB] Set Digital IO Delay @@ -1174,8 +1172,10 @@ class Detector { std::string getUserDetails() const; - Result getReceiverCurrentFrameIndex(Positions pos = {}) const; + Result getRxCurrentFrameIndex(Positions pos = {}) const; +private: +std::vector getPortNumbers(int start_port); }; diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp index 3a670b64c..fe355206e 100644 --- a/slsDetectorSoftware/src/Detector.cpp +++ b/slsDetectorSoftware/src/Detector.cpp @@ -231,131 +231,481 @@ void Detector::setTimingMode(defs::timingMode value, Positions pos) { void Detector::acquire() { pimpl->acquire(); } - - - - - - - - - - - - -Result Detector::getQuad(Positions pos) const { - return pimpl->Parallel(&slsDetector::getQuad, pos); +void Detector::startAcquisition() { + if (getUseReceiverFlag({}).squash()) + pimpl->Parallel(&slsDetector::startReceiver, {}); + pimpl->Parallel(&slsDetector::startAcquisition, {}); } -void Detector::setQuad(const bool value) { - pimpl->setQuad(value); +void Detector::stopAcquisition() { + pimpl->Parallel(&slsDetector::stopAcquisition, {}); + if (getUseReceiverFlag({}).squash()) //TODO: problem for acquire() + pimpl->Parallel(&slsDetector::stopReceiver, {}); } -Result Detector::getPartialReadout(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReadNLines, pos); +void Detector::clearAcquiringFlag() { pimpl->setAcquiringFlag(0); } + +Result Detector::getDetectorStatus(Positions pos) const{ + return pimpl->Parallel(&slsDetector::getRunStatus, pos); } -void Detector::setPartialReadout(const int lines, Positions pos) { - pimpl->Parallel(&slsDetector::setReadNLines, pos, lines); +Result Detector::getReceiverStatus(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverStatus, pos); } -Result Detector::getControlPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getControlPort, pos); +Result Detector::getFramesCaught(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFramesCaughtByReceiver, pos); } -void Detector::setControlPort(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setControlPort, pos, value); +Result Detector::getStartingFrameNumber(Positions pos) const { + return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos); } -Result Detector::getStopPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getStopPort, pos); +void Detector::setStartingFrameNumber(uint64_t value, Positions pos) { + pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value); } -void Detector::setStopPort(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setStopPort, pos, value); -} - -Result Detector::getDetectorLock(Positions pos) const { - return pimpl->Parallel(&slsDetector::lockServer, pos, -1); -} - -void Detector::setDetectorLock(bool lock, Positions pos) { - pimpl->Parallel(&slsDetector::lockServer, pos, static_cast(lock)); -} - -Result Detector::getLastClientIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getLastClientIP, pos); -} - -void Detector::execCommand(const std::string &value, Positions pos) { - pimpl->Parallel(&slsDetector::execCommand, pos, value); +void Detector::sendSoftwareTrigger(Positions pos) { + pimpl->Parallel(&slsDetector::sendSoftwareTrigger, pos); } -Result Detector::getThresholdEnergy(Positions pos) const { - return pimpl->Parallel(&slsDetector::getThresholdEnergy, pos); -} - -void Detector::setThresholdEnergy(int threshold_ev, defs::detectorSettings settings, - bool trimbits, Positions pos) { - pimpl->Parallel(&slsDetector::setThresholdEnergy, pos, threshold_ev, settings, static_cast(trimbits)); -} - -Result Detector::getSettingsDir(Positions pos) const { - return pimpl->Parallel(&slsDetector::getSettingsDir, pos); -} - -void Detector::setSettingsDir(const std::string &value, Positions pos) { - pimpl->Parallel(&slsDetector::setSettingsDir, pos, value); -} - -void Detector::loadTrimbits(const std::string &value, Positions pos) { - pimpl->Parallel(&slsDetector::loadSettingsFile, pos, value); -} +// Network Configuration (Detector<->Receiver) void Detector::configureMAC(Positions pos) { pimpl->Parallel(&slsDetector::configureMAC, pos); } - -Result Detector::getNumberOfAdditionalStorageCells() const { - return pimpl->Parallel(&slsDetector::setTimer, {}, - defs::STORAGE_CELL_NUMBER, -1); +Result Detector::getNumberofUDPInterfaces(Positions pos) const { + return pimpl->Parallel(&slsDetector::getNumberofUDPInterfaces, pos); } -void Detector::setNumberOfAdditionalStorageCells(int64_t value) { - pimpl->Parallel(&slsDetector::setTimer, {}, defs::STORAGE_CELL_NUMBER, - value); +void Detector::setNumberofUDPInterfaces(int n, Positions pos) { + int previouslyClientStreaming = pimpl->enableDataStreamingToClient(); + bool previouslyReceiverStreaming = true;//getRxZmqIP(pos).squash(false); //FIXME TODO + pimpl->Parallel(&slsDetector::setNumberofUDPInterfaces, pos, n); + // redo the zmq sockets if enabled + if (previouslyClientStreaming != 0) { + pimpl->enableDataStreamingToClient(0); + pimpl->enableDataStreamingToClient(1); + } + if (previouslyReceiverStreaming) { + setRxZmqDataStream(false, pos); + setRxZmqDataStream(true, pos); + } } -Result Detector::getStorageCellStart(Positions pos) const { - return pimpl->Parallel(&slsDetector::setStoragecellStart, pos, -1); +Result Detector::getSelectedUDPInterface(Positions pos) const { + return pimpl->Parallel(&slsDetector::getSelectedUDPInterface, pos); } -void Detector::setStoragecellStart(int cell, Positions pos) { - pimpl->Parallel(&slsDetector::setStoragecellStart, pos, cell); +void Detector::selectUDPInterface(int interface, Positions pos) { + pimpl->Parallel(&slsDetector::selectUDPInterface, pos, interface); +} + +Result Detector::getSourceUDPIP(Positions pos) const { + return pimpl->Parallel(&slsDetector::getDetectorIP, pos); +} + +void Detector::setSourceUDPIP(const std::string &ip, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorIP, pos, ip); +} + +Result Detector::getSourceUDPIP2(Positions pos) const { + return pimpl->Parallel(&slsDetector::getDetectorIP2, pos); +} + +void Detector::setSourceUDPIP2(const std::string &ip, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorIP2, pos, ip); +} + +Result Detector::getSourceUDPMAC(Positions pos) const { + return pimpl->Parallel(&slsDetector::getDetectorMAC, pos); +} + +void Detector::setSourceUDPMAC(const std::string &mac, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorMAC, pos, mac); +} + +Result Detector::getSourceUDPMAC2(Positions pos) const { + return pimpl->Parallel(&slsDetector::getDetectorMAC2, pos); +} + +void Detector::setSourceUDPMAC2(const std::string &mac, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorMAC2, pos, mac); +} + +Result Detector::getDestinationUDPIP(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPIP, pos); +} + +void Detector::setDestinationUDPIP(const std::string &ip, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverUDPIP, pos, ip); +} + +Result Detector::getDestinationUDPIP2(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPIP2, pos); +} + +void Detector::setDestinationUDPIP2(const std::string &ip, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverUDPIP2, pos, ip); +} + +Result Detector::getDestinationUDPMAC(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPMAC, pos); +} + +void Detector::setDestinationUDPMAC(const std::string &mac, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverUDPMAC, pos, mac); +} + +Result Detector::getDestinationUDPMAC2(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPMAC2, pos); +} + +void Detector::setDestinationUDPMAC2(const std::string &mac, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverUDPMAC2, pos, mac); +} + +Result Detector::getDestinationUDPPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPPort, pos); +} + +void Detector::setDestinationUDPPort(int port, int module_id) { + if (module_id == -1) { + std::vector port_list = getPortNumbers(port); + for (int idet = 0; idet < size(); ++idet) { + pimpl->Parallel(&slsDetector::setReceiverUDPPort, {idet}, port_list[idet]); + } + } else { + pimpl->Parallel(&slsDetector::setReceiverUDPPort, {module_id}, port); + } +} + +Result Detector::getDestinationUDPPort2(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPPort2, pos); +} + +void Detector::setDestinationUDPPort2(int port, int module_id) { + if (module_id == -1) { + std::vector port_list = getPortNumbers(port); + for (int idet = 0; idet < size(); ++idet) { + pimpl->Parallel(&slsDetector::setReceiverUDPPort2, {idet}, port_list[idet]); + } + } else { + pimpl->Parallel(&slsDetector::setReceiverUDPPort2, {module_id}, port ); + } +} + +Result Detector::printRxConfiguration(Positions pos) const { + return pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos); +} + +Result Detector::getTenGiga(Positions pos) const { + return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1); +} + +void Detector::setTenGiga(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, + static_cast(value)); +} + +Result Detector::getTenGigaGFlowControl(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::FLOW_CONTROL_10G, -1); +} + +void Detector::setTenGigaGFlowControl(bool enable, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::FLOW_CONTROL_10G, static_cast(enable)); +} + +Result Detector::getTransmissionDelayFrame(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_FRAME, -1); +} + +void Detector::setTransmissionDelayFrame(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_FRAME, value); +} + +Result Detector::getTransmissionDelayLeft(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_LEFT, -1); +} + +void Detector::setTransmissionDelayLeft(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_LEFT, value); +} + +Result Detector::getTransmissionDelayRight(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_RIGHT, -1); +} + +void Detector::setTransmissionDelayRight(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, + defs::DETECTOR_TXN_DELAY_RIGHT, value); } -Result Detector::getNumberOfAnalogSamples(Positions pos) const { - return pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES, - -1); + +// Receiver + +Result Detector::getUseReceiverFlag(Positions pos) const { + return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos); } -void Detector::setNumberOfAnalogSamples(int64_t value, Positions pos) { - pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES, value); +Result Detector::getRxHostname(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverHostname, pos); } -Result Detector::getNumberOfDigitalSamples(Positions pos) const { - return pimpl->Parallel(&slsDetector::setTimer, pos, defs::DIGITAL_SAMPLES, - -1); +void Detector::setRxHostname(const std::string &receiver, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverHostname, pos, receiver); } -void Detector::setNumberOfDigitalSamples(int64_t value, Positions pos) { - pimpl->Parallel(&slsDetector::setTimer, pos, defs::DIGITAL_SAMPLES, value); +Result Detector::getRxPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverPort, pos); } +void Detector::setRxPort(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverPort, pos, value); +} + +Result Detector::getRxFifoDepth(Positions pos) const { + return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1); +} + +void Detector::setRxFifoDepth(int nframes, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes); +} + +Result Detector::getRxSilentMode(Positions pos) const { + return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1); +} + +void Detector::setRxSilentMode(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, + static_cast(value)); +} + +Result +Detector::getRxFrameDiscardPolicy(Positions pos) const { + return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, + defs::GET_FRAME_DISCARD_POLICY); +} + +void Detector::setRxFrameDiscardPolicy(defs::frameDiscardPolicy f, + Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f); +} + +Result Detector::getPartialFramesPadding(Positions pos) const { + return pimpl->Parallel(&slsDetector::getPartialFramesPadding, pos); +} + +void Detector::setPartialFramesPadding(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setPartialFramesPadding, pos, value); +} + +Result Detector::getRxUDPSocketBufferSize(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverUDPSocketBufferSize, pos); +} + +void Detector::setRxUDPSocketBufferSize(int64_t udpsockbufsize, + Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverUDPSocketBufferSize, pos, + udpsockbufsize); +} + +Result +Detector::getRxRealUDPSocketBufferSize(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverRealUDPSocketBufferSize, + pos); +} + +Result Detector::getRxLock(Positions pos) { + return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1); +} + +void Detector::setRxLock(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast(value)); +} + +Result Detector::getRxLastClientIP(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos); +} + + + +// File + +Result Detector::getFileFormat(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFileFormat, pos); +} + +void Detector::setFileFormat(defs::fileFormat f, Positions pos) { + pimpl->Parallel(&slsDetector::setFileFormat, pos, f); +} + +Result Detector::getFilePath(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFilePath, pos); +} + +void Detector::setFilePath(const std::string &fpath, Positions pos) { + pimpl->Parallel(&slsDetector::setFilePath, pos, fpath); +} + +Result Detector::getFileNamePrefix(Positions pos) const { + return pimpl->Parallel(&slsDetector::setFileName, pos, ""); +} +void Detector::setFileNamePrefix(const std::string &fname, Positions pos) { + pimpl->Parallel(&slsDetector::setFileName, pos, fname); +} + +Result Detector::getAcquisitonIndex(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFileIndex, pos); +} + +void Detector::setAcquisitionIndex(int i, Positions pos) { + pimpl->Parallel(&slsDetector::setFileIndex, pos, i); +} + +Result Detector::getFileWrite(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFileWrite, pos); +} + +void Detector::setFileWrite(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setFileWrite, pos, value); +} + +void Detector::setMasterFileWrite(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setMasterFileWrite, pos, value); +} + +Result Detector::getMasterFileWrite(Positions pos) const { + return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos); +} + +Result Detector::getFileOverWrite(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFileOverWrite, pos); +} + +void Detector::setFileOverWrite(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setFileOverWrite, pos, value); +} + +Result Detector::getFramesPerFile(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFramesPerFile, pos); +} + +void Detector::setFramesPerFile(int n, Positions pos) { + pimpl->Parallel(&slsDetector::setFramesPerFile, pos, n); +} + + + +// Zmq Streaming (Receiver<->Client) + +Result Detector::getRxZmqDataStream(Positions pos) const { + return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1); +} + +void Detector::setRxZmqDataStream(bool enable, Positions pos) { + pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, + static_cast(enable)); +} + +Result Detector::getRxZmqFrequency(Positions pos) const { + return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1); +} + +void Detector::setRxZmqFrequency(int freq, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverStreamingFrequency, pos, freq); +} + +Result Detector::getRxZmqTimer(Positions pos) const { + return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1); +} + +void Detector::setRxZmqTimer(int time_in_ms, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, time_in_ms); +} + +Result Detector::getRxZmqPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverStreamingPort, pos); +} + +void Detector::setRxZmqPort(int port, int module_id) { + if (module_id == -1) { + std::vector port_list = getPortNumbers(port); + for (int idet = 0; idet < size(); ++idet) { + pimpl->Parallel(&slsDetector::setReceiverStreamingPort, {idet}, port_list[idet]); + } + } else { + pimpl->Parallel(&slsDetector::setReceiverStreamingPort, {module_id}, port); + } +} + +Result Detector::getRxZmqIP(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverStreamingIP, pos); +} + +void Detector::setRxZmqIP(const std::string &ip, + Positions pos) { + bool previouslyReceiverStreaming = + getRxZmqDataStream(pos).squash(false); + // TODO! probably in one call + pimpl->Parallel(&slsDetector::setReceiverStreamingIP, pos, ip); + if (previouslyReceiverStreaming) { + setRxZmqDataStream(false, pos); + setRxZmqDataStream(true, pos); + } +} + +Result Detector::getClientZmqPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getClientStreamingPort, pos); +} + +void Detector::setClientZmqPort(int port, int module_id) { + if (module_id == -1) { + std::vector port_list = getPortNumbers(port); + for (int idet = 0; idet < size(); ++idet) { + pimpl->Parallel(&slsDetector::setClientStreamingPort, {idet}, port_list[idet]); + } + } else { + pimpl->Parallel(&slsDetector::setClientStreamingPort, {module_id}, port); + } +} + +Result Detector::getClientZmqIp(Positions pos) const { + return pimpl->Parallel(&slsDetector::getClientStreamingIP, pos); +} + +void Detector::setClientZmqIp(const std::string &ip, + Positions pos) { + int previouslyClientStreaming = pimpl->enableDataStreamingToClient(-1); + // TODO! probably in one call ?? + pimpl->Parallel(&slsDetector::setClientStreamingIP, pos, ip); + if (previouslyClientStreaming != 0) { + pimpl->enableDataStreamingToClient(0); + pimpl->enableDataStreamingToClient(1); + } +} + + + +// Eiger Specific + +Result Detector::getDynamicRange(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDynamicRange, pos, -1); +} + +void Detector::setDynamicRange(int value) { pimpl->setDynamicRange(value); } + Result Detector::getSubExptime(Positions pos) const { return pimpl->Parallel(&slsDetector::setTimer, pos, @@ -377,39 +727,111 @@ void Detector::setSubDeadTime(ns value, Positions pos) { value.count()); } -Result Detector::getStorageCellDelay(Positions pos) const { - return pimpl->Parallel(&slsDetector::setTimer, pos, - defs::STORAGE_CELL_DELAY, -1); +Result Detector::getThresholdEnergy(Positions pos) const { + return pimpl->Parallel(&slsDetector::getThresholdEnergy, pos); } -void Detector::setStorageCellDelay(ns value, Positions pos) { - pimpl->Parallel(&slsDetector::setTimer, pos, defs::STORAGE_CELL_DELAY, - value.count()); +void Detector::setThresholdEnergy(int threshold_ev, defs::detectorSettings settings, + bool trimbits, Positions pos) { + pimpl->Parallel(&slsDetector::setThresholdEnergy, pos, threshold_ev, settings, static_cast(trimbits)); } -Result Detector::getExptimeLeft(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTimeLeft, pos, - defs::ACQUISITION_TIME); +Result Detector::getSettingsDir(Positions pos) const { + return pimpl->Parallel(&slsDetector::getSettingsDir, pos); } -Result Detector::getPeriodLeft(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTimeLeft, pos, defs::FRAME_PERIOD); +void Detector::setSettingsDir(const std::string &value, Positions pos) { + pimpl->Parallel(&slsDetector::setSettingsDir, pos, value); } - - -Result Detector::getNumberOfFramesFromStart(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTimeLeft, pos, - defs::FRAMES_FROM_START); +void Detector::loadTrimbits(const std::string &value, Positions pos) { + pimpl->Parallel(&slsDetector::loadSettingsFile, pos, value); } -Result Detector::getActualTime(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTimeLeft, pos, defs::ACTUAL_TIME); +Result Detector::getRxAddGapPixels(Positions pos) const { + return pimpl->Parallel(&slsDetector::enableGapPixels, pos, -1); } -Result Detector::getMeasurementTime(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTimeLeft, pos, - defs::MEASUREMENT_TIME); +void Detector::setRxAddGapPixels(bool enable) { + pimpl->setGapPixelsEnable(enable, {}); +} + +Result Detector::getParallelMode(Positions pos) const { + auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, + defs::GET_READOUT_FLAGS); + Result booleanRes; + for (unsigned int i = 0; i < res.size(); ++i) { + booleanRes[i] = (res[i] & defs::PARALLEL) ? true : false; + } + return booleanRes; +} + +void Detector::setParallelMode(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setReadOutFlags, pos, + value ? defs::PARALLEL : defs::NONPARALLEL); +} + +Result Detector::getOverFlowMode(Positions pos) const { + auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, + defs::GET_READOUT_FLAGS); + Result booleanRes; + for (unsigned int i = 0; i < res.size(); ++i) { + booleanRes[i] = (res[i] & defs::SHOW_OVERFLOW) ? true : false; + } + return booleanRes; +} + +void Detector::setOverFlowMode(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setReadOutFlags, pos, + value ? defs::SHOW_OVERFLOW : defs::NOOVERFLOW); +} + +Result Detector::getBottom(Positions pos) const { + return pimpl->Parallel(&slsDetector::getFlippedDataX, pos); +} + +void Detector::setBottom(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setFlippedDataX, pos, static_cast(value)); +} + +Result Detector::getAllTrimbits(Positions pos) const { + return pimpl->Parallel(&slsDetector::setAllTrimbits, pos, -1); +} + +void Detector::setAllTrimbits(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setAllTrimbits, pos, value); +} + +Result> Detector::getTrimEnergies(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTrimEn, pos); +} + +void Detector::setTrimEnergies(std::vector energies, Positions pos) { + pimpl->Parallel(&slsDetector::setTrimEn, pos, energies); +} + +Result Detector::getRateCorrection(Positions pos) const { + return pimpl->Parallel(&slsDetector::getRateCorrection, pos); +} + +void Detector::setRateCorrection(ns dead_time, Positions pos) { + pimpl->Parallel(&slsDetector::setRateCorrection, pos, 0);//FIXME TODO dead_time); +} + +Result Detector::getPartialReadout(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReadNLines, pos); +} + +void Detector::setPartialReadout(const int lines, Positions pos) { + pimpl->Parallel(&slsDetector::setReadNLines, pos, lines); +} + +Result Detector::getInterruptSubframe(Positions pos) const { + return pimpl->Parallel(&slsDetector::getInterruptSubframe, pos); +} + +void Detector::setInterruptSubframe(const bool enable, Positions pos) { + pimpl->Parallel(&slsDetector::setInterruptSubframe, pos, enable); } Result Detector::getMeasuredPeriod(Positions pos) const { @@ -422,10 +844,272 @@ Result Detector::getMeasuredSubFramePeriod(Positions pos) const { defs::MEASURED_SUBPERIOD); } +Result Detector::getActive(Positions pos) const { + return pimpl->Parallel(&slsDetector::activate, pos, -1); +} + +void Detector::setActive(bool active, Positions pos) { + pimpl->Parallel(&slsDetector::activate, pos, static_cast(active)); +} + +Result Detector::getRxPadDeactivatedMode(Positions pos) const { + return pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, -1); +} + +void Detector::setRxPadDeactivatedMode(bool pad, Positions pos) { + pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, + static_cast(pad)); +} + +Result Detector::getPartialReset(Positions pos) const { + return pimpl->Parallel(&slsDetector::setCounterBit, pos, -1); +} + +void Detector::setPartialReset(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setCounterBit, pos, !value); +} + +void Detector::pulsePixel(int n,defs::xy pixel, Positions pos) { + pimpl->Parallel(&slsDetector::pulsePixel, pos, n, pixel.x, pixel.y); +} + +void Detector::pulsePixelNMove(int n, defs::xy pixel, Positions pos) { + pimpl->Parallel(&slsDetector::pulsePixelNMove, pos, n, pixel.x, pixel.y); +} + +void Detector::pulseChip(int n, Positions pos) { + pimpl->Parallel(&slsDetector::pulseChip, pos, n); +} + +Result Detector::getQuad(Positions pos) const { + return pimpl->Parallel(&slsDetector::getQuad, pos); +} + +void Detector::setQuad(const bool value) { + pimpl->setQuad(value); +} +// Jungfrau Specific +Result Detector::getThresholdTemperature(Positions pos) const { + auto res = pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1); + for (auto &it : res) { + it /= 1000; + } + return res; +} + +void Detector::setThresholdTemperature(int temp, Positions pos) { + pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp * 1000); +} + +Result Detector::getTemperatureControl(Positions pos) const { + return pimpl->Parallel(&slsDetector::setTemperatureControl, pos, -1); +} + +void Detector::setTemperatureControl(bool enable, Positions pos) { + pimpl->Parallel(&slsDetector::setTemperatureControl, pos, + static_cast(enable)); +} + +Result Detector::getTemperatureEvent(Positions pos) const { + return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1); +} + +void Detector::resetTemperatureEvent(Positions pos) { + pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, 0); +} + +Result Detector::getPowerChip(Positions pos) const { + return pimpl->Parallel(&slsDetector::powerChip, pos, -1); +} + +void Detector::setPowerChip(bool on, Positions pos) { + if (on && pimpl->size() > 3) { + for (unsigned int i = 0; i != pimpl->size(); ++i) { + pimpl->powerChip(static_cast(on), i); + usleep(1000 * 1000); + } + } else { + pimpl->Parallel(&slsDetector::powerChip, pos, static_cast(on)); + } +} + +Result Detector::getAutoCompDisable(Positions pos) const { + return pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, -1); +} + +void Detector::setAutoCompDisable(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, + static_cast(value)); +} + +Result Detector::getNumberOfAdditionalStorageCells() const { + return pimpl->Parallel(&slsDetector::setTimer, {}, + defs::STORAGE_CELL_NUMBER, -1); +} + +void Detector::setNumberOfAdditionalStorageCells(int64_t value) { + pimpl->Parallel(&slsDetector::setTimer, {}, defs::STORAGE_CELL_NUMBER, + value); +} + +Result Detector::getStorageCellStart(Positions pos) const { + return pimpl->Parallel(&slsDetector::setStoragecellStart, pos, -1); +} + +void Detector::setStoragecellStart(int cell, Positions pos) { + pimpl->Parallel(&slsDetector::setStoragecellStart, pos, cell); +} + +Result Detector::getStorageCellDelay(Positions pos) const { + return pimpl->Parallel(&slsDetector::setTimer, pos, + defs::STORAGE_CELL_DELAY, -1); +} + +void Detector::setStorageCellDelay(ns value, Positions pos) { + pimpl->Parallel(&slsDetector::setTimer, pos, defs::STORAGE_CELL_DELAY, + value.count()); +} + + + +// Gotthard Specific + + +Result Detector::getROI(Positions pos) const { + return pimpl->Parallel(&slsDetector::getROI, pos); +} + +void Detector::setROI(defs::ROI value, int moduleId) { + if (moduleId < 0 && size() > 1) { + throw RuntimeError("Cannot set ROI for all modules simultaneously"); + } + pimpl->Parallel(&slsDetector::setROI, {moduleId}, value); +} + +Result Detector::getExptimeLeft(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTimeLeft, pos, + defs::ACQUISITION_TIME); +} + +Result Detector::getPeriodLeft(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTimeLeft, pos, defs::FRAME_PERIOD); +} + +Result +Detector::getExternalSignalFlags(Positions pos) const { + return pimpl->Parallel(&slsDetector::setExternalSignalFlags, pos, + defs::GET_EXTERNAL_SIGNAL_FLAG); +} + +void Detector::setExternalSignalFlags(defs::externalSignalFlag value, + Positions pos) { + pimpl->Parallel(&slsDetector::setExternalSignalFlags, pos, value); +} + +void Detector::loadDarkImage(const std::string &fname, int module_id) { + if (module_id == -1) { + pimpl->loadImageToDetector(defs::DARK_IMAGE, fname, -1); + } + pimpl->Parallel(&slsDetector::loadImageToDetector, {module_id}, defs::DARK_IMAGE, + fname); +} + +void Detector::loadGainImage(const std::string &fname, int module_id) { + if (module_id == -1) { + pimpl->loadImageToDetector(defs::GAIN_IMAGE, fname, -1); + } + pimpl->Parallel(&slsDetector::loadImageToDetector, {module_id}, defs::GAIN_IMAGE, + fname); +} + +void Detector::getCounterMemoryBlock(const std::string &fname, bool startACQ, + Positions pos) { + if (pos.empty() || (pos.size() == 1 && pos[0] == -1)) { + pimpl->writeCounterBlockFile(fname, static_cast(startACQ), -1); + } + if (pos.size() > 1) { + throw RuntimeError( + "Cannot load get counter memory block on a subset of modules"); + } + pimpl->Parallel(&slsDetector::writeCounterBlockFile, pos, fname, + static_cast(startACQ)); +} + +void Detector::resetCounterBlock(bool startACQ, Positions pos) { + pimpl->Parallel(&slsDetector::resetCounterBlock, pos, + static_cast(startACQ)); +} + +Result Detector::getDigitalTestBit(Positions pos) { + return pimpl->Parallel(&slsDetector::digitalTest, pos, + defs::DIGITAL_BIT_TEST, -1); +} + +Result Detector::setDigitalTestBit(int value, Positions pos) { + return pimpl->Parallel(&slsDetector::digitalTest, pos, + defs::DIGITAL_BIT_TEST, value); +} + + + +// CTB Specific + +Result Detector::getNumberOfAnalogSamples(Positions pos) const { + return pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES, + -1); +} + +void Detector::setNumberOfAnalogSamples(int64_t value, Positions pos) { + pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES, value); +} + +Result Detector::getNumberOfDigitalSamples(Positions pos) const { + return pimpl->Parallel(&slsDetector::setTimer, pos, defs::DIGITAL_SAMPLES, + -1); +} + +void Detector::setNumberOfDigitalSamples(int64_t value, Positions pos) { + pimpl->Parallel(&slsDetector::setTimer, pos, defs::DIGITAL_SAMPLES, value); +} + +Result Detector::getSignalType(Positions pos) const { + auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, + defs::GET_READOUT_FLAGS); + for (auto &it : res) { + if (it & defs::ANALOG_AND_DIGITAL) { + it = 2; + } else if (it & defs::DIGITAL_ONLY) { + it = 1; + } else if (it == defs::NORMAL_READOUT) { + it = 0; + } else { + throw RuntimeError("Unknown Signal Type"); + } + } + return res; +} + +void Detector::setSignalType(int value, Positions pos) { + defs::readOutFlags flag; + switch (value) { + case 0: + flag = defs::NORMAL_READOUT; + break; + case 1: + flag = defs::DIGITAL_ONLY; + break; + case 2: + flag = defs::ANALOG_AND_DIGITAL; + break; + default: + throw RuntimeError("Unknown Signal Type"); + } + pimpl->Parallel(&slsDetector::setReadOutFlags, pos, flag); +} Result Detector::getDBITPhase(bool inDeg, Positions pos) const { return pimpl->Parallel(&slsDetector::setSpeed, pos, defs::DBIT_PHASE, -1, @@ -491,20 +1175,6 @@ void Detector::setDBITPipeline(int value, Positions pos) { pimpl->Parallel(&slsDetector::setSpeed, pos, defs::DBIT_PIPELINE, value, 0); } -Result Detector::getDynamicRange(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDynamicRange, pos, -1); -} - -void Detector::setDynamicRange(int value) { pimpl->setDynamicRange(value); } - -Result Detector::getIODelay(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDAC, pos, -1, defs::IO_DELAY, 0); -} - -void Detector::setIODelay(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setDAC, pos, value, defs::IO_DELAY, 0); -} - Result Detector::getVrefVoltage(bool mV, Positions pos) const { return pimpl->Parallel(&slsDetector::setDAC, pos, -1, defs::ADC_VPP, mV); @@ -584,318 +1254,143 @@ Result Detector::getSlowADC(defs::dacIndex index, Positions pos) const { return pimpl->Parallel(&slsDetector::getADC, pos, index); } - - - - -Result -Detector::getExternalSignalFlags(Positions pos) const { - return pimpl->Parallel(&slsDetector::setExternalSignalFlags, pos, - defs::GET_EXTERNAL_SIGNAL_FLAG); +Result Detector::getADCEnableMask(Positions pos) const { + return pimpl->Parallel(&slsDetector::getADCEnableMask, pos); } -void Detector::setExternalSignalFlags(defs::externalSignalFlag value, - Positions pos) { - pimpl->Parallel(&slsDetector::setExternalSignalFlags, pos, value); +void Detector::setADCEnableMask(uint32_t mask, Positions pos) { + pimpl->Parallel(&slsDetector::setADCEnableMask, pos, mask); } -Result Detector::getParallelMode(Positions pos) const { - auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, - defs::GET_READOUT_FLAGS); - Result booleanRes; - for (unsigned int i = 0; i < res.size(); ++i) { - booleanRes[i] = (res[i] & defs::PARALLEL) ? true : false; - } - return booleanRes; +Result Detector::getADCInvert(Positions pos) const { + return pimpl->Parallel(&slsDetector::getADCInvert, pos); } -void Detector::setParallelMode(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setReadOutFlags, pos, - value ? defs::PARALLEL : defs::NONPARALLEL); +void Detector::setADCInvert(uint32_t value, Positions pos) { + pimpl->Parallel(&slsDetector::setADCInvert, pos, value); } -Result Detector::getOverFlowMode(Positions pos) const { - auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, - defs::GET_READOUT_FLAGS); - Result booleanRes; - for (unsigned int i = 0; i < res.size(); ++i) { - booleanRes[i] = (res[i] & defs::SHOW_OVERFLOW) ? true : false; - } - return booleanRes; +Result Detector::getExternalSamplingSource(Positions pos) const { + return pimpl->Parallel(&slsDetector::getExternalSamplingSource, pos); } -void Detector::setOverFlowMode(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setReadOutFlags, pos, - value ? defs::SHOW_OVERFLOW : defs::NOOVERFLOW); +void Detector::setExternalSamplingSource(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setExternalSamplingSource, pos, value); } -Result Detector::getSignalType(Positions pos) const { - auto res = pimpl->Parallel(&slsDetector::setReadOutFlags, pos, - defs::GET_READOUT_FLAGS); - for (auto &it : res) { - if (it & defs::ANALOG_AND_DIGITAL) { - it = 2; - } else if (it & defs::DIGITAL_ONLY) { - it = 1; - } else if (it == defs::NORMAL_READOUT) { - it = 0; - } else { - throw RuntimeError("Unknown Signal Type"); - } - } - return res; +Result Detector::getExternalSampling(Positions pos) const { + return pimpl->Parallel(&slsDetector::getExternalSampling, pos); } -void Detector::setSignalType(int value, Positions pos) { - defs::readOutFlags flag; - switch (value) { - case 0: - flag = defs::NORMAL_READOUT; - break; - case 1: - flag = defs::DIGITAL_ONLY; - break; - case 2: - flag = defs::ANALOG_AND_DIGITAL; - break; - default: - throw RuntimeError("Unknown Signal Type"); - } - pimpl->Parallel(&slsDetector::setReadOutFlags, pos, flag); +void Detector::setExternalSampling(bool value, Positions pos) { + pimpl->Parallel(&slsDetector::setExternalSampling, pos, value); } -// Erik -Result Detector::getInterruptSubframe(Positions pos) const { - return pimpl->Parallel(&slsDetector::getInterruptSubframe, pos); +Result> Detector::getRxDbitList(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverDbitList, pos); } -void Detector::setInterruptSubframe(const bool enable, Positions pos) { - pimpl->Parallel(&slsDetector::setInterruptSubframe, pos, enable); +void Detector::setRxDbitList(std::vector list, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverDbitList, pos, list); } -void Detector::writeRegister(uint32_t addr, uint32_t val, Positions pos) { - pimpl->Parallel(&slsDetector::writeRegister, pos, addr, val); +Result Detector::getRxDbitOffset(Positions pos) const { + return pimpl->Parallel(&slsDetector::getReceiverDbitOffset, pos); } -Result Detector::readRegister(uint32_t addr, Positions pos) const { - return pimpl->Parallel(&slsDetector::readRegister, pos, addr); +void Detector::setRxDbitOffset(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setReceiverDbitOffset, pos, value); } -void Detector::setBit(uint32_t addr, int bitnr, Positions pos) { - pimpl->Parallel(&slsDetector::setBit, pos, addr, bitnr); +void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) { + pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay); } -void Detector::clearBit(uint32_t addr, int bitnr, Positions pos) { - pimpl->Parallel(&slsDetector::clearBit, pos, addr, bitnr); +Result Detector::getLEDEnable(Positions pos) const { + return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1); } -Result Detector::getSourceUDPMAC(Positions pos) const { - return pimpl->Parallel(&slsDetector::getDetectorMAC, pos); -} -void Detector::setSourceUDPMAC(const std::string &detectorMAC, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorMAC, pos, detectorMAC); +void Detector::setLEDEnable(bool enable, Positions pos) { + pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast(enable)); } -Result Detector::getDetectorMAC2(Positions pos) const { - return pimpl->Parallel(&slsDetector::getDetectorMAC2, pos); -} -void Detector::setDetectorMAC2(const std::string &detectorMAC, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorMAC2, pos, detectorMAC); + + +// Pattern + +void Detector::setPattern(const std::string &fname, Positions pos) { + pimpl->Parallel(&slsDetector::setPattern, pos, fname); } -Result Detector::getSourceUDPIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getDetectorIP, pos); +Result Detector::getPatternIOControl(Positions pos) const { + return pimpl->Parallel(&slsDetector::setPatternIOControl, pos, -1); } -void Detector::setSourceUDPIP(const std::string &detectorIP, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorIP, pos, detectorIP); +void Detector::setPatternIOControl(uint64_t word, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word); } -Result Detector::getDetectorIP2(Positions pos) const { - return pimpl->Parallel(&slsDetector::getDetectorIP2, pos); +Result Detector::getPatternClockControl(Positions pos) const { + return pimpl->Parallel(&slsDetector::setPatternClockControl, pos, -1); } -void Detector::setDetectorIP2(const std::string &detectorIP, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorIP2, pos, detectorIP); +void Detector::setPatternClockControl(uint64_t word, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word); } -Result Detector::getRxHostname(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverHostname, pos); +void Detector::setPatternWord(int addr, uint64_t word, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word); } -void Detector::setRxHostname(const std::string &receiver, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverHostname, pos, receiver); +Result> Detector::getPatternLoops(int level, + Positions pos) const { + return pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, -1, -1, + -1); } -Result Detector::getDestinationUDPIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPIP, pos); +void Detector::setPatternLoops(int level, int start, int stop, int n, + Positions pos) { + pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n); } -void Detector::setDestinationUDPIP(const std::string &udpip, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPIP, pos, udpip); +Result Detector::getPatternWaitAddr(int level, Positions pos) const { + return pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, -1); } -Result Detector::getRxUDPIP2(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPIP2, pos); +void Detector::setPatternWaitAddr(int level, int addr, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr); } -void Detector::setReceiverUDPIP2(const std::string &udpip, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPIP2, pos, udpip); +Result Detector::getPatternWaitTime(int level, Positions pos) const { + return pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, -1); } -Result Detector::getDestinationUDPMAC(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPMAC, pos); +void Detector::setPatternWaitTime(int level, uint64_t t, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t); } -void Detector::setDestinationUDPMAC(const std::string &udpmac, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPMAC, pos, udpmac); +Result Detector::getPatternMask(Positions pos) { + return pimpl->Parallel(&slsDetector::getPatternMask, pos); } -Result Detector::getReceiverUDPMAC2(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPMAC2, pos); +void Detector::setPatternMask(uint64_t mask, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternMask, pos, mask); } -void Detector::setReceiverUDPMAC2(const std::string &udpmac, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPMAC2, pos, udpmac); +Result Detector::getPatternBitMask(Positions pos) const { + return pimpl->Parallel(&slsDetector::getPatternBitMask, pos); } -Result Detector::getReceiverUDPPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPPort, pos); +void Detector::setPatternBitMask(uint64_t mask, Positions pos) { + pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask); } -void Detector::setReceiverUDPPort(int udpport, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPPort, pos, udpport); -} -Result Detector::getReceiverUDPPort2(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPPort2, pos); -} -void Detector::setReceiverUDPPort2(int udpport, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPPort2, pos, udpport); -} +// Moench -Result Detector::getNumberofUDPInterfaces(Positions pos) const { - return pimpl->Parallel(&slsDetector::getNumberofUDPInterfaces, pos); -} - -void Detector::setNumberofUDPInterfaces(int n, Positions pos) { - bool previouslyClientStreaming = getDataStreamingToClient(); - bool previouslyReceiverStreaming = - getDataStreamingFromReceiver(pos).squash(false); - pimpl->Parallel(&slsDetector::setNumberofUDPInterfaces, pos, n); - // redo the zmq sockets if enabled - if (previouslyClientStreaming) { - setDataStreamingToClient(false); - setDataStreamingToClient(true); - } - if (previouslyReceiverStreaming) { - setDataStreamingFromReceiver(false, pos); - setDataStreamingFromReceiver(true, pos); - } -} - -Result Detector::getSelectedUDPInterface(Positions pos) const { - return pimpl->Parallel(&slsDetector::getSelectedUDPInterface, pos); -} - -void Detector::selectUDPInterface(int interface, Positions pos) { - pimpl->Parallel(&slsDetector::selectUDPInterface, pos, interface); -} - -Result Detector::getClientStreamingPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getClientStreamingPort, pos); -} - -void Detector::setClientDataStreamingInPort(int port, Positions pos) { - if (pos.size() > 1 && pos.size() < pimpl->size()) { - throw RuntimeError( - "Cannot set client streaming port to a subset of modules"); - } - pimpl->setClientDataStreamingInPort(port, pos.empty() ? -1 : pos[0]); -} - -Result Detector::getRxStreamingPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverStreamingPort, pos); -} - -void Detector::setRxDataStreamingOutPort(int port, Positions pos) { - if (pos.size() > 1 && pos.size() < pimpl->size()) { - throw RuntimeError( - "Cannot set receiver streaming port to a subset of modules"); - } - pimpl->setReceiverDataStreamingOutPort(port, pos.empty() ? -1 : pos[0]); -} - -Result Detector::getClientStreamingIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getClientStreamingIP, pos); -} - -void Detector::setClientDataStreamingInIP(const std::string &ip, - Positions pos) { - bool previouslyClientStreaming = getDataStreamingToClient(); - // TODO! probably in one call ?? - pimpl->Parallel(&slsDetector::setClientStreamingIP, pos, ip); - if (previouslyClientStreaming) { - setDataStreamingToClient(false); - setDataStreamingToClient(true); - } -} - -Result Detector::getRxStreamingIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverStreamingIP, pos); -} - -void Detector::setRxDataStreamingOutIP(const std::string &ip, - Positions pos) { - bool previouslyReceiverStreaming = - getDataStreamingFromReceiver(pos).squash(false); - // TODO! probably in one call - pimpl->Parallel(&slsDetector::setReceiverStreamingIP, pos, ip); - if (previouslyReceiverStreaming) { - setDataStreamingFromReceiver(false, pos); - setDataStreamingFromReceiver(true, pos); - } -} - -Result Detector::getFlowControl10G(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::FLOW_CONTROL_10G, -1); -} - -void Detector::setFlowControl10G(bool enable, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::FLOW_CONTROL_10G, static_cast(enable)); -} - -Result Detector::getTransmissionDelayFrame(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_FRAME, -1); -} - -void Detector::setTransmissionDelayFrame(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_FRAME, value); -} - -Result Detector::getTransmissionDelayLeft(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_LEFT, -1); -} - -void Detector::setTransmissionDelayLeft(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_LEFT, value); -} - -Result Detector::getTransmissionDelayRight(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_RIGHT, -1); -} - -void Detector::setTransmissionDelayRight(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setDetectorNetworkParameter, pos, - defs::DETECTOR_TXN_DELAY_RIGHT, value); +Result Detector::getAdditionalJsonHeader(Positions pos) const { + return pimpl->Parallel(&slsDetector::getAdditionalJsonHeader, pos); } void Detector::setAdditionalJsonHeader(const std::string &jsonheader, @@ -903,10 +1398,6 @@ void Detector::setAdditionalJsonHeader(const std::string &jsonheader, pimpl->Parallel(&slsDetector::setAdditionalJsonHeader, pos, jsonheader); } -Result Detector::getAdditionalJsonHeader(Positions pos) const { - return pimpl->Parallel(&slsDetector::getAdditionalJsonHeader, pos); -} - Result Detector::getAdditionalJsonParameter(const std::string &key, Positions pos) const { return pimpl->Parallel(&slsDetector::getAdditionalJsonParameter, pos, key); @@ -981,219 +1472,9 @@ void Detector::setDetectorMode(defs::detectorModeType value, Positions pos) { "detectorMode", defs::getDetectorModeType(value)); } -Result Detector::getDigitalTestBit(Positions pos) { - return pimpl->Parallel(&slsDetector::digitalTest, pos, - defs::DIGITAL_BIT_TEST, -1); -} -Result Detector::setDigitalTestBit(int value, Positions pos) { - return pimpl->Parallel(&slsDetector::digitalTest, pos, - defs::DIGITAL_BIT_TEST, value); -} -Result Detector::executeFirmwareTest(Positions pos) { - return pimpl->Parallel(&slsDetector::digitalTest, pos, - defs::DETECTOR_FIRMWARE_TEST, -1); -} - -Result Detector::executeBusTest(Positions pos) { - return pimpl->Parallel(&slsDetector::digitalTest, pos, - defs::DETECTOR_BUS_TEST, -1); -} - -void Detector::loadDarkImage(const std::string &fname, Positions pos) { - // TODO! optimize away multiple loads in multi - if (pos.empty() || (pos.size() == 1 && pos[0] == -1)) { - pimpl->loadImageToDetector(defs::DARK_IMAGE, fname, -1); - } - if (pos.size() > 1) { - throw RuntimeError("Cannot load dark image on a subset of modules"); - } - pimpl->Parallel(&slsDetector::loadImageToDetector, pos, defs::DARK_IMAGE, - fname); -} - -void Detector::loadGainImage(const std::string &fname, Positions pos) { - // TODO! optimize away multiple loadsin multi - if (pos.empty() || (pos.size() == 1 && pos[0] == -1)) { - pimpl->loadImageToDetector(defs::GAIN_IMAGE, fname, -1); - } - if (pos.size() > 1) { - throw RuntimeError("Cannot load gain image on a subset of modules"); - } - pimpl->Parallel(&slsDetector::loadImageToDetector, pos, defs::GAIN_IMAGE, - fname); -} - -void Detector::getCounterMemoryBlock(const std::string &fname, bool startACQ, - Positions pos) { - if (pos.empty() || (pos.size() == 1 && pos[0] == -1)) { - pimpl->writeCounterBlockFile(fname, static_cast(startACQ), -1); - } - if (pos.size() > 1) { - throw RuntimeError( - "Cannot load get counter memory block on a subset of modules"); - } - pimpl->Parallel(&slsDetector::writeCounterBlockFile, pos, fname, - static_cast(startACQ)); -} - -void Detector::resetCounterBlock(bool startACQ, Positions pos) { - pimpl->Parallel(&slsDetector::resetCounterBlock, pos, - static_cast(startACQ)); -} - -Result Detector::getCounterBit(Positions pos) const { - return pimpl->Parallel(&slsDetector::setCounterBit, pos, -1); -} - -void Detector::setCounterBit(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setCounterBit, pos, !value); -} - -Result Detector::getROI(Positions pos) const { - return pimpl->Parallel(&slsDetector::getROI, pos); -} - -void Detector::setROI(defs::ROI value, int moduleId) { - if (moduleId < 0 && size() > 1) { - throw RuntimeError("Cannot set ROI for all modules simultaneously"); - } - pimpl->Parallel(&slsDetector::setROI, {moduleId}, value); -} - -Result Detector::getADCEnableMask(Positions pos) const { - return pimpl->Parallel(&slsDetector::getADCEnableMask, pos); -} - -void Detector::setADCEnableMask(uint32_t mask, Positions pos) { - pimpl->Parallel(&slsDetector::setADCEnableMask, pos, mask); -} - -Result Detector::getADCInvert(Positions pos) const { - return pimpl->Parallel(&slsDetector::getADCInvert, pos); -} - -void Detector::setADCInvert(uint32_t value, Positions pos) { - pimpl->Parallel(&slsDetector::setADCInvert, pos, value); -} - -Result Detector::getExternalSamplingSource(Positions pos) const { - return pimpl->Parallel(&slsDetector::getExternalSamplingSource, pos); -} - -void Detector::setExternalSamplingSource(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setExternalSamplingSource, pos, value); -} - -Result Detector::getExternalSampling(Positions pos) const { - return pimpl->Parallel(&slsDetector::getExternalSampling, pos); -} - -void Detector::setExternalSampling(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setExternalSampling, pos, value); -} - -Result> Detector::getRxDbitList(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverDbitList, pos); -} - -void Detector::setRxDbitList(std::vector list, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverDbitList, pos, list); -} - -Result Detector::getRxDbitOffset(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverDbitOffset, pos); -} - -void Detector::setRxDbitOffset(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverDbitOffset, pos, value); -} - -void Detector::writeAdcRegister(uint32_t addr, uint32_t value, Positions pos) { - pimpl->Parallel(&slsDetector::writeAdcRegister, pos, addr, value); -} - -Result Detector::getActive(Positions pos) const { - return pimpl->Parallel(&slsDetector::activate, pos, -1); -} - -void Detector::setActive(bool active, Positions pos) { - pimpl->Parallel(&slsDetector::activate, pos, static_cast(active)); -} - -Result Detector::getBottom(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFlippedDataX, pos); -} - -void Detector::setBottom(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setFlippedDataX, pos, static_cast(value)); -} - -Result Detector::getAllTrimbits(Positions pos) const { - return pimpl->Parallel(&slsDetector::setAllTrimbits, pos, -1); -} - -void Detector::setAllTrimbits(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setAllTrimbits, pos, value); -} - -Result Detector::getGapPixelsEnable(Positions pos) const { - return pimpl->Parallel(&slsDetector::enableGapPixels, pos, -1); -} - -void Detector::setGapPixelsEnable(bool enable) { - pimpl->setGapPixelsEnable(enable, {}); -} - -Result> Detector::getTrimEnergies(Positions pos) const { - return pimpl->Parallel(&slsDetector::getTrimEn, pos); -} - -void Detector::setTrimEnergies(std::vector energies, Positions pos) { - pimpl->Parallel(&slsDetector::setTrimEn, pos, energies); -} - -void Detector::pulsePixel(int n, int x, int y, Positions pos) { - pimpl->Parallel(&slsDetector::pulsePixel, pos, n, x, y); -} - -void Detector::pulsePixelNMove(int n, int x, int y, Positions pos) { - pimpl->Parallel(&slsDetector::pulsePixelNMove, pos, n, x, y); -} - -void Detector::pulseChip(int n, Positions pos) { - pimpl->Parallel(&slsDetector::pulseChip, pos, n); -} - -Result Detector::getThresholdTemperature(Positions pos) const { - auto res = pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1); - for (auto &it : res) { - it /= 1000; - } - return res; -} - -void Detector::setThresholdTemperature(int temp, Positions pos) { - pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp * 1000); -} - -Result Detector::getTemperatureControl(Positions pos) const { - return pimpl->Parallel(&slsDetector::setTemperatureControl, pos, -1); -} - -void Detector::setTemperatureControl(bool enable, Positions pos) { - pimpl->Parallel(&slsDetector::setTemperatureControl, pos, - static_cast(enable)); -} - -Result Detector::getTemperatureEvent(Positions pos) const { - return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1); -} - -void Detector::ResetTemperatureEvent(Positions pos) { - pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, 0); -} +// Advanced void Detector::programFPGA(const std::string &fname, Positions pos) { FILE_LOG(logINFO) << "Updating Firmware. This can take awhile. Please be patient..."; @@ -1224,359 +1505,113 @@ void Detector::updateFirmwareAndServer(const std::string &sname, rebootController(pos); } -Result Detector::getPowerChip(Positions pos) const { - return pimpl->Parallel(&slsDetector::powerChip, pos, -1); +Result Detector::readRegister(uint32_t addr, Positions pos) const { + return pimpl->Parallel(&slsDetector::readRegister, pos, addr); } -void Detector::setPowerChip(bool on, Positions pos) { - if (on && pimpl->size() > 3) { - for (unsigned int i = 0; i != pimpl->size(); ++i) { - pimpl->powerChip(static_cast(on), i); - usleep(1000 * 1000); - } - } else { - pimpl->Parallel(&slsDetector::powerChip, pos, static_cast(on)); - } +void Detector::writeRegister(uint32_t addr, uint32_t val, Positions pos) { + pimpl->Parallel(&slsDetector::writeRegister, pos, addr, val); } -Result Detector::getAutoCompDisable(Positions pos) const { - return pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, -1); +void Detector::setBit(uint32_t addr, int bitnr, Positions pos) { + pimpl->Parallel(&slsDetector::setBit, pos, addr, bitnr); } -void Detector::setAutoCompDisable(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos, - static_cast(value)); +void Detector::clearBit(uint32_t addr, int bitnr, Positions pos) { + pimpl->Parallel(&slsDetector::clearBit, pos, addr, bitnr); } -Result Detector::getRateCorrection(Positions pos) const { - return pimpl->Parallel(&slsDetector::getRateCorrection, pos); +Result Detector::executeFirmwareTest(Positions pos) { + return pimpl->Parallel(&slsDetector::digitalTest, pos, + defs::DETECTOR_FIRMWARE_TEST, -1); } -void Detector::setRateCorrection(int64_t dead_time_ns, Positions pos) { - pimpl->Parallel(&slsDetector::setRateCorrection, pos, dead_time_ns); +Result Detector::executeBusTest(Positions pos) { + return pimpl->Parallel(&slsDetector::digitalTest, pos, + defs::DETECTOR_BUS_TEST, -1); } -Result Detector::getStartingFrameNumber(Positions pos) const { - return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos); +void Detector::writeAdcRegister(uint32_t addr, uint32_t value, Positions pos) { + pimpl->Parallel(&slsDetector::writeAdcRegister, pos, addr, value); } -void Detector::setStartingFrameNumber(uint64_t value, Positions pos) { - pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value); + + +// Insignificant + + +Result Detector::getControlPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getControlPort, pos); } -Result Detector::getTenGigaEnabled(Positions pos) const { - return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1); +void Detector::setControlPort(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setControlPort, pos, value); } -void Detector::setTenGigaEnabled(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, - static_cast(value)); +Result Detector::getStopPort(Positions pos) const { + return pimpl->Parallel(&slsDetector::getStopPort, pos); } -Result Detector::getLEDEnable(Positions pos) const { - return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1); +void Detector::setStopPort(int value, Positions pos) { + pimpl->Parallel(&slsDetector::setStopPort, pos, value); } -void Detector::setLEDEnable(bool enable, Positions pos) { - pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast(enable)); +Result Detector::getDetectorLock(Positions pos) const { + return pimpl->Parallel(&slsDetector::lockServer, pos, -1); } -void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) { - pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay); -} -// File -Result Detector::getFileFormat(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFileFormat, pos); +void Detector::setDetectorLock(bool lock, Positions pos) { + pimpl->Parallel(&slsDetector::lockServer, pos, static_cast(lock)); } -void Detector::setFileFormat(defs::fileFormat f, Positions pos) { - pimpl->Parallel(&slsDetector::setFileFormat, pos, f); +Result Detector::getLastClientIP(Positions pos) const { + return pimpl->Parallel(&slsDetector::getLastClientIP, pos); } -Result Detector::getFilePath(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFilePath, pos); +void Detector::execCommand(const std::string &value, Positions pos) { + pimpl->Parallel(&slsDetector::execCommand, pos, value); } -void Detector::setFilePath(const std::string &fpath, Positions pos) { - pimpl->Parallel(&slsDetector::setFilePath, pos, fpath); +Result Detector::getNumberOfFramesFromStart(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTimeLeft, pos, + defs::FRAMES_FROM_START); } -Result Detector::getFileNamePrefix(Positions pos) const { - return pimpl->Parallel(&slsDetector::setFileName, pos, ""); -} -void Detector::setFileNamePrefix(const std::string &fname, Positions pos) { - pimpl->Parallel(&slsDetector::setFileName, pos, fname); +Result Detector::getActualTime(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTimeLeft, pos, defs::ACTUAL_TIME); } -Result Detector::getFileIndex(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFileIndex, pos); +Result Detector::getMeasurementTime(Positions pos) const { + return pimpl->Parallel(&slsDetector::getTimeLeft, pos, + defs::MEASUREMENT_TIME); } -void Detector::setFileIndex(int i, Positions pos) { - pimpl->Parallel(&slsDetector::setFileIndex, pos, i); -} +std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); } -Result Detector::getFileWrite(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFileWrite, pos); -} - -void Detector::setFileWrite(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setFileWrite, pos, value); -} - -void Detector::setMasterFileWrite(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setMasterFileWrite, pos, value); -} - -Result Detector::getMasterFileWrite(Positions pos) const { - return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos); -} - -Result Detector::getFileOverWrite(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFileOverWrite, pos); -} - -void Detector::setFileOverWrite(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setFileOverWrite, pos, value); -} - -Result Detector::getFramesPerFile(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFramesPerFile, pos); -} - -void Detector::setFramesPerFile(int n, Positions pos) { - pimpl->Parallel(&slsDetector::setFramesPerFile, pos, n); -} - -// Receiver -Result Detector::getUseReceiverFlag(Positions pos) const { - return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos); -} - -Result Detector::printRxConfiguration(Positions pos) const { - return pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos); -} - -Result Detector::getRxPort(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverPort, pos); -} - -void Detector::setRxPort(int value, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverPort, pos, value); -} - -Result Detector::getRxLock(Positions pos) { - return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1); -} - -void Detector::setRxLock(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast(value)); -} - -Result Detector::getRxLastClientIP(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos); -} - -Result Detector::getRxStreamingFrequency(Positions pos) const { - return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1); -} - -void Detector::setRxStreamingFrequency(int freq, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverStreamingFrequency, pos, freq); -} - -Result Detector::getRxStreamingTimer(Positions pos) const { - return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1); -} - -void Detector::setRxStreamingTimer(int time_in_ms, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, time_in_ms); -} - -bool Detector::getDataStreamingToClient() const { - return pimpl->enableDataStreamingToClient(-1); -} - -void Detector::setDataStreamingToClient(bool enable) { - pimpl->enableDataStreamingToClient(static_cast(enable)); -} - -Result Detector::getDataStreamingFromRx(Positions pos) const { - return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1); -} - -void Detector::setDataStreamingFromRx(bool enable, Positions pos) { - pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, - static_cast(enable)); -} - -Result Detector::getRxFifoDepth(Positions pos) const { - return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1); -} - -void Detector::setRxFifoDepth(int nframes, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes); -} - -Result Detector::getRxSilentMode(Positions pos) const { - return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1); -} - -void Detector::setRxSilentMode(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, - static_cast(value)); -} - -Result -Detector::getRxFrameDiscardPolicy(Positions pos) const { - return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, - defs::GET_FRAME_DISCARD_POLICY); -} - -void Detector::setRxFrameDiscardPolicy(defs::frameDiscardPolicy f, - Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f); -} - -Result Detector::getPartialFramesPadding(Positions pos) const { - return pimpl->Parallel(&slsDetector::getPartialFramesPadding, pos); -} - -void Detector::setPartialFramesPadding(bool value, Positions pos) { - pimpl->Parallel(&slsDetector::setPartialFramesPadding, pos, value); -} - -Result Detector::getRxPadDeactivatedMod(Positions pos) const { - return pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, -1); -} - -void Detector::setRxPadDeactivatedMod(bool pad, Positions pos) { - pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, - static_cast(pad)); -} - -Result Detector::getRxUDPSocketBufferSize(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverUDPSocketBufferSize, pos); -} - -void Detector::setRxUDPSocketBufferSize(int64_t udpsockbufsize, - Positions pos) { - pimpl->Parallel(&slsDetector::setReceiverUDPSocketBufferSize, pos, - udpsockbufsize); -} - -Result -Detector::getRxRealUDPSocketBufferSize(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverRealUDPSocketBufferSize, - pos); -} - -// Acquisition - -void Detector::clearAcquiringFlag() { pimpl->setAcquiringFlag(0); } - -Result Detector::getDetectorStatus(Positions pos) const{ - return pimpl->Parallel(&slsDetector::getRunStatus, pos); -} - -void Detector::startAcquisition() { - if (getUseReceiverFlag({}).squash()) - pimpl->Parallel(&slsDetector::startReceiver, {}); - pimpl->Parallel(&slsDetector::startAcquisition, {}); -} - -void Detector::stopAcquisition() { - pimpl->Parallel(&slsDetector::stopAcquisition, {}); - if (getUseReceiverFlag({}).squash()) //TODO: problem for acquire() - pimpl->Parallel(&slsDetector::stopReceiver, {}); -} - -void Detector::sendSoftwareTrigger(Positions pos) { - pimpl->Parallel(&slsDetector::sendSoftwareTrigger, pos); -} - -Result Detector::getRxStatus(Positions pos) const { - return pimpl->Parallel(&slsDetector::getReceiverStatus, pos); -} - -Result Detector::getFramesCaught(Positions pos) const { - return pimpl->Parallel(&slsDetector::getFramesCaughtByReceiver, pos); -} Result Detector::getRxCurrentFrameIndex(Positions pos) const { return pimpl->Parallel(&slsDetector::getReceiverCurrentFrameIndex, pos); } -// pattern - -void Detector::setPattern(const std::string &fname, Positions pos) { - pimpl->Parallel(&slsDetector::setPattern, pos, fname); +std::vector Detector::getPortNumbers(int start_port) { + int num_sockets_per_detector = 1; + switch (getDetectorType({}).squash()) { + case defs::EIGER: + num_sockets_per_detector *= 2; + break; + case defs::JUNGFRAU: + if(getNumberofUDPInterfaces({}).squash() == 2) { + num_sockets_per_detector *= 2; + } + break; + default: + break; + } + std::vector res; + for (int idet = 0; idet < size(); ++idet) { + res.push_back(start_port + (idet * num_sockets_per_detector)); + } + return res; } -Result Detector::getPatternIOControl(Positions pos) const { - return pimpl->Parallel(&slsDetector::setPatternIOControl, pos, -1); -} - -void Detector::setPatternIOControl(uint64_t word, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word); -} - -Result Detector::getPatternClockControl(Positions pos) const { - return pimpl->Parallel(&slsDetector::setPatternClockControl, pos, -1); -} - -void Detector::setPatternClockControl(uint64_t word, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word); -} - -void Detector::setPatternWord(int addr, uint64_t word, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word); -} - -Result> Detector::getPatternLoops(int level, - Positions pos) const { - return pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, -1, -1, - -1); -} - -void Detector::setPatternLoops(int level, int start, int stop, int n, - Positions pos) { - pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n); -} - -Result Detector::getPatternWaitAddr(int level, Positions pos) const { - return pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, -1); -} - -void Detector::setPatternWaitAddr(int level, int addr, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr); -} - -Result Detector::getPatternWaitTime(int level, Positions pos) const { - return pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, -1); -} - -void Detector::setPatternWaitTime(int level, uint64_t t, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t); -} - -Result Detector::getPatternMask(Positions pos) { - return pimpl->Parallel(&slsDetector::getPatternMask, pos); -} - -void Detector::setPatternMask(uint64_t mask, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternMask, pos, mask); -} - -Result Detector::getPatternBitMask(Positions pos) const { - return pimpl->Parallel(&slsDetector::getPatternBitMask, pos); -} - -void Detector::setPatternBitMask(uint64_t mask, Positions pos) { - pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask); -} - - -std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); } - } // namespace sls \ No newline at end of file