mirror of
https://github.com/slsdetectorgroup/slsDetectorPackage.git
synced 2025-05-05 12:20:02 +02:00
added tests to check file size and frames caught with an acquire (virtual) for every detector
This commit is contained in:
parent
adf0124ea3
commit
f09879a46c
@ -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]") {
|
||||
|
||||
@ -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]") {
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
@ -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;
|
||||
|
||||
@ -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]") {
|
||||
|
||||
@ -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]") {
|
||||
|
||||
@ -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]") {
|
||||
|
||||
@ -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
|
||||
@ -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
|
||||
<< " nAnalogDataBytes:" << nAnalogDataBytes
|
||||
<< " ctbDbitOffset:" << ctbDbitOffset
|
||||
<< " nTransceiverDataBytes:" << nTransceiverDataBytes
|
||||
<< " size:" << size;
|
||||
LOG(logINFORED) << "totalNumBytes: " << totalNumBytes
|
||||
<< " nAnalogDataBytes:" << nAnalogDataBytes
|
||||
<< " ctbDbitOffset:" << ctbDbitOffset
|
||||
<< " nTransceiverDataBytes:" << nTransceiverDataBytes
|
||||
<< " size:" << size;
|
||||
}
|
||||
|
||||
void DataProcessor::CropImage(size_t &size, char *data) {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user