v1.0.0-rc.159 (#69)

This is an UNSTABLE release. It includes many experimental features, as well as many AI generated fixes. We recommend using rc.152 for production use.

* rugnux: Add `--model model.pdb` - score the merged data against an atomic model and compute initial maps. It reports R-work/R-free (scaling the model to the observed amplitudes with an overall scale, an anisotropic B and a flat bulk solvent - the standard few-parameter model, so a batch of maps stays directly comparable) and writes 2Fo-Fc / Fo-Fc electron-density maps (CCP4) plus a map-coefficient MTZ. The structure itself is not refined; the model is only re-fractionalised into the data cell.
* rugnux: The merged reflection output now carries French-Wilson amplitudes (|F| and its sigma) next to the intensities - MTZ `F`/`SIGF`, mmCIF `_refln.F_meas_au`, and the text HKL - computed with the correct centric/acentric Wilson prior and epsilon multiplicity, so a downstream program (e.g. phenix.refine) can refine against amplitudes. The intensity columns are unchanged.
* rugnux: R-free test-set flags are now assigned deterministically and consistently across symmetry - a Bijvoet pair I(+)/I(-) is never split between the work and free sets, and the assignment is a reproducible per-hkl hash that depends only on the reflection index, so every dataset of one crystal form gets the same ~5% free set (what a multi-dataset campaign such as PanDDA needs). On small data the fraction is floored so the test set stays large enough for a stable R-free (~500 reflections, capped at 10%); it stays flat at 5% on ordinary data. When a reference MTZ carries a `FreeR_flag` column its test set is imported instead, letting a whole campaign inherit one shared free set.
* rugnux: A reference MTZ (`--reference-mtz`) can now fix the space group and cell for rotation data too (previously rejected), without being used to scale - the rotation merge stays self-consistent. When the crystal has an indexing (merohedral) ambiguity - a lattice symmetry higher than its Laue symmetry, e.g. P3/P4/P6/C2 - the reference also resolves it: each candidate reindexing (identity plus the twin-law cosets of the metric symmetry) is scored by its intensity correlation against the reference and the data are re-merged in the best-correlating one. This is a metric-preserving relabelling of hkl (the cell is unchanged) and a no-op for a holohedral crystal such as lysozyme.
* rugnux: `--model` validation now aligns the data to the model before scoring - the observed reflections are reindexed into the model's enantiomorph when the two differ only by hand (indistinguishable from merged intensities). A merohedral indexing ambiguity is resolved against the reference MTZ when one is given (so a whole campaign shares one indexing convention); only with a model and no reference does validation fall back to fitting each candidate reindexing and keeping the lowest R-free.
* rugnux: De-novo symmetry - recover a genuine high-symmetry group whose data are imperfectly scaled. Such a merge's within-orbit chi² lands just past the self-consistency bound (each real symmetry step adds a little systematic scatter), right where a merohedral twin also lands, so the chi² ratio alone cannot separate them. The candidate is now rescued when the extra intensity-proportional systematic error it invokes stays small relative to the confirmed subgroup - a genuine symmetry step gains multiplicity without inflating the merge error model's b, whereas a twin forces non-equivalent reflections together and b balloons. Fixes cubic insulin (I23 instead of I222) with no change to any other crystal in the test battery, including the twins that must stay in their lower symmetry.
* Docs: Document the French-Wilson amplitude estimation, R-free flagging, reference-based space-group/ambiguity resolution, and model-based validation/maps in CPU_DATA_ANALYSIS.md.
* Frontend: The status-bar pill now shows a progress bar during detector calibration (previously only during measurement), and the calibration state and its button are labelled "Calibration"/"CALIBRATE" (the internal `Pedestal` state name is unchanged for back-compatibility).Reviewed-on: #69

Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

image_analysis/scale_merge/Merge.cpp

@@ -17,6 +17,8 @@
 #include "../../common/ResolutionShells.h"
 #include "../../common/Definitions.h"
 #include "HKLKey.h"
+#include "RfreeFlags.h"
+#include "FrenchWilson.h"
 
 namespace {
     // Deterministic CC1/2 half-set assignment: a splitmix64 bit-mix of the image's stable index.
@@ -438,9 +440,6 @@ bool MergeOnTheFly::Mask(const IntegrationOutcome &outcome, bool cc_mask) {
 std::vector<MergedReflection> MergeOnTheFly::ExportReflections() {
     std::unique_lock ul(merged_mutex);
 
-    float d_min = std::numeric_limits<float>::max();
-    float d_max = 0.0f;
-
     std::vector<MergedReflection> out;
     out.reserve(accumulator.size());
     for (const auto &accum: accumulator | std::views::values) {
@@ -470,42 +469,11 @@ std::vector<MergedReflection> MergeOnTheFly::ExportReflections() {
         if (!std::isfinite(accum.d) || accum.d <= 0.0f)
             continue;
 
-        d_min = std::min(d_min, accum.d);
-        d_max = std::max(d_max, accum.d);
-
         out.emplace_back(mr);
     }
 
-    const double rfree_fraction = scaling_settings.GetRfreeFraction();
-    if (rfree_fraction > 0.0 && !out.empty()) {
-        if (d_min < d_max && d_min > 0.0f) {
-            constexpr int n_shells = 20;
-
-            const float d_min_pad = d_min * 0.999f;
-            const float d_max_pad = d_max * 1.001f;
-
-            ResolutionShells shells(d_min_pad, d_max_pad, n_shells);
-            std::vector<std::vector<size_t>> shell_groups(n_shells);
-
-            for (size_t i = 0; i < out.size(); ++i) {
-                const auto shell = shells.GetShell(out[i].d);
-                if (!shell.has_value())
-                    continue;
-
-                const int s = *shell;
-                if (s >= 0 && s < n_shells)
-                    shell_groups[s].push_back(i);
-            }
-
-            std::mt19937 rfree_rng(12345u);
-            std::bernoulli_distribution rfree_dist(rfree_fraction);
-
-            for (const auto &group: shell_groups) {
-                for (const size_t idx: group)
-                    out[idx].rfree_flag = rfree_dist(rfree_rng);
-            }
-        }
-    }
+    AssignRfreeFlags(out, space_group_number, scaling_settings.GetRfreeFraction());
+    ApplyFrenchWilson(out, space_group_number);
     return out;
 }