v1.0.0-rc.164 (#74)

* rugnux now tells you whether a crystal diffracts anisotropically and how far it reaches in each direction, without a second program: a new `9. DIFFRACTION ANISOTROPY` section in `<prefix>_report.txt` and matching `_reflns.pdbx_aniso_B_tensor_*` / `_reflns.jfjoch_aniso_*` items in the merged mmCIF report the anisotropic deltaB, the diffraction limit along each principal direction, and a `NOT DETECTED` / `DETECTED` / `CANNOT DETERMINE` verdict measured against the data set's own systematic error. It is a description only - no intensity is corrected, no reflection is removed, and the merged data do not depend on direction.
* rugnux can hand its integrated observations to another scaling program: `--export-unmerged` writes `<prefix>_unmerged.mtz`, an unmerged MTZ readable by aimless, pointless, careless and `iotbx.merging_statistics`, in `--mode mx` and `--mode scale` alike. Each rotation reflection's partials are summed into one full; `--export-unmerged-partials` writes one row per image instead. Intensities carry the Lorentz-polarization factor and nothing else, since those programs scale the data themselves. Lattice-centring absences are not written; screw and glide absences are.
* rugnux integrates crystals with broad spots better - where it changes anything, per-shell mean I/sigma improves by up to 31% and R_meas by up to 24% - because on rotation data the integration signal radius is now taken from the crystal's own measured spot width instead of a fixed 4 px. `--adaptive-integration-radius=off` restores the fixed radius and an explicit `--integration-radius` still overrides both. The widened radius applies to the final integration pass only, and a pattern too dense for it is re-integrated at 4 px with a note in the log.
* rugnux discards fewer stills reflections for want of a background ring, improving per-shell R_meas over most of the signal-bearing range: the stills background ring now runs to 14 px instead of 12. The gain reverses in shells below a mean I/sigma of about 4.
* rugnux determines the space group with thresholds that mean the same thing on a weak crystal as on a strong one: symmetry operators are scored on resolution-normalised intensities (E squared) instead of raw merged intensities, and a reflection counts as genuinely present on its counting significance instead of on the merged I/sigma, which saturates at the merge's own ISa. The search resolution cut is no longer able to move the answer, and the twin-law H bound moves from 1.70 to 1.85, which stops one class of correct high-symmetry assignment being refused as twinning.
* rugnux says what the space-group search tested and what it could not: the twin-law disagreement H is printed for every operator together with the adopted point group's H ratio and its bound; alternatives that are not on the reported lattice are named with how their cell differs; and a lattice centring the data could not test - the crystal having been integrated on the primitive sub-cell, so the reflections it extinguishes were never measured - is marked `UNTESTED` and warned about where it is adopted, as coming from the lattice metric rather than from the intensities.
* rugnux `--mode scale` re-merges a `_process.h5` in the right symmetry without being told it: the file now records the space group on every run - a two-pass rotation run wrote none before, so re-merging defaulted to P1 - together with the change of basis under `/entry/MX/reindexMatrix` where the lattice was re-seated, and `--mode scale` also reports the Wilson B-factor estimate instead of `WILSON_B= nan`. A file written before this stops with a message naming the two cells and the override to use, instead of failing inside the merge. A third-party reader of a `_process.h5` must apply `reindexMatrix` where it is present.
* rugnux installs on its own, as a package called `rugnux` - `dnf install rugnux` or `apt install rugnux` - instead of arriving inside `jfjoch-viewer`. It pulls in none of the acquisition stack, so a machine that only processes data no longer has to carry the broker, the detector libraries or Qt to get it. Installing it over a `jfjoch-viewer` from rc.163 or earlier, which still owns `/usr/bin/rugnux`, upgrades cleanly rather than failing on the duplicate file.
* rugnux is also a standalone download, built for arm64 as well as x86_64: `rugnux-<version>-linux-{x86_64|aarch64}-cuda<major>.tgz` and `rugnux-<version>-win64-cuda<major>.zip` on the release page, for machines that are not managed by a package manager. The aarch64 build targets GH200 and DGX Spark, and is untested on hardware.
* Every portable Linux binary is now a single self-contained file: cuFFT is linked statically instead of being shipped beside the executable and found through an rpath, so `rugnux` and `jfjoch_viewer` need nothing but an NVIDIA driver, and only to use the GPU. The `.rpm`/`.deb` continue to take cuFFT from the distribution. The developer utilities `jfjoch_extract_hkl` and `jfjoch_recompress` are no longer packaged anywhere.
* Jungfraujoch needs six fewer shared libraries on the machine - libopenblas and libmetis, and libgfortran, libquadmath, libgomp and libz behind them - because the Ceres LAPACK, METIS and SuiteSparse back-ends are no longer built. Nothing in the code ever selected them, and results are unchanged.
* The PCIe driver DKMS package builds for the kernel it is being installed for instead of the running one, so a module built while a kernel update is being applied loads after the reboot.
* The PCIe driver builds on RHEL 9.5 and later, and on their CentOS Stream, Rocky and AlmaLinux equivalents, where the `vm_flags` kernel interface was backported into the 5.14 kernel.
* A data collection started with `async_start` that fails to start - a writer refusing to overwrite an existing file, for instance - is reported as an error by `/wait_until_running` and `/wait_till_done` instead of as a timeout and a successful collection respectively. The error message is the one the writer gave.
* A calibration that is cancelled or that fails to collect its pedestals is no longer reported as a successful one. The broker goes to `Inactive` with an error message and has to be initialized again, instead of sitting in `Idle` looking ready to measure while holding partial pedestals - data collected in that state was silently mis-converted.
* A failed `/initialize` is reported to `/wait_until_running` and `/wait_till_done` as soon as it happens, instead of when their timeout expires.
* `space_group_number` accepts space groups up to 230 in the API schema, so cubic space groups can be recorded. The broker always accepted them; the generated clients rejected them before the request was sent.
* The results report's `REPORT_VERSION` is 3, two sections having been added. Existing key names and table columns are unchanged.
* The merged statistics table has **9** resolution shells instead of 10, which is what XDS reports. The bins were already XDS's - equal steps in 1/d^2 between the lowest- and the highest-resolution reflection the merge kept - so at the same resolution limits the two tables now have the same shell boundaries and can be read row for row. `--resolution-shells` sets a different count.
* `rugnux --model` now settles the frame the merged reflections are written in, not only the frame the R-factors and the maps are computed in: the `.mtz`/`.cif`/`.hkl` come out in the model's indexing, and where the data were merged in the model's enantiomorph they take the model's hand and space group - which on anomalous data puts I(+) and I(-) the right way round. The indexing choice is logged with the winning R-free and the runner-up, so a decision made within noise is visible.
* `rugnux --model` can resolve the indexing ambiguity of a **serial stills** run, which a model could not do before: structure factors computed from the model become the per-image reference, the same role a reference MTZ plays. It needs the cell and space group up front (`-C` / `-S`). Without one or the other, a merohedral serial run still merges both hands together and says so.
* The rugnux documentation opens with a quick start - the default run, and runs with a reference MTZ, with a model, or with the space group and cell pinned - and explains the indexing ambiguity: what it costs on rotation and on serial data, and which of `-z` / `--model` resolves it in each case. The long reference pages now carry a table of contents.

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

tests/SearchSpaceGroupTest.cpp

@@ -294,3 +294,76 @@ TEST_CASE("SearchSpaceGroup weighs a screw's absences by evidence, not by how ma
         CHECK(result.best_space_group->short_name() == "P2");
     }
 }
+
+// The operator correlation is on resolution-normalised E^2, not on raw I (see SearchSpaceGroup.cpp).
+// Both members of a symmetry pair sit at the same |s|, so on raw intensities the resolution fall-off
+// is variance shared perfectly between the two arms of every pair and reads as a correlation for ANY
+// pairing at all. These two cases pin that down from both sides.
+TEST_CASE("SearchSpaceGroup operator correlation reads symmetry, not the resolution fall-off",
+          "[SearchSpaceGroup]") {
+    // Intensities that are a smooth function of resolution times an INDEPENDENT per-reflection
+    // factor: a Wilson-like fall-off with no symmetry in it whatsoever.
+    auto radial_only = [](int hmax) {
+        std::vector<MergedReflection> merged;
+        for (int h = -hmax; h <= hmax; ++h)
+            for (int k = -hmax; k <= hmax; ++k)
+                for (int l = -hmax; l <= hmax; ++l) {
+                    if ((h == 0 && k == 0 && l == 0) || std::make_tuple(-h, -k, -l) < std::make_tuple(h, k, l))
+                        continue;
+                    const double d = CalcSyntheticD(h, k, l);
+                    const double falloff = std::exp(-30.0 / (d * d));
+                    // Deterministic, independent of any symmetry mate: reuse the hash on the raw index.
+                    const double jitter = SyntheticIntensityFromAsu(gemmi::Op::Miller{{h, k, l}}) / 350.0;
+                    const double I = 1.0e5 * falloff * jitter;
+                    merged.push_back(MergedReflection{
+                        .h = h, .k = k, .l = l, .I = I, .sigma = I / 20.0, .d = d});
+                }
+        return merged;
+    };
+
+    SearchSpaceGroupOptions opt;
+    opt.merge_friedel = true;
+
+    SECTION("a fall-off with no symmetry in it confirms no operator") {
+        const auto result = SearchSpaceGroup(radial_only(8), opt);
+        INFO(SearchSpaceGroupResultToText(result));
+        REQUIRE(result.operator_scores.size() > 1);
+        for (const auto& s : result.operator_scores) {
+            INFO("operator " << s.op_triplet_hkl);
+            CHECK(s.n_pairs >= opt.min_pairs_per_operator);
+            CHECK(s.cc < opt.min_operator_cc);
+            CHECK_FALSE(s.present);
+        }
+        CHECK(result.point_group_hm == "1");
+    }
+
+    SECTION("a real operator under the same fall-off is confirmed, and does not move with the cut") {
+        // Same fall-off, but the intensities now carry a genuine monoclinic 2-fold.
+        const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 2 1");
+        const gemmi::ReciprocalAsu rasu(&sg);
+        const gemmi::GroupOps gops = sg.operations();
+        auto merged = radial_only(8);
+        for (auto& r : merged) {
+            const auto [asu, plus] = rasu.to_asu_sign(gemmi::Op::Miller{{r.h, r.k, r.l}}, gops);
+            const double falloff = std::exp(-30.0 / (r.d * r.d));
+            r.I = 1.0e5 * falloff * SyntheticIntensityFromAsu(asu) / 350.0;
+            r.sigma = r.I / 20.0;
+        }
+        auto two_fold_cc = [&](double d_min) {
+            SearchSpaceGroupOptions o = opt;
+            o.d_min_limit_A = d_min;
+            const auto result = SearchSpaceGroup(merged, o);
+            INFO(SearchSpaceGroupResultToText(result));
+            REQUIRE(result.point_group_hm == "2");
+            double cc = -2.0;
+            for (const auto& s : result.operator_scores)
+                if (s.present)
+                    cc = s.cc;
+            REQUIRE(cc > opt.min_operator_cc);
+            return cc;
+        };
+        // The whole point of normalising: how much of the fall-off is inside the merge no longer
+        // moves the operator's score, so the search resolution cut cannot decide the symmetry.
+        CHECK(std::fabs(two_fold_cc(0.0) - two_fold_cc(6.0)) < 0.05);
+    }
+}