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/BraggIntegrationEngineGPUTest.cpp

@@ -140,12 +140,13 @@ DiffractionExperiment MakeExperiment(IntegratorMode mode, std::optional<float> b
     return experiment;
 }
 
-void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
+// Returns the fraction of the predicted reflections the engines kept.
+double CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
                      float clip_nsigma = 4.0f, bool radial = false, int spacing = 60,
                      float stencil_k = 0.0f,
                      float r1 = 0.0f, float r2 = 0.0f, float r3 = 0.0f,
                      OverlapMode overlap = OverlapMode::Off, float companion_dx = 0.0f,
-                     bool clip_spots = false) {
+                     bool clip_spots = false, float odd_partiality = 1.0f) {
     const DiffractionExperiment experiment =
             MakeExperiment(mode, bandwidth_fwhm, clip_nsigma, radial, DetJF(2), stencil_k, r1, r2, r3,
                            overlap);
@@ -154,7 +155,9 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
     const size_t npixel = experiment.GetPixelsNum();
     REQUIRE(npixel == width * height);
 
-    const Scene scene = BuildScene(width, height, spacing, companion_dx, clip_spots);
+    Scene scene = BuildScene(width, height, spacing, companion_dx, clip_spots);
+    for (size_t i = 1; i < scene.predicted.size(); i += 2)
+        scene.predicted[i].partiality = odd_partiality;
     REQUIRE(scene.image.size() == npixel);
     REQUIRE(scene.predicted.size() > 60);
 
@@ -180,6 +183,8 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
     // atomic summation of the learned profile, so compare up to a small tolerance.
     REQUIRE(out_gpu.size() == out_cpu.size());
     REQUIRE(out_cpu.size() > 40);
+    CHECK(gpu.Counts().bkg_starved == cpu.Counts().bkg_starved);
+    CHECK(gpu.Counts().bkg_starved_by_neighbour == cpu.Counts().bkg_starved_by_neighbour);
     if (clip_spots) {
         // Guard against the coverage going vacuous: the punched pixels have to actually cost some
         // reflections, or the two engines are being compared on a case neither of them meets.
@@ -200,6 +205,7 @@ void CompareCpuVsGpu(IntegratorMode mode, std::optional<float> bandwidth_fwhm,
         CHECK(out_gpu[i].I == Catch::Approx(out_cpu[i].I).epsilon(0.03).margin(2.0));
         CHECK(out_gpu[i].sigma == Catch::Approx(out_cpu[i].sigma).epsilon(0.03).margin(0.5));
     }
+    return static_cast<double>(out_cpu.size()) / static_cast<double>(scene.predicted.size());
 }
 
 } // namespace
@@ -269,6 +275,18 @@ TEST_CASE("BraggIntegrationEngineGPU_MatchesCPU") {
         CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 4.0f, false, 60, 0.0f,
                         0.0f, 0.0f, 0.0f, OverlapMode::Exclude);
     }
+    // Spots 8 px apart: the neighbours' r2 regions cover every background ring, so only the edge of
+    // the grid keeps a clean ring pixel, and both engines have to drop the same reflections for want
+    // of a background - and count them as the neighbours' doing.
+    SECTION("ProfileGaussian neighbour-starved rings") {
+        CHECK(CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 4.0f, false, 8) < 0.5);
+    }
+    // The same crowding with every other prediction in the tail of its rocking curve: those do not
+    // mask the rings, and both engines have to agree on which ones do.
+    SECTION("ProfileGaussian tail neighbours") {
+        CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 4.0f, false, 8, 0.0f,
+                        0.0f, 0.0f, 0.0f, OverlapMode::Off, 0.0f, false, 0.01f);
+    }
     SECTION("ProfileGaussian mono trim") { CompareCpuVsGpu(IntegratorMode::ProfileGaussian, std::nullopt, 0.0f); }
     // Unreadable pixels inside the signal disks themselves: the MINPK rescue keeps the reflection and
     // fits it over what is left, and the peak-loss rule throws back the ones that lost the profile's