v1.0.0-rc.173 (#83)

* jfjoch_broker: Optional per-dataset authentication - statistics, images and plots can require a bearer token, which jfjoch_viewer supports.
* jfjoch_viewer: Dark mode and a theme-matched colour scheme, a magnifier panel, and simpler contrast and background controls.
* Rugnux: Multiple performance improvements on GPU and CPU (CPU-only processing up to 40% faster, faster image decoding on ARM), with unchanged results.
* Rugnux: `--model` rigid-body refinement runs on the GPU, and the model-validation check is faster and more reliable.
* Rugnux: Improved scaling and merging - error model, outlier rejection, absorption correction and French-Wilson amplitudes now agree more closely with XDS and ctruncate.
* Rugnux: Improved integration - radial background on powder and ice rings, crowded rotation data keep their reflections, and CPU-only builds integrate large unit cells as GPU builds do.
* Rugnux: More robust detector geometry - measured beam centre, X-ray bandwidth and goniometer rate, and geometry refinement accepted only on significant evidence.
* Rugnux: Merged files are written in the standard setting, or in the setting of a reference MTZ, structure-factor mmCIF or model, with its free-R flags.
* Rugnux: Richer report - ice and powder rings, further lattices, superstructure candidates and mosaicity, with warnings worded as prompts to check.
* Rugnux: Clear error messages when a data set needs more GPU or host memory than is available.

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

tests/IndexingUnitTest.cpp

@@ -7,6 +7,7 @@
 #include "../writer/HDF5Objects.h"
 #include "../image_analysis/indexing/IndexerFactory.h"
 #include "../image_analysis/indexing/PostIndexingRefinement.h"
+#include "../image_analysis/IndexAndRefine.h"
 #include "../image_analysis/bragg_prediction/BraggPrediction.h"
 #include "../common/Logger.h"
 
@@ -734,3 +735,53 @@ TEST_CASE("FFTIndexer_CoplanarNoiseFrameLeavesTheIndexerUsable", "[Indexing]") {
         CHECK(lengths[2] == Catch::Approx(uc.c).epsilon(0.01));
     }
 }
+
+TEST_CASE("FFTIndexer_ManyNoiseFrames", "[Indexing]") {
+    // A grid scan: frame after frame of junk, sparse or dense, through one pooled indexer. Noise
+    // leaves dozens of shortlist directions whose lengths fall in the same FFT bins, so the length
+    // sort sees many exact ties. When that sort recomputed Length() inside its comparator, an LTO
+    // build contracted it into FMAs differently at different inlined sites, a tie flipped by one ulp
+    // between comparisons, and std::sort ran off its index array - the broker SEGV. Only about one
+    // noise frame in a thousand did it; frame 1632 crashed the rc.172 LTO build
+    // (-march=x86-64-v3 -flto=auto) on the GPU FFT path. A non-LTO build never crashed: there Length()
+    // stays out of line and rounds the same way at every call.
+    constexpr int FIRST_FRAME = 1628, LAST_FRAME = 1636;
+
+    for (const auto algorithm: FFTAlgorithms()) {
+        INFO("algorithm " << static_cast<int>(algorithm));
+        auto indexer = MakeFFTIndexer(algorithm);
+        REQUIRE(indexer);
+
+        size_t lattices = 0;
+        for (int frame = FIRST_FRAME; frame <= LAST_FRAME; frame++)
+            lattices += indexer->Run(NoiseCloud(20 + (frame * 37) % 1500, 20260923 + frame)).lattice.size();
+        SUCCEED(lattices << " candidate lattices from noise frames");
+    }
+}
+
+TEST_CASE("FitSupercellProbe", "[SupercellProbe]") {
+    // A class whose intensity is 3 at any rocking plus 40 times its partiality: the fit separates the
+    // two, and the part that rocks is known to the noise the scatter about the line allows.
+    SupercellProbeClass c;
+    std::mt19937 rng(1);
+    std::normal_distribution<double> noise(0.0, 1.0);
+    for (int i = 0; i < 20000; i++) {
+        const double p = (i % 100) / 100.0;
+        const double I = 3.0 + 40.0 * p + noise(rng);
+        c.n++;
+        c.sum_i += I;
+        c.sum_i_over_sigma += I;
+        c.sum_p += p;
+        c.sum_pp += p * p;
+        c.sum_pi += p * I;
+        c.sum_ii += I * I;
+    }
+    const SupercellProbeFit f = FitSupercellProbe(c);
+    CHECK(f.b == Catch::Approx(40.0).margin(0.1));
+    CHECK(f.a == Catch::Approx(3.0).margin(0.05));
+    CHECK(f.b_se == Catch::Approx(1.0 / std::sqrt(20000.0 * (0.9999 / 12.0))).epsilon(0.05));
+    CHECK(f.mean_p == Catch::Approx(0.495));
+
+    // Too few reflections to fit a line: nothing.
+    CHECK(FitSupercellProbe(SupercellProbeClass{}).b == 0.0);
+}