v1.0.0-rc.176 (#86)

* jfjoch_broker: Optional live Rugnux analysis of DECTRIS rotation collections inside the broker, with merged data, maps and the placed model written beside the master file, the rotation lattice in the scan result, and a "Rugnux live" tab and dashboard row in the web frontend.
* Rugnux: Faster processing, with molecular replacement and model validation spread over several GPUs and run on the Apple GPU on macOS.
* Rugnux: The polarization stated in miniCBF and d*TREK headers is used, twinned crystals' space groups are decided more reliably, and a run that finds no lattice still reports every image.

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

tests/ModelScaleGPUTest.cpp

@@ -30,6 +30,7 @@
 #include "../image_analysis/structure_refinement/ModelScaleGPU.h"
 #include "../image_analysis/structure_refinement/ModelValidation.h"
 #include "../image_analysis/structure_refinement/RigidBodyRefine.h"
+#include "../writer/RugnuxModelFile.h"
 
 namespace {
 
@@ -104,7 +105,7 @@ gemmi::Scaling<float> ModelPoints(const char *cryst, double zone) {
     const std::string path = "model_scale_gpu_test.pdb";
     std::ofstream(path) << pdb;
     Logger logger("ModelScaleGPUTest");
-    const auto reference = ModelReferenceIntensities(path, {}, {}, 3.0, logger);
+    const auto reference = ModelReferenceIntensities(ReadRugnuxModelFile(path), {}, {}, 3.0, logger);
     gemmi::Structure st = gemmi::read_structure_gz(path, gemmi::CoorFormat::Detect);
     std::filesystem::remove(path);
     st.setup_cell_images();
@@ -314,7 +315,11 @@ TEST_CASE("ModelScaleGPU_MatchesGemmiOnAModelsPoints", "[ModelValidation][gpu]")
             // As above: the same grid point, or a near-tie's neighbour at the CPU winner's R.
             const bool same_point = solvent.k_sol == cpu.k_sol && solvent.b_sol == cpu.b_sol;
             CHECK(std::fabs(solvent.r - report.r_work_fit) < R_TOLERANCE);
-            if (same_point)
+            // The 6 A zone holds few points, so its B minimum is flat and the last bit of the model's
+            // structure factors moves where gemmi's fit stops by more than the parameters' tolerance: there
+            // the two fits are held to the same R, as in ModelScaleGPU_FitMatchesGemmi, not the same B.
+            const bool flat = zone >= 6.0;
+            if (same_point && !flat)
                 CheckSameScale(solvent.scale, cpu);
 
             gemmi::Scaling<float> ref = cpu;
@@ -325,7 +330,12 @@ TEST_CASE("ModelScaleGPU_MatchesGemmiOnAModelsPoints", "[ModelValidation][gpu]")
             ref.fit_isotropic_b_approximately();
             ref.fit_parameters();
             const ModelScaleParams p = gpu.scale.Fit(gpu.fcmol, gpu.fmask, cpu.k_sol, cpu.b_sol);
-            CheckSameScale(p, ref);
+            if (!flat)
+                CheckSameScale(p, ref);
+            gemmi::Scaling<float> with_gpu = ref;
+            with_gpu.k_overall = p.k_overall;
+            with_gpu.b_star = {p.b_star[0], p.b_star[1], p.b_star[2], p.b_star[3], p.b_star[4], p.b_star[5]};
+            CHECK(std::fabs(with_gpu.calculate_r_factor() - ref.calculate_r_factor()) < R_TOLERANCE);
         }
 }
 
@@ -382,4 +392,24 @@ TEST_CASE("ModelScaleGPUPool_MatchesFitModelScale", "[ModelValidation][gpu]") {
     }
 }
 
+// ModelScaling fits past a reflection the solvent cancels exactly (ModelScalingTest.cpp), on the card.
+TEST_CASE("ModelScaleGPUPool_FitsPastAReflectionTheSolventCancelsExactly", "[ModelValidation][gpu]") {
+    if (get_gpu_count() == 0)
+        SKIP("No GPU");
+    gemmi::UnitCell cell(72, 44, 51, 90, 112, 90);
+    gemmi::Scaling<float> scaling = MakeScaling(cell, *gemmi::find_spacegroup_by_name("C 1 2 1"), 2.5);
+    // exp(-b_sol s^2) = 1 at s = 0, so at the grid's k_sol = 0.10 the sum is -0.1f + 0.1f = 0 for every b_sol
+    auto &p = *std::find_if(scaling.points.begin(), scaling.points.end(),
+                            [](const auto &q) { return q.fobs >= 1 && q.fobs >= q.sigma; });
+    p.stol2 = 0;
+    p.fcmol = {-0.1f, 0.f};
+    p.fmask = {1.f, 0.f};
+
+    ModelScaleGPUPool pool(0, scaling.points.size(), 1);
+    ModelScaleReport report;
+    REQUIRE_NOTHROW(report = pool.Fit(scaling, 80.0, 2));
+    CHECK(std::isfinite(report.r_work_fit));
+    CHECK(std::isfinite(scaling.k_overall));
+}
+
 #endif