WIP

slsDetectorSoftware/src/Detector.cpp

@@ -12,78 +12,21 @@ Detector::Detector(int multi_id)
     : pimpl(sls::make_unique<multiSlsDetector>(multi_id)) {}
 Detector::~Detector() = default;
 
-// Acquisition
-void Detector::acquire() { pimpl->acquire(); }
-
-void Detector::startReceiver(Positions pos) {
-    pimpl->Parallel(&slsDetector::startReceiver, pos);
-}
-void Detector::stopReceiver(Positions pos) {
-    pimpl->Parallel(&slsDetector::stopReceiver, pos);
-}
-
-Result<defs::runStatus> Detector::getReceiverStatus(Positions pos) {
-    return pimpl->Parallel(&slsDetector::getReceiverStatus, pos);
-}
-
-bool Detector::getAcquiringFlag() const { return pimpl->getAcquiringFlag(); }
-
-void Detector::setAcquiringFlag(bool value) { pimpl->setAcquiringFlag(value); }
-
 // Configuration
-Result<std::string> Detector::getHostname(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getHostname, pos);
-}
-
 void Detector::freeSharedMemory() { pimpl->freeSharedMemory(); }
 
 void Detector::setConfig(const std::string &fname) {
     pimpl->readConfigurationFile(fname);
 }
 
-
-
-
-
-Result<uint64_t> Detector::getStartingFrameNumber(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos);
-}
-void Detector::setStartingFrameNumber(uint64_t value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value);
+Result<std::string> Detector::getHostname(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getHostname, pos);
 }
 
-// File
-void Detector::setFileName(const std::string &fname, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFileName, pos, fname);
-}
-Result<std::string> Detector::getFileName(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setFileName, pos, "");
+void Detector::setHostname(const std::vector<std::string> &value) {
+    pimpl->setHostname(value);
 }
 
-void Detector::setFilePath(const std::string &fpath, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFilePath, pos, fpath);
-}
-Result<std::string> Detector::getFilePath(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getFilePath, pos);
-}
-
-void Detector::setFileWrite(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFileWrite, pos, value);
-}
-
-Result<bool> Detector::getFileWrite(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getFileWrite, pos);
-}
-
-void Detector::setFileOverWrite(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFileOverWrite, pos, value);
-}
-
-Result<bool> Detector::getFileOverWrite(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getFileOverWrite, pos);
-}
-
-// dhanya
 int Detector::getMultiId() const { return pimpl->getMultiId(); }
 
 void Detector::checkDetectorVersionCompatibility(Positions pos) const {
@@ -119,10 +62,6 @@ Result<int64_t> Detector::getReceiverSoftwareVersion(Positions pos) const {
 
 std::string Detector::getUserDetails() const { return pimpl->getUserDetails(); }
 
-void Detector::setHostname(const std::vector<std::string> &value) {
-    pimpl->setHostname(value);
-}
-
 defs::detectorType Detector::getDetectorType() const {
     return pimpl->getDetectorTypeAsEnum();
 }
@@ -339,6 +278,15 @@ void Detector::setNumberOfStorageCells(int64_t value) {
                     value);
 }
 
+Result<int> 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<int64_t> Detector::getNumberOfAnalogSamples(Positions pos) const {
     return pimpl->Parallel(&slsDetector::setTimer, pos, defs::ANALOG_SAMPLES,
                            -1);
@@ -1256,7 +1204,281 @@ void Detector::pulseChip(int n, Positions pos) {
     pimpl->Parallel(&slsDetector::pulseChip, pos, n);
 }
 
+Result<int> Detector::getThresholdTemperature(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1);
+}
 
+void Detector::setThresholdTemperature(int temp, Positions pos) {
+    pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp);
+}
+
+Result<bool> 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<int>(enable));
+}
+
+Result<int> Detector::getTemperatureEvent(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1);
+}
+
+void Detector::ResetTemperatureEvent(Positions pos) {
+    pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, 0);
+}
+
+void Detector::programFPGA(const std::string &fname, Positions pos) {
+    FILE_LOG(logINFO) << "Updating Firmware. This can take awhile. Please be patient...";
+    std::vector<char> buffer = pimpl->readPofFile(fname);
+    pimpl->Parallel(&slsDetector::programFPGA, pos, buffer);
+}
+
+void Detector::resetFPGA(Positions pos) {
+    pimpl->Parallel(&slsDetector::resetFPGA, pos);
+}
+
+void Detector::copyDetectorServer(const std::string &fname,
+                                  const std::string &hostname, Positions pos) {
+    pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
+    rebootController(pos);
+}
+
+void Detector::rebootController(Positions pos) {
+    pimpl->Parallel(&slsDetector::rebootController, pos);
+}
+
+void Detector::updateFirmwareAndServer(const std::string &sname,
+                                       const std::string &hostname,
+                                       const std::string &fname,
+                                       Positions pos) {
+    pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
+    programFPGA(fname, pos);
+    rebootController(pos);
+}
+
+Result<bool> 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<int>(on), i);
+            usleep(1000 * 1000);
+        }
+    } else {
+        pimpl->Parallel(&slsDetector::powerChip, pos, static_cast<int>(on));
+    }
+}
+
+Result<bool> 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<int>(value));
+}
+
+Result<int64_t> Detector::getRateCorrection(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getRateCorrection, pos);
+}
+
+void Detector::setRateCorrection(int64_t dead_time_ns, Positions pos) {
+    pimpl->Parallel(&slsDetector::setRateCorrection, pos, dead_time_ns);
+}
+
+Result<uint64_t> Detector::getStartingFrameNumber(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getStartingFrameNumber, pos);
+}
+
+void Detector::setStartingFrameNumber(uint64_t value, Positions pos) {
+    pimpl->Parallel(&slsDetector::setStartingFrameNumber, pos, value);
+}
+
+Result<bool> Detector::getTenGigaEnabled(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1);
+}
+
+void Detector::setTenGigaEnabled(bool value, Positions pos) {
+    pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos,
+                    static_cast<int>(value));
+}
+
+Result<bool> Detector::getLEDEnable(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1);
+}
+
+void Detector::setLEDEnable(bool enable, Positions pos) {
+    pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast<int>(enable));
+}
+
+void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) {
+    pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay);
+}
+// File
+Result<defs::fileFormat> 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<std::string> 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<std::string> 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<int> Detector::getFileIndex(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getFileIndex, pos);
+}
+
+void Detector::setFileIndex(int i, Positions pos) {
+    pimpl->Parallel(&slsDetector::setFileIndex, pos, i);
+}
+
+Result<bool> 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<bool> Detector::getMasterFileWrite(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos);
+}
+
+Result<bool> 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<int> 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<bool> Detector::getUseReceiverFlag(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos);
+}
+
+Result<std::string> Detector::printReceiverConfiguration(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos);
+}
+
+Result<bool> Detector::getReceiverLock(Positions pos) {
+    return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1);
+}
+
+void Detector::setReceiverLock(bool value, Positions pos) {
+    pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast<int>(value));
+}
+
+Result<std::string> Detector::getReceiverLastClientIP(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos);
+}
+
+void Detector::exitReceiver(Positions pos) {
+    pimpl->Parallel(&slsDetector::exitReceiver, pos);
+}
+
+void Detector::execReceiverCommand(const std::string &cmd, Positions pos) {
+    pimpl->Parallel(&slsDetector::execReceiverCommand, pos, cmd);
+}
+
+Result<int> Detector::getReceiverStreamingFrequency(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
+}
+
+void Detector::setReceiverStreamingFrequency(int freq, Positions pos) {
+    pimpl->Parallel(&slsDetector::setReceiverStreamingFrequency, pos, freq);
+}
+
+Result<int> Detector::getReceiverStreamingTimer(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
+}
+
+void Detector::setReceiverStreamingTimer(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<int>(enable));
+}
+
+Result<bool> Detector::getDataStreamingFromReceiver(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1);
+}
+
+void Detector::setDataStreamingFromReceiver(bool enable, Positions pos) {
+    pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos,
+                    static_cast<int>(enable));
+}
+
+Result<int> Detector::getReceiverFifoDepth(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1);
+}
+
+void Detector::setReceiverFifoDepth(int nframes, Positions pos) {
+    pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes);
+}
+
+Result<bool> Detector::getReceiverSilentMode(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1);
+}
+
+void Detector::setReceiverSilentMode(bool value, Positions pos) {
+    pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos,
+                    static_cast<int>(value));
+}
+
+Result<defs::frameDiscardPolicy>
+Detector::getReceiverFrameDiscardPolicy(Positions pos) const {
+    return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos,
+                           defs::GET_FRAME_DISCARD_POLICY);
+}
+
+void Detector::setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
+                                             Positions pos) {
+    pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f);
+}
+
+Result<bool> 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<bool> Detector::getRxPadDeactivatedMod(Positions pos) const {
     return pimpl->Parallel(&slsDetector::setDeactivatedRxrPaddingMode, pos, -1);
@@ -1283,8 +1505,23 @@ Detector::getReceiverRealUDPSocketBufferSize(Positions pos) const {
                            pos);
 }
 
+// Acquisition
+void Detector::acquire() { pimpl->acquire(); }
 
+bool Detector::getAcquiringFlag() const { return pimpl->getAcquiringFlag(); }
 
+void Detector::setAcquiringFlag(bool value) { pimpl->setAcquiringFlag(value); }
+
+void Detector::startReceiver(Positions pos) {
+    pimpl->Parallel(&slsDetector::startReceiver, pos);
+}
+void Detector::stopReceiver(Positions pos) {
+    pimpl->Parallel(&slsDetector::stopReceiver, pos);
+}
+
+Result<defs::runStatus> Detector::getReceiverStatus(Positions pos) {
+    return pimpl->Parallel(&slsDetector::getReceiverStatus, pos);
+}
 
 Result<int> Detector::getFramesCaughtByReceiver(Positions pos) const {
     return pimpl->Parallel(&slsDetector::getFramesCaughtByReceiver, pos);
@@ -1298,92 +1535,30 @@ void Detector::resetFramesCaught(Positions pos) {
     pimpl->Parallel(&slsDetector::resetFramesCaught, pos);
 }
 
-void Detector::setMasterFileWrite(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setMasterFileWrite, pos, value);
-}
-
-Result<bool> Detector::getMasterFileWrite(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getMasterFileWrite, pos);
-}
-
-void Detector::setReceiverStreamingTimer(int time_in_ms, Positions pos) {
-    pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, time_in_ms);
-}
-
-Result<int> Detector::getReceiverStreamingTimer(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setReceiverStreamingTimer, pos, -1);
-}
-
-bool Detector::getDataStreamingToClient() const {
-    return pimpl->enableDataStreamingToClient(-1);
-}
-
-void Detector::setDataStreamingToClient(bool enable) {
-    pimpl->enableDataStreamingToClient(static_cast<int>(enable));
-}
-
-Result<bool> Detector::getDataStreamingFromReceiver(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos, -1);
-}
-
-void Detector::setDataStreamingFromReceiver(bool enable, Positions pos) {
-    pimpl->Parallel(&slsDetector::enableDataStreamingFromReceiver, pos,
-                    static_cast<int>(enable));
-}
-
-void Detector::setTenGigaEnabled(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos,
-                    static_cast<int>(value));
-}
-
-Result<bool> Detector::getTenGigaEnabled(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::enableTenGigabitEthernet, pos, -1);
-}
-
-Result<int> Detector::getReceiverFifoDepth(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, -1);
-}
-
-void Detector::setReceiverFifoDepth(int nframes, Positions pos) {
-    pimpl->Parallel(&slsDetector::setReceiverFifoDepth, pos, nframes);
-}
-
-Result<bool> Detector::getReceiverSilentMode(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos, -1);
-}
-
-void Detector::setReceiverSilentMode(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setReceiverSilentMode, pos,
-                    static_cast<int>(value));
-}
+// pattern
 
 void Detector::setPattern(const std::string &fname, Positions pos) {
     pimpl->Parallel(&slsDetector::setPattern, pos, fname);
 }
 
-void Detector::setPatternIOControl(uint64_t word, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word);
-}
-
 Result<uint64_t> Detector::getPatternIOControl(Positions pos) const {
     return pimpl->Parallel(&slsDetector::setPatternIOControl, pos, -1);
 }
 
-void Detector::setPatternClockControl(uint64_t word, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
+void Detector::setPatternIOControl(uint64_t word, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternIOControl, pos, word);
 }
 
 Result<uint64_t> Detector::getPatternClockControl(Positions pos) const {
     return pimpl->Parallel(&slsDetector::setPatternClockControl, pos, -1);
 }
 
-void Detector::setPatternWord(int addr, uint64_t word, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
+void Detector::setPatternClockControl(uint64_t word, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternClockControl, pos, word);
 }
 
-void Detector::setPatternLoops(int level, int start, int stop, int n,
-                               Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n);
+void Detector::setPatternWord(int addr, uint64_t word, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternWord, pos, addr, word);
 }
 
 Result<std::array<int, 3>> Detector::getPatternLoops(int level,
@@ -1392,220 +1567,41 @@ Result<std::array<int, 3>> Detector::getPatternLoops(int level,
                            -1);
 }
 
-void Detector::setPatternWaitAddr(int level, int addr, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr);
+void Detector::setPatternLoops(int level, int start, int stop, int n,
+                               Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternLoops, pos, level, start, stop, n);
 }
 
 Result<int> Detector::getPatternWaitAddr(int level, Positions pos) const {
     return pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, -1);
 }
 
-void Detector::setPatternWaitTime(int level, uint64_t t, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternWaitTime, pos, level, t);
+void Detector::setPatternWaitAddr(int level, int addr, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternWaitAddr, pos, level, addr);
 }
 
 Result<uint64_t> 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<uint64_t> Detector::getPatternMask(Positions pos) {
     return pimpl->Parallel(&slsDetector::getPatternMask, pos);
 }
 
-void Detector::setPatternBitMask(uint64_t mask, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask);
+void Detector::setPatternMask(uint64_t mask, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternMask, pos, mask);
 }
 
 Result<uint64_t> Detector::getPatternBitMask(Positions pos) const {
     return pimpl->Parallel(&slsDetector::getPatternBitMask, pos);
 }
 
-void Detector::setLEDEnable(bool enable, Positions pos) {
-    pimpl->Parallel(&slsDetector::setLEDEnable, pos, static_cast<int>(enable));
+void Detector::setPatternBitMask(uint64_t mask, Positions pos) {
+    pimpl->Parallel(&slsDetector::setPatternBitMask, pos, mask);
 }
-
-Result<bool> Detector::getLEDEnable(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setLEDEnable, pos, -1);
-}
-
-void Detector::setDigitalIODelay(uint64_t pinMask, int delay, Positions pos) {
-    pimpl->Parallel(&slsDetector::setDigitalIODelay, pos, pinMask, delay);
-}
-
-Result<int> Detector::getFileIndex(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getFileIndex, pos);
-}
-
-void Detector::setFileIndex(int i, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFileIndex, pos, i);
-}
-
-Result<defs::fileFormat> 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<bool> Detector::getPartialFramesPadding(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getPartialFramesPadding, pos);
-}
-
-void Detector::setPartialFramesPadding(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setPartialFramesPadding, pos, value);
-}
-
-void Detector::setReceiverFrameDiscardPolicy(defs::frameDiscardPolicy f,
-                                             Positions pos) {
-    pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos, f);
-}
-
-Result<defs::frameDiscardPolicy>
-Detector::getReceiverFrameDiscardPolicy(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setReceiverFramesDiscardPolicy, pos,
-                           defs::GET_FRAME_DISCARD_POLICY);
-}
-
-void Detector::setFramesPerFile(int n, Positions pos) {
-    pimpl->Parallel(&slsDetector::setFramesPerFile, pos, n);
-}
-
-Result<int> Detector::getFramesPerFile(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getFramesPerFile, pos);
-}
-
-Result<std::string> Detector::getReceiverLastClientIP(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getReceiverLastClientIP, pos);
-}
-
-void Detector::setReceiverLock(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::lockReceiver, pos, static_cast<int>(value));
-}
-
-Result<bool> Detector::getReceiverLock(Positions pos) {
-    return pimpl->Parallel(&slsDetector::lockReceiver, pos, -1);
-}
-
-Result<bool> Detector::getUseReceiverFlag(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getUseReceiverFlag, pos);
-}
-
-void Detector::printReceiverConfiguration(Positions pos) const {
-    pimpl->Parallel(&slsDetector::printReceiverConfiguration, pos,
-                    TLogLevel::logINFO);
-}
-
-Result<int64_t> Detector::getRateCorrection(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::getRateCorrection, pos);
-}
-
-void Detector::setRateCorrection(int64_t dead_time_ns, Positions pos) {
-    pimpl->Parallel(&slsDetector::setRateCorrection, pos, dead_time_ns);
-}
-
-void Detector::setAutoCompDisable(bool value, Positions pos) {
-    pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, pos,
-                    static_cast<int>(value));
-}
-
-Result<bool> Detector::getAutoCompDisable(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setAutoComparatorDisableMode, 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<int>(on), i);
-            usleep(1000 * 1000);
-        }
-    } else {
-        pimpl->Parallel(&slsDetector::powerChip, pos, static_cast<int>(on));
-    }
-}
-
-Result<bool> Detector::getPowerChip(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::powerChip, pos, -1);
-}
-
-void Detector::updateFirmwareAndServer(const std::string &sname,
-                                       const std::string &hostname,
-                                       const std::string &fname,
-                                       Positions pos) {
-    copyDetectorServer(fname, hostname, pos);
-    programFPGA(fname, pos);
-}
-
-void Detector::rebootController(Positions pos) {
-    pimpl->Parallel(&slsDetector::rebootController, pos);
-}
-
-void Detector::copyDetectorServer(const std::string &fname,
-                                  const std::string &hostname, Positions pos) {
-    pimpl->Parallel(&slsDetector::copyDetectorServer, pos, fname, hostname);
-}
-
-void Detector::resetFPGA(Positions pos) {
-    pimpl->Parallel(&slsDetector::resetFPGA, pos);
-}
-
-void Detector::programFPGA(const std::string &fname, Positions pos) {
-    FILE_LOG(logINFO) << "This can take awhile. Please be patient...";
-    std::vector<char> buffer = pimpl->readPofFile(fname);
-    pimpl->Parallel(&slsDetector::programFPGA, pos, buffer);
-}
-
-void Detector::setStoragecellStart(int cell, Positions pos) {
-    pimpl->Parallel(&slsDetector::setStoragecellStart, pos, cell);
-}
-
-Result<int> Detector::getStorageCellStart(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setStoragecellStart, pos, -1);
-}
-
-void Detector::setTemperatureEvent(int val, Positions pos) {
-    pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, val);
-}
-
-Result<int> Detector::getTemperatureEvent(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setTemperatureEvent, pos, -1);
-}
-
-void Detector::setTemperatureControl(bool enable, Positions pos) {
-    pimpl->Parallel(&slsDetector::setTemperatureControl, pos,
-                    static_cast<int>(enable));
-}
-
-Result<bool> Detector::getTemperatureControl(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setTemperatureControl, pos, -1);
-}
-
-void Detector::setThresholdTemperature(int temp, Positions pos) {
-    pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, temp);
-}
-
-Result<int> Detector::getThresholdTemperature(Positions pos) const {
-    return pimpl->Parallel(&slsDetector::setThresholdTemperature, pos, -1);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
 
 } // namespace sls

slsDetectorSoftware/src/multiSlsDetector.cpp

@@ -2910,16 +2910,15 @@ int64_t multiSlsDetector::getRateCorrection(int detPos) {
     return sls::minusOneIfDifferent(r);
 }
 
-void multiSlsDetector::printReceiverConfiguration(TLogLevel level, int detPos) {
+std::string multiSlsDetector::printReceiverConfiguration(int detPos) {
     // single
     if (detPos >= 0) {
-        return detectors[detPos]->printReceiverConfiguration(level);
+        return detectors[detPos]->printReceiverConfiguration();
     }
 
     // multi
-    for (auto &d : detectors) {
-        d->printReceiverConfiguration(level);
-    }
+    auto r = parallelCall(&slsDetector::printReceiverConfiguration);
+    return sls::concatenateIfDifferent(r);
 }
 
 bool multiSlsDetector::getUseReceiverFlag(int detPos) {
@@ -3761,24 +3760,14 @@ int multiSlsDetector::setReceiverSilentMode(int i, int detPos) {
     return sls::minusOneIfDifferent(r);
 }
 
-int multiSlsDetector::setPattern(const std::string &fname, int detPos) {
+void multiSlsDetector::setPattern(const std::string &fname, int detPos) {
     // single
     if (detPos >= 0) {
-        return detectors[detPos]->setPattern(fname);
-    }
-    FILE *fd = fopen(fname.c_str(), "r");
-    if (fd == nullptr) {
-        throw RuntimeError("multiSlsDetector::setPattern: Could not open file");
-    } else {
-        int addr{0};
-        uint64_t word{0};
-        while (fread(&word, sizeof(word), 1, fd) != 0u) {
-            serialCall(&slsDetector::setPatternWord, addr, word);
-            ++addr;
-        }
-        fclose(fd);
-        return addr;
+        detectors[detPos]->setPattern(fname);
     }
+
+    // multi
+    parallelCall(&slsDetector::setPattern, fname);
 }
 
 uint64_t multiSlsDetector::setPatternIOControl(uint64_t word, int detPos) {

slsDetectorSoftware/src/slsDetector.cpp

@@ -2264,7 +2264,7 @@ void slsDetector::setUDPConnection() {
     } else {
         throw ReceiverError("setUDPConnection: Receiver is OFFLINE");
     }
-    printReceiverConfiguration(logDEBUG1);
+    FILE_LOG(logDEBUG1) << printReceiverConfiguration();
 }
 
 int slsDetector::digitalTest(digitalTestMode mode, int ival) {
@@ -2945,19 +2945,20 @@ void slsDetector::updateRateCorrection() {
     }
 }
 
-void slsDetector::printReceiverConfiguration(TLogLevel level) {
-    FILE_LOG(level) << "#Detector " << detId << ":\n Receiver Hostname:\t"
-                    << getReceiverHostname()
-                    << "\nDetector UDP IP (Source):\t\t" << getDetectorIP()
-                    << "\nDetector UDP IP2 (Source):\t\t" << getDetectorIP2()
-                    << "\nDetector UDP MAC:\t\t" << getDetectorMAC()
-                    << "\nDetector UDP MAC2:\t\t" << getDetectorMAC2()
-                    << "\nReceiver UDP IP:\t" << getReceiverUDPIP()
-                    << "\nReceiver UDP IP2:\t" << getReceiverUDPIP2()
-                    << "\nReceiver UDP MAC:\t" << getReceiverUDPMAC()
-                    << "\nReceiver UDP MAC2:\t" << getReceiverUDPMAC2()
-                    << "\nReceiver UDP Port:\t" << getReceiverUDPPort()
-                    << "\nReceiver UDP Port2:\t" << getReceiverUDPPort2();
+std::string slsDetector::printReceiverConfiguration() {
+    std::ostringstream os;
+    os << "#Detector " << detId << ":\n Receiver Hostname:\t"
+       << getReceiverHostname() << "\nDetector UDP IP (Source):\t\t"
+       << getDetectorIP() << "\nDetector UDP IP2 (Source):\t\t"
+       << getDetectorIP2() << "\nDetector UDP MAC:\t\t" << getDetectorMAC()
+       << "\nDetector UDP MAC2:\t\t" << getDetectorMAC2()
+       << "\nReceiver UDP IP:\t" << getReceiverUDPIP()
+       << "\nReceiver UDP IP2:\t" << getReceiverUDPIP2()
+       << "\nReceiver UDP MAC:\t" << getReceiverUDPMAC()
+       << "\nReceiver UDP MAC2:\t" << getReceiverUDPMAC2()
+       << "\nReceiver UDP Port:\t" << getReceiverUDPPort()
+       << "\nReceiver UDP Port2:\t" << getReceiverUDPPort2();
+    return os.str();
 }
 
 bool slsDetector::getUseReceiverFlag() const { return shm()->useReceiverFlag; }
@@ -3439,7 +3440,7 @@ void slsDetector::restreamStopFromReceiver() {
     }
 }
 
-int slsDetector::setPattern(const std::string &fname) {
+void slsDetector::setPattern(const std::string &fname) {
     uint64_t word;
     uint64_t addr = 0;
     FILE *fd = fopen(fname.c_str(), "r");
@@ -3451,9 +3452,8 @@ int slsDetector::setPattern(const std::string &fname) {
         }
         fclose(fd);
     } else {
-        return -1;
+        throw RuntimeError("Could not open file to set pattern");
     }
-    return addr;
 }
 
 uint64_t slsDetector::setPatternIOControl(uint64_t word) {

slsDetectorSoftware/src/slsDetectorCommand.cpp

@@ -4864,7 +4864,7 @@ std::string slsDetectorCommand::cmdConfiguration(int narg, const char * const ar
     } else if (cmd == "rx_printconfig") {
         if (action == PUT_ACTION)
             return std::string("cannot put");
-        myDet->printReceiverConfiguration(logINFO, detPos);
+        FILE_LOG(logINFO) << myDet->printReceiverConfiguration(detPos);
         return std::string("");
     } else if (cmd == "parameters") {
         if (action == PUT_ACTION) {
@@ -5171,7 +5171,8 @@ std::string slsDetectorCommand::cmdPattern(int narg, const char * const args[],
 
         if (action == PUT_ACTION) {
             fname = std::string(args[1]);
-            os << myDet->setPattern(fname, detPos);
+            myDet->setPattern(fname, detPos);
+            os << "successful";
         } else if (action == GET_ACTION)
             os << "Cannot get";
     } else if (cmd == "patword") {