// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only #include #include #include #include #include "../common/ImageBuffer.h" #include "../common/time_utc.h" #include "../image_analysis/structure_refinement/RugnuxModel.h" #include "../receiver/StillsGPUAnalysis.h" namespace { struct TestSink : public StillsSink { std::function ready = [](const StillsSetup &) {}; std::function analysed = [](DataMessage &) {}; std::function failed = [] {}; void StillsReady(const StillsSetup &setup) override { ready(setup); } void SendAnalysedImage(DataMessage &message, const AzimuthalIntegrationProfile &) override { analysed(message); } SpotFindingSettings AnalysisSettings() override { return DiffractionExperiment::DefaultDataProcessingSettings(); } void StillsSetupFailed(const JFJochException &) override { failed(); } }; DiffractionExperiment StillsExperiment() { DiffractionExperiment x(DetJF(1)); x.ImagesPerTrigger(StillsGPUAnalysis::PREPASS_IMAGES + 200).NumTriggers(1).DetectorDistance_mm(100).BeamX_pxl(500).BeamY_pxl(250) .IncidentEnergy_keV(12.4); return x; } // A frame after the pre-pass's sample (numbers from PREPASS_IMAGES on are never in it), in a slot of `buffer`. std::shared_ptr Frame(ImageBuffer &buffer, int64_t number) { auto held = std::make_shared(); held->slot = buffer.GetImageSlot(); REQUIRE(held->slot != nullptr); held->message.number = StillsGPUAnalysis::PREPASS_IMAGES + number; held->message.image_collection_efficiency = 1.0f; return held; } StartMessage Start(const DiffractionExperiment &x) { StartMessage start; x.FillMessage(start); return start; } } TEST_CASE("StillsGPUAnalysis_StartFailureReleasesThreads", "[StillsGPUAnalysis]") { Logger logger(Catch::getResultCapture().getCurrentTestName()); const DiffractionExperiment x = StillsExperiment(); const PixelMask mask(x); ImageBuffer buffer(64 * 1024 * 1024); buffer.StartMeasurement(x); RugnuxLiveStatus status; std::atomic failed = 0, sunk = 0; TestSink sink; sink.ready = [](const StillsSetup &) { throw JFJochException(JFJochExceptionCategory::ZeroMQ, "Timeout on pushing start message"); }; sink.analysed = [&](DataMessage &) { ++sunk; }; sink.failed = [&] { ++failed; }; { StillsGPUAnalysis gpu(x, mask, Start(x), nullptr, 4, 100, logger, sink, status); for (int i = 0; i < 3; i++) gpu.Hold(Frame(buffer, i)); REQUIRE_THROWS_AS(gpu.Finish(), JFJochException); } CHECK(failed == 1); CHECK(sunk == 0); CHECK(status.Get().state == RugnuxLiveState::Failed); // Every slot the frames were held in is back. CHECK(buffer.GetAvailSlots() == buffer.GetStatus().total_slots); } TEST_CASE("StillsGPUAnalysis_HoldIsBounded", "[StillsGPUAnalysis]") { Logger logger(Catch::getResultCapture().getCurrentTestName()); const DiffractionExperiment x = StillsExperiment(); const PixelMask mask(x); ImageBuffer buffer(64 * 1024 * 1024); buffer.StartMeasurement(x); REQUIRE(buffer.GetStatus().total_slots >= 4); RugnuxLiveStatus status; TestSink sink; sink.ready = [](const StillsSetup &) { throw JFJochException(JFJochExceptionCategory::ZeroMQ, "no writer"); }; StillsGPUAnalysis gpu(x, mask, Start(x), nullptr, 2, 3, logger, sink, status); // Past what the pre-pass holds, frames are still taken: only the image buffer bounds them. for (int i = 0; i < 4; i++) gpu.Hold(Frame(buffer, i)); CHECK(buffer.GetStatus().preparation_slots == 4); CHECK(buffer.GetImageSlot(buffer.GetStatus().available_slots) == nullptr); REQUIRE_THROWS(gpu.Finish()); CHECK(buffer.GetStatus().preparation_slots == 0); } TEST_CASE("StillsGPUAnalysis_FailingFrameDoesNotStopAnalysis", "[StillsGPUAnalysis]") { Logger logger(Catch::getResultCapture().getCurrentTestName()); const DiffractionExperiment x = StillsExperiment(); const PixelMask mask(x); ImageBuffer buffer(64 * 1024 * 1024); buffer.StartMeasurement(x); RugnuxLiveStatus status; std::atomic sunk = 0; TestSink sink; sink.analysed = [&](DataMessage &m) { ++sunk; if (m.number == StillsGPUAnalysis::PREPASS_IMAGES) throw std::runtime_error("not a JFJochException"); }; StillsGPUAnalysis gpu(x, mask, Start(x), nullptr, 1, 100, logger, sink, status); // The frames carry no image, so their analysis fails too - they are passed on all the same. for (int i = 0; i < 3; i++) gpu.Hold(Frame(buffer, i)); REQUIRE_NOTHROW(gpu.Finish()); CHECK(sunk == 3); // The outcome waits for everything to be written, and comes after the latency. CHECK(status.Get().state == RugnuxLiveState::Running); CHECK(!status.Get().last_image_to_written_s); status.Latency(SecondsSince(status.LastImage().value())); gpu.ReportOutcome(); const auto s = status.Get(); CHECK(s.state == RugnuxLiveState::Failed); CHECK(!s.message.empty()); REQUIRE(s.last_image_to_written_s); REQUIRE(s.last_image_s); CHECK(s.elapsed_s >= s.last_image_s.value() + s.last_image_to_written_s.value() - 1e-6); REQUIRE(!s.steps.empty()); CHECK(s.steps.back().title == "Writing"); CHECK(s.steps.back().duration_s); CHECK(buffer.GetStatus().preparation_slots == 0); } TEST_CASE("StillsGPUAnalysis_CancelCutsTheModelStep", "[StillsGPUAnalysis]") { Logger logger(Catch::getResultCapture().getCurrentTestName()); const DiffractionExperiment x = StillsExperiment(); const PixelMask mask(x); TestSink sink; const auto run = [&](RugnuxLiveStatus &status, std::shared_ptr model) { return std::make_unique(x, mask, Start(x), nullptr, 1, 100, logger, sink, status, true, std::move(model), 60.0); }; RugnuxLiveStatus during; auto a = run(during, std::make_shared()); a->Cut("cancel"); CHECK(during.Get().cut == "cancel"); REQUIRE_NOTHROW(a->Finish()); // Nothing is left to cut once the model step has ended, and nothing runs without a model. RugnuxLiveStatus after; auto b = run(after, std::make_shared()); b->Finish(); b->Cut("cancel"); CHECK(after.Get().cut.empty()); RugnuxLiveStatus no_model; auto c = run(no_model, nullptr); c->Cut("cancel"); CHECK(no_model.Get().cut.empty()); c->Finish(); } TEST_CASE("StillsGPUAnalysis_FramesDuringThePrePassAreAnalysed", "[StillsGPUAnalysis]") { Logger logger(Catch::getResultCapture().getCurrentTestName()); const DiffractionExperiment x = StillsExperiment(); const PixelMask mask(x); ImageBuffer buffer(64 * 1024 * 1024); buffer.StartMeasurement(x); const int64_t frames = 3 + 5; REQUIRE(buffer.GetStatus().total_slots >= frames); std::atomic sunk = 0; std::latch offered(1); RugnuxLiveStatus status; TestSink sink; // The pre-pass is not over until every frame has been offered. sink.ready = [&](const StillsSetup &) { offered.wait(); }; sink.analysed = [&](DataMessage &) { ++sunk; }; StillsGPUAnalysis gpu(x, mask, Start(x), nullptr, 2, 3, logger, sink, status); CHECK(status.Get().stills->images_needed == 3); for (int i = 0; i < frames; i++) gpu.Hold(Frame(buffer, i)); offered.count_down(); REQUIRE_NOTHROW(gpu.Finish()); CHECK(sunk == frames); CHECK(buffer.GetStatus().preparation_slots == 0); }