added tests to check file size and frames caught with an acquire (virtual) for every detector

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

@@ -17,6 +17,257 @@ namespace sls {
 using test::GET;
 using test::PUT;
 
+struct testCtbAcquireInfo {
+    defs::readoutMode readout_mode{defs::ANALOG_AND_DIGITAL};
+    bool teng_giga{false};
+    int num_adc_samples{5000};
+    int num_dbit_samples{6000};
+    int num_trans_samples{288};
+    uint32_t adc_enable_1g{0xFFFFFFFF};
+    uint32_t adc_enable_10g{0xFFFFFFFF};
+    int dbit_offset{0};
+    std::vector<int> dbit_list{0, 12, 2, 43};
+    bool dbit_reorder{false};
+    uint32_t transceiver_mask{0x3};
+};
+
+testCtbAcquireInfo get_ctb_config_state(const Detector &det) {
+    return testCtbAcquireInfo{
+        det.getReadoutMode().tsquash("inconsistent readout mode to test"),
+        det.getTenGiga().tsquash("inconsistent ten giga enable to test"),
+        det.getNumberOfAnalogSamples().tsquash(
+            "inconsistent number of analog samples to test"),
+        det.getNumberOfDigitalSamples().tsquash(
+            "inconsistent number of digital samples to test"),
+        det.getNumberOfTransceiverSamples().tsquash(
+            "inconsistent number of transceiver samples to test"),
+        det.getADCEnableMask().tsquash("inconsistent adc enable mask to test"),
+        det.getTenGigaADCEnableMask().tsquash(
+            "inconsistent ten giga adc enable mask to test"),
+        det.getRxDbitOffset().tsquash("inconsistent rx dbit offset to test"),
+        det.getRxDbitList().tsquash("inconsistent rx dbit list to test"),
+        det.getRxDbitReorder().tsquash("inconsistent rx dbit reorder to test"),
+        det.getTransceiverEnableMask().tsquash(
+            "inconsistent transceiver mask to test")};
+}
+
+void set_ctb_config_state(Detector &det,
+                          const testCtbAcquireInfo &ctb_config_info) {
+    det.setReadoutMode(ctb_config_info.readout_mode);
+    det.setTenGiga(ctb_config_info.teng_giga);
+    det.setNumberOfAnalogSamples(ctb_config_info.num_adc_samples);
+    det.setNumberOfDigitalSamples(ctb_config_info.num_dbit_samples);
+    det.setNumberOfTransceiverSamples(ctb_config_info.num_trans_samples);
+    det.setADCEnableMask(ctb_config_info.adc_enable_1g);
+    det.setTenGigaADCEnableMask(ctb_config_info.adc_enable_10g);
+    det.setRxDbitOffset(ctb_config_info.dbit_offset);
+    det.setRxDbitList(ctb_config_info.dbit_list);
+    det.setRxDbitReorder(ctb_config_info.dbit_reorder);
+    det.setTransceiverEnableMask(ctb_config_info.transceiver_mask);
+}
+
+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
+    test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+    // check frames caught
+    test_frames_caught(det, num_frames_to_acquire);
+
+    // calculate image size
+    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.teng_giga ? test_info.adc_enable_1g
+                                 : test_info.adc_enable_10g);
+        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;
+        std::cout << "[Analog Databytes: " << num_analog_bytes << ']';
+    }
+
+    // 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);
+        }
+        std::cout << "[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;
+        std::cout << "[Transceiver Databytes: " << num_transceiver_bytes << ']';
+    }
+    std::cout << std::endl;
+    // check file size (assuming local pc)
+    uint64_t expected_image_size =
+        num_analog_bytes + num_digital_bytes + num_transceiver_bytes;
+    std::cout << "Expected image size: " << expected_image_size << std::endl;
+    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);
+}
+
+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;
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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();
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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();
+            set_ctb_config_state(det, test_ctb_config);
+            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();
+            set_ctb_config_state(det, test_ctb_config);
+            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;
+            set_ctb_config_state(det, test_ctb_config);
+            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,6 +17,62 @@ 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 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.setReadNRows(256);
+        det.setDynamicRange(16);
+
+        // acquire
+        test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+        // check frames caught
+        test_frames_caught(det, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        // pixels_row_per_chip * pixels_col_per_chip * num_chips *
+        // bytes_per_pixel
+        size_t expected_image_size = 256 * 256 * 2 * 2;
+        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.setReadNRows(n_rows);
+        det.setDynamicRange(dynamic_range);
+    }
+}
+
 /** temperature */
 
 TEST_CASE("temp_fpgaext", "[.cmdcall]") {

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

@@ -88,4 +88,91 @@ void test_onchip_dac_caller(defs::dacIndex index, const std::string &dacname,
     }
 }
 
+testFileInfo get_file_state(const Detector &det) {
+    return testFileInfo{
+        det.getFilePath().tsquash("Inconsistent file path"),
+        det.getFileNamePrefix().tsquash("Inconsistent file prefix"),
+        det.getAcquisitionIndex().tsquash(
+            "Inconsistent file acquisition index"),
+        det.getFileWrite().tsquash("Inconsistent file write state"),
+        det.getFileOverWrite().tsquash("Inconsistent file overwrite state"),
+        det.getFileFormat().tsquash("Inconsistent file format")};
+}
+
+void set_file_state(Detector &det, const testFileInfo &file_info) {
+    if (!file_info.file_path.empty())
+        det.setFilePath(file_info.file_path);
+    det.setFileNamePrefix(file_info.file_prefix);
+    det.setAcquisitionIndex(file_info.file_acq_index);
+    det.setFileWrite(file_info.file_write);
+    det.setFileOverWrite(file_info.file_overwrite);
+    det.setFileFormat(file_info.file_format);
+}
+
+void test_acquire_binary_file_size(const testFileInfo &file_info,
+                                   uint64_t num_frames_to_acquire,
+                                   uint64_t expected_image_size) {
+    assert(file_info.file_format == defs::BINARY);
+    std::string fname = file_info.file_path + "/" + file_info.file_prefix +
+                        "_d0_f0_" + std::to_string(file_info.file_acq_index) +
+                        ".raw";
+    uint64_t expected_file_size =
+        num_frames_to_acquire *
+        (expected_image_size + sizeof(defs::sls_receiver_header));
+    std::cout << "exepected file size: " << expected_file_size
+              << " receiver header size :" << sizeof(defs::sls_receiver_header)
+              << " num frames:" << num_frames_to_acquire << std::endl;
+    auto actual_file_size = std::filesystem::file_size(fname);
+    REQUIRE(actual_file_size == expected_file_size);
+}
+
+void test_frames_caught(const Detector &det, int num_frames_to_acquire) {
+    auto frames_caught = det.getFramesCaught().tsquash(
+        "Inconsistent number of frames caught")[0];
+    REQUIRE(frames_caught == num_frames_to_acquire);
+}
+
+void test_acquire_with_receiver(Caller &caller, std::chrono::seconds timeout) {
+    REQUIRE_NOTHROW(caller.call("rx_start", {}, -1, PUT));
+    REQUIRE_NOTHROW(caller.call("start", {}, -1, PUT));
+    std::this_thread::sleep_for(timeout);
+    REQUIRE_NOTHROW(caller.call("rx_stop", {}, -1, PUT));
+}
+
+testCommonDetAcquireInfo get_common_acquire_config_state(const Detector &det) {
+    testCommonDetAcquireInfo det_config_info{
+        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"),
+        {}};
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+    if (det_type != defs::MYTHEN3) {
+        det_config_info.exptime[0] =
+            det.getExptime().tsquash("inconsistent exptime to test");
+    } else {
+        det_config_info.exptime =
+            det.getExptimeForAllGates().tsquash("inconsistent exptime to test");
+    }
+    return det_config_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);
+    auto det_type =
+        det.getDetectorType().tsquash("Inconsistent detector types to test");
+    if (det_type != defs::MYTHEN3) {
+        det.setExptime(det_config_info.exptime[0]);
+    } else {
+        for (int iGate = 0; iGate < 3; ++iGate) {
+            det.setExptime(iGate, det_config_info.exptime[iGate]);
+        }
+    }
+}
+
 } // namespace sls

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

@@ -1,9 +1,35 @@
 // SPDX-License-Identifier: LGPL-3.0-or-other
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #pragma once
+
+class Caller;
+#include "sls/Detector.h"
 #include "sls/sls_detector_defs.h"
 
+#include <chrono>
+#include <filesystem>
+#include <thread>
+
 namespace sls {
+struct testFileInfo {
+    std::string file_path{"/tmp"};
+    std::string file_prefix{"sls_test"};
+    int64_t file_acq_index{0};
+    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::array<std::chrono::nanoseconds, 3> exptime{
+        std::chrono::microseconds{200}, std::chrono::nanoseconds{0},
+        std::chrono::nanoseconds{0}};
+};
+
 void test_valid_port_caller(const std::string &command,
                             const std::vector<std::string> &arguments,
                             int detector_id, int action);
@@ -13,4 +39,18 @@ void test_dac_caller(slsDetectorDefs::dacIndex index,
 void test_onchip_dac_caller(slsDetectorDefs::dacIndex index,
                             const std::string &dacname, int dacvalue);
 
+testFileInfo get_file_state(const Detector &det);
+void set_file_state(Detector &det, const testFileInfo &file_info);
+void test_acquire_binary_file_size(const testFileInfo &file_info,
+                                   uint64_t num_frames_to_acquire,
+                                   uint64_t expected_image_size);
+
+void test_frames_caught(const Detector &det, int num_frames_to_acquire);
+
+void test_acquire_with_receiver(Caller &caller, std::chrono::seconds timeout);
+
+testCommonDetAcquireInfo get_common_acquire_config_state(const Detector &det);
+void set_common_acquire_config_state(
+    Detector &det, const testCommonDetAcquireInfo &det_config_info);
+
 } // namespace sls

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

@@ -17,6 +17,63 @@ 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 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.setBurstMode(defs::CONTINUOUS_EXTERNAL);
+        det.setNumberOfBursts(1);
+        det.setBurstPeriod(std::chrono::milliseconds{0});
+
+        // acquire
+        test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+        // check frames caught
+        test_frames_caught(det, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        // num_channels * num_chips * bytes_per_pixel * num_frames
+        size_t expected_image_size = 128 * 10 * 2;
+        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.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,6 +15,63 @@ 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 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.setReadNRows(512);
+
+        // acquire
+        test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+        // check frames caught
+        test_frames_caught(det, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        size_t expected_image_size = 0;
+        // pixels_row_per_chip * pixels_col_per_chip * num_chips *
+        // bytes_per_pixel
+        if (num_udp_interfaces == 1) {
+            expected_image_size = 256 * 256 * 8 * 2;
+        } else {
+            expected_image_size = 256 * 256 * 4 * 2;
+        }
+        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.setReadNRows(n_rows);
+    }
+}
+
 /* dacs */
 
 TEST_CASE("Setting and reading back Jungfrau dacs", "[.cmdcall][.dacs]") {

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

@@ -15,6 +15,62 @@ 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 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.setReadNRows(400);
+
+        // acquire
+        test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+        // check frames caught
+        test_frames_caught(det, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        size_t expected_image_size = 0;
+        // pixels_row * pixels_col * bytes_per_pixel
+        if (num_udp_interfaces == 1) {
+            expected_image_size = 400 * 400 * 2;
+        } else {
+            expected_image_size = 400 * 200 * 2;
+        }
+        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.setReadNRows(n_rows);
+    }
+}
+
 /* dacs */
 
 TEST_CASE("Setting and reading back moench dacs", "[.cmdcall][.dacs]") {

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

@@ -17,6 +17,61 @@ 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 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.setDynamicRange(16);
+        int test_counter_mask = 0x1;
+        int num_counters = __builtin_popcount(counter_mask);
+        det.setCounterMask(test_counter_mask);
+
+        // acquire
+        test_acquire_with_receiver(caller, std::chrono::seconds{2});
+
+        // check frames caught
+        test_frames_caught(det, num_frames_to_acquire);
+
+        // check file size (assuming local pc)
+        // num_channels * num_chips * num_counters
+        size_t expected_image_size = 128 * 10 * num_counters * 2;
+        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.setDynamicRange(dynamic_range);
+        det.setCounterMask(counter_mask);
+    }
+}
+
 /* dacs */
 
 TEST_CASE("Setting and reading back MYTHEN3 dacs", "[.cmdcall][.dacs]") {

slsDetectorSoftware/tests/Caller/test-Caller.cpp

@@ -3609,172 +3609,4 @@ TEST_CASE("sleep", "[.cmdcall]") {
     REQUIRE_THROWS(caller.call("sleep", {}, -1, GET));
 }
 
-TEST_CASE("acquire_check_file_size", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto det_type =
-        det.getDetectorType().tsquash("Inconsistent detector types to test");
-
-    // save previous file state
-    auto file_write =
-        det.getFileWrite().tsquash("Inconsistent file write state");
-    auto file_overwrite =
-        det.getFileOverWrite().tsquash("Inconsistent file overwrite state");
-    auto file_format = det.getFileFormat().tsquash("Inconsistent file format");
-    auto file_path = det.getFilePath().tsquash("Inconsistent file path");
-    auto file_prefix =
-        det.getFileNamePrefix().tsquash("Inconsistent file prefix");
-    auto file_acq_index = det.getAcquisitionIndex().tsquash(
-        "Inconsistent file acquisition index");
-    // save previous det config state
-    auto timing_mode = det.getTimingMode().tsquash("Inconsistent timing mode");
-    auto num_frames =
-        det.getNumberOfFrames().tsquash("Inconsistent number of frames");
-    auto num_triggers =
-        det.getNumberOfTriggers().tsquash("Inconsistent number of triggers");
-    auto period = det.getPeriod().tsquash("Inconsistent period");
-    std::array<std::chrono::nanoseconds, 3> exptime{};
-    if (det_type != defs::MYTHEN3) {
-        exptime[0] = det.getExptime().tsquash("inconsistent exptime to test");
-    } else {
-        exptime =
-            det.getExptimeForAllGates().tsquash("inconsistent exptime to test");
-    }
-    // save previous specific det type config
-    auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash(
-        "inconsistent number of udp interfaces");
-    auto n_rows = 0;
-    if (det_type == defs::EIGER || det_type == defs::JUNGFRAU ||
-        det_type == defs::MOENCH) {
-        n_rows =
-            det.getReadNRows().tsquash("inconsistent number of rows to test");
-    }
-    auto dynamic_range =
-        det.getDynamicRange().tsquash("inconsistent dynamic range to test");
-
-    uint32_t counter_mask = 0;
-    if (det_type == defs::MYTHEN3) {
-        counter_mask =
-            det.getCounterMask().tsquash("inconsistent counter mask to test");
-    }
-    int num_counters = __builtin_popcount(counter_mask);
-
-    // defaults
-    int num_frames_to_acquire = 2;
-    int bytes_per_pixel = 2;
-
-    // set default file state
-    det.setFileWrite(true);
-    det.setFileOverWrite(true);
-    det.setFileFormat(defs::BINARY);
-    det.setFilePath("/tmp");
-    det.setFileNamePrefix("sls_test");
-    det.setAcquisitionIndex(0);
-    // set default det config state
-    det.setTimingMode(defs::AUTO_TIMING);
-    det.setNumberOfFrames(num_frames_to_acquire);
-    det.setNumberOfTriggers(1);
-    det.setPeriod(std::chrono::milliseconds{2});
-    det.setExptime(-1, std::chrono::microseconds{200});
-    // set default specific det type config
-    if (det_type == defs::EIGER) {
-        det.setReadNRows(256);
-    } else if (det_type == defs::JUNGFRAU) {
-        det.setReadNRows(512);
-    } else if (det_type == defs::MOENCH) {
-        det.setReadNRows(400);
-    }
-    if (det_type == defs::EIGER || det_type == defs::MYTHEN3) {
-        det.setDynamicRange(bytes_per_pixel * 8);
-    }
-    if (det_type == defs::MYTHEN3) {
-        det.setCounterMask(0x1);
-    }
-
-    // acquire
-    REQUIRE_NOTHROW(caller.call("rx_start", {}, -1, PUT));
-    REQUIRE_NOTHROW(caller.call("start", {}, -1, PUT));
-    std::this_thread::sleep_for(std::chrono::seconds{1});
-    REQUIRE_NOTHROW(caller.call("rx_stop", {}, -1, PUT));
-
-    // check frames caught
-    auto frames_caught = det.getFramesCaught().tsquash(
-        "Inconsistent number of frames caught")[0];
-    REQUIRE(frames_caught == num_frames_to_acquire);
-
-    // check file size (assuming local pc)
-    size_t expected_image_size = 0;
-    switch (det_type) {
-    case defs::EIGER:
-        // pixels_row_per_chip * pixels_col_per_chip * num_chips *
-        // bytes_per_pixel
-        expected_image_size = 256 * 256 * 2 * bytes_per_pixel;
-        break;
-    case defs::JUNGFRAU:
-        // pixels_row_per_chip * pixels_col_per_chip * num_chips *
-        // bytes_per_pixel
-        if (num_udp_interfaces == 1) {
-            expected_image_size = 256 * 256 * 8 * bytes_per_pixel;
-        } else {
-            expected_image_size = 256 * 256 * 4 * bytes_per_pixel;
-        }
-        break;
-    case defs::MOENCH:
-        // pixels_row * pixels_col * bytes_per_pixel
-        if (num_udp_interfaces == 1) {
-            expected_image_size = 400 * 400 * bytes_per_pixel;
-        } else {
-            expected_image_size = 200 * 400 * bytes_per_pixel;
-        }
-        break;
-    case defs::GOTTHARD2:
-        // num_channels * num_chips
-        expected_image_size = 128 * 10 * bytes_per_pixel;
-        break;
-    case defs::MYTHEN3:
-        // num_channels * num_chips * num_counters
-        expected_image_size = 128 * 10 * num_counters * bytes_per_pixel;
-        break;
-    // to include ctb and xilinx_ctb
-    default:
-        break;
-    }
-    size_t expected_file_size =
-        num_frames_to_acquire *
-        (expected_image_size + sizeof(defs::sls_receiver_header));
-    std::string fname = file_path + "/" + file_prefix + "f0_" +
-                        std::to_string(file_acq_index) + ".raw";
-    auto actual_file_size = std::filesystem::file_size(fname);
-    REQUIRE(actual_file_size == expected_file_size);
-
-    // restore to previous file state
-    det.setFileWrite(file_write);
-    det.setFileOverWrite(file_overwrite);
-    det.setFileFormat(file_format);
-    det.setFilePath(file_path);
-    det.setFileNamePrefix(file_prefix);
-    det.setAcquisitionIndex(file_acq_index);
-    // restore to previous det config state
-    det.setTimingMode(timing_mode);
-    det.setNumberOfFrames(num_frames);
-    det.setNumberOfTriggers(num_triggers);
-    det.setPeriod(period);
-    if (det_type != defs::MYTHEN3) {
-        det.setExptime(exptime[0]);
-    } else {
-        for (int iGate = 0; iGate < 3; ++iGate) {
-            det.setExptime(iGate, exptime[iGate]);
-        }
-    }
-    // restore previous specific det type config
-    if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
-        det.setNumberofUDPInterfaces(num_udp_interfaces);
-    }
-    if (det_type == defs::EIGER || det_type == defs::MYTHEN3) {
-        det.setDynamicRange(dynamic_range);
-    }
-    if (det_type == defs::MYTHEN3) {
-        det.setCounterMask(counter_mask);
-    }
-
 } // namespace sls

slsReceiverSoftware/src/DataProcessor.cpp

@@ -591,6 +591,7 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
 
     // store each selected bit from all samples consecutively
     if (ctbDbitReorder) {
+        LOG(logINFORED) << "Reordering digital data";
         size_t numBitsPerDbit =
             numDigitalSamples; // num bits per selected digital
                                // Bit for all samples
@@ -605,6 +606,8 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
         if ((numBitsPerSample % 8) != 0)
             numBitsPerSample += (8 - (numBitsPerSample % 8));
         totalNumBytes = (numBitsPerSample / 8) * numDigitalSamples;
+        LOG(logINFORED) << "total numDigital bytes without reorder:"
+                        << totalNumBytes;
     }
 
     std::vector<uint8_t> result(totalNumBytes, 0);
@@ -677,11 +680,11 @@ void DataProcessor::ArrangeDbitData(size_t &size, char *data) {
     memcpy(data + nAnalogDataBytes, result.data(),
            totalNumBytes * sizeof(uint8_t));
 
-    LOG(logDEBUG1) << "totalNumBytes: " << totalNumBytes
+    LOG(logINFORED) << "totalNumBytes: " << totalNumBytes
-                   << " nAnalogDataBytes:" << nAnalogDataBytes
+                    << " nAnalogDataBytes:" << nAnalogDataBytes
-                   << " ctbDbitOffset:" << ctbDbitOffset
+                    << " ctbDbitOffset:" << ctbDbitOffset
-                   << " nTransceiverDataBytes:" << nTransceiverDataBytes
+                    << " nTransceiverDataBytes:" << nTransceiverDataBytes
-                   << " size:" << size;
+                    << " size:" << size;
 }
 
 void DataProcessor::CropImage(size_t &size, char *data) {