MockAcquisitionDeviceTest: the mock against the HLS simulation, and receiver tests on the mock

Equivalence: a scenario runs on HLSSimulatedDevice, what the card wrote is recorded and given
to MockAcquisitionDevice, and the host must see the same - every DeviceOutput byte, the buffer
each module went to (so the order of completions), delays, packet counters - for explicit
packets with incomplete/missing/out-of-order modules and bad packets, FPGA summation with an
incomplete group, EIGER, the internal packet generator and cancel. At receiver level, the
receiver on the HLS simulation and on the mock fed with that run's output give the same image,
status and plots.

Ported to the mock, with the card output given by the test: JFJochReceiverTest_Raw (also with
two devices running at the same time, impossible with the HLS simulation), _EIGER,
_PacketLost_Raw and _PedestalG0.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HVeDQsU5a8AJUdJPgWevAK
This commit is contained in:
leonarski_fandClaude Opus 5.5 committed 2026-11-08 07:53:00 +01:00
1 parent 8e3b0f88da
commit 497073dc9f
2 files changed
+515

No files matched your search

+1
View File
@@ -64,6 +64,7 @@ ADD_EXECUTABLE(jfjoch_test
../common/DiffractionExperiment.h
CheckImageOutput.h
FPGAIntegrationTest.cpp
MockAcquisitionDeviceTest.cpp
StrongPixelSetTest.cpp
AdaptiveThresholdTest.cpp
AdaptiveSpotFinderCPUTest.cpp
+514
View File
@@ -0,0 +1,514 @@
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
// MockAcquisitionDevice against HLSSimulatedDevice: the same scenario runs on the HLS simulation, what the card
// wrote is recorded and given to the mock, and the host must see the same on both - the buffers, which module
// went to which buffer (i.e. the order of completions), counters and, for the receiver, its results.
// Then receiver tests of JFJochReceiverIntegrationTest.cpp, run on the mock.
#include <catch2/catch_all.hpp>
#include <random>
#include "../acquisition_device/HLSSimulatedDevice.h"
#include "../acquisition_device/MockAcquisitionDevice.h"
#include "../image_pusher/TestImagePusher.h"
#include "../jungfrau/JFPedestalCalc.h"
#include "../receiver/JFJochReceiverService.h"
#include "../receiver/JFJochReceiverTest.h"
namespace {
// HLS simulation that can give away everything it wrote to the host - as long as no buffer was used twice
class RecordingHLSDevice : public HLSSimulatedDevice {
public:
using HLSSimulatedDevice::HLSSimulatedDevice;
void CopyOutputs(MockAcquisitionDevice &mock) const {
for (size_t h = 0; h < buffer_device.size(); h++) {
const DeviceOutput *output = GetDeviceOutput(h);
if (output->module_statistics.packet_count > 0)
mock.SetOutput(output->module_statistics.frame_number, output->module_statistics.module_number,
*output);
}
}
};
std::unique_ptr<DeviceOutput> OutputWithPixels(const uint16_t *pixels) {
auto ret = std::make_unique<DeviceOutput>();
memcpy(ret->pixels, pixels, RAW_MODULE_SIZE * sizeof(uint16_t));
return ret;
}
void CompareDevices(const AcquisitionDevice &hls, const AcquisitionDevice &mock, const DiffractionExperiment &x) {
CHECK(hls.GetBytesReceived() == mock.GetBytesReceived());
CHECK(hls.Counters().GetSlowestFrameNumber() == mock.Counters().GetSlowestFrameNumber());
CHECK(hls.Counters().GetFastestFrameNumber() == mock.Counters().GetFastestFrameNumber());
auto stats_hls = hls.GetStatistics();
auto stats_mock = mock.GetStatistics();
CHECK(stats_hls.good_packets == stats_mock.good_packets);
CHECK(stats_hls.packets_expected == stats_mock.packets_expected);
CHECK(stats_hls.packets_received_per_module == stats_mock.packets_received_per_module);
int64_t frames = x.GetFrameNum() / x.GetFPGASummation();
for (int64_t f = 0; f < frames; f++) {
for (int m = 0; m < x.GetModulesNum(); m++) {
INFO("frame " << f << " module " << m);
auto handle = hls.Counters().GetBufferHandle(f, m);
// The same buffer means the same order of completions
CHECK(handle == mock.Counters().GetBufferHandle(f, m));
CHECK(hls.Counters().CalculateDelay(f, m) == mock.Counters().CalculateDelay(f, m));
CHECK(hls.Counters().IsFullModuleCollected(f, m) == mock.Counters().IsFullModuleCollected(f, m));
if (handle != AcquisitionCounters::HandleNotFound)
CHECK(memcmp(hls.GetDeviceOutput(f, m), mock.GetDeviceOutput(f, m), sizeof(DeviceOutput)) == 0);
}
}
}
// Runs the same packets on both devices, the mock with what the HLS simulation wrote
template<class Packets>
void CompareOnPackets(const DiffractionExperiment &x, Packets packets) {
RecordingHLSDevice hls(0, 64);
packets(hls);
REQUIRE_NOTHROW(hls.StartAction(x));
REQUIRE_NOTHROW(hls.WaitForActionComplete());
REQUIRE(hls.GetBytesReceived() > 0);
MockAcquisitionDevice mock(0, 64);
hls.CopyOutputs(mock);
packets(mock);
REQUIRE_NOTHROW(mock.StartAction(x));
REQUIRE_NOTHROW(mock.WaitForActionComplete());
CompareDevices(hls, mock, x);
}
}
TEST_CASE("MockAcquisitionDevice_SameAsHLS_Packets", "[MockAcquisitionDevice][HLS]") {
const uint16_t nmodules = 4;
DiffractionExperiment x(DetJF(nmodules));
x.Raw();
x.PedestalG0Frames(0).ImagesPerTrigger(3).NumTriggers(1);
std::vector<uint16_t> module(RAW_MODULE_SIZE);
for (int i = 0; i < RAW_MODULE_SIZE; i++)
module[i] = (7 * i + 534 + 5 * i * i) % UINT16_MAX;
CompareOnPackets(x, [&](auto &d) {
// Frame 1: module 0 incomplete, both halves; module 1 missing; modules 2 and 3 complete
d.CreateJFPacket(x, 1, 0, 0, module.data());
d.CreateJFPacket(x, 1, 64, 0, module.data());
d.CreateJFPackets(x, 1, 1, 2, module.data());
d.CreateJFPackets(x, 1, 1, 3, module.data());
// Frame 3 before frame 2 for module 0; one packet with a wrong length, one with an Ethernet error
d.CreateJFPacket(x, 3, 5, 0, module.data());
d.CreateJFPacket(x, 2, 6, 0, module.data());
d.CreateJFPacket(x, 2, 7, 0, module.data(), -1);
d.CreateJFPacket(x, 2, 8, 0, module.data(), 0, 1);
d.CreateJFPackets(x, 2, 1, 1, module.data());
d.CreateJFPackets(x, 3, 1, 3, module.data());
// A frame after the last one
d.CreateJFPacket(x, 4, 1, 2, module.data());
d.CreateFinalPacket(x);
});
}
TEST_CASE("MockAcquisitionDevice_SameAsHLS_Summation", "[MockAcquisitionDevice][HLS]") {
const uint16_t nmodules = 2;
DiffractionExperiment x(DetJF(nmodules));
x.PedestalG0Frames(0).ImagesPerTrigger(3).NumTriggers(1).Summation(2)
.JungfrauConvPhotonCnt(false).PixelSigned(true).BitDepthImage(32);
REQUIRE(x.GetFPGASummation() == 2);
std::vector<uint16_t> module(RAW_MODULE_SIZE);
std::mt19937 g(1387);
std::uniform_int_distribution<uint16_t> dist(0, UINT16_MAX);
for (auto &i: module)
i = dist(g);
CompareOnPackets(x, [&](auto &d) {
for (int f = 1; f <= 6; f++) {
d.CreateJFPackets(x, f, 1, 0, module.data());
// Second frame of the second image is missing for module 1, so the whole image is dropped
if (f != 4)
d.CreateJFPackets(x, f, 1, 1, module.data());
}
d.CreateFinalPacket(x);
});
}
TEST_CASE("MockAcquisitionDevice_SameAsHLS_EIGER", "[MockAcquisitionDevice][HLS]") {
DiffractionExperiment x(DetEIGER(1));
x.Raw();
x.PedestalG0Frames(0).ImagesPerTrigger(1).NumTriggers(1);
std::vector<uint16_t> module(RAW_MODULE_SIZE);
for (int i = 0; i < RAW_MODULE_SIZE; i++)
module[i] = i % (UINT16_MAX - 11);
CompareOnPackets(x, [&](auto &d) {
for (int row = 0; row < 2; row++) {
for (int col = 0; col < 2; col++) {
for (int i = 0; i < 64; i++) {
if ((i != 10) || (col != row))
d.CreateEIGERPacket(x, 1, i, 0, col, row, module.data() + 2048 * (128 * row + col + 2 * i));
}
}
}
d.CreateFinalPacket(x);
});
}
TEST_CASE("MockAcquisitionDevice_SameAsHLS_InternalGenerator", "[MockAcquisitionDevice][HLS]") {
const uint16_t nmodules = 2;
DiffractionExperiment x(DetJF(nmodules));
x.Raw();
x.UseInternalPacketGenerator(true).ImagesPerTrigger(3).PedestalG0Frames(0);
CompareOnPackets(x, [&](auto &d) {});
}
TEST_CASE("MockAcquisitionDevice_SameAsHLS_Cancel", "[MockAcquisitionDevice][HLS]") {
DiffractionExperiment x(DetJF(4));
x.Raw();
x.PedestalG0Frames(0).ImagesPerTrigger(5).NumTriggers(1);
HLSSimulatedDevice hls(0, 64);
MockAcquisitionDevice mock(0, 64);
for (AcquisitionDevice *d: {static_cast<AcquisitionDevice *>(&hls), static_cast<AcquisitionDevice *>(&mock)}) {
REQUIRE_NOTHROW(d->StartAction(x));
d->Cancel();
REQUIRE_NOTHROW(d->WaitForActionComplete());
CHECK(d->Counters().GetSlowestFrameNumber() == 0);
CHECK(d->GetBytesReceived() == 0);
}
}
// The receiver on the HLS simulation, and on the mock with what the HLS simulation wrote during that run
TEST_CASE("MockAcquisitionDevice_SameAsHLS_Receiver", "[MockAcquisitionDevice][HLS]") {
const uint16_t nmodules = 2;
DiffractionExperiment x(DetJF(nmodules));
x.Conversion();
x.PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true).ImagesPerTrigger(4)
.IncidentEnergy_keV(12.4).DetectorDistance_mm(75).BeamX_pxl(500).BeamY_pxl(600)
.Compression(CompressionAlgorithm::BSHUF_LZ4);
JFCalibration calib(x);
std::vector<float> pedestal(RAW_MODULE_SIZE);
for (int m = 0; m < nmodules; m++) {
for (int i = 0; i < RAW_MODULE_SIZE; i++)
pedestal[i] = 3000 + 10 * m + i % 50;
calib.Pedestal(m, 0).LoadPedestal(pedestal);
}
// A few photons of background, some spots, one saturated and one bad pixel
std::vector<uint16_t> raw(nmodules * RAW_MODULE_SIZE);
std::mt19937 g(1900);
std::uniform_int_distribution<int> background(0, 300);
std::uniform_int_distribution<int> where(20 * RAW_MODULE_COLS, (RAW_MODULE_LINES - 20) * RAW_MODULE_COLS);
for (int i = 0; i < raw.size(); i++)
raw[i] = 3000 + 10 * (i / RAW_MODULE_SIZE) + i % 50 + background(g);
for (int s = 0; s < 80; s++) {
int i0 = where(g) + (s % nmodules) * RAW_MODULE_SIZE;
for (int y = 0; y < 3; y++)
for (int i = 0; i < 3; i++)
raw[i0 + y * RAW_MODULE_COLS + i] = 12000;
}
raw[50 * RAW_MODULE_COLS + 500] = 0xC000;
raw[60 * RAW_MODULE_COLS + 600] = 0xFFFF;
SpotFindingSettings settings = DiffractionExperiment::DefaultDataProcessingSettings();
settings.signal_to_noise_threshold = 3;
settings.photon_count_threshold = 2;
settings.min_pix_per_spot = 1;
settings.indexing = false;
auto run = [&](AcquisitionDeviceGroup &devices, std::vector<uint8_t> &image, std::vector<std::vector<float>> &plots) {
Logger logger("MockAcquisitionDevice_SameAsHLS_Receiver");
TestImagePusher pusher(x.GetImageNum() - 1);
JFJochReceiverService service(devices, logger, pusher);
service.NumThreads(4);
service.SetSpotFindingSettings(settings);
service.LoadInternalGeneratorImage(x, raw, 0);
PixelMask mask(x);
service.Start(x, mask, &calib);
auto output = service.Stop();
image = pusher.GetImage();
for (auto type: {PlotType::SpotCount, PlotType::StrongPixels, PlotType::ErrorPixels,
PlotType::SaturatedPixels, PlotType::PixelSum, PlotType::MaxValue,
PlotType::BkgEstimate, PlotType::PacketsReceived}) {
std::vector<float> v;
service.GetPlotRaw(v, type, "");
plots.push_back(v);
}
std::vector<float> azint;
service.GetPlotRaw(azint, PlotType::AzInt, "");
plots.push_back(azint);
return output;
};
AcquisitionDeviceGroup hls_devices;
hls_devices.Add(std::make_unique<RecordingHLSDevice>(0, 64));
std::vector<uint8_t> hls_image;
std::vector<std::vector<float>> hls_plots;
auto hls_output = run(hls_devices, hls_image, hls_plots);
auto mock = std::make_unique<MockAcquisitionDevice>(0, 64);
dynamic_cast<RecordingHLSDevice &>(hls_devices[0]).CopyOutputs(*mock);
AcquisitionDeviceGroup mock_devices;
mock_devices.Add(std::move(mock));
std::vector<uint8_t> mock_image;
std::vector<std::vector<float>> mock_plots;
auto mock_output = run(mock_devices, mock_image, mock_plots);
REQUIRE(hls_output.status.images_sent == x.GetImageNum());
CHECK(mock_output.status.images_sent == hls_output.status.images_sent);
CHECK(mock_output.status.max_image_number_sent == hls_output.status.max_image_number_sent);
CHECK(mock_output.status.compressed_size == hls_output.status.compressed_size);
CHECK(mock_output.efficiency == hls_output.efficiency);
CHECK(mock_output.received_packets == hls_output.received_packets);
CHECK(mock_output.expected_packets == hls_output.expected_packets);
CHECK(mock_image == hls_image);
REQUIRE(mock_plots.size() == hls_plots.size());
for (int i = 0; i < hls_plots.size(); i++) {
INFO("plot " << i);
REQUIRE(mock_plots[i].size() == hls_plots[i].size());
CHECK(memcmp(mock_plots[i].data(), hls_plots[i].data(), hls_plots[i].size() * sizeof(float)) == 0);
}
}
// Receiver tests of JFJochReceiverIntegrationTest.cpp on the mock; the card output is given by the test
TEST_CASE("MockAcquisitionDevice_JFJochReceiverTest_Raw", "[MockAcquisitionDevice]") {
DiffractionExperiment x(DetJF(4));
const uint16_t nthreads = 4;
x.Raw();
x.PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
.ImagesPerTrigger(100).ImagesPerFile(10).IncidentEnergy_keV(12.4).Compression(CompressionAlgorithm::NO_COMPRESSION);
// In raw mode the card writes the detector frame, here the one JFJochReceiverTest() expects
std::vector<uint16_t> raw(RAW_MODULE_SIZE * x.GetModulesNum());
for (int i = 0; i < raw.size(); i++)
raw[i] = i % 65536;
AcquisitionDeviceGroup aq_devices;
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
auto test = std::make_unique<MockAcquisitionDevice>(i, 64);
for (int m = 0; m < x.GetModulesNum(i); m++)
test->SetOutput(0, m, *OutputWithPixels(raw.data() + (x.GetFirstModuleOfDataStream(i) + m) * RAW_MODULE_SIZE));
aq_devices.Add(std::move(test));
}
Logger logger("MockAcquisitionDevice_JFJochReceiverTest_Raw");
PixelMask mask(x);
JFJochReceiverOutput output;
bool ret;
REQUIRE_NOTHROW(ret = JFJochReceiverTest(output, logger, aq_devices, x, mask, raw, nthreads));
REQUIRE(ret);
REQUIRE(output.efficiency == 1.0);
REQUIRE(output.status.images_sent == x.GetImageNum());
REQUIRE(output.status.compressed_ratio == 1.0);
REQUIRE(output.status.compressed_size == x.GetImageNum() * x.GetByteDepthImage() * x.GetPixelsNum());
REQUIRE(output.status.max_image_number_sent == x.GetImageNum());
REQUIRE(!output.status.cancelled);
}
// Two cards running at the same time - not possible with the HLS simulation
TEST_CASE("MockAcquisitionDevice_JFJochReceiverTest_Raw_TwoDevices", "[MockAcquisitionDevice]") {
DiffractionExperiment x(DetJF(4));
const uint16_t nthreads = 4;
x.Raw();
x.DataStreams(2);
x.PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
.ImagesPerTrigger(100).ImagesPerFile(10).IncidentEnergy_keV(12.4).Compression(CompressionAlgorithm::NO_COMPRESSION);
REQUIRE(x.GetDataStreamsNum() == 2);
std::vector<uint16_t> raw(RAW_MODULE_SIZE * x.GetModulesNum());
for (int i = 0; i < raw.size(); i++)
raw[i] = i % 65536;
AcquisitionDeviceGroup aq_devices;
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
auto test = std::make_unique<MockAcquisitionDevice>(i, 64);
for (int m = 0; m < x.GetModulesNum(i); m++)
test->SetOutput(0, m, *OutputWithPixels(raw.data() + (x.GetFirstModuleOfDataStream(i) + m) * RAW_MODULE_SIZE));
aq_devices.Add(std::move(test));
}
Logger logger("MockAcquisitionDevice_JFJochReceiverTest_Raw_TwoDevices");
PixelMask mask(x);
JFJochReceiverOutput output;
bool ret;
REQUIRE_NOTHROW(ret = JFJochReceiverTest(output, logger, aq_devices, x, mask, raw, nthreads));
REQUIRE(ret);
REQUIRE(output.efficiency == 1.0);
REQUIRE(output.status.images_sent == x.GetImageNum());
REQUIRE(!output.status.cancelled);
}
TEST_CASE("MockAcquisitionDevice_JFJochReceiverTest_EIGER", "[MockAcquisitionDevice]") {
Logger logger("MockAcquisitionDevice_JFJochReceiverTest_EIGER");
DiffractionExperiment x(DetEIGER(2));
const uint16_t nthreads = 4;
x.Raw();
x.PedestalG0Frames(0).NumTriggers(1).UseInternalPacketGenerator(true)
.ImagesPerTrigger(32).ImagesPerFile(10).IncidentEnergy_keV(12.4).Compression(CompressionAlgorithm::BSHUF_ZSTD);
std::vector<uint16_t> raw(RAW_MODULE_SIZE * x.GetModulesNum());
for (int i = 0; i < raw.size(); i++)
raw[i] = i % 65536;
AcquisitionDeviceGroup aq_devices;
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
auto test = std::make_unique<MockAcquisitionDevice>(i, 64);
for (int m = 0; m < x.GetModulesNum(i); m++)
test->SetOutput(0, m, *OutputWithPixels(raw.data() + (x.GetFirstModuleOfDataStream(i) + m) * RAW_MODULE_SIZE));
aq_devices.Add(std::move(test));
}
PixelMask mask(x);
JFJochReceiverOutput output;
bool ret;
REQUIRE_NOTHROW(ret = JFJochReceiverTest(output, logger, aq_devices, x, mask, raw, nthreads));
REQUIRE(ret);
REQUIRE(output.efficiency == 1.0);
REQUIRE(output.status.images_sent == x.GetImageNum());
REQUIRE(!output.status.cancelled);
}
TEST_CASE("MockAcquisitionDevice_JFJochReceiverTest_PacketLost_Raw", "[MockAcquisitionDevice]") {
DiffractionExperiment x(DetJF(2));
const uint16_t nthreads = 4;
std::vector<uint16_t> frame_in(RAW_MODULE_SIZE);
for (auto &i: frame_in) i = 776;
x.Raw();
x.PedestalG0Frames(0).NumTriggers(1)
.UseInternalPacketGenerator(false).ImagesPerTrigger(4).IncidentEnergy_keV(12.4)
.Compression(CompressionAlgorithm::NO_COMPRESSION);
PixelMask pixel_mask(x);
// The card writes the missing packet as UINT16_MAX
std::vector<uint16_t> frame_lost = frame_in;
for (int i = 127 * 4096; i < RAW_MODULE_SIZE; i++)
frame_lost[i] = UINT16_MAX;
AcquisitionDeviceGroup aq_devices;
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
auto test = std::make_unique<MockAcquisitionDevice>(i, 64);
for (int image = 0; image < 4; image++) {
test->SetOutput(image, 0, *OutputWithPixels((image == 3) ? frame_lost.data() : frame_in.data()));
test->SetOutput(image, 1, *OutputWithPixels(frame_in.data()));
}
test->CreateJFPackets(x, 1, 1, 0, frame_in.data());
test->CreateJFPackets(x, 1, 1, 1, frame_in.data());
test->CreateJFPackets(x, 2, 1, 0, frame_in.data());
test->CreateJFPackets(x, 2, 1, 1, frame_in.data());
test->CreateJFPackets(x, 3, 1, 0, frame_in.data());
test->CreateJFPackets(x, 3, 1, 1, frame_in.data());
for (int j = 0; j < 127; j++)
test->CreateJFPacket(x, 4, j, 0, nullptr);
test->CreateJFPackets(x, 4, 1, 1, frame_in.data());
test->CreateFinalPacket(x);
aq_devices.Add(std::move(test));
}
Logger logger("MockAcquisitionDevice_JFJochReceiverTest_PacketLost_Raw");
JFCalibration calib(x);
TestImagePusher pusher(x.GetImageNum() - 1);
JFJochReceiverService service(aq_devices, logger, pusher);
service.NumThreads(nthreads);
service.Start(x, pixel_mask, &calib);
auto receiver_out = service.Stop();
const auto image = pusher.GetImage();
REQUIRE(aq_devices[0].GetBytesReceived() == (8 * 128 - 1) * 8192UL);
REQUIRE(image.size() == 2 * RAW_MODULE_SIZE * sizeof(uint16_t));
REQUIRE(pusher.GetCounter() == x.GetImageNum());
auto raw = (const uint16_t *) (image.data());
CHECK(raw[0] == 776);
CHECK(raw[256 * 1024 + 315] == 776);
CHECK(raw[RAW_MODULE_SIZE - 4095] == UINT16_MAX);
CHECK(raw[RAW_MODULE_SIZE - 1] == UINT16_MAX);
CHECK(raw[RAW_MODULE_SIZE + 0] == 776);
CHECK(raw[RAW_MODULE_SIZE + 256 * 1024 + 315] == 776);
CHECK(raw[2 * RAW_MODULE_SIZE - 1] == 776);
REQUIRE(receiver_out.efficiency < 1.0);
REQUIRE(receiver_out.status.images_sent == x.GetImageNum());
}
TEST_CASE("MockAcquisitionDevice_JFJochReceiverTest_PedestalG0", "[MockAcquisitionDevice]") {
DiffractionExperiment x(DetJF(1));
const uint16_t nthreads = 4;
size_t nframes = 500;
// The card output repeats every distinct_frames frames
size_t distinct_frames = 25;
std::vector<uint16_t> pedestal_in(RAW_MODULE_SIZE * distinct_frames);
// Predictable random number generator
std::mt19937 g1(1900);
std::normal_distribution<double> distribution(3000, 50);
for (auto &i: pedestal_in) {
uint16_t number = distribution(g1);
if (number < 20) number = 20;
if (number > 16300) number = 16300;
i = number;
}
x.Mode(DetectorMode::PedestalG0);
x.PedestalG0Frames(nframes)
.NumTriggers(1).UseInternalPacketGenerator(false)
.ImagesPerTrigger(0).IncidentEnergy_keV(12.4);
AcquisitionDeviceGroup aq_devices;
for (int i = 0; i < x.GetDataStreamsNum(); i++) {
auto test = std::make_unique<MockAcquisitionDevice>(i, 64);
for (int f = 0; f < distinct_frames; f++)
test->SetOutput(f, 0, *OutputWithPixels(pedestal_in.data() + f * RAW_MODULE_SIZE));
for (int f = 0; f < nframes; f++)
test->CreateJFPackets(x, f + 1, 1, 0, pedestal_in.data() + (f % distinct_frames) * RAW_MODULE_SIZE);
test->CreateFinalPacket(x);
aq_devices.Add(std::move(test));
}
JFPedestalCalc pc(x);
for (int i = 0; i < nframes; i++)
pc.AnalyzeImage(pedestal_in.data() + (i % distinct_frames) * RAW_MODULE_SIZE);
PixelMask mask(x);
Logger logger("MockAcquisitionDevice_JFJochReceiverTest_PedestalG0");
JFJochReceiverOutput output;
bool ret;
REQUIRE_NOTHROW(ret = JFJochReceiverTest(output, logger, aq_devices, x, mask, nthreads));
REQUIRE(ret);
REQUIRE(output.status.images_sent == x.GetImageNum());
REQUIRE(output.efficiency == 1.0);
JFModulePedestal ref_pedestal;
pc.Export(ref_pedestal, 0);
JFModulePedestal out_pedestal = output.pedestal_result.at(0);
REQUIRE(abs(ref_pedestal.Mean() - out_pedestal.Mean()) < 0.65);
REQUIRE(out_pedestal.CountMaskedPixels() == 0);
REQUIRE(out_pedestal.GetFrameCount() == nframes);
}