v1.0.0-rc.178 (#88)

* Rugnux: Processes serial crystallography data from XFELs - SACLA (MPCCD), PAL-XFEL and European XFEL (CXI), LCLS (XTC) and SwissFEL Alvra (JUNGFRAU with a CrystFEL module geometry) - with several files or Jungfraujoch master files merged in one run (`rugnux *_master.h5`).
* Rugnux: Stills processing takes a known unit cell and space group as a starting point, finds the beam centre (and, with a cell, the detector distance) from the images, detects the saturation level in other facilities' files and refines the placement of individual detector panels.
* Rugnux: The stills report gives R_split and CC1/2 from frame half-sets, comparable with CrystFEL.
* jfjoch_viewer: Opens the same XFEL file formats.
* Validation: A stills battery checks Rugnux against deposited structures from SACLA, PAL-XFEL, LCLS, European XFEL and SwissFEL.
* Rugnux: More reliable convergence of rotation scaling, and live molecular replacement starts as soon as the model is uploaded.
* jfjoch_broker: Initialize clears the previous dataset's bearer tokens, image buffer and live Rugnux status, and a slow CUDA JIT cache is reported at start.

Reviewed-on: #88
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/MXAnalysisWithoutFPGA.cpp

@@ -4,6 +4,7 @@
 #include "MXAnalysisWithoutFPGA.h"
 
 #include <algorithm>
+#include <cmath>
 #include <spdlog/spdlog.h>
 
 #include "spot_finding/StrongPixelSet.h"
@@ -205,14 +206,14 @@ void MXAnalysisWithoutFPGA::Analyze(DataMessage &output,
                                          int64_t image_number) {
             if (count_crowding)
                 crowding_engine->CountNeighbourCrowding(predicted, npredicted);
-            return bragg_engine->Run(*preprocessor_buffer, predicted, npredicted, image_number);
+            return IntegrateOnImage(predicted, npredicted, image_number);
         };
         // The supercell probe integrates on the same engine, but what the engine counts is the run's
         // measurement of its own stencil, and the probe's reflections are not the run's: keep them out.
         const auto probe_integrate_fn = [this](const std::vector<Reflection> &predicted, size_t npredicted,
                                                int64_t image_number) {
             const BraggIntegrationCounts before = bragg_engine->Counts();
-            auto ret = bragg_engine->Run(*preprocessor_buffer, predicted, npredicted, image_number);
+            auto ret = IntegrateOnImage(predicted, npredicted, image_number);
             const BraggIntegrationCounts after = bragg_engine->Counts();
             probe_counts.predicted += after.predicted - before.predicted;
             probe_counts.bkg_starved += after.bkg_starved - before.bkg_starved;
@@ -504,3 +505,31 @@ void MXAnalysisWithoutFPGA::UpdateMaskResolution(const SpotFindingSettings &sett
         spotFinder->SetResolutionMaskBits(*mask_resolution);
     adaptiveSpotFinder->SetResolutionMaskBits(*mask_resolution);
 }
+
+std::vector<Reflection> MXAnalysisWithoutFPGA::IntegrateOnImage(const std::vector<Reflection> &predicted,
+                                                                size_t npredicted, int64_t image_number) {
+    const auto &modules = experiment.GetModules();
+    if (modules.empty())
+        return bragg_engine->Run(*preprocessor_buffer, predicted, npredicted, image_number);
+
+    // Predictions are where the reflections fall on the detector plane; the engine reads the image, so
+    // each goes to where its module put those pixels, and comes back to the plane once integrated.
+    std::vector<Reflection> on_image(predicted.begin(), predicted.begin() + static_cast<int64_t>(npredicted));
+    for (auto &r: on_image) {
+        const auto [x, y] = modules.PlaneToImage(r.predicted_x, r.predicted_y);
+        r.predicted_x = static_cast<float>(x);
+        r.predicted_y = static_cast<float>(y);
+    }
+    auto ret = bragg_engine->Run(*preprocessor_buffer, on_image, npredicted, image_number);
+    for (auto &r: ret) {
+        const auto [px, py] = modules.ImageToPlane(r.predicted_x, r.predicted_y);
+        r.predicted_x = static_cast<float>(px);
+        r.predicted_y = static_cast<float>(py);
+        if (std::isfinite(r.observed_x) && std::isfinite(r.observed_y)) {
+            const auto [ox, oy] = modules.ImageToPlane(r.observed_x, r.observed_y);
+            r.observed_x = static_cast<float>(ox);
+            r.observed_y = static_cast<float>(oy);
+        }
+    }
+    return ret;
+}