diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp index cf713b0e3..d4e44a088 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-acquire.cpp @@ -10,7 +10,9 @@ #include "acquire/Acquire.h" #include "acquire/CTBState.h" +#include "acquire/ExpectedState.h" #include "acquire/FileState.h" +#include "checks/MasterFileChecks.h" #include #include @@ -18,6 +20,7 @@ namespace sls { namespace acq = sls::test::acquire; +namespace checks = sls::test::checks; using test::GET; using test::PUT; @@ -25,140 +28,32 @@ using test::PUT; // disable for jungfrau as it requires higher maximum receive buffer size // sysctl net.core.rmem_max=$((100*1024*1024)) // sysctl net.core.rmem_default=$((100*1024*1024)) -TEST_CASE("jungfrau_or_moench_acquire_check_file_size", +TEST_CASE("acquire_check_binary_file_size", "[.detectorintegration][.disable_check_data_file]") { 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"); - - int64_t num_frames_to_acquire = 2; - auto f = acq::default_file_state(); - acq::run(det, num_frames_to_acquire, f); - - // 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; - REQUIRE_NOTHROW(test_acquire_binary_file_size( - f, num_frames_to_acquire, expected_image_size)); - } - } -} - -TEST_CASE("eiger_acquire_check_file_size", - "[.detectorintegration][.disable_check_data_file]") { - 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"); - } - int64_t num_frames_to_acquire = 2; - auto f = acq::default_file_state(); - acq::run(det, num_frames_to_acquire, f); - - // 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; - REQUIRE_NOTHROW(test_acquire_binary_file_size( - f, num_frames_to_acquire, expected_image_size)); - } - } -} - -TEST_CASE("mythen3_acquire_check_file_size", - "[.detectorintegration][.disable_check_data_file]") { - 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); - int64_t num_frames_to_acquire = 2; - auto f = acq::default_file_state(); - acq::run(det, num_frames_to_acquire, f); - - // 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; - REQUIRE_NOTHROW(test_acquire_binary_file_size( - f, num_frames_to_acquire, expected_image_size)); - } - } -} - -TEST_CASE("gotthard2_acquire_check_file_size", - "[.detectorintegration][.disable_check_data_file]") { - Detector det; - Caller caller(&det); - auto det_type = - det.getDetectorType().tsquash("Inconsistent detector types to test"); - - if (det_type == defs::GOTTHARD2) { - - int64_t num_frames_to_acquire = 2; - auto f = acq::default_file_state(); - acq::run(det, num_frames_to_acquire, f); - - // 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; - REQUIRE_NOTHROW(test_acquire_binary_file_size( - f, num_frames_to_acquire, expected_image_size)); - } + if (det_type == defs::CHIPTESTBOARD || + det_type == defs::XILINX_CHIPTESTBOARD) { + // skip for CTB as it has different tests for file size + return; } + auto acq_state = acq::default_acquisition_state(); + acq_state.num_frames = 2; + acq::run(det, acq_state); + auto image_size = acq::get_expected_image_size(det); + checks::check_binary_file_size(image_size, acq_state.num_frames); } void test_ctb_file_size_with_acquire(Detector &det, int64_t num_frames, const acq::CTBState &test_info, bool isXilinxCtb) { - - auto f = acq::default_file_state(); - acq::run(det, num_frames, test_info, f); - - // check file size (assuming local pc) - uint64_t expected_image_size = - calculate_ctb_image_size(test_info, isXilinxCtb).first; - REQUIRE_NOTHROW( - test_acquire_binary_file_size(f, num_frames, expected_image_size)); + auto acq_state = acq::default_acquisition_state(); + acq_state.num_frames = num_frames; + acq::run(det, acq_state); + auto image_size = acq::get_expected_image_size(det, test_info); + checks::check_binary_file_size(image_size, acq_state.num_frames); } // disable for xilinx_ctb as it requires higher maximum receive buffer size diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp index eeb88b5c4..38fcd5542 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp @@ -231,26 +231,32 @@ TEST_CASE("check_master_file_attributes", "[.detectorintegration][.disable_check_data_file]") { Detector det; + // currently num frame = 1 (default) auto acq_state = acq::default_acquisition_state(); auto file_state = acq::default_file_state(); + // binary => /tmp/sls_test_master_0.json file_state.file_format = defs::BINARY; acq::run(det, acq_state, file_state); - // (/tmp/sls_test_master_0.json) + // get json context std::string fname = acq::get_master_file_name(file_state); auto doc = parse_binary_master_attributes(fname); mf::Checker checker(mf::JsonContext{doc}); - acq::ExpectedState expected_state = acq::build_expected_state(det); + // get expected state of parameters and check against master file + acq::ExpectedState expected_state = + acq::build_expected_state(det, acq_state, file_state); checks::check_metadata(checker, expected_state); #ifdef HDF5C try { + // hdf5 => /tmp/sls_test_master_0.h5 file_state.file_format = defs::HDF5; - acq::run(det, num_frames, file_state); - // (/tmp/sls_test_master_0.h5) + acq::run(det, acq_state, file_state); + // get h5 context std::string fname = acq::get_master_file_name(file_state); mf::Checker checker(mf::H5Context{fname}); - acq::ExpectedState expected_state = acq::build_expected_state(det); + acq::ExpectedState expected_state = + acq::build_expected_state(det, acq_state, file_state); checks::check_metadata(checker, expected_state); } catch (H5::Exception &e) { LOG(logERROR) << "HDF5 error: " << e.getDetailMsg(); diff --git a/slsDetectorSoftware/tests/acquire/CTBState.h b/slsDetectorSoftware/tests/acquire/CTBState.h index 486434537..d30e076f8 100644 --- a/slsDetectorSoftware/tests/acquire/CTBState.h +++ b/slsDetectorSoftware/tests/acquire/CTBState.h @@ -12,10 +12,10 @@ namespace sls::test::acquire { struct CTBState { defs::readoutMode readout_mode; - bool ten_giga; int num_adc_samples; int num_dbit_samples; int num_trans_samples; + bool ten_giga; uint32_t adc_enable_1g; uint32_t adc_enable_10g; int dbit_offset; @@ -25,30 +25,22 @@ struct CTBState { }; inline CTBState default_ctb_state(bool isAltera = false) { - return {defs::ANALOG_AND_DIGITAL, - isAltera ? false : true, - 5000, - 6000, - 288, - 0xFFFFFF00, - 0xFF00FFFF, - 0, - {0, 12, 2, 43}, - false, - 0x3}; + return {defs::ANALOG_AND_DIGITAL, 5000, 6000, 288, + isAltera ? false : true, 0xFFFFFF00, 0xFF00FFFF, 0, + {0, 12, 2, 43}, false, 0x3}; } inline CTBState get_ctb_state(const Detector &det, bool isAltera) { return CTBState{ det.getReadoutMode().tsquash("Inconsistent readout mode"), - isAltera ? det.getTenGiga().tsquash("Inconsisten ten giga enable") - : true, det.getNumberOfAnalogSamples().tsquash( "Inconsistent number of analog samples"), det.getNumberOfDigitalSamples().tsquash( "Inconsistent number of digital samples"), det.getNumberOfTransceiverSamples().tsquash( "Inconsistent number of transceiver samples"), + isAltera ? det.getTenGiga().tsquash("Inconsisten ten giga enable") + : true, isAltera ? det.getADCEnableMask().tsquash("Inconsistent adc enable mask") : 0, @@ -80,10 +72,10 @@ inline void set_ctb_state(Detector &det, const CTBState &s, bool isAltera) { inline void print_ctb_state(const CTBState &s) { LOG(logINFO) << "CTB State:" << "\n Readout Mode: " << ToString(s.readout_mode) - << "\n Ten Giga: " << s.ten_giga << "\n Num ADC Samples: " << s.num_adc_samples << "\n Num DBIT Samples: " << s.num_dbit_samples << "\n Num Trans Samples: " << s.num_trans_samples + << "\n Ten Giga: " << s.ten_giga << "\n ADC Enable 1G: " << ToStringHex(s.adc_enable_1g) << "\n ADC Enable 10G: " << ToStringHex(s.adc_enable_10g) << "\n DBIT Offset: " << s.dbit_offset diff --git a/slsDetectorSoftware/tests/acquire/ExpectedState.cpp b/slsDetectorSoftware/tests/acquire/ExpectedState.cpp index acb9afeb5..6e4a788cb 100644 --- a/slsDetectorSoftware/tests/acquire/ExpectedState.cpp +++ b/slsDetectorSoftware/tests/acquire/ExpectedState.cpp @@ -26,48 +26,6 @@ int get_dynamic_range(const Detector &det) { return det.getDynamicRange().tsquash("Inconsistent dynamic range"); } -int get_image_size(const Detector &det) { - auto det_type = get_detector_type(det); - auto dynamic_range = get_dynamic_range(det); - int bytes_per_pixel = dynamic_range / 8; - int image_size = 0; - detParameters par(det_type); - - switch (det_type) { - case defs::EIGER: { - int num_chips = (par.nChipX / 2); - image_size = par.nChanX * par.nChanY * num_chips * bytes_per_pixel; - } break; - case defs::JUNGFRAU: - case defs::MOENCH: { - auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash( - "inconsistent number of udp interfaces"); - image_size = (par.nChanX * par.nChanY * par.nChipX * par.nChipY * - bytes_per_pixel) / - num_udp_interfaces; - } break; - case defs::MYTHEN3: { - int counter_mask = det.getCounterMask().squash(); - int num_counters = __builtin_popcount(counter_mask); - int num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS; - image_size = num_channels_per_counter * num_counters * par.nChipX * - bytes_per_pixel; - } break; - case defs::GOTTHARD2: { - image_size = par.nChanX * par.nChipX * bytes_per_pixel; - } break; - case defs::CHIPTESTBOARD: - case defs::XILINX_CHIPTESTBOARD: { - acq::CTBState test_info = acq::default_ctb_state(); - image_size = sls::calculate_ctb_image_size( - test_info, (det_type == defs::XILINX_CHIPTESTBOARD)) - .first; - } break; - default: - throw sls::RuntimeError("Unsupported detector type for this test"); - } -} - defs::xy get_port_shape(const Detector &det) { auto det_type = get_detector_type(det); auto portSize = det.getPortSize()[0]; @@ -190,12 +148,13 @@ std::pair get_sub_exptime_and_sub_period(const Detector& det) { return std::make_pair(ns(exptime), ns(sub_period)); } -acq::CommonExpectedState build_common_state(const Detector& det) { +acq::CommonExpectedState build_common_state(const Detector &det, + const acq::CTBState &ctb_state) { acq::CommonExpectedState e; e.det_type = get_detector_type(det); e.timing_mode = det.getTimingMode().tsquash("Inconsistent timing mode"); e.geometry = get_geometry(det); - e.image_size = get_image_size(det); + e.image_size = acq::get_expected_image_size(det, ctb_state); e.port_shape = get_port_shape(det); e.max_frames_per_file = det.getFramesPerFile().tsquash("Inconsistent frames per file"); @@ -311,11 +270,53 @@ namespace sls::test::acquire { ExpectedState build_expected_state(const Detector& det, const AcquisitionState &acq_state, const FileState &file_state, const CTBState &ctb_state) { ExpectedState e; - e.common_state = build_common_state(det); + e.common_state = build_common_state(det, ctb_state); e.file_state = file_state; e.acquisition_state = acq_state; e.detector_specific_state = build_detector_specific_state(det, ctb_state); return e; } +int get_expected_image_size(const Detector &det, const CTBState &ctb_state) { + auto det_type = get_detector_type(det); + auto dynamic_range = get_dynamic_range(det); + int bytes_per_pixel = dynamic_range / 8; + int image_size = 0; + detParameters par(det_type); + + switch (det_type) { + case defs::EIGER: { + int num_chips = (par.nChipX / 2); + image_size = par.nChanX * par.nChanY * num_chips * bytes_per_pixel; + } break; + case defs::JUNGFRAU: + case defs::MOENCH: { + auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash( + "inconsistent number of udp interfaces"); + image_size = (par.nChanX * par.nChanY * par.nChipX * par.nChipY * + bytes_per_pixel) / + num_udp_interfaces; + } break; + case defs::MYTHEN3: { + int counter_mask = det.getCounterMask().squash(); + int num_counters = __builtin_popcount(counter_mask); + int num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS; + image_size = num_channels_per_counter * num_counters * par.nChipX * + bytes_per_pixel; + } break; + case defs::GOTTHARD2: { + image_size = par.nChanX * par.nChipX * bytes_per_pixel; + } break; + case defs::CHIPTESTBOARD: + image_size = sls::calculate_ctb_image_size(ctb_state, false).first; + break; + case defs::XILINX_CHIPTESTBOARD: { + image_size = sls::calculate_ctb_image_size(ctb_state, true).first; + } break; + default: + throw sls::RuntimeError("Unsupported detector type for this test"); + } + return image_size; +} + } // namespace sls::test::acquire \ No newline at end of file diff --git a/slsDetectorSoftware/tests/acquire/ExpectedState.h b/slsDetectorSoftware/tests/acquire/ExpectedState.h index 52fb95f55..72bcffeae 100644 --- a/slsDetectorSoftware/tests/acquire/ExpectedState.h +++ b/slsDetectorSoftware/tests/acquire/ExpectedState.h @@ -18,8 +18,8 @@ struct CommonExpectedState { int image_size{}; defs::xy port_shape{}; int max_frames_per_file{}; - int frame_discard_policy{}; - int partial_frames_padding{}; + defs::frameDiscardPolicy frame_discard_policy{}; + bool partial_frames_padding{}; defs::scanParameters scan_parameters{}; uint64_t total_frames{}; uint64_t frames_in_file{}; @@ -106,6 +106,13 @@ const T& get_detector_specific_state(const ExpectedState& expected_state) { return std::get(expected_state.detector_specific_state); } +template bool is_type(const ExpectedState &e) { + return std::holds_alternative(e.detector_specific_state); +} + ExpectedState build_expected_state(const Detector& det, const AcquisitionState &acq_state = default_acquisition_state(), const FileState &file_state = default_file_state(), const CTBState &ctb_state = default_ctb_state()); +int get_expected_image_size(const Detector &det, + const CTBState &ctb_state = default_ctb_state()); + } // namespace sls::test::acquire \ No newline at end of file diff --git a/slsDetectorSoftware/tests/acquire/FileState.h b/slsDetectorSoftware/tests/acquire/FileState.h index 6350596fd..2ba86d3ca 100644 --- a/slsDetectorSoftware/tests/acquire/FileState.h +++ b/slsDetectorSoftware/tests/acquire/FileState.h @@ -58,6 +58,15 @@ get_virtual_file_name(const FileState &s = default_file_state()) { std::to_string(s.file_acq_index) + ".h5"; } +inline std::string +get_first_port_first_file_name(const FileState &s = default_file_state()) { + auto file_prefix = s.file_path + "/" + s.file_prefix + "_" + "_d0_f0_" + + std::to_string(s.file_acq_index); + if (s.file_format == defs::BINARY) + return file_prefix + ".bin"; + return file_prefix + ".h5"; +} + inline void print_file_state(const FileState &s) { LOG(logINFO) << "File State:" << "\n Path: " << s.file_path diff --git a/slsDetectorSoftware/tests/checks/MasterFileChecks.h b/slsDetectorSoftware/tests/checks/MasterFileChecks.h index 163bd7132..6be2ff9b8 100644 --- a/slsDetectorSoftware/tests/checks/MasterFileChecks.h +++ b/slsDetectorSoftware/tests/checks/MasterFileChecks.h @@ -26,813 +26,410 @@ void check_version(CheckerT &checker) { } template -void check_detector_type(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_DETECTOR_TYPE.data(), ToString(expected.common_state.det_type)); +void check_detector_type(CheckerT &checker, const defs::detectorType &value) { + checker.template check( + MasterAttributes::N_DETECTOR_TYPE.data(), ToString(value)); } template -void check_timing_mode(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_TIMING_MODE.data(), ToString(expected.common_state.timing_mode)); +void check_timing_mode(CheckerT &checker, const defs::timingMode &value) { + checker.template check(MasterAttributes::N_TIMING_MODE.data(), + ToString(value)); } template -void check_geometry(CheckerT &checker, const acq::ExpectedState& expected) { +void check_geometry(CheckerT &checker, const defs::xy &value) { checker.template check(MasterAttributes::N_GEOMETRY.data(), expected.common_state.geometry); } template -void check_image_size(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_IMAGE_SIZE.data(), expected.common_state.image_size); +void check_image_size(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_IMAGE_SIZE.data(), value); } template -void check_port_shape(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_PIXELS.data(), expected.common_state.port_shape); +void check_port_shape(CheckerT &checker, const defs::xy &value) { + checker.template check(MasterAttributes::N_PIXELS.data(), value); } template -void check_frames_per_file(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_MAX_FRAMES_PER_FILE.data(), expected.common_state.max_frames_per_file); +void check_frames_per_file(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_MAX_FRAMES_PER_FILE.data(), + value); } template -void check_frame_discard_policy(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_FRAME_DISCARD_POLICY.data(), ToString(expected.common_state.frame_discard_policy)); +void check_frame_discard_policy(CheckerT &checker, + const defs::frameDiscardPolicy &value) { + checker.template check( + MasterAttributes::N_FRAME_DISCARD_POLICY.data(), ToString(value)); } template -void check_partial_frames_padding(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_FRAME_PADDING.data(), expected.common_state.partial_frames_padding); -} - -template -void check_scan_parameters(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_SCAN_PARAMETERS.data(), expected.common_state.scan_parameters); +void check_partial_frames_padding(CheckerT &checker, const bool &value) { + checker.template check(MasterAttributes::N_FRAME_PADDING.data(), + static_cast(value)); } template -void check_total_frames(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_TOTAL_FRAMES.data(), expected.common_state.total_frames); +void check_scan_parameters(CheckerT &checker, + const defs::scanParameters &value) { + checker.template check( + MasterAttributes::N_SCAN_PARAMETERS.data(), value); } template -void check_frames_in_file(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_FRAMES_IN_FILE.data(), expected.common_state.frames_in_file); +void check_total_frames(CheckerT &checker, const uint64_t &value) { + checker.template check(MasterAttributes::N_TOTAL_FRAMES.data(), + value); } template -void check_additional_json_header(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_ADDITIONAL_JSON_HEADER.data(), expected.common_state.additional_json_header); +void check_frames_in_file(CheckerT &checker, const uint64_t &value) { + checker.template check(MasterAttributes::N_FRAMES_IN_FILE.data(), + value); } template -void check_rois(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_RECEIVER_ROIS.data(), expected.detector_specific_state.rois); +void check_additional_json_header( + CheckerT &checker, const std::map &value) { + checker.template check>( + MasterAttributes::N_ADDITIONAL_JSON_HEADER.data(), value); } template -void check_exptime(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_EXPOSURE_TIME.data(), ToString(expected.detector_specific_state.exptime)); +void check_rois(CheckerT &checker, const std::vector &value) { + checker.template check>( + MasterAttributes::N_RECEIVER_ROIS.data(), value); } template -void check_period(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_ACQUISITION_PERIOD.data(), ToString(expected.detector_specific_state.period)); +void check_exptime(CheckerT &checker, const ns &value) { + checker.template check( + MasterAttributes::N_EXPOSURE_TIME.data(), ToString(value)); } template -void check_num_udp_interfaces(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_NUM_UDP_INTERFACES.data(), expected.detector_specific_state.num_udp_interfaces); +void check_period(CheckerT &checker, const ns &value) { + checker.template check( + MasterAttributes::N_ACQUISITION_PERIOD.data(), ToString(value)); } template -void check_read_n_rows(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_NUMBER_OF_ROWS.data(), expected.detector_specific_state.read_n_rows); +void check_num_udp_interfaces(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_NUM_UDP_INTERFACES.data(), + value); } template -void check_readout_speed(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_READOUT_SPEED.data(), ToString(expected.detector_specific_state.readout_speed)); +void check_read_n_rows(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_NUMBER_OF_ROWS.data(), + value); } template -void check_dynamic_range(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_DYNAMIC_RANGE.data(), expected.detector_specific_state.dynamic_range); +void check_readout_speed(CheckerT &checker, const defs::speedLevel &value) { + checker.template check( + MasterAttributes::N_READOUT_SPEED.data(), ToString(value)); } template -void check_ten_giga(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_TEN_GIGA.data(), static_cast(expected.detector_specific_state.ten_giga)); +void check_dynamic_range(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_DYNAMIC_RANGE.data(), + value); } template -void check_threshold_energy(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_THRESHOLD_ENERGY.data(), expected.detector_specific_state.threshold_energy); +void check_ten_giga(CheckerT &checker, const bool &value) { + checker.template check(MasterAttributes::N_TEN_GIGA.data(), + static_cast(value)); } template -void check_sub_exptime(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_SUB_EXPOSURE_TIME.data(), ToString(expected.detector_specific_state.sub_exptime)); +void check_threshold_energy(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_THRESHOLD_ENERGY.data(), + value); } template -void check_sub_period(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_SUB_ACQUISITION_PERIOD.data(), ToString(expected.detector_specific_state.sub_period)); +void check_sub_exptime(CheckerT &checker, const ns &value) { + checker.template check( + MasterAttributes::N_SUB_EXPOSURE_TIME.data(), ToString(value)); } template -void check_quad(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_QUAD.data(), static_cast(expected.detector_specific_state.quad)); +void check_sub_period(CheckerT &checker, const ns &value) { + checker.template check( + MasterAttributes::N_SUB_ACQUISITION_PERIOD.data(), ToString(value)); } template -void check_rate_corrections(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_RATE_CORRECTIONS.data(), expected.detector_specific_state.rate_corrections); +void check_quad(CheckerT &checker, const bool &value) { + checker.template check(MasterAttributes::N_QUAD.data(), + static_cast(value)); } template -void check_counter_mask(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_COUNTER_MASK.data(), expected.detector_specific_state.counter_mask); +void check_rate_corrections(CheckerT &checker, + const std::vector &value) { + checker.template check>( + MasterAttributes::N_RATE_CORRECTIONS.data(), value); } template -void check_exptime_array(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_EXPOSURE_TIMES.data(), expected.detector_specific_state.exp_times); +void check_counter_mask(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_COUNTER_MASK.data(), value); } template -void check_gate_delay_array(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_GATE_DELAYS.data(), expected.detector_specific_state.gate_delays); +void check_exptime_array(CheckerT &checker, + const std::array &value) { + checker.template check>( + MasterAttributes::N_EXPOSURE_TIMES.data(), value); } template -void check_gates(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_GATES.data(), expected.detector_specific_state.num_gates); +void check_gate_delay_array(CheckerT &checker, + const std::array &value) { + checker.template check>( + MasterAttributes::N_GATE_DELAYS.data(), value); } template -void check_threshold_energies(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check>(MasterAttributes::N_THRESHOLD_ENERGIES.data(), expected.detector_specific_state.thresholdAllEnergyeV); +void check_gates(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_GATES.data(), value); } template -void check_burst_mode(CheckerT &checker, const acq::ExpectedState& expected) { - checker.template check(MasterAttributes::N_BURST_MODE.data(), ToString(expected.detector_specific_state.burst_mode)); -} -/* - -template -void test_master_file_adc_mask(const Detector &det, CheckerT &checker) { - acq::CTBState test_ctb_config = acq::default_ctb_state(); - auto adc_mask = test_ctb_config.adc_enable_10g; - auto det_type = det.getDetectorType().squash(); - if (det_type == defs::CHIPTESTBOARD) { - auto tengiga = test_ctb_config.ten_giga; - if (!tengiga) - adc_mask = test_ctb_config.adc_enable_1g; - } - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_ADC_MASK.data(), adc_mask)); +void check_threshold_energies(CheckerT &checker, + const std::array &value) { + checker.template check>( + MasterAttributes::N_THRESHOLD_ENERGIES.data(), value); } template -void test_master_file_analog_flag(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto romode = test_info.readout_mode; +void check_burst_mode(CheckerT &checker, const defs::burstMode &value) { + checker.template check(MasterAttributes::N_BURST_MODE.data(), + ToString(value)); +} + +template +void check_readout_mode(CheckerT &checker, const defs::readoutMode &value) { auto analog = static_cast( - (romode == defs::ANALOG_ONLY || romode == defs::ANALOG_AND_DIGITAL)); + (value == defs::ANALOG_ONLY || value == defs::ANALOG_AND_DIGITAL)); + auto digital = static_cast(value == defs::DIGITAL_ONLY || + value == defs::ANALOG_AND_DIGITAL || + value == defs::DIGITAL_AND_TRANSCEIVER); + auto trans = static_cast(value == defs::DIGITAL_AND_TRANSCEIVER || + value == defs::TRANSCEIVER_ONLY); - REQUIRE_NOTHROW( - checker.template check(MasterAttributes::N_ANALOG.data(), analog)); + if (analog) + checker.template check(MasterAttributes::N_ANALOG.data(), + analog); + if (digital) + checker.template check(MasterAttributes::N_DIGITAL.data(), + digital); + if (trans) + checker.template check( + MasterAttributes::N_TRANSCEIVER.data(), trans); } template -void test_master_file_analog_samples(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto analog_samples = test_info.num_adc_samples; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_ANALOG_SAMPLES.data(), analog_samples)); +void check_analog_samples(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_ANALOG_SAMPLES.data(), + value); } template -void test_master_file_digital_flag(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto romode = test_info.readout_mode; - auto digital = static_cast(romode == defs::DIGITAL_ONLY || - romode == defs::ANALOG_AND_DIGITAL || - romode == defs::DIGITAL_AND_TRANSCEIVER); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DIGITAL.data(), digital)); +void check_digital_samples(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_DIGITAL_SAMPLES.data(), + value); } template -void test_master_file_digital_samples(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto digital_samples = test_info.num_dbit_samples; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DIGITAL_SAMPLES.data(), digital_samples)); +void check_transceiver_samples(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_TRANSCEIVER_SAMPLES.data(), + value); } template -void test_master_file_dbit_offset(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto dbit_offset = test_info.dbit_offset; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DBIT_OFFSET.data(), dbit_offset)); +void check_adc_mask(CheckerT &checker, const uint32_t &value) { + checker.template check(MasterAttributes::N_ADC_MASK.data(), + value); } template -void test_master_file_dbit_reorder(const Detector &det, CheckerT &checker) { - acq::CTBState test_info - -template -void test_master_file_timing_mode(const Detector &det, CheckerT &checker) { - auto timing_mode = det.getTimingMode().tsquash("Inconsistent timing mode"); - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TIMING_MODE.data(), ToString(timing_mode))); +void check_dbit_offset(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_DBIT_OFFSET.data(), value); } template -void test_master_file_geometry(const Detector &det, CheckerT &checker) { - auto modGeometry = det.getModuleGeometry(); - auto portperModGeometry = det.getPortPerModuleGeometry(); - auto geometry = defs::xy{modGeometry.x * portperModGeometry.x, - modGeometry.y * portperModGeometry.y}; - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_GEOMETRY.data(), geometry)); -} - -template -void test_master_file_image_size(const Detector &det, CheckerT &checker) { - - auto det_type = - det.getDetectorType().tsquash("Inconsistent detector types to test"); - int bytes_per_pixel = det.getDynamicRange().squash() / 8; - detParameters par(det_type); - - int image_size = 0; - switch (det_type) { - - case defs::EIGER: { - int num_chips = (par.nChipX / 2); - image_size = par.nChanX * par.nChanY * num_chips * bytes_per_pixel; - } break; - - case defs::JUNGFRAU: - case defs::MOENCH: { - auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash( - "inconsistent number of udp interfaces"); - image_size = (par.nChanX * par.nChanY * par.nChipX * par.nChipY * - bytes_per_pixel) / - num_udp_interfaces; - } break; - - case defs::MYTHEN3: { - int counter_mask = det.getCounterMask().squash(); - int num_counters = __builtin_popcount(counter_mask); - int num_channels_per_counter = par.nChanX / MAX_NUM_COUNTERS; - image_size = num_channels_per_counter * num_counters * par.nChipX * - bytes_per_pixel; - } break; - - case defs::GOTTHARD2: { - image_size = par.nChanX * par.nChipX * bytes_per_pixel; - } break; - - case defs::CHIPTESTBOARD: - case defs::XILINX_CHIPTESTBOARD: { - acq::CTBState test_info = acq::default_ctb_state(); - image_size = calculate_ctb_image_size( - test_info, (det_type == defs::XILINX_CHIPTESTBOARD)) - .first; - } break; - - default: - throw sls::RuntimeError("Unsupported detector type for this test"); - } - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_IMAGE_SIZE.data(), image_size)); -} - -template -void test_master_file_det_size(const Detector &det, CheckerT &checker) { - - auto det_type = - det.getDetectorType().tsquash("Inconsistent detector types to test"); - auto portSize = det.getPortSize()[0]; - - // m3 assumes all counters enabled when getting num channels from client - // TODO: in future, remove assumption - if (det_type == defs::MYTHEN3) { - int nchan = portSize.x / MAX_NUM_COUNTERS; - auto counter_mask = det.getCounterMask().tsquash( - "Inconsistent counter mask for Mythen3 detector"); - int num_counters = __builtin_popcount(counter_mask); - portSize.x = nchan * num_counters; - } else if (det_type == defs::CHIPTESTBOARD || - det_type == defs::XILINX_CHIPTESTBOARD) { - acq::CTBState test_info = acq::default_ctb_state(); - portSize.x = calculate_ctb_image_size( - test_info, det_type == defs::XILINX_CHIPTESTBOARD) - .second; - portSize.y = 1; - } - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_PIXELS.data(), portSize)); -} - -template -void test_master_file_max_frames_per_file(const Detector &det, - CheckerT &checker) { - auto max_frames_per_file = - det.getFramesPerFile().tsquash("Inconsistent max frames per file"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_MAX_FRAMES_PER_FILE.data(), max_frames_per_file)); -} - -template -void test_master_file_frame_discard_policy(const Detector &det, - CheckerT &checker) { - auto policy = det.getRxFrameDiscardPolicy().tsquash( - "Inconsistent frame discard policy"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_FRAME_DISCARD_POLICY.data(), ToString(policy))); -} - -template -void test_master_file_frame_padding(const Detector &det, CheckerT &checker) { - auto padding = static_cast( - det.getPartialFramesPadding().tsquash("Inconsistent frame padding")); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_FRAME_PADDING.data(), padding)); -} - -template -void test_master_file_scan_parameters(const Detector &det, CheckerT &checker) { - auto scan_params = det.getScan().tsquash("Inconsistent scan parameters"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_SCAN_PARAMETERS.data(), scan_params)); -} - -template -void test_master_file_total_frames(const Detector &det, CheckerT &checker) { - uint64_t repeats = - det.getNumberOfTriggers().tsquash("Inconsistent number of triggers"); - uint64_t numFrames = - det.getNumberOfFrames().tsquash("Inconsistent number of frames"); - int numAdditionalStorageCells = 0; - auto det_type = - det.getDetectorType().tsquash("Inconsistent detector types"); - if (det_type == defs::GOTTHARD2) { - auto timing_mode = - det.getTimingMode().tsquash("Inconsistent timing mode"); - auto burst_mode = det.getBurstMode().tsquash("Inconsistent burst mode"); - auto numBursts = - det.getNumberOfBursts().tsquash("Inconsistent number of bursts"); - if (timing_mode == defs::AUTO_TIMING) { - // burst mode, repeats = #bursts - if (burst_mode == defs::BURST_INTERNAL || - burst_mode == defs::BURST_EXTERNAL) { - repeats = numBursts; - } - // continuous, repeats = 1 (no trigger as well) - else { - repeats = 1; - } - } else { - // trigger - // continuous, numFrames is limited - if (burst_mode == defs::CONTINUOUS_INTERNAL || - burst_mode == defs::CONTINUOUS_EXTERNAL) { - numFrames = 1; - } - } - } else if (det_type == defs::JUNGFRAU) { - numAdditionalStorageCells = - det.getNumberOfAdditionalStorageCells().tsquash( - "Inconsistent number of additional storage cells"); - } - uint64_t total_frames = - numFrames * repeats * (int64_t)(numAdditionalStorageCells + 1); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TOTAL_FRAMES.data(), total_frames)); -} - -template -void test_master_file_rois(const Detector &det, CheckerT &checker) { - auto rois = det.getRxROI(); - auto detsize = det.getDetectorSize(); - auto det_type = - det.getDetectorType().tsquash("Inconsistent detector types to test"); - // compensate for m3 channel size and counter mask mess - if (det_type == defs::MYTHEN3) { - int nchan = detsize.x / MAX_NUM_COUNTERS; - auto counter_mask = det.getCounterMask().tsquash( - "Inconsistent counter mask for Mythen3 detector"); - int num_counters = __builtin_popcount(counter_mask); - detsize.x = nchan * num_counters; - } - // replace -1 for complete ROI - bool is2D = (detsize.y > 1); - for (auto &roi : rois) { - if (roi.completeRoi()) { - roi.xmin = 0; - roi.xmax = detsize.x - 1; - if (is2D) { - roi.ymin = 0; - roi.ymax = detsize.y - 1; - } - } - } - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_RECEIVER_ROIS.data(), rois)); -} - -template -void test_master_file_exptime(const Detector &det, CheckerT &checker) { - auto exptime = det.getExptime().tsquash("Inconsistent exposure time"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_EXPOSURE_TIME.data(), ToString(exptime))); -} - -template -void test_master_file_period(const Detector &det, CheckerT &checker) { - auto period = det.getPeriod().tsquash("Inconsistent period"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_ACQUISITION_PERIOD.data(), ToString(period))); -} - -template -void test_master_file_num_udp_interfaces(const Detector &det, - CheckerT &checker) { - auto num_udp_interfaces = det.getNumberofUDPInterfaces().tsquash( - "Inconsistent number of UDP interfaces"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_NUM_UDP_INTERFACES.data(), num_udp_interfaces)); -} - -template -void test_master_file_read_n_rows(const Detector &det, CheckerT &checker) { - auto readnrows = det.getReadNRows().tsquash("Inconsistent number of rows"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_NUMBER_OF_ROWS.data(), readnrows)); -} - -template -void test_master_file_readout_speed(const Detector &det, CheckerT &checker) { - auto readout_speed = - det.getReadoutSpeed().tsquash("Inconsistent readout speed"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_READOUT_SPEED.data(), ToString(readout_speed))); -} - -template -void test_master_file_frames_in_file(CheckerT &checker, - const int frames_in_file) { - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_FRAMES_IN_FILE.data(), frames_in_file)); -} - -template -void test_master_file_json_header(const Detector &det, CheckerT &checker) { - auto json_header = - det.getAdditionalJsonHeader().tsquash("Inconsistent JSON header"); - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_ADDITIONAL_JSON_HEADER.data(), json_header)); -} - -template -void test_master_file_dynamic_range(const Detector &det, CheckerT &checker) { - auto dr = det.getDynamicRange().tsquash("Inconsistent dynamic range"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DYNAMIC_RANGE.data(), dr)); -} - -template -void test_master_file_ten_giga(const Detector &det, CheckerT &checker) { - auto ten_giga = - static_cast(det.getTenGiga().tsquash("Inconsistent ten giga")); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TEN_GIGA.data(), ten_giga)); -} - -template -void test_master_file_threshold_energy(const Detector &det, CheckerT &checker) { - auto threshold = - det.getThresholdEnergy().tsquash("Inconsistent threshold energy"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_THRESHOLD_ENERGY.data(), threshold)); -} - -template -void test_master_file_sub_exptime(const Detector &det, CheckerT &checker) { - auto sub_exptime = - det.getSubExptime().tsquash("Inconsistent sub exposure time"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_SUB_EXPOSURE_TIME.data(), ToString(sub_exptime))); -} - -template -void test_master_file_sub_period(const Detector &det, CheckerT &checker) { - auto exptime = det.getSubExptime().tsquash("Inconsistent sub exptime"); - auto deadtime = det.getSubDeadTime().tsquash("Inconsistent sub deadtime"); - auto sub_period = exptime + deadtime; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_SUB_ACQUISITION_PERIOD.data(), - ToString(sub_period))); -} - -template -void test_master_file_quad(const Detector &det, CheckerT &checker) { - auto quad = static_cast(det.getQuad().tsquash("Inconsistent quad")); - - REQUIRE_NOTHROW( - checker.template check(MasterAttributes::N_QUAD.data(), quad)); -} - -template -void test_master_file_rate_corrections(const Detector &det, CheckerT &checker) { - std::vector dead_times; - for (auto item : det.getRateCorrection()) - dead_times.push_back(item.count()); - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_RATE_CORRECTIONS.data(), dead_times)); -} - -template -void test_master_file_counter_mask(const Detector &det, CheckerT &checker) { - auto counter_mask = static_cast( - det.getCounterMask().tsquash("Inconsistent counter mask")); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_COUNTER_MASK.data(), counter_mask)); -} - -template -void test_master_file_exptimes(const Detector &det, CheckerT &checker) { - auto exptimes = - det.getExptimeForAllGates().tsquash("Inconsistent exposure times"); - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_EXPOSURE_TIMES.data(), exptimes)); -} - -template -void test_master_file_gate_delays(const Detector &det, CheckerT &checker) { - auto gate_delays = - det.getGateDelayForAllGates().tsquash("Inconsistent GateDelay"); - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_GATE_DELAYS.data(), gate_delays)); -} - -template -void test_master_file_gates(const Detector &det, CheckerT &checker) { - auto gates = det.getNumberOfGates().tsquash("Inconsistent number of gates"); - - REQUIRE_NOTHROW( - checker.template check(MasterAttributes::N_GATES.data(), gates)); -} - -template -void test_master_file_threadhold_energies(const Detector &det, - CheckerT &checker) { - auto threshold_energies = - det.getAllThresholdEnergy().tsquash("Inconsistent threshold energies"); - - REQUIRE_NOTHROW(checker.template check>( - MasterAttributes::N_THRESHOLD_ENERGIES.data(), threshold_energies)); -} - -template -void test_master_file_burst_mode(const Detector &det, CheckerT &checker) { - auto burst_mode = det.getBurstMode().tsquash("Inconsistent burst mode"); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_BURST_MODE.data(), ToString(burst_mode))); -} - -template -void test_master_file_adc_mask(const Detector &det, CheckerT &checker) { - acq::CTBState test_ctb_config = acq::default_ctb_state(); - auto adc_mask = test_ctb_config.adc_enable_10g; - auto det_type = det.getDetectorType().squash(); - if (det_type == defs::CHIPTESTBOARD) { - auto tengiga = test_ctb_config.ten_giga; - if (!tengiga) - adc_mask = test_ctb_config.adc_enable_1g; - } - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_ADC_MASK.data(), adc_mask)); -} - -template -void test_master_file_analog_flag(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto romode = test_info.readout_mode; - auto analog = static_cast( - (romode == defs::ANALOG_ONLY || romode == defs::ANALOG_AND_DIGITAL)); - - REQUIRE_NOTHROW( - checker.template check(MasterAttributes::N_ANALOG.data(), analog)); -} - -template -void test_master_file_analog_samples(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto analog_samples = test_info.num_adc_samples; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_ANALOG_SAMPLES.data(), analog_samples)); -} - -template -void test_master_file_digital_flag(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto romode = test_info.readout_mode; - auto digital = static_cast(romode == defs::DIGITAL_ONLY || - romode == defs::ANALOG_AND_DIGITAL || - romode == defs::DIGITAL_AND_TRANSCEIVER); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DIGITAL.data(), digital)); -} - -template -void test_master_file_digital_samples(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto digital_samples = test_info.num_dbit_samples; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DIGITAL_SAMPLES.data(), digital_samples)); -} - -template -void test_master_file_dbit_offset(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto dbit_offset = test_info.dbit_offset; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DBIT_OFFSET.data(), dbit_offset)); -} - -template -void test_master_file_dbit_reorder(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto dbit_reorder = test_info.dbit_reorder; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DBIT_REORDER.data(), dbit_reorder)); -} - -template -void test_master_file_dbit_bitset(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); +void check_dbit_list(CheckerT &checker, const std::vector &value) { uint64_t dbit_bitset = 0; - for (auto &i : test_info.dbit_list) { + for (auto &i : value) { dbit_bitset |= (static_cast(1) << i); } - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_DBIT_BITSET.data(), dbit_bitset)); + checker.template check(MasterAttributes::N_DBIT_LIST.data(), + dbit_bitset); } template -void test_master_file_transceiver_mask(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto trans_mask = test_info.transceiver_mask; - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TRANSCEIVER_MASK.data(), trans_mask)); +void check_dbit_reorder(CheckerT &checker, const int &value) { + checker.template check(MasterAttributes::N_DBIT_REORDER.data(), value); } template -void test_master_file_transceiver_flag(const Detector &det, CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto romode = test_info.readout_mode; - auto trans = static_cast(romode == defs::DIGITAL_AND_TRANSCEIVER || - romode == defs::TRANSCEIVER_ONLY); - - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TRANSCEIVER.data(), trans)); +void check_metadata(CheckerT &checker, const acq::ExpectedState &expected) { + switch (expected.common_state.det_type) { + case defs::JUNGFRAU: + check_jungfrau_metadata(checker, expected); + break; + case defs::MOENCH: + check_moench_metadata(checker, expected); + break; + case defs::EIGER: + check_eiger_metadata(checker, expected); + break; + case defs::MYTHEN3: + check_mythen3_metadata(checker, expected); + break; + case defs::GOTTHARD2: + check_gotthard2_metadata(checker, expected); + break; + case defs::CHIPTESTBOARD: + check_ctb_metadata(checker, expected); + break; + default: + throw std::runtime_error( + "Unsupported detector type for metadata checks"); + } } -template -void test_master_file_transceiver_samples(const Detector &det, - CheckerT &checker) { - acq::CTBState test_info = acq::default_ctb_state(); - auto trans_samples = test_info.num_trans_samples; - REQUIRE_NOTHROW(checker.template check( - MasterAttributes::N_TRANSCEIVER_SAMPLES.data(), trans_samples)); -} - -*/ - -template -void check_metadata(CheckerT &checker, const acq::ExpectedState& expected); - template void check_common_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_version(checker, expected); - check_detector_type(checker, expected); - check_geometry(checker, expected); - check_image_size(checker, expected); - check_port_shape(checker, expected); - check_frames_per_file(checker, expected); - check_frame_discard_policy(checker, expected); - check_partial_frames_padding(checker, expected); - check_scan_parameters(checker, expected); - check_total_frames(checker, expected); - check_frames_in_file(checker, expected); - check_additional_json_header(checker, expected); + check_version(checker); + auto st = expected.common_state; + check_detector_type(checker, st.det_type); + check_geometry(checker, st.geometry); + check_image_size(checker, st.image_size); + check_port_shape(checker, st.port_shape); + check_frames_per_file(checker, st.max_frames_per_file); + check_frame_discard_policy(checker, st.frame_discard_policy); + check_partial_frames_padding(checker, st.partial_frames_padding); + check_scan_parameters(checker, st.scan_parameters); + check_total_frames(checker, st.total_frames); + check_frames_in_file(checker, st.frames_in_file); + check_additional_json_header(checker, st.additional_json_header); } template void check_jungfrau_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_rois(checker, expected); - check_exptime(checker, expected); - check_period(checker, expected); - check_num_udp_interfaces(checker, expected); - check_read_n_rows(checker, expected); - check_readout_speed(checker, expected); + const auto &st = + std::get(expected.detector_specific_state); + check_rois(checker, st.rois); + check_exptime(checker, st.exptime); + check_period(checker, st.period); + check_num_udp_interfaces(checker, st.num_udp_interfaces); + check_read_n_rows(checker, st.read_n_rows); + check_readout_speed(checker, st.readout_speed); } template void check_moench_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_rois(checker, expected); - check_exptime(checker, expected); - check_period(checker, expected); - check_num_udp_interfaces(checker, expected); - check_read_n_rows(checker, expected); - check_readout_speed(checker, expected); + const auto &st = + std::get(expected.detector_specific_state); + check_rois(checker, st.rois); + check_exptime(checker, st.exptime); + check_period(checker, st.period); + check_num_udp_interfaces(checker, st.num_udp_interfaces); + check_read_n_rows(checker, st.read_n_rows); + check_readout_speed(checker, st.readout_speed); } template void check_eiger_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_rois(checker, expected); - check_dynamic_range(checker, expected); - check_ten_giga(checker, expected); - check_exptime(checker, expected); - check_period(checker, expected); - check_threshold_energy(checker, expected); - check_sub_exptime(checker, expected); - check_sub_period(checker, expected); - check_quad(checker, expected); - check_read_n_rows(checker, expected); - check_rate_corrections(checker, expected); - check_readout_speed(checker, expected); + const auto &st = + std::get(expected.detector_specific_state); + check_rois(checker, st.rois); + check_dynamic_range(checker, st.dynamic_range); + check_ten_giga(checker, st.ten_giga); + check_exptime(checker, st.exptime); + check_period(checker, st.period); + check_threshold_energy(checker, st.threshold_energy); + check_sub_exptime(checker, st.sub_exptime); + check_sub_period(checker, st.sub_period); + check_quad(checker, st.quad); + check_read_n_rows(checker, st.read_n_rows); + check_rate_corrections(checker, st.rate_corrections); + check_readout_speed(checker, st.readout_speed); } template void check_mythen3_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_rois(checker, expected); - check_dynamic_range(checker, expected); - check_ten_giga(checker, expected); - check_period(checker, expected); - check_counter_mask(checker, expected); - check_exptime_array(checker, expected); - check_gate_delay_array(checker, expected); - check_gates(checker, expected); - check_threshold_energies(checker, expected); - check_readout_speed(checker, expected); + const auto &st = + std::get(expected.detector_specific_state); + check_rois(checker, st.rois); + check_dynamic_range(checker, st.dynamic_range); + check_ten_giga(checker, st.ten_giga); + check_period(checker, st.period); + check_counter_mask(checker, st.counter_mask); + check_exptime_array(checker, st.exp_times); + check_gate_delay_array(checker, st.gate_delays); + check_gates(checker, st.num_gates); + check_threshold_energies(checker, st.threshold_energies); + check_readout_speed(checker, st.readout_speed); } template void check_gotthard2_metadata(CheckerT &checker, const acq::ExpectedState& expected) { - check_rois(checker, expected); - check_exptime(checker, expected); - check_period(checker, expected); - check_burst_mode(checker, expected); - check_readout_speed(checker, expected); + const auto &st = + std::get(expected.detector_specific_state); + check_rois(checker, st.rois); + check_exptime(checker, st.exptime); + check_period(checker, st.period); + check_burst_mode(checker, st.burst_mode); + check_readout_speed(checker, st.readout_speed); } template -void check_ctb_metadata(CheckerT &checker, const acq::ExpectedState& expected); +void check_ctb_metadata(CheckerT &checker, const acq::ExpectedState &expected) { + const auto &st = + std::get(expected.detector_specific_state); + check_exptime(checker, st.exptime); + check_period(checker, st.period); -} \ No newline at end of file + // 10g for xilinx, 1g/10g for altera ctb + bool ten_giga = true; + if (expected.common_state.det_type == defs::CHIPTESTBOARD) { + check_ten_giga(checker, st.ctb_acq_state.ten_giga); + if (!st.ctb_acq_state.ten_giga) { + ten_giga = false; + } + } + if (ten_giga) + check_adc_mask(checker, st.ctb_acq_state.adc_enable_10g); + else + check_adc_mask(checker, st.ctb_acq_state.adc_enable_1g); + + check_readout_mode(checker, st.ctb_acq_state.readout_mode); + check_analog_samples(checker, st.ctb_acq_state.num_adc_samples); + check_digital_samples(checker, st.ctb_acq_state.num_dbit_samples); + check_transceiver_samples(checker, st.ctb_acq_state.num_trans_samples); + check_dbit_offset(checker, st.ctb_acq_state.dbit_offset); + check_dbit_bitset(checker, st.ctb_acq_state.dbit_list); + check_dbit_reorder(checker, st.ctb_acq_state.dbit_reorder); + check_transceiver_mask(checker, st.ctb_acq_state.transceiver_mask); +} + +void check_binary_file_size( + const int expected_image_size, const int64_t num_frames, + const acq::FileState &st = acq::default_file_state()) { + assert(st.file_format == defs::BINARY); + auto fname = acq::get_first_port_first_file_name(st); + auto expected_file_size = + num_frames * (expected_image_size + sizeof(defs::sls_receiver_header)); + auto actual_file_size = std::filesystem::file_size(fname); + REQUIRE(actual_file_size == expected_file_size); +} + +} // namespace sls::test::checks \ No newline at end of file