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

@@ -5,6 +5,7 @@
 
 #include <filesystem>
 #include <string>
+#include <cstring>
 
 #include <gemmi/mtz.hpp>
 
@@ -31,7 +32,7 @@ namespace {
     }
 }
 
-TEST_CASE("Merged MTZ: the data dataset is id 1 and carries the wavelength", "[write_reflections]") {
+TEST_CASE("Merged MTZ: the data dataset is id 1 and carries the wavelength", "[write_reflections][portable]") {
     jfjoch_test::SyntheticMergeParams params;
     params.true_space_group = "P 43 21 2";
     params.twin_supergroup = "P 43 21 2";
@@ -74,7 +75,7 @@ TEST_CASE("Merged MTZ: the data dataset is id 1 and carries the wavelength", "[w
 }
 
 TEST_CASE("Unmerged MTZ: LP is Lorentz-polarization, QE the sensor efficiency, FLIGHT the flight path",
-          "[write_reflections]") {
+          "[write_reflections][portable]") {
     // The whole point of the split: LP must mean what XDS and DIALS mean by it, and the raw count
     // sum must still be recoverable from the file alone, as I / LP * QE * FLIGHT.
     auto experiment = TestExperiment();
@@ -137,3 +138,50 @@ TEST_CASE("Unmerged MTZ: LP is Lorentz-polarization, QE the sensor efficiency, F
         CHECK(I == Catch::Approx(raw[i] * lp[i] * qe[i] * fl[i]).epsilon(1e-5));
     }
 }
+
+TEST_CASE("Unmerged MTZ: built on several workers, the same rows as on one", "[write_reflections][portable]") {
+    // A sweep large enough that the sort, the event sums and the row fill are all split into
+    // pieces, with events of several parts, events cut short by the sweep's ends, and parts that
+    // share (h,k,l) and image_number - the tie the sort has to break the same way every time.
+    auto experiment = TestExperiment();
+    experiment.Goniometer(GoniometerAxis("omega", 0.0f, 0.1f, Coord(-1, 0, 0), {}));
+
+    uint32_t seed = 12345;
+    const auto next = [&seed] { seed = seed * 1664525u + 1013904223u; return (seed >> 8) / 16777216.0f; };
+
+    std::vector<IntegrationOutcome> outcomes(200);
+    for (int f = 0; f < 200; ++f) {
+        for (int q = 0; q < 8000; ++q) {
+            if ((f + q) % 7 >= 3)
+                continue;   // each reflection is seen on three consecutive images out of seven
+            Reflection r{};
+            r.h = q % 20 - 10; r.k = (q / 20) % 20 - 10; r.l = q / 400 + 1;
+            r.image_number = static_cast<float>(f);
+            r.I = 1000.0f * next();
+            r.sigma = 1.0f + 10.0f * next();
+            r.bkg = next();
+            r.var_bkg = next();
+            r.prescaling_corr = 1.0f + next();
+            r.partiality = 0.2f + 0.2f * next();
+            r.predicted_x = 1000.0f * next(); r.predicted_y = 1000.0f * next();
+            r.observed_x = NAN; r.observed_y = NAN;
+            outcomes[f].reflections.push_back(r);
+            if (q % 97 == 0) {
+                r.I = 1000.0f * next();
+                outcomes[f].reflections.push_back(r);
+            }
+        }
+    }
+
+    for (bool sum_partials : {true, false}) {
+        INFO("sum_partials " << sum_partials);
+        const gemmi::Mtz serial = UnmergedMtz(outcomes, TETRAGONAL_CELL, experiment, sum_partials, 1);
+        const gemmi::Mtz parallel = UnmergedMtz(outcomes, TETRAGONAL_CELL, experiment, sum_partials, 8);
+        REQUIRE(serial.nreflections > 100000);
+        REQUIRE(parallel.nreflections == serial.nreflections);
+        CHECK(std::memcmp(parallel.data.data(), serial.data.data(), serial.data.size() * sizeof(float)) == 0);
+        REQUIRE(parallel.batches.size() == serial.batches.size());
+        CHECK(parallel.batches.front().number == serial.batches.front().number);
+        CHECK(parallel.batches.back().number == serial.batches.back().number);
+    }
+}