readoutspeed in rx master file and other master file inconsistencies (#1245)

readout speed added to json and h5 master files.
Also fixed master file inconsistencies

Sserver binaries
- update server binaries because readoutspeed needs to be sent to receiver with rx_hostname command

API
- added const to Detector class set/getburstmode

Python
- updated python bindings (burstmode const and roi arguments)

Cmd generation
- added pragma once in Caller.in.h as Caller is included in test files

m3: num channels due to #counters < 3
* workaround for m3 for messed up num channels (client always assumes all counters enabled and adds them to num channels), fix for hdf5

g2: exptime master file inconsistency
- exptime didnt match because of round of when setting burst mode (sets to a different clk divider)
- so updating actual time for all timers (exptime, period, subexptime etc, )  in Module class, get timer values from detector when setting it and then send to receiver to write in master file

ctb image size incorrect:
-  write actual size into master file and not the reserved size (digital reduces depending on dbit list and dbit offset)
- added a calculate ctb image size free function in generalData.h that is used there as well as for the tests.


master file inconsistencies
- refactored master attributes writing using templates
-    names changed to keep it consistent between json and hdf5 master file (Version, Pixels, Exposure Times, GateDelays, Acquisition Period, etc.)
-  datatypes changed to keep it simple where possible: imageSize, dynamicRange, tengiga, quad, readnrows, analog, analogsamples, digital, digitalsamples, dbitreorder, dbitoffset, transceivermask, transeiver, transceiversamples, countermask, gates =>int
- replacing "toString" with arrays, objects etc for eg for scan, rois, etc.
- json header always written (empty dataset or empty brackets)
- hdf5 needs const char* so have to convert strings to it, but taking care that strings exist prior to push_back
- master attributes (redundant string literals->error prone

tests for master file
- suppressed deprecated functions in rapidjson warnings just for the tests
- added slsREceiverSoftware/src to allow access to receiver_defs.h to test binary/hdf5 version
- refactored acquire tests by moving all the acquire tests from individual detector type files to a single one=test-Caller-acquire.cpp
- set some default settings (loadBasicSettings) for a basic acquire at load config part for the test_simulator python scripts. so minimum number of settings for detector to be set for any acquire tests.
- added tests to test master files for json and hdf5= test-Caller-master-attributes.cpp
- added option to add '-m' markers for tests using test_simulator python script

slsDetectorSoftware/generator/Caller.in.h

@@ -1,5 +1,5 @@
 // This file is used as input to generate the caller class
-
+#pragma once
 #include "CmdParser.h"
 #include "HelpDacs.h"
 #include "sls/Detector.h"

slsDetectorSoftware/include/sls/Detector.h

@@ -1449,7 +1449,7 @@ class Detector {
                      Positions pos = {});
 
     /** [Gotthard2]  */
-    Result<defs::burstMode> getBurstMode(Positions pos = {});
+    Result<defs::burstMode> getBurstMode(Positions pos = {}) const;
 
     /** [Gotthard2]  BURST_INTERNAL (default), BURST_EXTERNAL,
      * CONTINUOUS_INTERNAL, CONTINUOUS_EXTERNAL. Also changes clkdiv 2, 3, 4 */

slsDetectorSoftware/src/Caller.h

@@ -1,5 +1,5 @@
 // This file is used as input to generate the caller class
-
+#pragma once
 #include "CmdParser.h"
 #include "HelpDacs.h"
 #include "sls/Detector.h"

slsDetectorSoftware/src/Detector.cpp

@@ -1883,7 +1883,7 @@ void Detector::setVetoFile(const int chipIndex, const std::string &fname,
     pimpl->Parallel(&Module::setVetoFile, pos, chipIndex, fname);
 }
 
-Result<defs::burstMode> Detector::getBurstMode(Positions pos) {
+Result<defs::burstMode> Detector::getBurstMode(Positions pos) const {
     return pimpl->Parallel(&Module::getBurstMode, pos);
 }
 

slsDetectorSoftware/src/Module.cpp

@@ -657,9 +657,16 @@ void Module::setExptime(int gateIndex, int64_t value) {
     int64_t args[]{static_cast<int64_t>(gateIndex), value};
     sendToDetector(F_SET_EXPTIME, args, nullptr);
     if (shm()->useReceiverFlag) {
+        // get exact value due to clk
+        if (shm()->detType == MYTHEN3 && gateIndex == -1) {
+            value = getExptime(0); // m3 does not support -1
+        } else {
+            value = getExptime(gateIndex); // others only support -1
+        }
+        args[1] = value;
         sendToReceiver(F_RECEIVER_SET_EXPTIME, args, nullptr);
     }
-    if (prevVal != value) {
+    if (shm()->detType == EIGER && prevVal != value) {
         updateRateCorrection();
     }
 }
@@ -671,6 +678,7 @@ int64_t Module::getPeriod() const {
 void Module::setPeriod(int64_t value) {
     sendToDetector(F_SET_PERIOD, value, nullptr);
     if (shm()->useReceiverFlag) {
+        value = getPeriod(); // get exact value due to clk
         sendToReceiver(F_RECEIVER_SET_PERIOD, value, nullptr);
     }
 }
@@ -749,6 +757,9 @@ slsDetectorDefs::speedLevel Module::getReadoutSpeed() const {
 
 void Module::setReadoutSpeed(speedLevel value) {
     sendToDetector(F_SET_READOUT_SPEED, value, nullptr);
+    if (shm()->useReceiverFlag) {
+        sendToReceiver(F_SET_RECEIVER_READOUT_SPEED, value, nullptr);
+    }
 }
 
 int Module::getClockDivider(int clkIndex) const {
@@ -1777,6 +1788,7 @@ void Module::setSubExptime(int64_t value) {
     }
     sendToDetector(F_SET_SUB_EXPTIME, value, nullptr);
     if (shm()->useReceiverFlag) {
+        value = getSubExptime(); // get exact value due to clk
         sendToReceiver(F_RECEIVER_SET_SUB_EXPTIME, value, nullptr);
     }
     if (prevVal != value) {
@@ -1791,6 +1803,7 @@ int64_t Module::getSubDeadTime() const {
 void Module::setSubDeadTime(int64_t value) {
     sendToDetector(F_SET_SUB_DEADTIME, value, nullptr);
     if (shm()->useReceiverFlag) {
+        value = getSubDeadTime(); // get exact value due to clk
         sendToReceiver(F_RECEIVER_SET_SUB_DEADTIME, value, nullptr);
     }
 }
@@ -2288,6 +2301,8 @@ void Module::setBurstMode(slsDetectorDefs::burstMode value) {
     sendToDetector(F_SET_BURST_MODE, value, nullptr);
     if (shm()->useReceiverFlag) {
         sendToReceiver(F_SET_RECEIVER_BURST_MODE, value, nullptr);
+        // changing burst mode may change exptime due to clk change
+        setExptime(-1, getExptime(-1)); // update exact exptime in receiver
     }
 }
 
@@ -2379,6 +2394,9 @@ void Module::setGateDelay(int gateIndex, int64_t value) {
     int64_t args[]{static_cast<int64_t>(gateIndex), value};
     sendToDetector(F_SET_GATE_DELAY, args, nullptr);
     if (shm()->useReceiverFlag) {
+        // get exact value due to clk
+        args[1] =
+            getGateDelay(gateIndex == -1 ? 0 : gateIndex); // m3 doesnt allow -1
         sendToReceiver(F_SET_RECEIVER_GATE_DELAY, args, nullptr);
     }
 }

slsDetectorSoftware/tests/CMakeLists.txt

@@ -17,6 +17,8 @@ target_sources(tests PRIVATE
     ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-xilinx-chiptestboard.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-moench.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-global.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-acquire.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller-master-attributes.cpp
 
     
     ${CMAKE_CURRENT_SOURCE_DIR}/test-Result.cpp
@@ -34,10 +36,17 @@ if (SLS_USE_HDF5)
     )
 endif (SLS_USE_HDF5)
 
+target_compile_options(tests
+    PRIVATE
+    # Suppress warnings for deprecated functions in rapidjson
+        -Wno-deprecated-declarations
+) 
+
 target_include_directories(tests 
     PUBLIC 
         "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../src>"
         "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include/sls>"
+        "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../slsReceiverSoftware/src>"
     PRIVATE
     ${SLS_INTERNAL_RAPIDJSON_DIR}
 )

slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp

@@ -0,0 +1,279 @@
+// SPDX-License-Identifier: LGPL-3.0-or-other
+// Copyright (C) 2021 Contributors to the SLS Detector Package
+#include "Caller.h"
+#include "catch.hpp"
+#include "sls/Detector.h"
+#include "sls/sls_detector_defs.h"
+#include "sls/versionAPI.h"
+#include "test-Caller-global.h"
+#include "tests/globals.h"
+
+#include <filesystem>
+#include <sstream>
+
+namespace sls {
+
+using test::GET;
+using test::PUT;
+
+TEST_CASE("jungfrau_or_moench_acquire_check_file_size",
+          "[.cmdcall][.cmdacquire]") {
+
+    Detector det;
+    Caller caller(&det);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+
+    if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
+
+        auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
+            "inconsistent number of udp interfaces");
+
+        int num_frames_to_acquire = 2;
+        create_files_for_acquire(det, caller, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        {
+            detParameters par(det_type);
+            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            // if 2 udp interfaces, data split into half
+            size_t expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
+                                          par.nChipY * bytes_per_pixel) /
+                                         num_udp_interfaces;
+            testFileInfo test_file_info;
+            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
+                                          expected_image_size);
+        }
+    }
+}
+
+TEST_CASE("eiger_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+
+    if (det_type == defs::EIGER) {
+
+        int dynamic_range = det.getDynamicRange().squash();
+        if (dynamic_range != 16) {
+            throw RuntimeError(
+                "Eiger detector must have dynamic range 16 to test");
+        }
+        int num_frames_to_acquire = 2;
+        create_files_for_acquire(det, caller, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        {
+            detParameters par(det_type);
+            // data split into half due to 2 udp interfaces per half module
+            int num_chips = (par.nChipX / 2);
+            int bytes_per_pixel = (dynamic_range / 8);
+            size_t expected_image_size =
+                par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
+            testFileInfo test_file_info;
+            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
+                                          expected_image_size);
+        }
+    }
+}
+
+TEST_CASE("mythen3_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+
+    if (det_type == defs::MYTHEN3) {
+
+        int dynamic_range = det.getDynamicRange().squash();
+        int counter_mask = det.getCounterMask().squash();
+        if (dynamic_range != 16 && counter_mask != 0x3) {
+            throw RuntimeError("Mythen3 detector must have dynamic range 16 "
+                               "and counter mask 0x3 to test");
+        }
+        int num_counters = __builtin_popcount(counter_mask);
+        int num_frames_to_acquire = 2;
+        create_files_for_acquire(det, caller, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        {
+            detParameters par(det_type);
+            int bytes_per_pixel = dynamic_range / 8;
+            int num_channels_per_counter = par.nChanX / 3;
+            size_t expected_image_size = num_channels_per_counter *
+                                         num_counters * par.nChipX *
+                                         bytes_per_pixel;
+            testFileInfo test_file_info;
+            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
+                                          expected_image_size);
+        }
+    }
+}
+
+TEST_CASE("gotthard2_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+
+    if (det_type == defs::GOTTHARD2) {
+
+        int num_frames_to_acquire = 2;
+        create_files_for_acquire(det, caller, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        {
+            detParameters par(det_type);
+            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
+            size_t expected_image_size =
+                par.nChanX * par.nChipX * bytes_per_pixel;
+            testFileInfo test_file_info;
+            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
+                                          expected_image_size);
+        }
+    }
+}
+
+void test_ctb_file_size_with_acquire(Detector &det, Caller &caller,
+                                     int64_t num_frames,
+                                     const testCtbAcquireInfo &test_info,
+                                     bool isXilinxCtb) {
+    create_files_for_acquire(det, caller, num_frames, test_info);
+
+    // check file size (assuming local pc)
+    uint64_t expected_image_size =
+        calculate_ctb_image_size(test_info, isXilinxCtb).first;
+    testFileInfo test_file_info;
+    REQUIRE_NOTHROW(test_acquire_binary_file_size(test_file_info, num_frames,
+                                                  expected_image_size));
+}
+
+TEST_CASE("ctb_acquire_check_file_size", "[.cmdcall][.cmdacquire]") {
+    Detector det;
+    Caller caller(&det);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+
+    if (det_type == defs::CHIPTESTBOARD ||
+        det_type == defs::XILINX_CHIPTESTBOARD) {
+        bool isXilinxCtb = (det_type == defs::XILINX_CHIPTESTBOARD);
+        int num_frames_to_acquire = 2;
+        // all the test cases
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            test_ctb_config.dbit_offset = 16;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
+            test_ctb_config.dbit_offset = 16;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
+            test_ctb_config.dbit_list.clear();
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::TRANSCEIVER_ONLY;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+        {
+            testCtbAcquireInfo test_ctb_config;
+            test_ctb_config.readout_mode = defs::ANALOG_ONLY;
+            test_ctb_config.dbit_offset = 16;
+            test_ctb_config.dbit_list.clear();
+            test_ctb_config.dbit_reorder = true;
+            REQUIRE_NOTHROW(test_ctb_file_size_with_acquire(
+                det, caller, num_frames_to_acquire, test_ctb_config,
+                isXilinxCtb));
+        }
+    }
+}
+
+} // namespace sls

slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp

@@ -17,119 +17,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("ctb_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::CHIPTESTBOARD ||
-        det_type == defs::XILINX_CHIPTESTBOARD) {
-        int num_frames_to_acquire = 2;
-        // all the test cases
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            test_ctb_config.dbit_offset = 16;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_AND_DIGITAL;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
-            test_ctb_config.dbit_offset = 16;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
-            test_ctb_config.dbit_list.clear();
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::DIGITAL_AND_TRANSCEIVER;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::TRANSCEIVER_ONLY;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-        {
-            testCtbAcquireInfo test_ctb_config;
-            test_ctb_config.readout_mode = defs::ANALOG_ONLY;
-            test_ctb_config.dbit_offset = 16;
-            test_ctb_config.dbit_list.clear();
-            test_ctb_config.dbit_reorder = true;
-            REQUIRE_NOTHROW(test_ctb_acquire_with_receiver(
-                test_ctb_config, num_frames_to_acquire, det, caller));
-        }
-    }
-}
-
 /* dacs */
 
 TEST_CASE("dacname", "[.cmdcall]") {

slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp

@@ -17,70 +17,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("eiger_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::EIGER) {
-
-        // save previous state
-        testFileInfo prev_file_info = get_file_state(det);
-        testCommonDetAcquireInfo prev_det_config_info =
-            get_common_acquire_config_state(det);
-
-        // save previous specific det type config
-        auto exptime = det.getExptime().tsquash("inconsistent exptime to test");
-        auto n_rows =
-            det.getReadNRows().tsquash("inconsistent number of rows to test");
-        auto dynamic_range =
-            det.getDynamicRange().tsquash("inconsistent dynamic range to test");
-        REQUIRE(false ==
-                det.getTenGiga().tsquash("inconsistent 10Giga to test"));
-
-        // defaults
-        int num_frames_to_acquire = 2;
-        testFileInfo test_file_info;
-        set_file_state(det, test_file_info);
-        testCommonDetAcquireInfo det_config;
-        det_config.num_frames_to_acquire = num_frames_to_acquire;
-        set_common_acquire_config_state(det, det_config);
-
-        // set default specific det type config
-        det.setExptime(std::chrono::microseconds{200});
-        det.setReadNRows(256);
-        det.setDynamicRange(16);
-
-        // acquire
-        test_acquire_with_receiver(caller, det);
-
-        // check frames caught
-        test_frames_caught(det, num_frames_to_acquire);
-
-        // check file size (assuming local pc)
-        {
-            detParameters par(det_type);
-            // data split into half due to 2 udp interfaces per half module
-            int num_chips = (par.nChipX / 2);
-            int bytes_per_pixel = (dynamic_range / 8);
-            size_t expected_image_size =
-                par.nChanX * par.nChanY * num_chips * bytes_per_pixel;
-            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
-                                          expected_image_size);
-        }
-
-        // restore previous state
-        set_file_state(det, prev_file_info);
-        set_common_acquire_config_state(det, prev_det_config_info);
-
-        // restore previous specific det type config
-        det.setExptime(exptime);
-        det.setReadNRows(n_rows);
-        det.setDynamicRange(dynamic_range);
-    }
-}
-
 /** temperature */
 
 TEST_CASE("temp_fpgaext", "[.cmdcall]") {

slsDetectorSoftware/tests/Caller/test-Caller-global.cpp

@@ -2,6 +2,7 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #include "test-Caller-global.h"
 #include "Caller.h"
+#include "GeneralData.h"
 #include "catch.hpp"
 #include "sls/Detector.h"
 #include "sls/logger.h"
@@ -148,20 +149,52 @@ void test_acquire_with_receiver(Caller &caller, const Detector &det) {
     REQUIRE_NOTHROW(caller.call("rx_stop", {}, -1, PUT));
 }
 
-testCommonDetAcquireInfo get_common_acquire_config_state(const Detector &det) {
-    return testCommonDetAcquireInfo{
-        det.getTimingMode().tsquash("Inconsistent timing mode"),
-        det.getNumberOfFrames().tsquash("Inconsistent number of frames"),
-        det.getNumberOfTriggers().tsquash("Inconsistent number of triggers"),
-        det.getPeriod().tsquash("Inconsistent period")};
-}
+void create_files_for_acquire(Detector &det, Caller &caller, int64_t num_frames,
+                              std::optional<testCtbAcquireInfo> test_info) {
 
-void set_common_acquire_config_state(
-    Detector &det, const testCommonDetAcquireInfo &det_config_info) {
-    det.setTimingMode(det_config_info.timing_mode);
-    det.setNumberOfFrames(det_config_info.num_frames_to_acquire);
-    det.setNumberOfTriggers(det_config_info.num_triggers);
-    det.setPeriod(det_config_info.period);
+    // save previous state
+    testFileInfo prev_file_info = get_file_state(det);
+    auto prev_num_frames = det.getNumberOfFrames().tsquash(
+        "Inconsistent number of frames to acquire");
+    std::optional<testCtbAcquireInfo> prev_ctb_config_info{};
+    if (test_info) {
+        prev_ctb_config_info = get_ctb_config_state(det);
+    }
+
+    // set state for acquire
+    testFileInfo test_file_info;
+    set_file_state(det, test_file_info);
+    det.setNumberOfFrames(num_frames);
+    if (test_info) {
+        set_ctb_config_state(det, *test_info);
+    }
+
+    // acquire and get num frames caught
+    test_acquire_with_receiver(caller, det);
+    auto frames_caught = det.getFramesCaught().tsquash(
+        "Inconsistent number of frames caught")[0];
+    REQUIRE(frames_caught == num_frames);
+
+    // hdf5
+#ifdef HDF5C
+    test_file_info.file_format = defs::HDF5;
+    test_file_info.file_acq_index = 0;
+    set_file_state(det, test_file_info);
+
+    // acquire and get num frames caught
+    test_acquire_with_receiver(caller, det);
+    frames_caught = det.getFramesCaught().tsquash(
+        "Inconsistent number of frames caught")[0];
+    REQUIRE(frames_caught == num_frames);
+#endif
+
+    // restore previous state
+    // file
+    set_file_state(det, prev_file_info);
+    det.setNumberOfFrames(prev_num_frames);
+    if (test_info) {
+        set_ctb_config_state(det, *prev_ctb_config_info);
+    }
 }
 
 testCtbAcquireInfo get_ctb_config_state(const Detector &det) {
@@ -211,105 +244,30 @@ void set_ctb_config_state(Detector &det,
     det.setTransceiverEnableMask(ctb_config_info.transceiver_mask);
 }
 
-uint64_t calculate_ctb_image_size(const testCtbAcquireInfo &test_info) {
-    uint64_t num_analog_bytes = 0, num_digital_bytes = 0,
-             num_transceiver_bytes = 0;
-    if (test_info.readout_mode == defs::ANALOG_ONLY ||
-        test_info.readout_mode == defs::ANALOG_AND_DIGITAL) {
-        uint32_t adc_enable_mask =
-            (test_info.ten_giga ? test_info.adc_enable_10g
-                                : test_info.adc_enable_1g);
-        int num_analog_chans = __builtin_popcount(adc_enable_mask);
-        const int num_bytes_per_sample = 2;
-        num_analog_bytes =
-            num_analog_chans * num_bytes_per_sample * test_info.num_adc_samples;
-        LOG(logDEBUG1) << "[Analog Databytes: " << num_analog_bytes << ']';
-    }
+std::pair<uint64_t, int>
+calculate_ctb_image_size(const testCtbAcquireInfo &test_info,
+                         bool isXilinxCtb) {
 
-    // digital channels
-    if (test_info.readout_mode == defs::DIGITAL_ONLY ||
-        test_info.readout_mode == defs::ANALOG_AND_DIGITAL ||
-        test_info.readout_mode == defs::DIGITAL_AND_TRANSCEIVER) {
-        int num_digital_samples = test_info.num_dbit_samples;
-        if (test_info.dbit_offset > 0) {
-            uint64_t num_digital_bytes_reserved =
-                num_digital_samples * sizeof(uint64_t);
-            num_digital_bytes_reserved -= test_info.dbit_offset;
-            num_digital_samples = num_digital_bytes_reserved / sizeof(uint64_t);
-        }
-        int num_digital_chans = test_info.dbit_list.size();
-        if (num_digital_chans == 0) {
-            num_digital_chans = 64;
-        }
-        if (!test_info.dbit_reorder) {
-            uint32_t num_bits_per_sample = num_digital_chans;
-            if (num_bits_per_sample % 8 != 0) {
-                num_bits_per_sample += (8 - (num_bits_per_sample % 8));
-            }
-            num_digital_bytes = (num_bits_per_sample / 8) * num_digital_samples;
-        } else {
-            uint32_t num_bits_per_bit = num_digital_samples;
-            if (num_bits_per_bit % 8 != 0) {
-                num_bits_per_bit += (8 - (num_bits_per_bit % 8));
-            }
-            num_digital_bytes = num_digital_chans * (num_bits_per_bit / 8);
-        }
-        LOG(logDEBUG1) << "[Digital Databytes: " << num_digital_bytes << ']';
-    }
-    // transceiver channels
-    if (test_info.readout_mode == defs::TRANSCEIVER_ONLY ||
-        test_info.readout_mode == defs::DIGITAL_AND_TRANSCEIVER) {
-        int num_transceiver_chans =
-            __builtin_popcount(test_info.transceiver_mask);
-        const int num_bytes_per_channel = 8;
-        num_transceiver_bytes = num_transceiver_chans * num_bytes_per_channel *
-                                test_info.num_trans_samples;
-        LOG(logDEBUG1) << "[Transceiver Databytes: " << num_transceiver_bytes
-                       << ']';
+    sls::CtbImageInputs inputs{};
+    inputs.nAnalogSamples = test_info.num_adc_samples;
+    inputs.adcMask = test_info.adc_enable_10g;
+    if (!isXilinxCtb && !test_info.ten_giga) {
+        inputs.adcMask = test_info.adc_enable_1g;
     }
+    inputs.nTransceiverSamples = test_info.num_trans_samples;
+    inputs.transceiverMask = test_info.transceiver_mask;
+    inputs.nDigitalSamples = test_info.num_dbit_samples;
+    inputs.dbitOffset = test_info.dbit_offset;
+    inputs.dbitList = test_info.dbit_list;
+    inputs.dbitReorder = test_info.dbit_reorder;
 
+    auto out = computeCtbImageSize(inputs);
     uint64_t image_size =
-        num_analog_bytes + num_digital_bytes + num_transceiver_bytes;
+        out.nAnalogBytes + out.nDigitalBytes + out.nTransceiverBytes;
     LOG(logDEBUG1) << "Expected image size: " << image_size;
-    return image_size;
-}
-
-void test_ctb_acquire_with_receiver(const testCtbAcquireInfo &test_info,
-                                    int64_t num_frames_to_acquire,
-                                    Detector &det, Caller &caller) {
-
-    // save previous state
-    testFileInfo prev_file_info = get_file_state(det);
-    testCommonDetAcquireInfo prev_det_config_info =
-        // overwrite exptime if not using virtual ctb server
-        get_common_acquire_config_state(det);
-    testCtbAcquireInfo prev_ctb_config_info = get_ctb_config_state(det);
-
-    // defaults
-    testFileInfo test_file_info;
-    set_file_state(det, test_file_info);
-    testCommonDetAcquireInfo det_config;
-    det_config.num_frames_to_acquire = num_frames_to_acquire;
-    set_common_acquire_config_state(det, det_config);
-
-    // set ctb config
-    set_ctb_config_state(det, test_info);
-
-    // acquire
-    REQUIRE_NOTHROW(test_acquire_with_receiver(caller, det));
-
-    // check frames caught
-    REQUIRE_NOTHROW(test_frames_caught(det, num_frames_to_acquire));
-
-    // check file size (assuming local pc)
-    uint64_t expected_image_size = calculate_ctb_image_size(test_info);
-    REQUIRE_NOTHROW(test_acquire_binary_file_size(
-        test_file_info, num_frames_to_acquire, expected_image_size));
-
-    // restore previous state
-    set_file_state(det, prev_file_info);
-    set_common_acquire_config_state(det, prev_det_config_info);
-    set_ctb_config_state(det, prev_ctb_config_info);
+    int npixelx = out.nPixelsX;
+    LOG(logDEBUG1) << "Expected number of pixels in x: " << npixelx;
+    return std::make_pair(image_size, npixelx);
 }
 
 } // namespace sls

slsDetectorSoftware/tests/Caller/test-Caller-global.h

@@ -2,12 +2,13 @@
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #pragma once
 
-class Caller;
+#include "Caller.h"
 #include "sls/Detector.h"
 #include "sls/sls_detector_defs.h"
 
 #include <chrono>
 #include <filesystem>
+#include <optional>
 #include <thread>
 
 namespace sls {
@@ -18,13 +19,14 @@ struct testFileInfo {
     bool file_write{true};
     bool file_overwrite{true};
     slsDetectorDefs::fileFormat file_format{slsDetectorDefs::BINARY};
-};
-
-struct testCommonDetAcquireInfo {
-    slsDetectorDefs::timingMode timing_mode{slsDetectorDefs::AUTO_TIMING};
-    int64_t num_frames_to_acquire{2};
-    int64_t num_triggers{1};
-    std::chrono::nanoseconds period{std::chrono::milliseconds{2}};
+    std::string getMasterFileNamePrefix() const {
+        return file_path + "/" + file_prefix + "_master_" +
+               std::to_string(file_acq_index);
+    }
+    std::string getVirtualFileName() const {
+        return file_path + "/" + file_prefix + "_virtual_" +
+               std::to_string(file_acq_index) + ".h5";
+    }
 };
 
 struct testCtbAcquireInfo {
@@ -60,16 +62,14 @@ void test_frames_caught(const Detector &det, int num_frames_to_acquire);
 
 void test_acquire_with_receiver(Caller &caller, const Detector &det);
 
-testCommonDetAcquireInfo get_common_acquire_config_state(const Detector &det);
-void set_common_acquire_config_state(
-    Detector &det, const testCommonDetAcquireInfo &det_config_info);
+void create_files_for_acquire(
+    Detector &det, Caller &caller, int64_t num_frames = 1,
+    std::optional<testCtbAcquireInfo> test_info = std::nullopt);
 
 testCtbAcquireInfo get_ctb_config_state(const Detector &det);
 void set_ctb_config_state(Detector &det,
                           const testCtbAcquireInfo &ctb_config_info);
-uint64_t calculate_ctb_image_size(const testCtbAcquireInfo &test_info);
-void test_ctb_acquire_with_receiver(const testCtbAcquireInfo &test_info,
-                                    int64_t num_frames_to_acquire,
-                                    Detector &det, Caller &caller);
+std::pair<uint64_t, int>
+calculate_ctb_image_size(const testCtbAcquireInfo &test_info, bool isXilinxCtb);
 
 } // namespace sls

slsDetectorSoftware/tests/Caller/test-Caller-gotthard2.cpp

@@ -17,69 +17,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("gotthard2_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::GOTTHARD2) {
-
-        // save previous state
-        testFileInfo prev_file_info = get_file_state(det);
-        testCommonDetAcquireInfo prev_det_config_info =
-            get_common_acquire_config_state(det);
-
-        // save previous specific det type config
-        auto exptime = det.getExptime().tsquash("inconsistent exptime to test");
-        auto burst_mode =
-            det.getBurstMode().tsquash("inconsistent burst mode to test");
-        auto number_of_bursts = det.getNumberOfBursts().tsquash(
-            "inconsistent number of bursts to test");
-        auto burst_period =
-            det.getBurstPeriod().tsquash("inconsistent burst period to test");
-
-        // defaults
-        int num_frames_to_acquire = 2;
-        testFileInfo test_file_info;
-        set_file_state(det, test_file_info);
-        testCommonDetAcquireInfo det_config;
-        det_config.num_frames_to_acquire = num_frames_to_acquire;
-        set_common_acquire_config_state(det, det_config);
-
-        // set default specific det type config
-        det.setExptime(std::chrono::microseconds{200});
-        det.setBurstMode(defs::CONTINUOUS_EXTERNAL);
-        det.setNumberOfBursts(1);
-        det.setBurstPeriod(std::chrono::milliseconds{0});
-
-        // acquire
-        test_acquire_with_receiver(caller, det);
-
-        // check frames caught
-        test_frames_caught(det, num_frames_to_acquire);
-
-        // check file size (assuming local pc)
-        {
-            detParameters par(det_type);
-            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
-            size_t expected_image_size =
-                par.nChanX * par.nChipX * bytes_per_pixel;
-            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
-                                          expected_image_size);
-        }
-        // restore previous state
-        set_file_state(det, prev_file_info);
-        set_common_acquire_config_state(det, prev_det_config_info);
-
-        // restore previous specific det type config
-        det.setExptime(exptime);
-        det.setBurstMode(burst_mode);
-        det.setNumberOfBursts(number_of_bursts);
-        det.setBurstPeriod(burst_period);
-    }
-}
-
 // time specific measurements for gotthard2
 TEST_CASE("timegotthard2", "[.cmdcall]") {
     Detector det;

slsDetectorSoftware/tests/Caller/test-Caller-jungfrau.cpp

@@ -15,65 +15,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("jungfrau_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::JUNGFRAU) {
-
-        // save previous state
-        testFileInfo prev_file_info = get_file_state(det);
-        testCommonDetAcquireInfo prev_det_config_info =
-            get_common_acquire_config_state(det);
-
-        // save previous specific det type config
-        auto exptime = det.getExptime().tsquash("inconsistent exptime to test");
-        auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
-            "inconsistent number of udp interfaces");
-        auto n_rows =
-            det.getReadNRows().tsquash("inconsistent number of rows to test");
-
-        // defaults
-        int num_frames_to_acquire = 2;
-        testFileInfo test_file_info;
-        set_file_state(det, test_file_info);
-        testCommonDetAcquireInfo det_config;
-        det_config.num_frames_to_acquire = num_frames_to_acquire;
-        set_common_acquire_config_state(det, det_config);
-
-        // set default specific det type config
-        det.setExptime(std::chrono::microseconds{200});
-        det.setReadNRows(512);
-
-        // acquire
-        test_acquire_with_receiver(caller, det);
-
-        // check frames caught
-        test_frames_caught(det, num_frames_to_acquire);
-
-        // check file size (assuming local pc)
-        {
-            detParameters par(det_type);
-            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
-            // if 2 udp interfaces, data split into half
-            size_t expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
-                                          par.nChipY * bytes_per_pixel) /
-                                         num_udp_interfaces;
-            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
-                                          expected_image_size);
-        }
-        // restore previous state
-        set_file_state(det, prev_file_info);
-        set_common_acquire_config_state(det, prev_det_config_info);
-
-        // restore previous specific det type config
-        det.setExptime(exptime);
-        det.setReadNRows(n_rows);
-    }
-}
-
 /* dacs */
 
 TEST_CASE("Setting and reading back Jungfrau dacs", "[.cmdcall][.dacs]") {

slsDetectorSoftware/tests/Caller/test-Caller-moench.cpp

@@ -15,66 +15,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("moench_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::MOENCH) {
-
-        // save previous state
-        testFileInfo prev_file_info = get_file_state(det);
-        testCommonDetAcquireInfo prev_det_config_info =
-            get_common_acquire_config_state(det);
-
-        // save previous specific det type config
-        auto exptime = det.getExptime().tsquash("inconsistent exptime to test");
-        auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
-            "inconsistent number of udp interfaces");
-        auto n_rows =
-            det.getReadNRows().tsquash("inconsistent number of rows to test");
-
-        // defaults
-        int num_frames_to_acquire = 2;
-        testFileInfo test_file_info;
-        set_file_state(det, test_file_info);
-        testCommonDetAcquireInfo det_config;
-        det_config.num_frames_to_acquire = num_frames_to_acquire;
-        set_common_acquire_config_state(det, det_config);
-
-        // set default specific det type config
-        det.setExptime(std::chrono::microseconds{200});
-        det.setReadNRows(400);
-
-        // acquire
-        test_acquire_with_receiver(caller, det);
-
-        // check frames caught
-        test_frames_caught(det, num_frames_to_acquire);
-
-        // check file size (assuming local pc)
-        {
-            detParameters par(det_type);
-            int bytes_per_pixel = det.getDynamicRange().squash() / 8;
-            // if 2 udp interfaces, data split into half
-            size_t expected_image_size = (par.nChanX * par.nChanY * par.nChipX *
-                                          par.nChipY * bytes_per_pixel) /
-                                         num_udp_interfaces;
-            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
-                                          expected_image_size);
-        }
-
-        // restore previous state
-        set_file_state(det, prev_file_info);
-        set_common_acquire_config_state(det, prev_det_config_info);
-
-        // restore previous specific det type config
-        det.setExptime(exptime);
-        det.setReadNRows(n_rows);
-    }
-}
-
 /* dacs */
 
 TEST_CASE("Setting and reading back moench dacs", "[.cmdcall][.dacs]") {

slsDetectorSoftware/tests/Caller/test-Caller-mythen3.cpp

@@ -17,74 +17,6 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
-TEST_CASE("mythen3_acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    if (det_type == defs::MYTHEN3) {
-
-        // save previous state
-        testFileInfo prev_file_info = get_file_state(det);
-        testCommonDetAcquireInfo prev_det_config_info =
-            get_common_acquire_config_state(det);
-
-        // save previous specific det type config
-        auto exptime =
-            det.getExptimeForAllGates().tsquash("inconsistent exptime to test");
-        auto dynamic_range =
-            det.getDynamicRange().tsquash("inconsistent dynamic range to test");
-        uint32_t counter_mask =
-            det.getCounterMask().tsquash("inconsistent counter mask to test");
-
-        // defaults
-        int num_frames_to_acquire = 2;
-        testFileInfo test_file_info;
-        set_file_state(det, test_file_info);
-        testCommonDetAcquireInfo det_config;
-        det_config.num_frames_to_acquire = num_frames_to_acquire;
-        set_common_acquire_config_state(det, det_config);
-
-        // set default specific det type config
-        det.setExptime(-1, std::chrono::microseconds{200});
-        int test_dynamic_range = 16;
-        det.setDynamicRange(test_dynamic_range);
-        int test_counter_mask = 0x3;
-        int num_counters = __builtin_popcount(test_counter_mask);
-        det.setCounterMask(test_counter_mask);
-
-        // acquire
-        test_acquire_with_receiver(caller, det);
-
-        // check frames caught
-        test_frames_caught(det, num_frames_to_acquire);
-
-        // check file size (assuming local pc)
-        {
-            detParameters par(det_type);
-            int bytes_per_pixel = test_dynamic_range / 8;
-            int num_channels_per_counter = par.nChanX / 3;
-            size_t expected_image_size = num_channels_per_counter *
-                                         num_counters * par.nChipX *
-                                         bytes_per_pixel;
-            test_acquire_binary_file_size(test_file_info, num_frames_to_acquire,
-                                          expected_image_size);
-        }
-
-        // restore previous state
-        set_file_state(det, prev_file_info);
-        set_common_acquire_config_state(det, prev_det_config_info);
-
-        // restore previous specific det type config
-        for (int iGate = 0; iGate < 3; ++iGate) {
-            det.setExptime(iGate, exptime[iGate]);
-        }
-        det.setDynamicRange(dynamic_range);
-        det.setCounterMask(counter_mask);
-    }
-}
-
 /* dacs */
 
 TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmdcall][.dacs]") {

slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp

@@ -738,43 +738,19 @@ TEST_CASE("rx_roi", "[.cmdcall]") {
         // check master file creation
         // TODO: check roi in master file
         {
-            auto prev_write = det.getFileWrite().tsquash(
-                "inconsistent file write values in test");
-            auto prev_path = det.getFilePath().tsquash(
-                "inconsistent file path values in test");
-            auto prev_format = det.getFileFormat().tsquash(
-                "inconsistent file format values in test");
-            auto prev_index = det.getAcquisitionIndex().tsquash(
-                "inconsistent file index values in test");
-            auto prev_fname = det.getFileNamePrefix().tsquash(
-                "inconsistent file name prefix values in test");
-
-            det.setFileWrite(true);
-            det.setFilePath("/tmp");
-            det.setFileNamePrefix("test");
-
-            det.setAcquisitionIndex(0);
-            det.setFileFormat(defs::BINARY);
-            REQUIRE_NOTHROW(caller.call("acquire", {}, -1, PUT));
-            std::string file_path = "/tmp/test_master_0.json";
-            REQUIRE(std::filesystem::exists(file_path) == true);
+            create_files_for_acquire(det, caller);
+            testFileInfo file_info;
+            std::string master_file_prefix =
+                file_info.getMasterFileNamePrefix();
 
+            std::string fname = master_file_prefix + ".json";
+            REQUIRE(std::filesystem::exists(fname) == true);
 #ifdef HDF5C
-            det.setAcquisitionIndex(0);
-            det.setFileFormat(defs::HDF5);
-            REQUIRE_NOTHROW(caller.call("acquire", {}, -1, PUT));
-            file_path = "/tmp/test_master_0.h5";
-            REQUIRE(std::filesystem::exists(file_path) == true);
-            file_path = "/tmp/test_virtual_0.h5";
-            REQUIRE(std::filesystem::exists(file_path) == true);
+            fname = master_file_prefix + ".h5";
+            REQUIRE(std::filesystem::exists(fname) == true);
+            fname = file_info.getVirtualFileName();
+            REQUIRE(std::filesystem::exists(fname) == true);
 #endif
-
-            det.setFileWrite(prev_write);
-            if (!prev_path.empty())
-                det.setFilePath(prev_path);
-            det.setFileFormat(prev_format);
-            det.setAcquisitionIndex(prev_index);
-            det.setFileNamePrefix(prev_fname);
         }
 
         for (int i = 0; i != det.size(); ++i) {
@@ -801,7 +777,11 @@ TEST_CASE("rx_clearroi", "[.cmdcall]") {
             REQUIRE(oss.str() == "rx_clearroi successful\n");
         }
         for (int i = 0; i != det.size(); ++i) {
-            det.setRxROI(prev_val);
+            if (prev_val.size() == 1 && prev_val[0].completeRoi()) {
+                det.clearRxROI();
+            } else {
+                det.setRxROI(prev_val);
+            }
         }
     }
 }