From 5e7b53dd7b5b2feb4c2ac774c0cc0e348fd0b40a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 08:13:46 +0200
Subject: [PATCH 001/122] tools/battery: committed, reproducible validation
 battery

One runner for the open (vs PDB deposition) and in-house (vs XDS) arms,
replacing the scattered scripts outside the repository. Each run writes a
new, read-only directory named <date>_<rugnux git>_<label> holding a copy
of the binary with its sha256 and build flags, manifest.json (inputs,
references, options, host, GPU sharing) and results.json in one schema
for all arms, plus per-set work directories and a Markdown and a
self-contained HTML report (per-arm and per-population pass rates,
resolution gain, ISa/R_meas distributions, timing, failures, delta vs a
baseline run).

- Dataset lists and references are data files: open.json (151 public
  sets, deposited group/cell/resolution, pinned inputs) and inhouse.json
  (standard test crystals and no-crystal controls, XDS references). The
  private arm's manifest stays outside the repository; a private run gets
  its own run directory and report.
- Scoring is setting-invariant: lattice by Niggli-reduced primitive cell
  (beta vs 180-beta, C2 vs I2), symmetry via sgequiv on the open arm and
  by point group against XDS, then merge usability. Re-scoring the rc169
  and rc170 battery outputs reproduces their verdicts.
- Input discovery (`discover`) ranks sweeps by frame count, never by
  file size or sort order; a run never searches, it runs what the
  manifest names.
- `compare A B` flags per-set changes beyond noise; `--rerun-changed`
  reruns them with A's saved binary to separate real changes from
  run-to-run noise.
- `--tier smoke` selects a 22-set subset spanning the populations; a
  full-arm run takes a lock; `--gpulock` queues on the shared GPU and
  marks the timing as not a reference.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .gitignore                 |   3 +
 tools/battery/battery.py   | 445 +++++++++++++++++++++++++++++++++++++
 tools/battery/inhouse.json |  38 ++++
 tools/battery/inputs.py    | 154 +++++++++++++
 tools/battery/open.json    | 153 +++++++++++++
 tools/battery/render.py    | 107 +++++++++
 tools/battery/report.py    | 243 ++++++++++++++++++++
 tools/battery/score.py     | 173 ++++++++++++++
 tools/battery/sgequiv.py   |  47 ++++
 tools/battery/site.json    |  11 +
 10 files changed, 1374 insertions(+)
 create mode 100644 tools/battery/battery.py
 create mode 100644 tools/battery/inhouse.json
 create mode 100644 tools/battery/inputs.py
 create mode 100644 tools/battery/open.json
 create mode 100644 tools/battery/render.py
 create mode 100644 tools/battery/report.py
 create mode 100644 tools/battery/score.py
 create mode 100644 tools/battery/sgequiv.py
 create mode 100644 tools/battery/site.json

diff --git a/.gitignore b/.gitignore
index 8749e6a85..09815790f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -39,3 +39,6 @@ common/GitInfo.cpp
 # Review reports, work plans and investigation notes. They are working material for one task, they
 # go stale the moment the code moves, and Sphinx would publish anything left under docs/.
 docs/review/
+
+# Python bytecode (tools/battery and the root scripts)
+__pycache__/
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
new file mode 100644
index 000000000..97899f090
--- /dev/null
+++ b/tools/battery/battery.py
@@ -0,0 +1,445 @@
+#!/usr/bin/env python3
+"""Rugnux validation battery: run, score, report, compare.
+
+Arms and where their truth comes from:
+  open     public PDB depositions (and a few published small-molecule sets); scored against the
+           deposited space group, cell and resolution. Manifest: open.json (committed).
+  inhouse  standard test crystals measured at PSI (lysozyme, thaumatin, insulin, cytochrome C,
+           myoglobin) plus no-crystal controls; scored against XDS (point group only - XDS never
+           tests a screw axis). Manifest: inhouse.json (committed).
+  private  user data, scored like inhouse. Its manifest lives OUTSIDE the repository (path in the
+           site config) and a private run gets its own run directory and report.
+
+Usage:
+  battery.py run --rugnux BIN --label L [--arm open,inhouse|private] [--only a,b | --tier smoke]
+                 [--build-dir DIR] [--gpulock] [--threads N] [--unforced] [--baseline RUN]
+  battery.py compare RUN_A RUN_B [--all] [--rerun-changed]
+  battery.py report RUN --out DIR [--baseline RUN] re-render a run's report
+  battery.py discover [--refresh]                 open arm: propose inputs for new directories
+  battery.py refs --arm inhouse|private [--write] re-read the XDS references from CORRECT.LP
+
+A run writes <runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_<label>/ holding a copy of the binary,
+manifest.json (what was run, on what, with which references), results.json (one row per set),
+report.md + report.html and work/<arm>/<set>/ (log, report, cif). It is made read-only when done.
+A full-arm run (no --only / --tier) takes the site lock and refuses to start if another holds it.
+"""
+import argparse
+import datetime
+import fcntl
+import hashlib
+import json
+import os
+import re
+import shutil
+import socket
+import stat
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, HERE)
+
+import inputs  # noqa: E402
+import report  # noqa: E402
+import score   # noqa: E402
+
+DEFAULT_SITE = os.path.join(HERE, "site.json")
+
+
+# ------------------------------------------------------------------ configuration and manifests
+
+def load_site(path):
+    site = json.load(open(path))
+    for arm in site["arms"].values():
+        arm["manifest"] = os.path.join(HERE, arm["manifest"])   # an absolute path stays as it is
+    return site
+
+
+def load_sets(site, arm):
+    cfg = site["arms"][arm]
+    man = json.load(open(cfg["manifest"]))
+    for e in man["sets"]:
+        e["arm"] = arm
+    return man["sets"]
+
+
+def select(site, arms, only, tier):
+    sets = [e for arm in arms for e in load_sets(site, arm)]
+    if only:
+        want = [s.strip() for s in only.split(",") if s.strip()]
+        unknown = [w for w in want if w not in {e["id"] for e in sets}]
+        if unknown:
+            sys.exit(f"not in the {'/'.join(arms)} manifest(s): {', '.join(unknown)}")
+        sets = [e for e in sets if e["id"] in want]
+    if tier:
+        sets = [e for e in sets if tier in e.get("tiers", {})]
+    return sets
+
+
+# ------------------------------------------------------------------ the binary
+
+def sha256(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as fh:
+        for block in iter(lambda: fh.read(1 << 20), b""):
+            h.update(block)
+    return h.hexdigest()
+
+
+def binary_info(path, build_dir):
+    """Version and git hash as the binary itself prints them, plus the build flags from the
+    CMakeCache of its build tree (given, or found above the binary)."""
+    out = subprocess.run([path], capture_output=True, text=True, timeout=120).stdout
+    m = re.search(r"Version (\S+) \(git (\w+)", out)
+    info = {"version": m.group(1) if m else None, "git": m.group(2) if m else "unknown"}
+    cache = None
+    d = build_dir or os.path.dirname(os.path.realpath(path))
+    for _ in range(4):
+        if os.path.exists(os.path.join(d, "CMakeCache.txt")):
+            cache = os.path.join(d, "CMakeCache.txt")
+            break
+        d = os.path.dirname(d)
+    if cache:
+        vals = {}
+        for line in open(cache, errors="replace"):
+            m = re.match(r"^(CMAKE_BUILD_TYPE|CMAKE_CXX_FLAGS|CMAKE_HOME_DIRECTORY|JFJOCH_USE_CUDA):\w+=(.*)$",
+                         line.strip())
+            if m:
+                vals[m.group(1)] = m.group(2)
+        info["cmake_cache"] = cache
+        info["flags"] = (f"{vals.get('CMAKE_BUILD_TYPE', '?')} CXX_FLAGS='{vals.get('CMAKE_CXX_FLAGS', '')}' "
+                         f"CUDA={vals.get('JFJOCH_USE_CUDA', '?')}")
+        src = vals.get("CMAKE_HOME_DIRECTORY")
+        if src:
+            info["source"] = src
+            info["source_head"] = git(src, "rev-parse", "HEAD")
+            info["source_dirty"] = bool(git(src, "status", "--porcelain", "--untracked-files=no"))
+    return info
+
+
+def git(d, *args):
+    r = subprocess.run(["git", "-C", d] + list(args), capture_output=True, text=True)
+    return r.stdout.strip() if r.returncode == 0 else None
+
+
+def gpu_others():
+    """Number of processes other than ours on the GPU right now (None if nvidia-smi is absent)."""
+    try:
+        out = subprocess.run(["nvidia-smi", "--query-compute-apps=pid", "--format=csv,noheader"],
+                             capture_output=True, text=True, timeout=30).stdout
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return len([x for x in out.split() if x.strip().isdigit()])
+
+
+# ------------------------------------------------------------------ running
+
+def command(binary, e, opts):
+    cmd = [binary, "-o", "p", "--no-export-unmerged"]
+    if opts["threads"]:
+        cmd += ["-N", str(opts["threads"])]
+    ref = e.get("ref") or {}
+    # On an XDS-referenced arm the only thing fixed is XDS's resolution range, so the two programs
+    # merge the same reflections. --unforced leaves rugnux its own cut.
+    if opts["xds_range"] and e.get("reference") == "xds":
+        if ref.get("dmin"):
+            cmd += ["--scaling-high-resolution", f"{ref['dmin']:.3f}"]
+        if ref.get("dmax"):
+            cmd += ["--scaling-low-resolution", f"{ref['dmax']:.3f}"]
+    cmd += opts["extra_args"]
+    cmd.append(e["input_path"])
+    if opts["gpulock"]:
+        cmd = [opts["gpulock"]] + cmd
+    return cmd
+
+
+def failure_note(log):
+    """rugnux's own last error message, without the spdlog timestamp and severity prefix."""
+    try:
+        lines = [l.strip() for l in open(log, errors="replace") if l.strip()]
+    except OSError:
+        return ""
+    for l in reversed(lines):
+        if "[error]" in l or "failed" in l.lower():
+            return l.split("] ")[-1][:300]
+    return lines[-1].split("] ")[-1][:300] if lines else ""
+
+
+def run_one(run_dir, binary, e, opts):
+    wd = os.path.join(run_dir, "work", e["arm"], e["id"])
+    os.makedirs(wd)
+    row = {"set": e["id"], "arm": e["arm"], "tags": e.get("tags", []), "input": e["input_path"],
+           "gpu_others": gpu_others()}
+    if not os.path.exists(e["input_path"]):
+        row.update(score.judge(e, {}, "no input"), exit_code=None, elapsed_s=None, wall_s=None, cmd=None)
+        return row
+    cmd = command(binary, e, opts)
+    row["cmd"] = " ".join(cmd)
+    t0 = time.time()
+    note = ""
+    with open(os.path.join(wd, "run.log"), "w") as log:
+        try:
+            rc = subprocess.run(cmd, cwd=wd, stdout=log, stderr=subprocess.STDOUT,
+                                timeout=opts["timeout"]).returncode
+        except subprocess.TimeoutExpired:
+            rc, note = None, "timeout"
+    row["elapsed_s"] = round(time.time() - t0, 1)
+    row["exit_code"] = rc
+    if rc:
+        note = f"exit {rc}: {failure_note(os.path.join(wd, 'run.log'))}"
+    row.update(score.judge(e, score.read_report(os.path.join(wd, "p_report.txt")), note))
+    # rugnux's own WALL_TIME where it wrote one: the runner's clock also counts the wait for a
+    # GPU slot under --gpulock
+    row["wall_s"] = row["rugnux_wall_s"] if row["rugnux_wall_s"] is not None else row["elapsed_s"]
+    return row
+
+
+def make_read_only(path):
+    for dp, dirs, files in os.walk(path):
+        for fn in files:
+            p = os.path.join(dp, fn)
+            if not os.path.islink(p):
+                os.chmod(p, os.stat(p).st_mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH))
+    for dp, dirs, files in os.walk(path, topdown=False):
+        os.chmod(dp, os.stat(dp).st_mode & ~(stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH))
+
+
+def write_json(path, obj):
+    with open(path + ".tmp", "w") as fh:
+        json.dump(obj, fh, indent=1)
+    os.replace(path + ".tmp", path)
+
+
+def write_manifest(path, man):
+    """A manifest with one set per line, so a diff of it reads set by set."""
+    lines = [json.dumps(e) for e in man["sets"]]
+    head = json.dumps({k: v for k, v in man.items() if k != "sets"})[:-1]
+    with open(path, "w") as fh:
+        fh.write(head + ', "sets": [\n ' + ",\n ".join(lines) + "\n]}\n")
+
+
+def write_report(run_dir, baseline=None, out_dir=None):
+    """report.md and report.html (report_PRIVATE.* for a private run) into out_dir, by default
+    the run directory itself."""
+    man = json.load(open(os.path.join(run_dir, "manifest.json")))
+    base = os.path.join(out_dir or run_dir, "report_PRIVATE" if man.get("private") else "report")
+    doc = report.build(run_dir, baseline)
+    open(base + ".md", "w").write(doc.markdown())
+    open(base + ".html", "w").write(doc.html())
+    return base + ".html"
+
+
+def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, baseline=None, lock=None):
+    """Run the given manifest rows into a new run directory. Returns the directory."""
+    private = any(site["arms"][a].get("private") for a in arms)
+    if private and len(arms) > 1:
+        sys.exit("the private arm runs on its own: its results must not share a run or a report")
+    lock_fh = None
+    if lock:
+        os.makedirs(os.path.dirname(lock), exist_ok=True)
+        lock_fh = open(lock, "w")
+        try:
+            fcntl.flock(lock_fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except BlockingIOError:
+            sys.exit(f"another full battery run holds {lock}; refusing to start a second one")
+
+    info = binary_info(binary_src, build_dir)
+    stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M")
+    run_dir = os.path.join(opts["runs_root"],
+                           f"{stamp}_{info['git']}_{label}" + ("_private" if private else ""))
+    os.makedirs(run_dir)                      # never reuse or overwrite a run directory
+    binary = os.path.join(run_dir, "bin", "rugnux")
+    os.makedirs(os.path.dirname(binary))
+    shutil.copy2(binary_src, binary)
+    info.update(copied_from=os.path.realpath(binary_src), sha256=sha256(binary))
+
+    for e in sets:
+        e["reference"] = site["arms"][e["arm"]]["reference"]
+        e.setdefault("input_path", os.path.join(site["arms"][e["arm"]]["data_root"], e["input"]))
+    man = {"label": label, "arms": arms, "private": private, "subset": subset, "baseline": baseline,
+           "binary": info,
+           "runner_git": git(HERE, "rev-parse", "--short", "HEAD") or "unknown",
+           "runner_dirty": bool(git(HERE, "status", "--porcelain", "--", ".")),
+           "host": socket.gethostname(), "start": datetime.datetime.now().isoformat(timespec="seconds"),
+           "end": None, "complete": False, "options": {k: v for k, v in opts.items() if k != "runs_root"},
+           "gpu_shared": bool(opts["gpulock"]), "sets": sets}
+    write_json(os.path.join(run_dir, "manifest.json"), man)
+    print(f"run directory {run_dir}", flush=True)
+
+    results = []
+    for n, e in enumerate(sets, 1):
+        row = run_one(run_dir, binary, e, opts)
+        results.append(row)
+        if row.get("gpu_others"):
+            man["gpu_shared"] = True
+        write_json(os.path.join(run_dir, "results.json"), results)
+        print(f"[{n}/{len(sets)}] {e['arm']:8s} {e['id']:24s} {row['verdict']:8s} "
+              f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
+              f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
+
+    man.update(end=datetime.datetime.now().isoformat(timespec="seconds"), complete=True)
+    write_json(os.path.join(run_dir, "manifest.json"), man)
+    print(f"report {write_report(run_dir, baseline)}", flush=True)
+    make_read_only(run_dir)
+    if lock_fh:
+        lock_fh.close()
+    return run_dir
+
+
+# ------------------------------------------------------------------ subcommands
+
+def cmd_run(a, site):
+    arms = [x.strip() for x in a.arm.split(",")]
+    for arm in arms:
+        if arm not in site["arms"]:
+            sys.exit(f"unknown arm {arm}; the site config has {', '.join(site['arms'])}")
+    sets = select(site, arms, a.only, a.tier)
+    if not sets:
+        sys.exit("nothing selected")
+    subset = a.only or (f"tier {a.tier}" if a.tier else None)
+    opts = {"threads": a.threads, "xds_range": not a.unforced, "timeout": a.timeout,
+            "gpulock": site["gpulock"] if a.gpulock else None, "extra_args": a.extra.split(),
+            "runs_root": a.runs_root or site["runs_root"]}
+    run_sets(site, sets, arms, a.rugnux, a.build_dir, a.label, opts, subset, a.baseline,
+             lock=None if subset else site["lock_file"])
+
+
+def cmd_compare(a, site):
+    man_a, res_a = report.load_run(a.run_a)
+    man_b, res_b = report.load_run(a.run_b)
+    rows = report.compare_rows(res_a, res_b)
+    doc = report.Doc(f"{os.path.basename(os.path.normpath(a.run_a))}  vs  "
+                     f"{os.path.basename(os.path.normpath(a.run_b))}")
+    doc.p(f"A: rugnux {man_a['binary'].get('version')} ({man_a['binary']['sha256'][:12]}); "
+          f"B: rugnux {man_b['binary'].get('version')} ({man_b['binary']['sha256'][:12]}). "
+          f"{len(rows)} sets, {sum(1 for r in rows if r[3])} changed beyond noise.")
+    report.compare_table(doc, rows, only_changed=not a.all)
+    print(doc.markdown())
+    if not a.rerun_changed:
+        return
+    # Rerun the changed sets with A's own binary and options: a set that moves again under the
+    # same binary was noise; one that reproduces A was changed by B for real.
+    changed = {k for k, ra, rb, ch in rows if ra and rb and [c for c in ch if c != "time"]}
+    if not changed:
+        print("nothing changed beyond noise; no rerun")
+        return
+    sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in changed]
+    opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"])
+    label = "rerunA-" + man_a["label"]
+    rerun = run_sets(site, sets, man_a["arms"], os.path.join(a.run_a, "bin", "rugnux"), None, label,
+                     opts, ",".join(e["id"] for e in sets))
+    _, res_a2 = report.load_run(rerun)
+    again = {k: ch for k, ra, ra2, ch in report.compare_rows(res_a, res_a2) if ra and ra2}
+    doc = report.Doc("Changed sets, rerun with A's binary")
+    rows_out = []
+    for k, ra, rb, ch in rows:
+        if k not in changed:
+            continue
+        noise = [c for c in again.get(k, []) if c != "time"]
+        rows_out.append([k[1], k[0], ", ".join(c for c in ch if c != "time"),
+                         ", ".join(noise) or "-",
+                         "NOISE - A itself moved" if noise else "REAL - A reproduces"])
+    doc.table(["set", "arm", "A -> B", "A -> A again", "reading"], rows_out)
+    doc.p(f"rerun directory: {rerun}")
+    print(doc.markdown())
+
+
+def cmd_report(a, site):
+    # a finished run directory is read-only, so a re-render goes elsewhere
+    os.makedirs(a.out, exist_ok=True)
+    print(write_report(a.run, a.baseline, a.out))
+
+
+def cmd_discover(a, site):
+    """Propose an input for every open-arm directory the manifest does not have yet; with
+    --refresh, also show where today's discovery disagrees with the manifest's (unpinned) input."""
+    cfg = site["arms"]["open"]
+    root = cfg["data_root"]
+    sets = {e["id"]: e for e in load_sets(site, "open")}
+    for d in sorted(os.listdir(root)):
+        if d.startswith(".") or not os.path.isdir(os.path.join(root, d)):
+            continue
+        e = sets.get(d)
+        if e and (not a.refresh or e.get("pinned")):
+            continue
+        path, fmt, note = inputs.find_input(os.path.join(root, d))
+        rel = os.path.relpath(path, root) if path else None
+        if not e:
+            print(f"NEW   {d:10s} {rel}   [{note}]")
+        elif rel != e["input"]:
+            print(f"DIFF  {d:10s} manifest {e['input']}\n      {'':10s} discover {rel}   [{note}]")
+    for d in sorted(set(sets) - set(os.listdir(root))):
+        print(f"GONE  {d:10s} in the manifest, not on disk")
+
+
+def cmd_refs(a, site):
+    """Re-read every set's XDS reference from the CORRECT.LP beside its input."""
+    cfg = site["arms"][a.arm]
+    if cfg["reference"] != "xds":
+        sys.exit(f"the {a.arm} arm is not referenced to XDS")
+    man = json.load(open(cfg["manifest"]))
+    for e in man["sets"]:
+        lp = os.path.join(cfg["data_root"], os.path.dirname(e["input"]), "CORRECT.LP")
+        if not os.path.exists(lp):
+            print(f"{e['id']:24s} no CORRECT.LP")
+            continue
+        new = inputs.parse_correct_lp(lp)
+        if new != e.get("ref"):
+            print(f"{e['id']:24s} {e.get('ref')}\n{'':24s} -> {new}")
+            e["ref"] = new
+    if a.write:
+        write_manifest(cfg["manifest"], man)
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
+    ap.add_argument("--site", default=os.environ.get("BATTERY_SITE", DEFAULT_SITE),
+                    help="site config (data roots, runs root, private manifest, lock file)")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("run")
+    r.add_argument("--rugnux", required=True)
+    r.add_argument("--label", required=True, help="short name, part of the run directory's name")
+    r.add_argument("--arm", default="open,inhouse", help="comma-separated (default: open,inhouse)")
+    r.add_argument("--only", help="comma-separated set ids")
+    r.add_argument("--tier", help="named subset from the manifests, e.g. smoke")
+    r.add_argument("--build-dir", help="build tree whose CMakeCache.txt records the flags")
+    r.add_argument("--gpulock", action="store_true",
+                   help="queue each rugnux behind the site's GPU lock (timing is then not a reference)")
+    r.add_argument("--threads", type=int, default=0, help="-N for rugnux (default: its own choice)")
+    r.add_argument("--unforced", action="store_true",
+                   help="do not force XDS's resolution range on the XDS-referenced arms")
+    r.add_argument("--timeout", type=int, default=10800)
+    r.add_argument("--extra", default="", help="extra rugnux arguments, applied to every set")
+    r.add_argument("--baseline", help="earlier run directory to report the delta against")
+    r.add_argument("--runs-root")
+
+    c = sub.add_parser("compare")
+    c.add_argument("run_a")
+    c.add_argument("run_b")
+    c.add_argument("--all", action="store_true", help="list unchanged sets too")
+    c.add_argument("--rerun-changed", action="store_true",
+                   help="rerun the changed sets with A's saved binary to separate real change from noise")
+    c.add_argument("--runs-root")
+
+    p = sub.add_parser("report")
+    p.add_argument("run")
+    p.add_argument("--baseline")
+    p.add_argument("--out", required=True, help="directory for the re-rendered report")
+
+    d = sub.add_parser("discover")
+    d.add_argument("--refresh", action="store_true")
+
+    f = sub.add_parser("refs")
+    f.add_argument("--arm", required=True)
+    f.add_argument("--write", action="store_true")
+
+    a = ap.parse_args()
+    site = load_site(a.site)
+    {"run": cmd_run, "compare": cmd_compare, "report": cmd_report,
+     "discover": cmd_discover, "refs": cmd_refs}[a.cmd](a, site)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
new file mode 100644
index 000000000..f9cb11b12
--- /dev/null
+++ b/tools/battery/inhouse.json
@@ -0,0 +1,38 @@
+{"arm": "inhouse", "sets": [
+ {"id": "E08_lyso_2_006", "input": "E08_lyso_2_006/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "E08_lyso_2_007", "input": "E08_lyso_2_007/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_2", "input": "lyso_2/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_6_5keV", "input": "lyso_6_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
+ {"id": "lysoC_14_f46f0a", "input": "lysoC_14_f46f0a/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_ref", "input": "lyso_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
+ {"id": "lyso_strong", "input": "lyso_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_half_image", "input": "lyso_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "thau_16keV", "input": "thau_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "Thau_9", "input": "Thau_9/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_BL1A_1p9A", "input": "thau_BL1A_1p9A/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_BL1A_2p7A", "input": "thau_BL1A_2p7A/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_BL1A_3p3A", "input": "thau_BL1A_3p3A/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
+ {"id": "thau_injection", "input": "thau_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_pink", "input": "thau_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
+ {"id": "Ins_H_2_fa9841", "input": "Ins_H_2_fa9841/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "Ins_H_3_d05684", "input": "Ins_H_3_d05684/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
+ {"id": "Ins_I_16", "input": "Ins_I_16/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
+ {"id": "Ins_I_2_1a530d", "input": "Ins_I_2_1a530d/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "Ins_I_3_5e90e3", "input": "Ins_I_3_5e90e3/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "Ins_I_6_13keV", "input": "Ins_I_6_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "Ins_I_6_5keV", "input": "Ins_I_6_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "Ins_I_6_6keV", "input": "Ins_I_6_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "Ins_I_7_5keV", "input": "Ins_I_7_5keV/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
+ {"id": "cytC_10", "input": "cytC_10/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytC_2_0770b5", "input": "cytC_2_0770b5/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytC_3_874285", "input": "cytC_3_874285/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "MyoB_13", "input": "MyoB_13/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
+ {"id": "MyoB_9_446b70", "input": "MyoB_9_446b70/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
+ {"id": "MyoB2-1", "input": "MyoB2-1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
+ {"id": "MyoB2-2", "input": "MyoB2-2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "MyoB2-4", "input": "MyoB2-4/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "MyoB2-5", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "onlyice", "input": "onlyice/onlyice_master.h5", "expect": "no_lattice", "tags": ["h5", "control"], "tiers": {"smoke": "no-crystal control (ice rings only): must refuse"}},
+ {"id": "nothing_3400ac", "input": "nothing/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
+ {"id": "nothing_9bf604", "input": "nothing/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
+]}
diff --git a/tools/battery/inputs.py b/tools/battery/inputs.py
new file mode 100644
index 000000000..9f1ee9daa
--- /dev/null
+++ b/tools/battery/inputs.py
@@ -0,0 +1,154 @@
+"""Finding a dataset's input file, and reading an XDS CORRECT.LP as a reference.
+
+Both run only when a manifest is (re)built - `battery.py discover` and `battery.py refs`. A battery
+run itself never searches: it runs the input the manifest names, so two runs of one manifest always
+process the same files.
+"""
+import glob
+import os
+import re
+
+# XDS writes calibration images beside the frames; none of them is a sweep.
+XDS_AUX = ("-CORRECTIONS", "BKGINIT", "BKGPIX", "BLANK", "GAIN", "DECAY", "ABS.", "MODPIX", "FRAME.")
+
+
+def master_frames(path):
+    """Number of frames a NXmx master describes.
+
+    A sweep is chosen by frame count, never by file size: a master with a few embedded screening
+    frames can outweigh the master of a real sweep whose frames sit in external data files."""
+    import h5py
+    try:
+        with h5py.File(path, "r") as h:
+            det = "entry/instrument/detector/detectorSpecific"
+            if f"{det}/nimages" in h:
+                n = int(h[f"{det}/nimages"][()])
+                if f"{det}/ntrigger" in h:
+                    n *= max(1, int(h[f"{det}/ntrigger"][()]))
+                return n
+            omega = "entry/sample/goniometer/omega"
+            if omega in h and h[omega].shape:
+                return int(h[omega].shape[0])
+            n = 0
+            for k in h.get("entry/data", {}):
+                try:
+                    n += int(h["entry/data"][k].shape[0])
+                except (KeyError, OSError):   # an external link whose file is missing
+                    pass
+            return n
+    except OSError:
+        return 0
+
+
+def detector_frame(path):
+    """'marCCD' or 'SMV' if the file's header says so, else None. These formats have no reliable
+    extension (.mccd, .img, .001, ...; .img is SMV at one site and marCCD at the next)."""
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(64)
+            if head[:2] in (b"II", b"MM"):
+                fh.seek(1028)
+                return "marCCD" if fh.read(3) == b"MMX" else None
+            if head[:1] == b"{" and b"HEADER_BYTES" in head:
+                return "SMV"
+    except OSError:
+        pass
+    return None
+
+
+def find_input(d):
+    """(input file, format, note) for the largest sweep under directory d, or (None, None, why).
+
+    Frames are grouped per directory by template (the last run of digits in the name), and the
+    biggest group by frame count wins; a tie goes to the alphabetically first. Groups are never
+    merged across directories - two crystals can have identically named frames side by side."""
+    masters = [m for m in glob.glob(f"{d}/**/*master*.h5", recursive=True)
+               if not os.path.basename(m).startswith("._")]
+    if not masters:
+        # Diamond writes a NeXus .nxs master beside _NNNNNN.h5 data files
+        masters = [m for m in glob.glob(f"{d}/**/*.nxs", recursive=True)
+                   if not os.path.basename(m).startswith("._") and "meta" not in os.path.basename(m)]
+    if masters:
+        best = min(masters, key=lambda m: (-master_frames(m), m))
+        return best, "nxs" if best.endswith(".nxs") else "h5", \
+            f"master, {master_frames(best)} frames, {len(masters)} master(s)"
+
+    groups = {}
+    for p in glob.glob(f"{d}/**/*", recursive=True):
+        name = os.path.basename(p)
+        if not os.path.isfile(p) or name.startswith("._") or any(a in name.upper() for a in XDS_AUX):
+            continue
+        key = (os.path.dirname(p), re.sub(r"\d+(?=\D*$)", "#", name))
+        groups.setdefault(key, []).append(p)
+    for key, files in sorted(groups.items(), key=lambda kv: (-len(kv[1]), kv[0])):
+        if len(files) < 10:
+            break
+        files.sort()
+        if files[0].endswith((".cbf", ".cbf.gz")):
+            fmt = "cbf"
+        else:
+            fmt = detector_frame(files[0])
+        if fmt:
+            return files[0], fmt, f'{fmt} "{key[1]}" x{len(files)} of {len(groups)} group(s)'
+    return None, None, "no readable sweep found"
+
+
+def input_format(path):
+    """Format tag of an input file named in a manifest."""
+    if path.endswith(".h5"):
+        return "h5"
+    if path.endswith(".nxs"):
+        return "nxs"
+    if path.endswith((".cbf", ".cbf.gz")):
+        return "cbf"
+    return detector_frame(path) or "other"
+
+
+def parse_correct_lp(path):
+    """Reference values from an XDS CORRECT.LP: the space group and cell CORRECT refined, the
+    resolution range it merged, and its overall merging statistics.
+
+    CORRECT.LP states the group and cell twice - first as the INPUT to INTEGRATE (routinely P1),
+    then as CORRECT's own answer. The last SPACE_GROUP_NUMBER and the refined UNIT CELL PARAMETERS
+    are the ones the statistics were computed in."""
+    txt = open(path, errors="replace").read()
+    ref = {}
+    sgs = re.findall(r"SPACE_GROUP_NUMBER=\s*(\d+)", txt)
+    ref["sgno"] = int(sgs[-1]) if sgs else None
+    cells = re.findall(r"UNIT CELL PARAMETERS\s+([\d.\s]+)", txt)
+    if cells:
+        ref["cell"] = [float(x) for x in cells[-1].split()[:6]]
+    else:
+        m = re.findall(r"UNIT_CELL_CONSTANTS=\s*([\d.\s]+)", txt)
+        ref["cell"] = [float(x) for x in m[-1].split()[:6]] if m else None
+    m = re.search(r"FRIEDEL'S_LAW=\s*(TRUE|FALSE)", txt)
+    ref["anomalous"] = bool(m and m.group(1) == "FALSE")
+    m = re.search(r"^\s*a\s+b\s+ISa\s*\n\s*[\d.Ee+-]+\s+[\d.Ee+-]+\s+([\d.]+)", txt, re.M)
+    ref["isa"] = float(m.group(1)) if m else None
+
+    # the last "... AS FUNCTION OF RESOLUTION" table; shells from low to high resolution, then total
+    seg = txt[txt.rfind("AS FUNCTION OF RESOLUTION"):]
+    num = lambda x: float(x.rstrip("*%"))
+    shells, total = [], None
+    for line in seg.splitlines():
+        f = line.split()
+        if f and f[0] == "total" and len(f) >= 11:
+            total = f
+            break
+        if f and re.match(r"^\d+\.\d+$", f[0]) and len(f) >= 11:
+            shells.append(f)
+    if total:
+        ref["completeness"] = num(total[4])
+        ref["r_meas"] = round(num(total[9]) / 100, 4)
+        ref["cc_half"] = round(num(total[10]) / 100, 4)
+        ref["multiplicity"] = round(int(total[1]) / int(total[2]), 2) if int(total[2]) else None
+
+    # The resolution range to hand to rugnux so both programs merge the same reflections: the
+    # explicit INCLUDE_RESOLUTION_RANGE, or - when XDS.INP left the high limit at 0.0, "the whole
+    # detector" - the finest shell actually tabulated.
+    m = re.search(r"INCLUDE_RESOLUTION_RANGE=\s*([\d.]+)\s+([\d.]+)", txt)
+    include_low, include_high = (float(m.group(1)), float(m.group(2))) if m else (0.0, 0.0)
+    table_high = float(shells[-1][0]) if shells else 0.0
+    ref["dmin"] = (include_high if include_high > 0 else table_high) or None
+    ref["dmax"] = include_low or None
+    return ref
diff --git a/tools/battery/open.json b/tools/battery/open.json
new file mode 100644
index 000000000..d7f9da2e6
--- /dev/null
+++ b/tools/battery/open.json
@@ -0,0 +1,153 @@
+{"arm": "open", "sets": [
+ {"id": "11if", "input": "11if/BopeA_18500_a_B2-PEF_11if/data/PSL-1503_13949_master.h5", "ref": {"sg": "P 43", "sgno": 78, "cell": [51.14, 51.14, 71.92, 90.0, 90.0, 90.0], "dmin": 1.51}, "tags": ["h5", "tetragonal"], "tiers": {"smoke": "Eiger NXmx from another facility, 4-fold screw"}},
+ {"id": "36gk", "input": "36gk/CLS-0074_5-3_36GK/data/CLS-0074_5-3_master.h5", "ref": {"sg": "I 2 2 2", "sgno": 23, "cell": [120.58, 189.49, 199.69, 90.0, 90.0, 90.0], "dmin": 2.28}, "tags": ["h5", "orthorhombic"]},
+ {"id": "3inp", "input": "3inp/IDP02542_3inp/data/idp02542b.001", "ref": {"sg": "F 41 3 2", "sgno": 210, "cell": [224.08, 224.08, 224.08, 90.0, 90.0, 90.0], "dmin": 2.05}, "tags": ["marCCD", "cubic"]},
+ {"id": "3ky7", "input": "3ky7/IDP90258_3ky7/data/idp90258f.001", "ref": {"sg": "P 43 3 2", "sgno": 212, "cell": [125.176, 125.176, 125.176, 90.0, 90.0, 90.0], "dmin": 2.35}, "tags": ["marCCD", "cubic"]},
+ {"id": "5ebi", "input": "5ebi/dna-rna-chimera_Ba_high_2_001.img", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [35.72, 44.1, 35.72, 90.0, 119.98, 90.0], "dmin": 1.09}, "pinned": true, "tags": ["marCCD", "monoclinic", "twin"]},
+ {"id": "5epe", "input": "5epe/030805_5epe/data/E1_7_set.001", "ref": {"sg": "F 2 3", "sgno": 196, "cell": [157.536, 157.536, 157.536, 90.0, 90.0, 90.0], "dmin": 1.9}, "tags": ["marCCD", "cubic"]},
+ {"id": "5f6m", "input": "5f6m/crystal3_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [54.81, 58.51, 67.42, 90.0, 90.0, 90.0], "dmin": 1.1}, "tags": ["cbf", "orthorhombic", "diffuse"]},
+ {"id": "5j23", "input": "5j23/012132_5j23/data/XZ2_set.001", "ref": {"sg": "H 3", "sgno": 146, "cell": [175.822, 175.822, 136.839, 90.0, 90.0, 120.0], "dmin": 2.3}, "tags": ["marCCD", "trigonal", "twin"]},
+ {"id": "5jvn", "input": "5jvn/5jvn/data/PPDK-AV2820_w1_3_0001.cbf", "ref": {"sg": "P 6 2 2", "sgno": 177, "cell": [249.43, 249.43, 84.06, 90.0, 90.0, 120.0], "dmin": 2.9}, "tags": ["cbf", "hexagonal"]},
+ {"id": "5lzl", "input": "5lzl/pcalad/alad-levoil6_M3S15_1_0001.cbf", "ref": {"sg": "P 31 2 1", "sgno": 152, "cell": [205.561, 205.561, 199.171, 90.0, 90.0, 120.0], "dmin": 3.47}, "tags": ["cbf", "trigonal"]},
+ {"id": "5m17", "input": "5m17/BxGH99_WTDD_HA00AG2801_2_0001.cbf", "ref": {"sg": "I 4", "sgno": 79, "cell": [108.576, 108.576, 67.746, 90.0, 90.0, 90.0], "dmin": 1.03}, "tags": ["cbf", "tetragonal"]},
+ {"id": "5nw5", "input": "5nw5/5NW5_1_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [92.14, 169.8, 390.16, 90.0, 90.0, 90.0], "dmin": 6.502}, "tags": ["cbf", "orthorhombic", "low-resolution"]},
+ {"id": "5reo", "input": "5reo/cbf/Mpro-x0752_1_0001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [112.39, 52.59, 44.38, 90.0, 103.04, 90.0], "dmin": 1.88}, "tags": ["cbf", "monoclinic"], "tiers": {"smoke": "fastest set (10 s): miniCBF, monoclinic"}},
+ {"id": "5src", "input": "5src/5src/data/FRS004_15_1_00001.cbf", "ref": {"sg": "P 43", "sgno": 78, "cell": [88.68, 88.68, 39.23, 90.0, 90.0, 90.0], "dmin": 1.05}, "tags": ["cbf", "tetragonal"]},
+ {"id": "6fid", "input": "6fid/Trypsin_x1_align_2_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [59.947, 64.107, 69.694, 90.0, 90.0, 90.0], "dmin": 2.2}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6fvz", "input": "6fvz/maox215_6fvz/data/maox215_w1_1_0001.cbf", "ref": {"sg": "C 2 2 2", "sgno": 21, "cell": [131.182, 222.753, 86.482, 90.0, 90.0, 90.0], "dmin": 1.8}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6fwc", "input": "6fwc/maox225_6fwc/data/maox225_1_00001.cbf", "ref": {"sg": "C 2 2 2", "sgno": 21, "cell": [131.728, 222.051, 86.293, 90.0, 90.0, 90.0], "dmin": 1.7}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6h2p", "input": "6h2p/ProlMut1MnCAC_6h2p/data/Prol_Mut1_Mn_X_pk1_2_0001.cbf", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [103.453, 107.075, 216.543, 90.0, 90.0, 90.0], "dmin": 1.479}, "tags": ["cbf", "orthorhombic", "long-wavelength"]},
+ {"id": "6h5t", "input": "6h5t/6h5t/data/SH3-1_x2_1_001.img", "ref": {"sg": "I 4 2 2", "sgno": 97, "cell": [86.792, 86.792, 141.768, 90.0, 90.0, 90.0], "dmin": 1.689}, "tags": ["marCCD", "tetragonal"]},
+ {"id": "6hv2", "input": "6hv2/6hv2/data/coll_1_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [68.928, 68.928, 133.563, 90.0, 90.0, 120.0], "dmin": 1.709}, "tags": ["h5", "hexagonal"]},
+ {"id": "6hwj", "input": "6hwj/bg3006_2_0001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [59.812, 96.07, 80.252, 90.0, 106.69, 90.0], "dmin": 1.979}, "tags": ["cbf", "monoclinic"]},
+ {"id": "6i3j", "input": "6i3j/6i3j/data/BF19_go_1_0001.img", "ref": {"sg": "F 2 2 2", "sgno": 22, "cell": [134.382, 203.846, 226.744, 90.0, 90.0, 90.0], "dmin": 2.59}, "tags": ["marCCD", "orthorhombic"]},
+ {"id": "6iu5", "input": "6iu5/6iu5_VIT1_MBD_Zn/peak/peak_000001.cbf", "ref": {"sg": "P 31", "sgno": 144, "cell": [84.942, 84.942, 98.19, 90.0, 90.0, 120.0], "dmin": 2.25}, "pinned": true, "tags": ["cbf", "trigonal", "twin"]},
+ {"id": "6iu6", "input": "6iu6/6iu6_VIT1_MBD_Ni/peak/peak_000001.cbf", "ref": {"sg": "P 31", "sgno": 144, "cell": [84.744, 84.744, 97.398, 90.0, 90.0, 120.0], "dmin": 2.9}, "pinned": true, "tags": ["cbf", "trigonal", "twin"]},
+ {"id": "6iu8", "input": "6iu8/6iu8_VIT1_MBD_Co/low/low_000001.cbf", "ref": {"sg": "P 31", "sgno": 144, "cell": [85.503, 85.503, 98.355, 90.0, 90.0, 120.0], "dmin": 2.7}, "tags": ["cbf", "trigonal"]},
+ {"id": "6iu9", "input": "6iu9/6iu9_VIT1_MBD_Fe/peak/data01_000001.cbf", "ref": {"sg": "P 31", "sgno": 144, "cell": [85.321, 85.321, 97.573, 90.0, 90.0, 120.0], "dmin": 3.0}, "pinned": true, "tags": ["cbf", "trigonal", "twin"]},
+ {"id": "6jgi", "input": "6jgi/6jgi/data/00001.img", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [50.857, 62.403, 69.172, 90.0, 90.0, 90.0], "dmin": 0.85}, "tags": ["marCCD", "orthorhombic"]},
+ {"id": "6jgj", "input": "6jgj/6jgj/data/000001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [50.87, 62.34, 68.85, 90.0, 90.0, 90.0], "dmin": 0.77}, "tags": ["cbf", "orthorhombic", "cdte"]},
+ {"id": "6moj", "input": "6moj/A9_1_00001.cbf", "ref": {"sg": "I 41 2 2", "sgno": 98, "cell": [130.418, 130.418, 293.453, 90.0, 90.0, 90.0], "dmin": 2.431}, "tags": ["cbf", "tetragonal"]},
+ {"id": "6o2h", "input": "6o2h/lys_nitr_10_1_0001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [27.424, 32.134, 34.513, 88.657, 108.46, 111.877], "dmin": 1.212}, "tags": ["cbf", "triclinic", "diffuse"]},
+ {"id": "6oel", "input": "6oel/1449-8_3_001.img", "ref": {"sg": "F 41 3 2", "sgno": 210, "cell": [328.1, 328.1, 328.1, 90.0, 90.0, 90.0], "dmin": 3.1}, "tags": ["SMV", "cubic"], "tiers": {"smoke": "SMV reader (ADSC), cubic F4132"}},
+ {"id": "6p8p", "input": "6p8p/14_12_1_0001.cbf", "ref": {"sg": "P 4", "sgno": 75, "cell": [97.525, 97.525, 60.134, 90.0, 90.0, 90.0], "dmin": 1.635}, "tags": ["cbf", "tetragonal"]},
+ {"id": "6pb3", "input": "6pb3/14_16_1_000001.cbf", "ref": {"sg": "P 6", "sgno": 168, "cell": [100.436, 100.436, 48.86, 90.0, 90.0, 120.0], "dmin": 2.048}, "tags": ["cbf", "hexagonal"]},
+ {"id": "6pxb", "input": "6pxb/TJB1_3_rachel_1_0001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [64.021, 64.021, 119.447, 90.0, 90.0, 120.0], "dmin": 1.747}, "tags": ["cbf", "trigonal"]},
+ {"id": "6pxc", "input": "6pxc/TJB6_1_Rachel_1_0001.cbf", "ref": {"sg": "I 2 2 2", "sgno": 23, "cell": [44.19, 64.827, 87.239, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6r72", "input": "6r72/V-CK63-8-ld_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [117.805, 110.754, 155.615, 90.0, 93.23, 90.0], "dmin": 3.95}, "pinned": true, "tags": ["h5", "monoclinic"]},
+ {"id": "6rlr", "input": "6rlr/_b4_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [39.986, 39.998, 63.643, 80.39, 76.29, 68.15], "dmin": 2.0}, "tags": ["h5", "triclinic", "twin"]},
+ {"id": "6toc", "input": "6toc/zenodo/dts_1_00001.cbf", "ref": {"sg": "P 42", "sgno": 77, "cell": [31.523, 31.523, 81.599, 90.0, 90.0, 90.0], "dmin": 1.853}, "tags": ["cbf", "tetragonal", "twin"]},
+ {"id": "6ttn", "input": "6ttn/6ttn/data/H6H_33_01_hyo_full_1_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [39.894, 79.841, 104.701, 90.0, 90.0, 90.0], "dmin": 1.12}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6u7g", "input": "6u7g/6u7g/data/SNB02_11_8_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [99.555, 98.682, 147.525, 90.0, 104.6, 90.0], "dmin": 2.35}, "pinned": true, "tags": ["h5", "monoclinic"]},
+ {"id": "6ukf", "input": "6ukf/6ukf/data/XDC-7_Pn6_000001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [61.018, 37.317, 69.027, 90.0, 109.768, 90.0], "dmin": 1.0}, "tags": ["cbf", "monoclinic"]},
+ {"id": "6vww", "input": "6vww/IDP51000_6vww/data/m4H11g_00001.cbf", "ref": {"sg": "P 63", "sgno": 173, "cell": [150.539, 150.539, 111.31, 90.0, 90.0, 120.0], "dmin": 2.2}, "tags": ["cbf", "hexagonal", "twin"], "tiers": {"smoke": "merohedral twin, P63"}},
+ {"id": "6w4h", "input": "6w4h/IDP51000_6W4H/data/idp51000-201-a_1_2_3.001", "ref": {"sg": "P 31 2 1", "sgno": 152, "cell": [167.74, 167.74, 51.942, 90.0, 90.0, 120.0], "dmin": 1.8}, "tags": ["marCCD", "trigonal"]},
+ {"id": "6wzo", "input": "6wzo/9_1_1_000001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [43.718, 50.061, 69.337, 106.499, 90.094, 97.145], "dmin": 1.42}, "tags": ["cbf", "triclinic"]},
+ {"id": "6yqf", "input": "6yqf/6yqf/data/SYCE2TEX12-8_1_0001.cbf", "ref": {"sg": "P 21 21 2", "sgno": 18, "cell": [42.67, 59.68, 156.49, 90.0, 90.0, 90.0], "dmin": 3.327}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "6z8o", "input": "6z8o/HASE01-gaKr1_w1_1_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [63.716, 97.022, 121.318, 90.0, 104.656, 90.0], "dmin": 2.2}, "tags": ["h5", "monoclinic"]},
+ {"id": "6ze4", "input": "6ze4/806/o8_1_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [93.56, 109.88, 116.11, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["cbf", "orthorhombic"], "tiers": {"smoke": "known hard: P212121 under-called as P21 since rc168"}},
+ {"id": "7arr", "input": "7arr/PF4N_04D_w1_1_00001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [30.937, 32.068, 43.087, 114.16, 91.88, 109.86], "dmin": 1.1}, "tags": ["cbf", "triclinic"]},
+ {"id": "7atg", "input": "7atg/7atg/data/put-2-2.0s_5_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [17.97, 31.02, 43.86, 90.0, 90.0, 90.0], "dmin": 0.6}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "7bgt", "input": "7bgt/MPMV2243_3_001.img", "ref": {"sg": "P 1", "sgno": 1, "cell": [29.296, 67.618, 69.716, 76.845, 83.875, 83.645], "dmin": 1.93}, "tags": ["marCCD", "triclinic"]},
+ {"id": "7brr", "input": "7brr/7brr/data/3C_2_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [55.45, 99.02, 59.583, 90.0, 108.54, 90.0], "dmin": 1.35}, "tags": ["h5", "monoclinic"]},
+ {"id": "7dkp", "input": "7dkp/7dkp/data/LOX1-sree-p1a9-1p2_w1_1_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [49.84, 169.451, 49.842, 90.0, 93.51, 90.0], "dmin": 1.45}, "tags": ["h5", "monoclinic"]},
+ {"id": "7k1l", "input": "7k1l/IDP52015_7k1l/data/cs1C2eg_00001.cbf", "ref": {"sg": "P 63", "sgno": 173, "cell": [150.83, 150.83, 110.73, 90.0, 90.0, 120.0], "dmin": 2.25}, "tags": ["cbf", "hexagonal"], "tiers": {"smoke": "known hard: screw axis (P6 vs P63)"}},
+ {"id": "7kcn", "input": "7kcn/7kcn/data/ttr_hiuase_1_D1_33_00001.cbf", "ref": {"sg": "P 41 2 2", "sgno": 91, "cell": [67.03, 67.03, 116.89, 90.0, 90.0, 90.0], "dmin": 1.46}, "tags": ["cbf", "tetragonal"]},
+ {"id": "7l6j", "input": "7l6j/7l6j/data/idp97824-102sm-a_1_1_7.001", "ref": {"sg": "I 41 3 2", "sgno": 214, "cell": [171.693, 171.693, 171.693, 90.0, 90.0, 90.0], "dmin": 1.78}, "tags": ["marCCD", "cubic"]},
+ {"id": "7l84", "input": "7l84/301_helical_1_0001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [79.344, 79.344, 37.81, 90.0, 90.0, 90.0], "dmin": 1.7}, "tags": ["cbf", "tetragonal"]},
+ {"id": "7mzt", "input": "7mzt/7mzt/data/BVG2_Pn3_000001.cbf", "ref": {"sg": "P 21 21 2", "sgno": 18, "cell": [113.619, 96.989, 108.33, 90.0, 90.0, 90.0], "dmin": 4.07}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "7n0i", "input": "7n0i/8_2_1_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [75.846, 131.557, 140.048, 90.0, 90.0, 90.0], "dmin": 2.2}, "tags": ["cbf", "orthorhombic", "tncs"]},
+ {"id": "7n2s", "input": "7n2s/1449-4_1_00001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [83.211, 52.789, 106.291, 90.0, 98.278, 90.0], "dmin": 2.37}, "tags": ["cbf", "monoclinic"]},
+ {"id": "7orr", "input": "7orr/7orr/data/Nsp10-VT00022_1_master.h5", "ref": {"sg": "I 21 3", "sgno": 199, "cell": [105.88, 105.88, 105.88, 90.0, 90.0, 90.0], "dmin": 1.79}, "tags": ["h5", "cubic"]},
+ {"id": "7os3", "input": "7os3/pos2_1/pos2_1_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [78.15, 91.05, 105.84, 90.0, 90.0, 90.0], "dmin": 2.177}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "7ph1", "input": "7ph1/7ph1/data/9_1_0001.cbf", "ref": {"sg": "I 2 2 2", "sgno": 23, "cell": [74.975, 81.289, 124.248, 90.0, 90.0, 90.0], "dmin": 1.18}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "7pq7", "input": "7pq7/7pq7/data/1436_p52_A3_1_1_00001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [120.88, 51.73, 75.54, 90.0, 125.14, 90.0], "dmin": 1.55}, "tags": ["cbf", "monoclinic"]},
+ {"id": "7qij", "input": "7qij/907/dg046_2_data_1_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [143.46, 324.92, 369.38, 90.0, 90.0, 90.0], "dmin": 4.1}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "7qis", "input": "7qis/7qis/data/Chymo_Dfe_x1_2_0001.cbf", "ref": {"sg": "P 61", "sgno": 169, "cell": [100.269, 100.269, 206.215, 90.0, 90.0, 120.0], "dmin": 1.83}, "tags": ["cbf", "hexagonal"]},
+ {"id": "7ris", "input": "7ris/7ris/data/GLVase_Ca_we21108b7b_1_2_2.001_master.h5", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [44.54, 44.54, 189.95, 90.0, 90.0, 120.0], "dmin": 1.72}, "pinned": true, "tags": ["h5", "trigonal"]},
+ {"id": "7rji", "input": "7rji/7rji/data/DD3_00000.cbf", "ref": {"sg": "H 3 2", "sgno": 155, "cell": [83.036, 83.036, 124.83, 90.0, 90.0, 120.0], "dmin": 1.71}, "tags": ["cbf", "trigonal"]},
+ {"id": "7t5t", "input": "7t5t/A1_2_00001.cbf", "ref": {"sg": "P 42 21 2", "sgno": 94, "cell": [95.309, 95.309, 104.915, 90.0, 90.0, 90.0], "dmin": 1.35}, "pinned": true, "tags": ["cbf", "tetragonal"]},
+ {"id": "7tcd", "input": "7tcd/7tcd/data/col_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [138.504, 47.902, 78.068, 90.0, 107.56, 90.0], "dmin": 1.7}, "tags": ["h5", "monoclinic"]},
+ {"id": "7yzx", "input": "7yzx/7yzx/data/783-1_1_0001.cbf", "ref": {"sg": "P 63 2 2", "sgno": 182, "cell": [169.42, 169.42, 141.83, 90.0, 90.0, 120.0], "dmin": 1.9}, "tags": ["cbf", "hexagonal"]},
+ {"id": "8a1a", "input": "8a1a/L1F11v1_8a1a/data/L1-F11-v1_9ly1_D06_01_2_master.h5", "ref": {"sg": "P 65", "sgno": 170, "cell": [191.866, 191.866, 122.409, 90.0, 90.0, 120.0], "dmin": 2.05}, "tags": ["h5", "hexagonal"]},
+ {"id": "8agq", "input": "8agq/8agq_zip_8AGQ/data/coll_1_00001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [89.948, 55.447, 54.787, 90.0, 113.55, 90.0], "dmin": 1.093}, "tags": ["cbf", "monoclinic"]},
+ {"id": "8dqb", "input": "8dqb/KloxA_17380_a_B1-Apo_I23_Form_8dqb/data/PSL-1405_653_master.h5", "ref": {"sg": "I 2 3", "sgno": 197, "cell": [164.124, 164.124, 164.124, 90.0, 90.0, 90.0], "dmin": 2.5}, "tags": ["h5", "cubic"]},
+ {"id": "8dyz", "input": "8dyz/lys_1_2_0001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [79.632, 79.632, 38.296, 90.0, 90.0, 90.0], "dmin": 1.272}, "tags": ["cbf", "tetragonal", "diffuse"]},
+ {"id": "8dz7", "input": "8dz7/lys_rt_2_38_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [30.486, 56.401, 73.852, 90.0, 90.0, 90.0], "dmin": 1.34}, "tags": ["cbf", "orthorhombic", "diffuse"]},
+ {"id": "8egn", "input": "8egn/PsaeA_00137_b_B5-az13643701_8egn/data/FKC8_4_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [71.69, 75.16, 109.79, 90.0, 90.0, 90.0], "dmin": 1.95}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "8iya", "input": "8iya/8iya/data/11_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [102.747, 50.077, 109.248, 90.0, 91.754, 90.0], "dmin": 2.43}, "tags": ["h5", "monoclinic"]},
+ {"id": "8k1g", "input": "8k1g/8k1g/data/KP02_0001.cbf", "ref": {"sg": "I 4 2 2", "sgno": 97, "cell": [182.01, 182.01, 80.71, 90.0, 90.0, 90.0], "dmin": 2.09}, "tags": ["cbf", "tetragonal"]},
+ {"id": "8oic", "input": "8oic/8oic/data/_b20_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [73.055, 94.665, 120.589, 105.081, 89.959, 93.826], "dmin": 2.8}, "tags": ["h5", "triclinic"]},
+ {"id": "8owm", "input": "8owm/p13x4_1_00001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [95.544, 95.629, 95.841, 90.416, 93.59, 117.775], "dmin": 1.7}, "tags": ["cbf", "triclinic"]},
+ {"id": "8pqd", "input": "8pqd/8pqd/data/11AT05_w1_1_1_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [59.39, 59.37, 192.89, 90.0, 90.0, 90.0], "dmin": 1.5}, "tags": ["h5", "orthorhombic"]},
+ {"id": "8qaw", "input": "8qaw/p18x3/p18x3_1_00001.cbf.gz", "ref": {"sg": "H 3", "sgno": 146, "cell": [137.68, 137.68, 265.907, 90.0, 90.0, 120.0], "dmin": 1.55}, "tags": ["cbf", "trigonal", "long-axis"]},
+ {"id": "8qj5", "input": "8qj5/8qj5/data/Lcsbc3_1_2_00001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [57.61, 100.63, 77.93, 90.0, 96.06, 90.0], "dmin": 1.63}, "tags": ["cbf", "monoclinic"]},
+ {"id": "8qq7", "input": "8qq7/cbf/SpNox-Sp49-B3-B_088_1_0001.cbf", "ref": {"sg": "P 64 2 2", "sgno": 181, "cell": [145.967, 145.967, 153.619, 90.0, 90.0, 120.0], "dmin": 3.62}, "tags": ["cbf", "hexagonal"]},
+ {"id": "8r5r", "input": "8r5r/8r5r/data/D5-33805_1_1_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [91.74, 132.91, 137.5, 90.0, 90.0, 90.0], "dmin": 3.08}, "tags": ["h5", "orthorhombic"]},
+ {"id": "8rud", "input": "8rud/p08x03_1_00001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [78.066, 91.386, 114.547, 90.0, 96.9, 90.0], "dmin": 2.1}, "tags": ["cbf", "monoclinic"]},
+ {"id": "8s38", "input": "8s38/MX733_2_00001.cbf", "ref": {"sg": "I 21 21 21", "sgno": 24, "cell": [95.368, 163.1, 219.023, 90.0, 90.0, 90.0], "dmin": 1.89}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "8sa8", "input": "8sa8/KlaeA_00906_a_B1-PLP_8sa8/data/PSL-0412_255_master.h5", "ref": {"sg": "I 1 2 1", "sgno": 5, "cell": [87.887, 131.544, 165.363, 90.0, 104.48, 90.0], "dmin": 1.3}, "tags": ["h5", "monoclinic"]},
+ {"id": "8sqo", "input": "8sqo/BrabA_00028_a_A1-Mg_8sqo/data/PSL-1801_942_master.h5", "ref": {"sg": "P 4 3 2", "sgno": 207, "cell": [112.91, 112.91, 112.91, 90.0, 90.0, 90.0], "dmin": 1.55}, "tags": ["h5", "cubic"]},
+ {"id": "8sqq", "input": "8sqq/BrabA_00028_a_A1-Apo_8sqq/data/PSL-1810_965_master.h5", "ref": {"sg": "F 4 3 2", "sgno": 209, "cell": [171.52, 171.52, 171.52, 90.0, 90.0, 90.0], "dmin": 2.25}, "tags": ["h5", "cubic"]},
+ {"id": "8sqt", "input": "8sqt/BrabA_00028_a_A1-Fe_8sqt/data/PSL-1812_971_master.h5", "ref": {"sg": "F 4 3 2", "sgno": 209, "cell": [170.72, 170.72, 170.72, 90.0, 90.0, 90.0], "dmin": 2.2}, "tags": ["h5", "cubic"]},
+ {"id": "8t7r", "input": "8t7r/8t7r/data/GREEN-04_Pn5_000001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [357.076, 259.582, 255.361, 90.0, 133.13, 90.0], "dmin": 3.84}, "tags": ["cbf", "monoclinic"]},
+ {"id": "8tha", "input": "8tha/1TEL_double_helix_8tha/data/A3_1_00001.cbf", "ref": {"sg": "P 64", "sgno": 172, "cell": [69.16, 69.16, 29.13, 90.0, 90.0, 120.0], "dmin": 1.68}, "tags": ["cbf", "hexagonal"]},
+ {"id": "8tyy", "input": "8tyy/CPS_2_1_000001.cbf", "ref": {"sg": "F 4 3 2", "sgno": 209, "cell": [214.891, 214.891, 214.891, 90.0, 90.0, 90.0], "dmin": 1.68}, "tags": ["cbf", "cubic"]},
+ {"id": "8u0i", "input": "8u0i/8u0i/data/dI-2-05a_4_00001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [50.317, 50.317, 90.596, 90.0, 90.0, 90.0], "dmin": 1.541}, "tags": ["cbf", "tetragonal"]},
+ {"id": "8v4o", "input": "8v4o/CaalA_00629_a_FS11-AMP_8v4o/data/PSL-1602_2180_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [139.46, 139.46, 544.99, 90.0, 90.0, 120.0], "dmin": 2.7}, "tags": ["h5", "hexagonal"]},
+ {"id": "8xbp", "input": "8xbp/8xbp/data/puck2872_3_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [148.29, 50.78, 60.21, 90.0, 92.33, 90.0], "dmin": 1.99}, "tags": ["h5", "monoclinic"]},
+ {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "tags": ["cbf", "trigonal"]},
+ {"id": "8xtf", "input": "8xtf/1102/puck03_12_1_master.h5", "ref": {"sg": "H 3 2", "sgno": 155, "cell": [211.75, 211.75, 67.42, 90.0, 90.0, 120.0], "dmin": 2.13}, "tags": ["h5", "trigonal"]},
+ {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "tags": ["cbf", "trigonal"]},
+ {"id": "8y74", "input": "8y74/1_1/1_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [125.782, 76.553, 87.143, 90.0, 92.449, 90.0], "dmin": 1.9}, "tags": ["h5", "monoclinic"]},
+ {"id": "8ys9", "input": "8ys9/8YS9_xray-data_8ys9/data/SDS_09_18112_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [71.04, 77.68, 83.16, 90.0, 90.0, 90.0], "dmin": 1.46}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9b22", "input": "9b22/KlpnC_20447_a_B1-AR6-AMP_9b22/data/PSL-1011_1580_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [39.826, 92.659, 57.716, 90.0, 91.68, 90.0], "dmin": 1.3}, "tags": ["h5", "monoclinic"]},
+ {"id": "9bn8", "input": "9bn8/EscoA_17938_a_AE1-UMA-A1AQS_9bn8/data/PSL-0401_8296_master.h5", "ref": {"sg": "P 41", "sgno": 76, "cell": [65.488, 65.488, 134.764, 90.0, 90.0, 90.0], "dmin": 1.35}, "tags": ["h5", "tetragonal"]},
+ {"id": "9c18", "input": "9c18/BLVRB-2_5217_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [41.94, 41.977, 60.212, 84.11, 87.24, 63.66], "dmin": 1.9}, "tags": ["h5", "triclinic"]},
+ {"id": "9chw", "input": "9chw/D1.001", "ref": {"sg": "P 61", "sgno": 169, "cell": [98.686, 98.686, 82.062, 90.0, 90.0, 120.0], "dmin": 2.16}, "tags": ["marCCD", "hexagonal"]},
+ {"id": "9crw", "input": "9crw/data_9crw/data/Kip3-475-22-2_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [83.96, 104.57, 118.78, 90.0, 93.37, 90.0], "dmin": 2.49}, "tags": ["h5", "monoclinic"]},
+ {"id": "9e2t", "input": "9e2t/ga026f4b-1_5_00001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [75.499, 78.082, 101.219, 94.63, 103.39, 114.55], "dmin": 2.28}, "tags": ["cbf", "triclinic"]},
+ {"id": "9ea5", "input": "9ea5/K4_1_00001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [65.868, 73.064, 98.399, 90.0, 108.725, 90.0], "dmin": 2.0}, "tags": ["cbf", "monoclinic"]},
+ {"id": "9fcg", "input": "9fcg/IBCH-15-p02x06_2_00001.cbf.gz", "ref": {"sg": "P 4", "sgno": 75, "cell": [87.79, 87.79, 35.633, 90.0, 90.0, 90.0], "dmin": 1.54}, "tags": ["cbf", "tetragonal"], "tiers": {"smoke": "cbf.gz reader, pure 4-fold"}},
+ {"id": "9fhc", "input": "9fhc/te/te312_2_001.img", "ref": {"sg": "I 2 3", "sgno": 197, "cell": [227.46, 227.46, 227.46, 90.0, 90.0, 90.0], "dmin": 2.2}, "tags": ["marCCD", "cubic"]},
+ {"id": "9gdj", "input": "9gdj/slh34_w1_1_1_master.h5", "ref": {"sg": "P 41 21 2", "sgno": 92, "cell": [123.92, 123.92, 126.44, 90.0, 90.0, 90.0], "dmin": 1.47}, "tags": ["h5", "tetragonal", "cdte"]},
+ {"id": "9gjx", "input": "9gjx/BlNTR_9gjx/data/SC6_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [76.776, 115.807, 103.807, 90.0, 110.29, 90.0], "dmin": 2.4}, "tags": ["h5", "monoclinic"]},
+ {"id": "9gqg", "input": "9gqg/MX-2555/FKBP51-MSP500-A-5522-11_1_3094759/FKBP51-MSP500-A-5522-11_1_1_master.h5", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [48.157, 48.157, 188.036, 90.0, 90.0, 120.0], "dmin": 2.0}, "tags": ["h5", "trigonal"]},
+ {"id": "9hnc", "input": "9hnc/asp_7_00001.cbf", "ref": {"sg": "P 1 2 1", "sgno": 3, "cell": [123.764, 123.645, 187.679, 90.0, 90.063, 90.0], "dmin": 1.879}, "tags": ["cbf", "monoclinic"]},
+ {"id": "9hs7", "input": "9hs7/9hs7/data/B28X1_1_0001.cbf", "ref": {"sg": "P 65", "sgno": 170, "cell": [65.44, 65.44, 88.77, 90.0, 90.0, 120.0], "dmin": 1.698}, "tags": ["cbf", "hexagonal"]},
+ {"id": "9i0a", "input": "9i0a/carm1END468_9i0a_tar_9I0A/data/X151B1_1_master.h5", "ref": {"sg": "P 21 21 2", "sgno": 18, "cell": [75.237, 98.676, 208.551, 90.0, 90.0, 90.0], "dmin": 2.22}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9i80", "input": "9i80/20230422-PX1-LecA_RO5-5315-1/LecA-RO5_1_master.h5", "ref": {"sg": "P 41", "sgno": 76, "cell": [81.214, 81.214, 165.029, 90.0, 90.0, 90.0], "dmin": 1.95}, "tags": ["h5", "tetragonal", "twin"]},
+ {"id": "9ig7", "input": "9ig7/9IG7/data/KOD-P596-G2_3_00001.cbf", "ref": {"sg": "P 21 21 2", "sgno": 18, "cell": [111.472, 153.471, 69.03, 90.0, 90.0, 90.0], "dmin": 2.6}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "9ih9", "input": "9ih9/run_01_05_datacollection_9IH9/data/design-Xinjian-P1Thro-4_1_5_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [78.758, 133.933, 82.32, 90.0, 101.356, 90.0], "dmin": 1.7}, "tags": ["h5", "monoclinic"]},
+ {"id": "9jzo", "input": "9jzo/JS_35P2_C3-002_diffraction_files_9JZO/data/JS_35P2_C3-002_0001.cbf", "ref": {"sg": "P 1", "sgno": 1, "cell": [41.63, 43.1, 54.2, 112.97, 90.11, 118.18], "dmin": 1.4}, "tags": ["cbf", "triclinic"], "tiers": {"smoke": "triclinic P1"}},
+ {"id": "9khr", "input": "9khr/PfPlrx-DTT-9KHR/data-PfPlrx-DTT-9KHR/ods1467-lp13D1-01001.mccd", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [48.704, 50.31, 78.018, 90.0, 90.0, 90.0], "dmin": 2.0}, "tags": ["marCCD", "orthorhombic"], "tiers": {"smoke": "marCCD reader (.mccd), fast"}},
+ {"id": "9mh4", "input": "9mh4/KlaeA_00150_a_B1_9mh4/data/PSL-0501_2719_master.h5", "ref": {"sg": "P 21 3", "sgno": 198, "cell": [138.65, 138.65, 138.65, 90.0, 90.0, 90.0], "dmin": 3.05}, "tags": ["h5", "cubic"]},
+ {"id": "9min", "input": "9min/1151/A8_31_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [95.45, 98.54, 155.74, 90.0, 90.0, 90.0], "dmin": 2.05}, "tags": ["cbf", "orthorhombic"], "tiers": {"smoke": "known hard: halved axis"}},
+ {"id": "9o0h", "input": "9o0h/3TEL-GG-TNK1-UBA_9o0h/data/E1_1_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [55.15, 65.54, 112.9, 90.0, 90.0, 90.0], "dmin": 2.24}, "tags": ["cbf", "orthorhombic"]},
+ {"id": "9p7q", "input": "9p7q/9p7q_9P7Q/data/SAMDC_MTA_273_40_00001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [96.978, 45.018, 72.061, 90.0, 105.109, 90.0], "dmin": 2.21}, "tags": ["cbf", "monoclinic"]},
+ {"id": "9pbb", "input": "9pbb/9pbb_9PBB/data/SAMDC_MTA_293_30_00001.cbf", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [97.418, 45.876, 72.248, 90.0, 104.971, 90.0], "dmin": 2.17}, "pinned": true, "tags": ["cbf", "monoclinic"]},
+ {"id": "9q41", "input": "9q41/apoSPDS_1_master.h5", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [118.568, 133.704, 82.369, 90.0, 90.0, 90.0], "dmin": 1.95}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9q66", "input": "9q66/PREP_JP417_D8a_12694_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [105.853, 67.294, 158.019, 90.0, 99.109, 90.0], "dmin": 2.01}, "tags": ["h5", "monoclinic"]},
+ {"id": "9qw8", "input": "9qw8/MX-2555/run_03_datacollection [2023-09-08 22:19:51]/FKBP12BRD4-5519-6-BD1-PPU688_w1_1_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [35.648, 35.65, 100.919, 86.458, 84.218, 72.475], "dmin": 1.8}, "tags": ["h5", "triclinic"]},
+ {"id": "9rci", "input": "9rci/FEN1-CD029134_A09-3_AD049A-10_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [35.869, 39.297, 100.916, 98.3, 90.32, 90.09], "dmin": 1.662}, "tags": ["h5", "triclinic", "tncs"]},
+ {"id": "9rcs", "input": "9rcs/760_B7_x1_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [70.01, 78.8, 82.34, 90.0, 88.64, 90.0], "dmin": 3.012}, "tags": ["h5", "monoclinic", "cdte"]},
+ {"id": "9rp9", "input": "9rp9/data_9RP9/data/TAR148-TAR148_X2_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [73.48, 59.78, 91.67, 90.0, 100.85, 90.0], "dmin": 2.1}, "tags": ["h5", "monoclinic"]},
+ {"id": "9sl0", "input": "9sl0/wt-1_9sl0/data/design-Yan-HLA-WT-1_1_5_1_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [60.181, 80.201, 111.589, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9t6s", "input": "9t6s/CadC-AF6586_1_5_1_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [63.004, 64.574, 102.705, 90.0, 90.0, 90.0], "dmin": 2.0}, "tags": ["h5", "orthorhombic", "tncs"]},
+ {"id": "9upt", "input": "9upt/Raw data 1A/C12_7_00001.img", "ref": {"sg": "P 6", "sgno": 168, "cell": [158.27, 158.27, 53.962, 90.0, 90.0, 120.0], "dmin": 2.369}, "tags": ["SMV", "hexagonal"]},
+ {"id": "9vyb", "input": "9vyb/Antitoxin Phd_9vyb/data/G7-5_4187_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [44.37, 47.76, 48.35, 90.0, 90.0, 90.0], "dmin": 2.12}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9w3y", "input": "9w3y/9w3y/data/collect_01_00001_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [60.75, 69.98, 94.24, 90.0, 90.0, 90.0], "dmin": 1.5}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9yl4", "input": "9yl4/data_MJ4720/UWO0004_06_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [95.837, 111.339, 402.967, 90.0, 90.0, 90.0], "dmin": 3.7}, "pinned": true, "tags": ["cbf", "orthorhombic"]},
+ {"id": "9yzk", "input": "9yzk/CC1_21_TGGGAAGATACTGGATGAGGT_empty_9yzk/data/run_29_00001.cbf", "ref": {"sg": "I 1 2 1", "sgno": 5, "cell": [75.836, 163.022, 192.278, 90.0, 98.614, 90.0], "dmin": 5.1}, "tags": ["cbf", "monoclinic"], "tiers": {"smoke": "I2/C2 setting choice at low resolution"}},
+ {"id": "9z44", "input": "9z44/CC1_10_CCCGGCCGG_Cclamp_9z44/data/run_41_00001.cbf", "ref": {"sg": "I 1 2 1", "sgno": 5, "cell": [73.491, 127.653, 141.183, 90.0, 91.984, 90.0], "dmin": 7.2}, "tags": ["cbf", "monoclinic"]},
+ {"id": "9z72", "input": "9z72/A7_1_00001.cbf", "ref": {"sg": "P 31 2 1", "sgno": 152, "cell": [59.173, 59.173, 426.203, 90.0, 90.0, 120.0], "dmin": 2.38}, "tags": ["cbf", "trigonal", "long-axis"], "tiers": {"smoke": "long axis c=426 A, at the FFT ceiling"}},
+ {"id": "9zlo", "input": "9zlo/ASP0887_09_0114_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [38.39, 89.98, 106.97, 90.0, 90.0, 90.0], "dmin": 2.0}, "tags": ["h5", "orthorhombic"]},
+ {"id": "9zm0", "input": "9zm0/Atg23ANNS_9zm0_9ZM0/data/SeAtg23_B_10_2115_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [50.409, 30.101, 91.244, 90.0, 97.146, 90.0], "dmin": 2.1}, "tags": ["h5", "monoclinic"]},
+ {"id": "9zmu", "input": "9zmu/BrmeA_18154_a_B2-Apo_9zmu/data/PSL-0613_7518_master.h5", "ref": {"sg": "P 65 2 2", "sgno": 179, "cell": [47.81, 47.81, 492.58, 90.0, 90.0, 120.0], "dmin": 1.98}, "tags": ["h5", "hexagonal"]},
+ {"id": "cuhf2", "input": "cuhf2/03_CuHF2pyz2PF6b_P_O/CuHF2pyz2PF6b_P_O_01.nxs", "pinned": true, "tags": ["nxs", "small-molecule"]},
+ {"id": "cytidine", "input": "cytidine/20151020-Cytidine-2th-30/fixed-omega--180-phi-scan01_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [13.98, 14.788, 5.119, 90.0, 90.0, 90.0], "dmin": null}, "tags": ["cbf", "orthorhombic", "small-molecule"]},
+ {"id": "dnba", "input": "dnba/35dnba_30K_2_04_00001.cbf", "ref": {"sg": "C 1 2/c 1", "sgno": 15, "cell": [20.2635, 8.7575, 9.6697, 90.0, 109.941, 90.0], "dmin": 0.48}, "tags": ["cbf", "monoclinic", "small-molecule"]},
+ {"id": "lalanine", "input": "lalanine/pgw240050_01_00001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [5.7952, 5.933, 12.362, 90.0, 90.0, 90.0], "dmin": null}, "tags": ["cbf", "orthorhombic", "small-molecule"], "tiers": {"smoke": "small molecule, miniCBF"}},
+ {"id": "metformin", "input": "metformin/013_Mmetformin_01_master.h5", "ref": {"sg": "P 1 21/c 1", "sgno": 14, "cell": [7.9104, 13.8794, 7.931, 90.0, 114.606, 90.0], "dmin": 0.45}, "tags": ["h5", "monoclinic", "small-molecule"], "tiers": {"smoke": "small molecule, Diamond I19 NXmx master"}},
+ {"id": "nidppe", "input": "nidppe/001_NiDppeCl2_01_master.h5", "ref": {"sg": "P 1 21/c 1", "sgno": 14, "cell": [11.2779, 13.3386, 15.8739, 90.0, 98.7953, 90.0], "dmin": 0.77}, "tags": ["h5", "monoclinic", "small-molecule"]}
+]}
diff --git a/tools/battery/render.py b/tools/battery/render.py
new file mode 100644
index 000000000..6cd7cd23c
--- /dev/null
+++ b/tools/battery/render.py
@@ -0,0 +1,107 @@
+"""One document, written twice: Markdown and a self-contained HTML page.
+
+The report is built as a list of blocks (heading, paragraph, bullet list, table) and each writer
+turns the same list into its format, so the two can never say different things.
+"""
+import html
+
+CSS = """
+:root { --bg:#fff; --fg:#1d1d1f; --mute:#6e6e73; --line:#d9d9de; --head:#f3f3f5;
+        --pass:#1a7f37; --fail:#c62828; --warn:#9a6700; --passbg:#e8f5ec; --failbg:#fdecea; }
+@media (prefers-color-scheme: dark) {
+  :root { --bg:#161618; --fg:#e8e8ea; --mute:#9a9aa0; --line:#3a3a3e; --head:#232326;
+          --pass:#5cc97a; --fail:#ff7b72; --warn:#e3b341; --passbg:#16301f; --failbg:#3a1a1a; }
+}
+body { background:var(--bg); color:var(--fg); margin:0 auto; max-width:1400px; padding:16px;
+       font:14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
+h1 { font-size:22px; margin:8px 0 4px; } h2 { font-size:18px; margin:28px 0 8px; }
+h3 { font-size:15px; margin:20px 0 6px; }
+p, li { max-width:900px; } .mute { color:var(--mute); }
+.wrap { overflow-x:auto; margin:8px 0 16px; }
+table { border-collapse:collapse; font-variant-numeric:tabular-nums; }
+th, td { border-bottom:1px solid var(--line); padding:4px 8px; text-align:left; white-space:nowrap; }
+th { background:var(--head); position:sticky; top:0; }
+td.num, th.num { text-align:right; }
+td.pass { color:var(--pass); font-weight:600; } td.fail { color:var(--fail); font-weight:600; }
+td.warn { color:var(--warn); font-weight:600; }
+tr.fail td { background:var(--failbg); }
+code { font:12px ui-monospace, Menlo, monospace; }
+"""
+
+
+class Doc:
+    def __init__(self, title):
+        self.title = title
+        self.blocks = []
+
+    def h(self, level, text):
+        self.blocks.append(("h", level, text))
+
+    def p(self, text):
+        self.blocks.append(("p", text))
+
+    def ul(self, items):
+        self.blocks.append(("ul", list(items)))
+
+    def table(self, head, rows, num=(), row_class=None, cell_class=None):
+        """head: column titles; rows: lists of str; num: indices of right-aligned columns;
+        row_class(row) and cell_class(i, value) give optional CSS classes (HTML only)."""
+        self.blocks.append(("table", head, rows, set(num), row_class, cell_class))
+
+    def markdown(self):
+        out = [f"# {self.title}", ""]
+        for b in self.blocks:
+            if b[0] == "h":
+                out += ["#" * b[1] + " " + b[2], ""]
+            elif b[0] == "p":
+                out += [b[1], ""]
+            elif b[0] == "ul":
+                out += ["- " + x for x in b[1]] + [""]
+            else:
+                _, head, rows, num, _, _ = b
+                if not rows:
+                    out += ["(none)", ""]
+                    continue
+                out.append("| " + " | ".join(head) + " |")
+                out.append("|" + "|".join("--:" if i in num else ":--" for i in range(len(head))) + "|")
+                for r in rows:
+                    out.append("| " + " | ".join(str(x).replace("|", "/") for x in r) + " |")
+                out.append("")
+        return "\n".join(out)
+
+    def html(self):
+        e = html.escape
+        out = ["<!DOCTYPE html>", '<html lang="en"><head><meta charset="utf-8">',
+               '<meta name="viewport" content="width=device-width, initial-scale=1">',
+               f"<title>{e(self.title)}</title><style>{CSS}</style></head><body>",
+               f"<h1>{e(self.title)}</h1>"]
+        for b in self.blocks:
+            if b[0] == "h":
+                out.append(f"<h{b[1]}>{e(b[2])}</h{b[1]}>")
+            elif b[0] == "p":
+                out.append(f"<p>{e(b[1])}</p>")
+            elif b[0] == "ul":
+                out.append("<ul>" + "".join(f"<li>{e(x)}</li>" for x in b[1]) + "</ul>")
+            else:
+                _, head, rows, num, row_class, cell_class = b
+                if not rows:
+                    out.append('<p class="mute">(none)</p>')
+                    continue
+                t = ['<div class="wrap"><table><thead><tr>']
+                t += [f'<th class="num">{e(h)}</th>' if i in num else f"<th>{e(h)}</th>"
+                      for i, h in enumerate(head)]
+                t.append("</tr></thead><tbody>")
+                for r in rows:
+                    rc = row_class(r) if row_class else ""
+                    t.append(f'<tr class="{rc}">' if rc else "<tr>")
+                    for i, x in enumerate(r):
+                        cls = ["num"] if i in num else []
+                        if cell_class and cell_class(i, x):
+                            cls.append(cell_class(i, x))
+                        c = f' class="{" ".join(cls)}"' if cls else ""
+                        t.append(f"<td{c}>{e(str(x))}</td>")
+                    t.append("</tr>")
+                t.append("</tbody></table></div>")
+                out.append("".join(t))
+        out.append("</body></html>")
+        return "\n".join(out)
diff --git a/tools/battery/report.py b/tools/battery/report.py
new file mode 100644
index 000000000..6199dbfba
--- /dev/null
+++ b/tools/battery/report.py
@@ -0,0 +1,243 @@
+"""The per-run report and the run-to-run comparison."""
+import json
+import os
+import statistics
+
+from render import Doc
+
+# A change smaller than these is treated as run-to-run noise. They are a starting point, to be
+# re-calibrated from `compare --rerun-changed`, which measures the noise directly.
+NOISE = {
+    "d_min": ("rel", 0.02),         # 2% of the resolution limit
+    "isa": ("rel", 0.05),
+    "r_meas": ("rel", 0.05),
+    "cc_half": ("abs", 0.005),
+    "completeness": ("abs", 1.0),   # percentage points
+    "cell_dev_pct": ("abs", 0.2),   # percentage points
+    "wall_s": ("rel", 0.25),        # and at least 10 s - see beyond_noise()
+}
+
+
+def load_run(run_dir):
+    man = json.load(open(os.path.join(run_dir, "manifest.json")))
+    res = json.load(open(os.path.join(run_dir, "results.json")))
+    return man, res
+
+
+def key(r):
+    return (r["arm"], r["set"])
+
+
+def f(x, fmt="{:.2f}", dash="-"):
+    return dash if x is None else fmt.format(x)
+
+
+def pct(x, nd=1):
+    return "-" if x is None else f"{100 * x:.{nd}f}%"
+
+
+def median(xs):
+    xs = [x for x in xs if x is not None]
+    return statistics.median(xs) if xs else None
+
+
+def quartiles(xs):
+    xs = sorted(x for x in xs if x is not None)
+    if not xs:
+        return None
+    if len(xs) < 4:
+        return xs[0], xs[len(xs) // 2], xs[len(xs) // 2], xs[len(xs) // 2], xs[-1]
+    q = statistics.quantiles(xs, n=4)
+    return xs[0], q[0], q[1], q[2], xs[-1]
+
+
+def beyond_noise(name, a, b):
+    if a is None or b is None:
+        return (a is None) != (b is None)
+    kind, tol = NOISE[name]
+    d = abs(b - a)
+    if name == "wall_s" and d < 10:
+        return False
+    return d > (tol * abs(a) if kind == "rel" else tol)
+
+
+def changes(ra, rb):
+    """What changed between two results of the same set, beyond noise."""
+    out = []
+    if ra["verdict"] != rb["verdict"]:
+        out.append(f"verdict {ra['verdict']}->{rb['verdict']}")
+    if ra.get("sgno") != rb.get("sgno"):
+        out.append("space group")
+    if ra.get("volume_ratio") and rb.get("volume_ratio") and \
+            abs(ra["volume_ratio"] - rb["volume_ratio"]) > 0.05:
+        out.append("lattice")
+    for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct"):
+        if beyond_noise(name, ra.get(name), rb.get(name)):
+            out.append(name)
+    if beyond_noise("wall_s", ra.get("wall_s"), rb.get("wall_s")):
+        out.append("time")
+    return out
+
+
+def compare_rows(res_a, res_b):
+    """[(key, ra, rb, changes)] over the sets both runs have, then those only one has."""
+    a = {key(r): r for r in res_a}
+    b = {key(r): r for r in res_b}
+    rows = [(k, a[k], b[k], changes(a[k], b[k])) for k in sorted(a) if k in b]
+    rows += [(k, a[k], None, ["only in A"]) for k in sorted(a) if k not in b]
+    rows += [(k, None, b[k], ["only in B"]) for k in sorted(b) if k not in a]
+    return rows
+
+
+def arrow(x, y, fmt=lambda v: str(v)):
+    x = "-" if x is None else fmt(x)
+    y = "-" if y is None else fmt(y)
+    return x if x == y else f"{x} -> {y}"
+
+
+def compare_table(doc, rows, only_changed=True):
+    head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
+            "cell dev %", "time s", "beyond noise"]
+    out = []
+    for (arm, s), ra, rb, ch in rows:
+        if only_changed and not ch:
+            continue
+        ra, rb = ra or {}, rb or {}
+        out.append([s, arm, arrow(ra.get("verdict"), rb.get("verdict")),
+                    arrow(ra.get("sg"), rb.get("sg")),
+                    arrow(ra.get("d_min"), rb.get("d_min"), lambda v: f"{v:.2f}"),
+                    arrow(ra.get("isa"), rb.get("isa"), lambda v: f"{v:.1f}"),
+                    arrow(ra.get("r_meas"), rb.get("r_meas"), lambda v: f"{100 * v:.1f}%"),
+                    arrow(ra.get("cc_half"), rb.get("cc_half"), lambda v: f"{v:.3f}"),
+                    arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
+                    arrow(ra.get("wall_s"), rb.get("wall_s"), lambda v: f"{v:.0f}"),
+                    ", ".join(ch)])
+    doc.table(head, out, row_class=lambda r: "fail" if "verdict" in r[-1] else "")
+
+
+def crystals(rs):
+    """Rows that describe a crystal - the no-crystal controls would only pollute a distribution."""
+    return [r for r in rs if "control" not in r.get("tags", [])]
+
+
+def scored(rs):
+    return [r for r in rs if r["verdict"] in ("pass", "fail")]
+
+
+def rate(rs):
+    s = scored(rs)
+    n = sum(r["verdict"] == "pass" for r in s)
+    return f"{n}/{len(s)} ({100 * n / len(s):.0f}%)" if s else "-"
+
+
+def build(run_dir, baseline=None):
+    """Markdown and HTML report of one run, with the delta against a baseline run if given."""
+    man, res = load_run(run_dir)
+    b = man["binary"]
+    doc = Doc(f"Rugnux battery - {os.path.basename(os.path.normpath(run_dir))}")
+    if man.get("private"):
+        doc.p("PRIVATE ARM - confidential user data. This report stays in the run directory; it "
+              "must not be copied into the repository, an issue or any public report.")
+    doc.ul([
+        f"rugnux {b.get('version', '?')}, sha256 {b['sha256'][:16]}, build flags: {b.get('flags') or 'unknown'}",
+        f"runner {man['runner_git']}, host {man['host']}, {man['start']} -> {man.get('end') or 'NOT FINISHED'}",
+        f"arms: {', '.join(man['arms'])}; {len(man['sets'])} sets"
+        + (f" (subset: {man['subset']})" if man.get("subset") else " (full arm)"),
+        "resolution: XDS's range forced on the XDS-referenced arms" if man["options"]["xds_range"]
+        else "resolution: rugnux's own choice everywhere (unforced)",
+        "timing: NOT a reference - the GPU was shared" if man.get("gpu_shared")
+        else "timing: GPU was not shared during the run",
+        f"command options: {' '.join(man['options']['extra_args']) or '(none beyond output selection)'}",
+    ])
+
+    forced = {e["arm"] for e in man["sets"]
+              if man["options"]["xds_range"] and e.get("reference") == "xds"}
+    order = {arm: i for i, arm in enumerate(man["arms"])}
+
+    def gain(rs, arm):
+        return "forced" if arm in forced else f(median(r.get("res_gain_pct") for r in rs), "{:+.1f}%")
+
+    doc.h(2, "Summary")
+    head = ["arm", "sets", "pass", "fail", "unscored", "not run", "pass rate",
+            "median res. gain", "median ISa", "median R_meas", "median time s", "total time min"]
+    rows = []
+    for arm in man["arms"]:
+        rs = [r for r in res if r["arm"] == arm]
+        cnt = {v: sum(r["verdict"] == v for r in rs) for v in ("pass", "fail", "unscored", "not_run")}
+        xs = crystals(rs)
+        rows.append([arm, len(rs), cnt["pass"], cnt["fail"], cnt["unscored"], cnt["not_run"], rate(rs),
+                     gain(xs, arm), f(median(r.get("isa") for r in xs), "{:.1f}"),
+                     pct(median(r.get("r_meas") for r in xs)),
+                     f(median(r.get("wall_s") for r in rs), "{:.0f}"),
+                     f(sum(r.get("wall_s") or 0 for r in rs) / 60, "{:.1f}")])
+    doc.table(head, rows, num=range(1, 12))
+    doc.p("Pass rate is over the scored sets (pass + fail). Resolution gain is (reference d_min - "
+          "our d_min) / reference d_min: positive = finer than the deposition, or than XDS; 'forced' "
+          "where XDS's resolution range was imposed, which makes it zero by construction. Medians "
+          "leave out the no-crystal controls. R_meas and CC1/2 are pooled over each run's own "
+          "resolution range, so they describe a run and do not rank two.")
+
+    doc.h(3, "By population")
+    rows = []
+    for arm in man["arms"]:
+        rs = [r for r in res if r["arm"] == arm]
+        for tag in sorted({t for r in rs for t in r.get("tags", [])}):
+            sub = [r for r in rs if tag in r.get("tags", [])]
+            rows.append([arm, tag, len(sub), rate(sub), gain(sub, arm)])
+    doc.table(["arm", "population", "sets", "pass rate", "median res. gain"], rows, num=(2, 4))
+
+    doc.h(3, "Distributions (sets that merged, controls left out)")
+    rows = []
+    for arm in man["arms"]:
+        rs = crystals(r for r in res if r["arm"] == arm)
+        for name, lab, fm in (("isa", "ISa", "{:.1f}"), ("r_meas", "R_meas", None),
+                              ("cc_half", "CC1/2", "{:.3f}"), ("res_gain_pct", "res. gain %", "{:+.1f}"),
+                              ("wall_s", "time s", "{:.0f}")):
+            if name == "res_gain_pct" and arm in forced:
+                continue
+            q = quartiles(r.get(name) for r in rs)
+            if q:
+                cells = [pct(x) if fm is None else f(x, fm) for x in q]
+                rows.append([arm, lab, sum(r.get(name) is not None for r in rs)] + cells)
+    doc.table(["arm", "metric", "n", "min", "q1", "median", "q3", "max"], rows, num=range(2, 8))
+
+    doc.h(2, "Failures")
+    fails = [r for r in res if r["verdict"] == "fail"]
+    doc.table(["set", "arm", "cause", "reason"],
+              [[r["set"], r["arm"], r["cause"], r["reason"]] for r in fails])
+    other = [r for r in res if r["verdict"] in ("unscored", "not_run")]
+    if other:
+        doc.p("Not scored: " + "; ".join(f"{r['set']} ({r['reason']})" for r in other))
+
+    if baseline:
+        bman, bres = load_run(baseline)
+        doc.h(2, f"Delta vs baseline {os.path.basename(os.path.normpath(baseline))}")
+        doc.p(f"Baseline rugnux {bman['binary'].get('version', '?')}. Pass rates on the sets both "
+              "runs have:")
+        both = {key(r) for r in res} & {key(r) for r in bres}
+        rows = []
+        for arm in man["arms"]:
+            ra = [r for r in bres if key(r) in both and r["arm"] == arm]
+            rb = [r for r in res if key(r) in both and r["arm"] == arm]
+            rows.append([arm, len(rb), rate(ra), rate(rb)])
+        doc.table(["arm", "common sets", "baseline", "this run"], rows, num=(1,))
+        doc.p("Sets whose result moved beyond noise (thresholds in report.py NOISE; confirm with "
+              "`compare --rerun-changed` before believing a single-set change):")
+        compare_table(doc, compare_rows(bres, res))
+
+    doc.h(2, "Per set")
+    head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
+            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx", "time s", "note"]
+    rows = []
+    for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
+        rows.append([r["set"], r["arm"], r["verdict"], r.get("sg") or "-", r.get("sg_ref") or "-",
+                     f(r.get("cell_dev_pct")), f(r.get("volume_ratio"), "{:.3f}"),
+                     f(r.get("d_min")), f(r.get("d_min_ref")), f(r.get("res_gain_pct"), "{:+.1f}%"),
+                     f(r.get("completeness"), "{:.1f}"), f(r.get("multiplicity"), "{:.1f}"),
+                     pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
+                     f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0),
+                     f(r.get("wall_s"), "{:.0f}"), r.get("reason") or ""])
+    doc.table(head, rows, num=range(5, 18),
+              row_class=lambda row: "fail" if row[2] == "fail" else "",
+              cell_class=lambda i, v: {"pass": "pass", "fail": "fail"}.get(v) if i == 2 else None)
+    return doc
diff --git a/tools/battery/score.py b/tools/battery/score.py
new file mode 100644
index 000000000..1384b53df
--- /dev/null
+++ b/tools/battery/score.py
@@ -0,0 +1,173 @@
+"""Scoring one rugnux run against its reference.
+
+One dataset, one verdict, one cause, decided in this order: did it run -> is the lattice right ->
+is the symmetry right -> is the merge usable. The order matters: a halved axis also makes the
+screw along it unobservable, and counting that row twice would hide the defect that cost the
+reflections.
+"""
+import itertools
+import os
+import re
+
+import gemmi
+
+import sgequiv
+
+REPORT_LINE = re.compile(r"^([A-Z_0-9]+)=\s*(.*)$")
+
+
+def read_report(path):
+    """KEY= value lines of a rugnux _report.txt."""
+    out = {}
+    if os.path.exists(path):
+        for line in open(path, errors="replace"):
+            m = REPORT_LINE.match(line.rstrip("\n"))
+            if m:
+                out[m.group(1)] = m.group(2).strip()
+    return out
+
+
+def fnum(s):
+    try:
+        return float(s.split()[0])
+    except (AttributeError, ValueError, IndexError):
+        return None
+
+
+def space_group(name, sgno):
+    """The space group in the SETTING the cell was given in: by name when there is one (I 1 2 1 and
+    C 1 2 1 are both number 5, with different centring vectors), else the standard setting."""
+    sg = gemmi.find_spacegroup_by_name(name) if name else None
+    return sg or gemmi.find_spacegroup_by_number(int(sgno or 1))
+
+
+def primitive_reduced(cell, sg):
+    """Niggli-reduced PRIMITIVE cell of a cell given in space group sg (a gemmi.SpaceGroup), and
+    its volume.
+
+    Setting-invariant: two settings of one lattice (C2 vs I2, a/c swapped, beta vs 180-beta)
+    reduce to the same cell, so they compare equal."""
+    gv = gemmi.GruberVector(gemmi.UnitCell(*cell), sg)
+    gv.niggli_reduce()
+    red = gv.cell_parameters()
+    return red, gemmi.UnitCell(*red).volume
+
+
+def lattice_match(cell, sg, ref_cell, ref_sg):
+    """(primitive volume ratio, largest relative deviation of the reduced edges)."""
+    red, vol = primitive_reduced(cell, sg)
+    ref_red, ref_vol = primitive_reduced(ref_cell, ref_sg)
+    edge_dev = max(abs(a - b) / b for a, b in zip(sorted(red[:3]), sorted(ref_red[:3])))
+    return vol / ref_vol, edge_dev
+
+
+def cell_dev_pct(cell, ref):
+    """Largest relative deviation of a, b, c in percent, minimised over the six axis orders, so
+    P212121 with a and c exchanged is not scored as a 6% error."""
+    return min(max(abs(p[i] - ref[i]) / ref[i] * 100 for i in range(3))
+               for p in itertools.permutations(cell[:3]))
+
+
+def point_group(sgno):
+    return gemmi.find_spacegroup_by_number(int(sgno)).point_group_hm()
+
+
+def sg_name(sgno):
+    return gemmi.find_spacegroup_by_number(int(sgno)).hm if sgno else None
+
+
+def judge(entry, rep, run_note):
+    """Score one set. entry is its manifest row (with 'ref'), rep its parsed report, run_note
+    what the runner saw ('', 'timeout', 'exit N: message', 'no input')."""
+    ref = dict(entry.get("ref") or {})
+    if entry.get("ref_override"):          # a reference measured by hand, replacing the file's
+        ref.update(entry["ref_override"])
+    r = {
+        "sgno": None, "sg": None, "pg": None,
+        "sgno_ref": ref.get("sgno"), "sg_ref": ref.get("sg") or sg_name(ref.get("sgno")),
+        "pg_ref": point_group(ref["sgno"]) if ref.get("sgno") else None,
+        "cell": None, "cell_ref": ref.get("cell"), "cell_dev_pct": None, "volume_ratio": None,
+        "d_min": None, "d_min_ref": ref.get("dmin"), "res_gain_pct": None,
+        "r_meas": fnum(rep.get("R_MEAS")), "cc_half": fnum(rep.get("CC_HALF")),
+        "isa": fnum(rep.get("ISA")), "completeness": fnum(rep.get("COMPLETENESS")),
+        "multiplicity": fnum(rep.get("MULTIPLICITY")), "i_over_sigma": fnum(rep.get("I_OVER_SIGMA")),
+        "indexing_rate": fnum(rep.get("INDEXING_RATE")), "images": fnum(rep.get("IMAGES_PROCESSED")),
+        "rugnux_wall_s": fnum(rep.get("WALL_TIME")), "rugnux_verdict": rep.get("VERDICT_TEXT"),
+        "r_meas_ref": ref.get("r_meas"), "cc_half_ref": ref.get("cc_half"), "isa_ref": ref.get("isa"),
+        "completeness_ref": ref.get("completeness"),
+    }
+    if rep.get("SPACE_GROUP_NUMBER"):
+        r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
+        r["sg"] = rep.get("SPACE_GROUP_NAME") or sg_name(r["sgno"])
+        r["pg"] = point_group(r["sgno"])
+    if rep.get("UNIT_CELL_CONSTANTS"):
+        r["cell"] = [float(x) for x in rep["UNIT_CELL_CONSTANTS"].split()[:6]]
+    rng = (rep.get("INCLUDE_RESOLUTION_RANGE") or "").split()
+    if len(rng) == 2:
+        r["d_min"] = float(rng[1])
+    if r["d_min"] and r["d_min_ref"]:
+        r["res_gain_pct"] = round((r["d_min_ref"] - r["d_min"]) / r["d_min_ref"] * 100, 1) + 0.0  # no -0.0
+    if r["cell"] and r["cell_ref"]:
+        r["cell_dev_pct"] = round(cell_dev_pct(r["cell"], r["cell_ref"]), 3)
+
+    def verdict(v, cause, reason):
+        r.update(verdict=v, cause=cause, reason=reason)
+        return r
+
+    have_lattice = r["sgno"] is not None and r["cell"] is not None
+    if entry.get("expect") == "no_lattice":
+        # a no-crystal control: the right answer is to refuse
+        if have_lattice:
+            return verdict("fail", "false_lattice",
+                           f"reported a lattice ({r['sg']}) on a set with no crystal")
+        return verdict("pass", None, "no lattice reported, as expected")
+    if not have_lattice:
+        if run_note == "no input":
+            return verdict("not_run", "no_input", "input file not found")
+        if run_note == "timeout":
+            return verdict("fail", "timeout", "timed out")
+        if re.search(r"Error reading input|Cannot open", run_note):
+            return verdict("fail", "reader", run_note)
+        if re.search(r"index|lattice", run_note, re.I):
+            return verdict("fail", "indexing", run_note)
+        return verdict("fail", "crash", run_note or "no lattice in the report")
+    if not ref.get("sgno") or not ref.get("cell"):
+        return verdict("unscored", "no_reference", "no reference to score against")
+
+    vr, edge = lattice_match(r["cell"], space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
+                             ref["cell"], space_group(ref.get("sg"), ref["sgno"]))
+    r["volume_ratio"] = round(vr, 4)
+    if not (0.95 < vr < 1.05 and edge < 0.02):
+        if 0.45 <= vr <= 0.55:
+            return verdict("fail", "lattice_halved", f"primitive volume ratio {vr:.2f}")
+        if 1.9 <= vr <= 2.1:
+            return verdict("fail", "lattice_doubled", f"primitive volume ratio {vr:.2f}")
+        return verdict("fail", "lattice_other",
+                       f"primitive volume ratio {vr:.2f}, reduced edges off by {edge:.1%}")
+
+    # XDS never tests a screw axis, so against an XDS reference only the point group can be
+    # judged - unless the group was measured by hand (sg_measured).
+    by_sg = entry["arm"] == "open" or ref.get("sg_measured")
+    if by_sg:
+        rel = sgequiv.describe(ref["sgno"], r["sgno"])
+        r["sg_relation"] = rel
+        ok = rel in ("match", "hand only (needs anomalous)", "UNDECIDABLE from intensities")
+    else:
+        ok = r["pg"] == r["pg_ref"]
+    if not ok:
+        order = len(gemmi.find_spacegroup_by_number(r["sgno"]).operations().sym_ops)
+        order_ref = len(gemmi.find_spacegroup_by_number(ref["sgno"]).operations().sym_ops)
+        if r["pg"] == r["pg_ref"]:
+            return verdict("fail", "sym_screw", f"{r['sg']} vs reference {r['sg_ref']}")
+        cause = ("sym_under" if order < order_ref else
+                 "sym_over" if order > order_ref else "sym_other")
+        return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
+
+    if r["r_meas"] is not None and r["r_meas"] > 0.6:
+        return verdict("fail", "merge", f"R_meas {r['r_meas']:.0%} overall")
+    if r["cc_half"] is not None and r["cc_half"] < 0.5:
+        return verdict("fail", "merge", f"CC1/2 {r['cc_half']:.2f} overall")
+    note = ""
+    if r["sgno"] != ref["sgno"]:
+        note = f"{r['sg']} vs reference {r['sg_ref']} ({r.get('sg_relation') or 'screws not judged against XDS'})"
+    return verdict("pass", None, note)
diff --git a/tools/battery/sgequiv.py b/tools/battery/sgequiv.py
new file mode 100644
index 000000000..f242f7ca0
--- /dev/null
+++ b/tools/battery/sgequiv.py
@@ -0,0 +1,47 @@
+"""Which space-group differences a diffraction experiment could actually have decided.
+
+A merged dataset sees only (a) which reflections are equivalent - the rotation parts of the
+operations in their real orientation - and (b) which are systematically absent. Two space
+groups agreeing on both cannot be told apart without solving the structure. Body centring is
+the usual culprit: h+k+l=2n already forces h00: h=2n, so a 2_1 along <100> adds nothing.
+"""
+import gemmi, collections
+
+_N = 7
+_HKL = [(h, k, l) for h in range(-_N, _N+1) for k in range(-_N, _N+1) for l in range(-_N, _N+1)
+        if (h, k, l) != (0, 0, 0)]
+
+def _signature(sg):
+    ops = sg.operations()
+    return (frozenset(tuple(map(tuple, op.rot)) for op in ops),
+            frozenset(tuple(t) for t in ops.cen_ops),
+            tuple(ops.is_systematically_absent(h) for h in _HKL))
+
+_by_sig = collections.defaultdict(set)
+for _n in range(1, 231):
+    _by_sig[_signature(gemmi.find_spacegroup_by_number(_n))].add(_n)
+CLASS = {n: frozenset(s) for s in _by_sig.values() for n in s if len(s) > 1}
+
+def indistinguishable(a, b):
+    """True if intensities alone could never have separated these two space groups."""
+    return a == b or b in CLASS.get(a, ())
+
+def enantiomorphic(a, b):
+    """True if the pair differs only by hand - anomalous signal can break it, absences cannot."""
+    return (indistinguishable(a, b) and a != b
+            and gemmi.find_spacegroup_by_number(a).is_enantiomorphic())
+
+def describe(a, b):
+    if a == b: return "match"
+    if enantiomorphic(a, b): return "hand only (needs anomalous)"
+    if indistinguishable(a, b): return "UNDECIDABLE from intensities"
+    return "REAL difference (absences differ)"
+
+if __name__ == "__main__":
+    seen = set()
+    for n, s in sorted(CLASS.items()):
+        if s in seen: continue
+        seen.add(s)
+        ns = sorted(s)
+        print("  ", "  =  ".join("%d %s" % (i, gemmi.find_spacegroup_by_number(i).hm) for i in ns),
+              "  ->", describe(ns[0], ns[1]))
diff --git a/tools/battery/site.json b/tools/battery/site.json
new file mode 100644
index 000000000..0edaaffb5
--- /dev/null
+++ b/tools/battery/site.json
@@ -0,0 +1,11 @@
+{
+ "runs_root": "/data/battery/runs",
+ "lock_file": "/data/battery/full_run.lock",
+ "gpulock": "/data/tmp/gpulock",
+ "arms": {
+  "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/home/data/nonsls/raw"},
+  "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/data/rotation_test"},
+  "private": {"manifest": "/data/battery/private.json", "reference": "xds", "data_root": "/data/rotation_test",
+              "private": true}
+ }
+}
-- 
2.54.0


From 615158c2528501d96db7d2b4a91e92e49f864c3a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 08:50:54 +0200
Subject: [PATCH 002/122] CLAUDE.md: the standard test proteins and the open
 battery arm may be named

Extends the lysozyme carve-out to thaumatin, insulin, cytochrome C and myoglobin
(plus the in-house no-crystal controls), and allows the public PDB depositions of
the open battery arm. The private arm stays out of the repository entirely.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index c6aa7dc87..b8110a9bd 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -179,11 +179,18 @@ a hard rule, not a preference.
 - **Fine**: general crystallographic descriptors — space group / Laue class ("a P2₁ crystal", "a
   holohedral 422 case"), lattice centering, twinning, "a crystal whose true axis is reported as its
   3× harmonic", pseudo-symmetry, etc. Describe the *crystallographic situation*, not the specimen.
-- **Exception — plain lysozyme.** Lysozyme (HEWL) is the field's universal standard test specimen,
-  not a user's confidential dataset, so naming it and using its well-known reference cell
-  (tetragonal ~79/79/38, P4₃2₁2) in tests, docs and comments is allowed. This carve-out is only for
-  generic lysozyme as a benchmark; a *named user dataset* that happens to be lysozyme is still off
-  limits, and every other real sample remains forbidden.
+- **Exception — the standard test proteins.** Lysozyme (HEWL), thaumatin, insulin, cytochrome C
+  and myoglobin are the field's standard reference specimens, not users' confidential datasets, so
+  naming them and using their well-known reference cells (e.g. lysozyme tetragonal ~79/79/38,
+  P4₃2₁2) in tests, docs, comments and the in-house battery manifest is allowed, and so are the
+  XDS-derived reference values of our own in-house measurements of them. The same goes for the
+  in-house no-crystal controls. This carve-out is only for these generic specimens as benchmarks; a
+  *named user dataset* that happens to be one of them is still off limits, and every other real
+  sample remains forbidden.
+- **Exception — the open battery arm.** Its datasets are public PDB depositions (plus a few openly
+  published small-molecule sets), so their PDB IDs and deposited space groups, cells and
+  resolutions may be named in the battery manifest, reports and commits. The private battery arm
+  is the opposite: its names, paths, cells and statistics never enter the repository.
 - **Tests** must otherwise use neutral names (e.g. `tetragonal_uc`, not a specimen-named variable)
   and, where a cell is needed, a synthetic cell chosen for the test — not a real dataset's parameters.
 
-- 
2.54.0


From a20bbcb05751bda9c1c731877f795e4abd0a95ed Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 08:51:07 +0200
Subject: [PATCH 003/122] tools/battery: 6h2p runs as two sets, one per
 wavelength

The crystal was measured at two wavelengths; both sweeps are kept. The native
sweep carries the deposited resolution, the 1.89 A sweep is scored on symmetry
and cell only.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/open.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tools/battery/open.json b/tools/battery/open.json
index d7f9da2e6..86c6da617 100644
--- a/tools/battery/open.json
+++ b/tools/battery/open.json
@@ -16,7 +16,8 @@
  {"id": "6fid", "input": "6fid/Trypsin_x1_align_2_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [59.947, 64.107, 69.694, 90.0, 90.0, 90.0], "dmin": 2.2}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6fvz", "input": "6fvz/maox215_6fvz/data/maox215_w1_1_0001.cbf", "ref": {"sg": "C 2 2 2", "sgno": 21, "cell": [131.182, 222.753, 86.482, 90.0, 90.0, 90.0], "dmin": 1.8}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6fwc", "input": "6fwc/maox225_6fwc/data/maox225_1_00001.cbf", "ref": {"sg": "C 2 2 2", "sgno": 21, "cell": [131.728, 222.051, 86.293, 90.0, 90.0, 90.0], "dmin": 1.7}, "tags": ["cbf", "orthorhombic"]},
- {"id": "6h2p", "input": "6h2p/ProlMut1MnCAC_6h2p/data/Prol_Mut1_Mn_X_pk1_2_0001.cbf", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [103.453, 107.075, 216.543, 90.0, 90.0, 90.0], "dmin": 1.479}, "tags": ["cbf", "orthorhombic", "long-wavelength"]},
+ {"id": "6h2p_native", "input": "6h2p/ProlMut1MnCAC_6h2p/data/Prol_Mut1_Mn_X1_nat_1_0002.cbf", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [103.453, 107.075, 216.543, 90.0, 90.0, 90.0], "dmin": 1.479}, "tags": ["cbf", "orthorhombic", "two-wavelength"]},
+ {"id": "6h2p_1p89A", "input": "6h2p/ProlMut1MnCAC_6h2p/data/Prol_Mut1_Mn_X_pk1_2_0001.cbf", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [103.453, 107.075, 216.543, 90.0, 90.0, 90.0], "dmin": null}, "tags": ["cbf", "orthorhombic", "long-wavelength", "two-wavelength"]},
  {"id": "6h5t", "input": "6h5t/6h5t/data/SH3-1_x2_1_001.img", "ref": {"sg": "I 4 2 2", "sgno": 97, "cell": [86.792, 86.792, 141.768, 90.0, 90.0, 90.0], "dmin": 1.689}, "tags": ["marCCD", "tetragonal"]},
  {"id": "6hv2", "input": "6hv2/6hv2/data/coll_1_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [68.928, 68.928, 133.563, 90.0, 90.0, 120.0], "dmin": 1.709}, "tags": ["h5", "hexagonal"]},
  {"id": "6hwj", "input": "6hwj/bg3006_2_0001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [59.812, 96.07, 80.252, 90.0, 106.69, 90.0], "dmin": 1.979}, "tags": ["cbf", "monoclinic"]},
-- 
2.54.0


From deb85728124e6a200b811f19310a3ddd753b13c1 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:15:37 +0200
Subject: [PATCH 004/122] tools/battery: one canonical runner, derived XDS
 d_min, clean inhouse layout

- Site config: site.example.json is committed; the local site.json (git-ignored) or
  $JFJOCH_BATTERY_SITE / --site names this machine's paths and the private manifest.
  Data roots are the arms' own directories, so copying them and editing the site
  config moves the battery.
- Run states: manifest records the runner's pid; a run is complete, running, aborted
  (Ctrl-C/SIGTERM, or `abort RUN`) or unfinished. compare and report refuse a run
  that did not finish unless --allow-incomplete, and the report says so.
- `list` shows runs and their state; `run` defaults its label to the rugnux version
  and its baseline to the site's persisted one; a baseline must be complete and of
  the same privacy as the run; a private report cannot be written into the repo.
- XDS reference d_min: when the finest shell of XDS's table has no significant
  CC1/2, XDS merged past its own signal (no resolution cut, or a cut at the detector
  edge) and its limit is the detector's reach. The reference is then where XDS's
  CC1/2 falls through 0.30 (rugnux's own target), and that is also the range forced
  on rugnux. The manifest keeps XDS's limit (dmin_xds) and the rule (dmin_rule).
  Forcing the old 1.08 A on the weak insulin set turned rugnux's I23 into I222
  (ISa 12.5); forced at the derived 1.81 A it is I23 again (ISa 18.0). Changed in
  the inhouse arm: insu_I_weak 1.08 -> 1.81, lyso_half_image 0.80 -> 2.60,
  cytc_eiger 2.04 -> 2.27, lyso_strong 1.18 -> 1.24; every other inhouse limit stands.
- inhouse.json follows the directory rename (ids and inputs, data root
  /home/data/inhouse); `remap` applies such a rename and keeps the old ids as
  aliases, so runs from before it still compare set by set.
- Optional open-arm model check (model_check.py, when present): R-free of the
  deposited model against each merge, recorded and plotted.
- results.json has a fixed, documented row schema (results_schema 1); the HTML
  report gains inline-SVG plots (verdicts per arm, d_min and R-free ratios per set).
- README.md: arms, data layout and provenance, prerequisites, running, run
  directory, results schema, report, comparing, protocol, adding datasets.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .gitignore                      |   5 +-
 tools/battery/README.md         | 279 ++++++++++++++++++++++++++++++++
 tools/battery/battery.py        | 263 +++++++++++++++++++++++++-----
 tools/battery/inhouse.json      |  74 ++++-----
 tools/battery/inputs.py         |  46 +++++-
 tools/battery/render.py         |  84 +++++++++-
 tools/battery/report.py         | 105 ++++++++++--
 tools/battery/score.py          |   5 +-
 tools/battery/site.example.json |  12 ++
 tools/battery/site.json         |  11 --
 10 files changed, 773 insertions(+), 111 deletions(-)
 create mode 100644 tools/battery/README.md
 create mode 100644 tools/battery/site.example.json
 delete mode 100644 tools/battery/site.json

diff --git a/.gitignore b/.gitignore
index 09815790f..8ecf683a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,7 @@ tmp_venv/
 # gen_python_client.sh: the built sdist/wheel.
 /dist/
 
-# rugnux_vs_xds.py output dirs (the default, and the ad-hoc ones used when comparing runs)
+# output dirs of the retired rugnux_vs_xds.py, still lying around in older working trees
 rugnux_cmp*/
 
 # rugnux_anomalous.py ANODE work dir, when the config does not point it at the data
@@ -42,3 +42,6 @@ docs/review/
 
 # Python bytecode (tools/battery and the root scripts)
 __pycache__/
+
+# tools/battery: the local site config (paths of this machine, private manifest); site.example.json is the template
+tools/battery/site.json
diff --git a/tools/battery/README.md b/tools/battery/README.md
new file mode 100644
index 000000000..18bec5d32
--- /dev/null
+++ b/tools/battery/README.md
@@ -0,0 +1,279 @@
+# Rugnux validation battery
+
+`battery.py` is the one way to run the Rugnux validation battery: run `rugnux` over a fixed list of
+rotation datasets, score each result against a reference, and write a standard report. Two runs
+of the same manifests with the same options give results you can compare set by set. Do not use
+ad-hoc runner scripts instead. The old ones (`rugnux_vs_xds.py`, `battery_run.py`,
+`battery2_serial.py`, `batstats.py`, ...) are retired because their numbers could not be compared
+with each other.
+
+## Arms
+
+| arm | datasets | reference | manifest |
+|---|---|---|---|
+| **open** | public PDB depositions of raw diffraction data, plus a few published small-molecule sets | the deposited space group, cell and resolution | `open.json` (committed) |
+| **inhouse** | standard test crystals measured at the SLS (lysozyme, thaumatin, insulin, cytochrome C, myoglobin), plus no-crystal controls | XDS, from the `CORRECT.LP` beside each dataset | `inhouse.json` (committed) |
+| **private** | user data | XDS, like inhouse | outside the repository; the local site config gives its path |
+
+Scoring checks four things in order, and the first one that fails decides the verdict: did it
+run, is the lattice right, is the symmetry right, is the merge usable (R_meas at most 60%, CC1/2 at
+least 0.5). The lattice test compares Niggli-reduced primitive cells: the primitive volume ratio
+must be 0.95-1.05 and the reduced edges must agree within 2%. On the open arm the space group is
+scored with `sgequiv`. On the XDS arms only the point group is scored, because XDS never tests a
+screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
+`score.py` has the details.
+
+The private arm is never mixed with the others. A private run gets its own run directory
+(suffix `_private`) and its own report (`report_PRIVATE.*`), and it cannot be the baseline of a
+public report or be written into the repository. Its names, paths and values never go into a
+commit, an issue or a public report.
+
+## Getting the data
+
+Each manifest row gives an `input` path relative to that arm's **data root**. The data root is
+set in the site config, and the first directory of each input is the dataset's directory:
+
+```
+<open data root>/11if/BopeA_18500_a_B2-PEF_11if/data/PSL-1503_13949_master.h5
+<inhouse data root>/lyso_ref/hewl_35_001_master.h5
+```
+
+To move the battery to another machine, copy the two data roots and point the new site config at
+the copies. The paths inside the manifests do not change.
+
+- **open**: every dataset is listed with its source repository and dataset DOI in
+  [`docs/EXTERNAL_TEST_DATA.md`](../../docs/EXTERNAL_TEST_DATA.md). The sources are IRRMC
+  (proteindiffraction.org), SBGrid Data Bank, Zenodo and a few others, and the page also says what
+  each archive holds. Please cite those DOIs. At PSI the data root is `/home/data/open`, a
+  symlink to `/home/data/nonsls/raw`. 51 of the dataset directories in it are themselves symlinks
+  into `/data/scout_staging2`, so **copy with symlinks followed**: `rsync -aL` or `cp -rL`.
+  A plain `rsync -a` copies dangling links. The open arm is about 1.7 TB.
+- **inhouse**: these are our own measurements and cannot be downloaded publicly. Ask the
+  maintainers for a copy. Each dataset directory holds the images and the XDS output
+  (`CORRECT.LP`, `XDS_ASCII.HKL`, ...) that the reference comes from. At PSI the data root is
+  `/home/data/inhouse` (about 130 GB). **Leave out `.master_backups_kek`** when copying it
+  (`rsync -a --exclude .master_backups_kek`): it holds backups of private masters, not battery data.
+- **private**: its data root and manifest are named only in the local site config.
+
+## Prerequisites
+
+- Python 3.9 or newer, with `gemmi` (scoring). `h5py` is needed only by `discover`.
+- A `rugnux` binary. Build it with the flags CI uses (`-march=x86-64-v3`, see `CLAUDE.md`),
+  because CPU-bound results and timings differ between builds. The runner records the build
+  flags from the `CMakeCache.txt` above the binary, or from the tree given with `--build-dir`.
+- XDS is not needed. The XDS references are already in the manifests (`refs` re-reads them from
+  `CORRECT.LP`).
+
+## Site config
+
+Machine-specific settings live in a site config: the data roots, the runs root, the lock file, an
+optional GPU-queue wrapper, the private arm, and the persisted baselines. The runner looks for it
+in this order:
+
+1. `--site PATH`
+2. `$JFJOCH_BATTERY_SITE`
+3. `tools/battery/site.json` (git-ignored)
+
+`site.example.json` is the committed template. Copy it and fill in your paths. The local file is
+kept out of git because it names the private manifest. At PSI the config is
+`/data/battery/site.json`: link it (`ln -s /data/battery/site.json tools/battery/site.json`) or
+export `JFJOCH_BATTERY_SITE=/data/battery/site.json`.
+
+```json
+{
+ "runs_root": "/data/battery/runs",
+ "lock_file": "/data/battery/full_run.lock",
+ "gpulock": "/data/tmp/gpulock",
+ "baseline": "/data/battery/runs/<a blessed full run>",
+ "baseline_private": null,
+ "arms": {
+  "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/home/data/open"},
+  "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/home/data/inhouse"},
+  "private": {"manifest": "/path/to/private.json", "reference": "xds",
+              "data_root": "/path/to/private/data", "private": true}
+ }
+}
+```
+
+A relative `manifest` path is resolved against `tools/battery/`. `gpulock` is a command that
+`rugnux` is prefixed with under `--gpulock`. At PSI it is a wrapper script that queues for one of
+the shared GPU slots. Set it to `null` if you have no such wrapper.
+
+## Running
+
+```
+B=tools/battery/battery.py
+R=build/rugnux/rugnux
+
+$B run --rugnux $R                                  # full battery: open + inhouse
+$B run --rugnux $R --tier smoke                     # 22 sets covering readers, symmetry, known hard cases
+$B run --rugnux $R --only 5reo,lyso_ref             # named sets
+$B run --rugnux $R --arm private                    # the private arm, on its own
+$B run --rugnux $R --arm inhouse --unforced         # XDS arms without XDS's resolution forced
+```
+
+Useful options:
+
+- `--label` names the run. By default the label is the rugnux version.
+- `--threads N` passes `-N` to rugnux.
+- `--gpulock` queues every rugnux behind the site's GPU wrapper.
+- `--extra "<args>"` adds rugnux arguments to every set.
+- `--baseline RUN|none` sets the run the report is compared against.
+- `--model-check` / `--no-model-check` turns the open-arm R-free check on or off (see below).
+
+A run prints one line per set and ends by writing its report. The **smoke** tier is marked in the
+manifests (`"tiers": {"smoke": "<why this set>"}`).
+
+**Full runs.** A run without `--only` or `--tier` takes the site lock (`flock`, non-blocking), so
+two full runs cannot overlap. Do not start one without the owner's go-ahead: it takes hours, and
+everything else on the machine competes with it.
+
+### The model check (open arm)
+
+If `tools/battery/model_check.py` is present, each open-arm merge (`p.mtz`) is also scored
+against the deposited model: `model_check.check(mtz, pdb_id, workdir)` returns R-free and R-work
+of the deposited model against our data, plus the deposited R-free. The runner records these as
+`rfree`, `rwork`, `rfree_deposited`, `rfree_ratio`, `model_status` and `model_reason`, and the
+report plots their ratio. The check is on by default when the module exists. Without the module
+the fields stay null. The PDB entry is the set id up to the first `_`, so `6h2p_native` is checked
+as `6h2p`. Small-molecule sets are skipped.
+
+`model_sweep.py` is a different tool: it runs `rugnux --model` over the open arm (same inputs, same
+site config) and compares the R-free that rugnux itself reports with the published value. It needs
+network access to the RCSB and runs separately from `battery.py`.
+
+## A run directory
+
+`<runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_<label>[_private]/` is never reused, and it is made
+read-only when the run completes.
+
+| path | content |
+|---|---|
+| `bin/rugnux` | the exact binary that ran (sha256 in the manifest) |
+| `manifest.json` | the label, arms, subset, options, binary version, build flags and source HEAD, runner git and dirty flag, host, pid, start and end, `complete` / `aborted`, `gpu_shared`, and every set with its resolved input, reference and tags |
+| `results.json` | one row per set (the schema is below) |
+| `report.md`, `report.html` | the report (`report_PRIVATE.*` for a private run) |
+| `work/<arm>/<set>/` | `run.log`, `p_report.txt`, `p.mtz`, `p.cif`, ... and `model_check/` |
+
+**Run states** (`battery.py list`): `complete`; `running` (its runner process is alive);
+`aborted` (interrupted by Ctrl-C or SIGTERM, or marked with `battery.py abort RUN --reason ...`);
+`unfinished` (it died without a trace, which is treated the same as aborted). An unfinished run
+covers an arbitrary part of its sets. `compare` and `report` refuse it unless given
+`--allow-incomplete`, and the report then says so at the top.
+
+### results.json (schema 1)
+
+This is a flat list with one object per set, and every arm uses the same keys. Missing values are
+`null`. `manifest.json` records the schema version as `results_schema`.
+
+| key | meaning |
+|---|---|
+| `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
+| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` |
+| `reason` | one line for a human |
+| `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours / the reference's |
+| `sg_relation` | open arm: how the two groups relate (`sgequiv`) |
+| `cell`, `cell_ref`, `cell_dev_pct`, `volume_ratio` | cells, the largest edge deviation in % (over axis orders), and the primitive volume ratio |
+| `d_min`, `d_min_ref`, `res_gain_pct` | our high-resolution limit, the reference's, and (ref - ours) / ref in % |
+| `d_min_ref_rule`, `d_min_xds` | XDS arms: how `d_min_ref` was derived (below), and the range XDS merged |
+| `r_meas`, `cc_half`, `isa`, `completeness`, `multiplicity`, `i_over_sigma`, `indexing_rate`, `images` | from rugnux's `_report.txt` |
+| `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref` | XDS's overall values, over XDS's own range |
+| `rfree`, `rwork`, `rfree_deposited`, `rfree_ratio`, `model_status`, `model_reason` | the model check (open arm) |
+| `wall_s`, `rugnux_wall_s`, `elapsed_s`, `exit_code`, `gpu_others`, `rugnux_verdict` | timing (`wall_s` is rugnux's own WALL_TIME, not the time spent waiting for the GPU queue), the exit code, other GPU processes seen before the set, and rugnux's own verdict line |
+
+## The report
+
+Every run writes the same report as Markdown and as a self-contained HTML page (inline CSS and
+SVG, no external files):
+
+- a header with the binary, build flags, host, subset, resolution mode and whether timing counts;
+- a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain,
+  ISa, R_meas, time) with a verdict bar chart;
+- a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
+  the main metrics;
+- plots per set: d_min(rugnux) / d_min(reference) for each arm whose resolution is not forced, and
+  R_free / deposited R_free for the open arm (HTML only; hovering a point shows the set);
+- the **failures**, and, if there is a baseline, the **delta against it**: pass rates on the
+  common sets and every set that moved beyond noise;
+- **one row per set** with all the numbers.
+
+Re-render a report, for example against another baseline (run directories are read-only, so the
+output goes elsewhere and is named after the run):
+
+```
+$B report RUN --out DIR [--baseline OTHER_RUN]      # writes DIR/<run>.md and DIR/<run>.html
+```
+
+**Keeping a report in the repository.** Public reports of blessed runs go to
+`tools/battery/reports/<run>.md` (Markdown only; the HTML stays with the run). `report` refuses
+to write a private run's report anywhere inside the repository.
+
+## Comparing runs
+
+```
+$B list                                             # runs, their state, and the baselines
+$B compare RUN_A RUN_B [--all]                      # per-set table of what moved beyond noise
+$B compare RUN_A RUN_B --rerun-changed              # rerun the changed sets with A's binary
+```
+
+`compare` pairs sets by arm and id, following the manifests' `aliases` across renames, and lists
+every set whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell,
+R-free or time moved by more than the noise thresholds in `report.py` (`NOISE`). Those thresholds
+are a first guess. `--rerun-changed` measures the noise directly: it reruns the changed sets with
+A's saved binary and options. A set that moves again under the same binary is noise. A set that
+reproduces A was really changed by B.
+
+## Protocol
+
+1. **Compare against a persisted baseline, never against a number from memory.** The site
+   config's `baseline` (and `baseline_private`) names a complete run. Every new run is reported
+   against it by default. Set a new baseline only when the owner blesses a run.
+2. **Keep the manifests unchanged between the two runs you compare.** A change to a manifest
+   (new sets, a new reference, a different input) is committed on its own, and the baseline is
+   re-run with it.
+3. **Pool fixes.** Run the full battery once on a branch that carries several fixes, not once per
+   fix. For one fix, run the sets it touches with `--only`, plus the smoke tier.
+4. **Timing.** `--gpulock`, or another process seen on the GPU, marks the run "timing NOT a
+   reference". Only a run with the machine to itself can be used to judge speed.
+5. **Resolution on the XDS arms.** By default XDS's resolution range is forced on rugnux, so both
+   programs merge the same reflections and the statistics are like for like. This answers "is our
+   processing better than XDS's, reflection for reflection". `--unforced` leaves rugnux its own
+   cut, which answers "what does a user get". A change can win one and lose the other, so at
+   important moments run both. Never quote the forced run as what rugnux delivers.
+
+### The XDS reference d_min
+
+`CORRECT.LP` gives the range XDS merged. That range is a resolution limit only if someone chose
+it. With `INCLUDE_RESOLUTION_RANGE` left at `0.0`, or set at the detector edge, it is the detector's
+reach, not the crystal's. It then gives a meaningless reference, and forcing it on rugnux makes
+rugnux merge shells of pure noise. On one insulin set, forcing XDS's 1.08 A (where the data end
+near 1.8 A) turned rugnux's correct I23 into I222. XDS marks each shell's CC1/2 with `*` when it
+is significant, and that decides which case applies (`inputs.reference_dmin`):
+
+- `xds_range`: the finest shell's CC1/2 is significant, so XDS's limit stands.
+- `cc_half_0.30`: it is not, meaning XDS merged past its own signal. The reference is then the
+  point where XDS's CC1/2 falls through 0.30 (the target of rugnux's own cutoff), interpolated in
+  1/d² between shell centres.
+
+The derived value is both the score reference and the forced range. The manifest keeps XDS's own
+limit as `dmin_xds` and the rule used as `dmin_rule`. XDS's pooled R_meas, CC1/2 and completeness
+still cover its whole range.
+
+## Adding or changing datasets
+
+- **Open arm**: put the dataset directory, named by its PDB code, under the open data root, then
+  run `battery.py discover`. It proposes an input for every directory the manifest does not have
+  (the largest sweep, chosen by frame count), and with `--refresh` it shows where discovery now
+  disagrees with an unpinned manifest input. Add the row to `open.json` with the deposited
+  reference (`sg`, `sgno`, `cell`, `dmin`) and tags. Set `"pinned": true` when the choice between
+  sweeps was deliberate. Record the source and DOI in `docs/EXTERNAL_TEST_DATA.md`.
+- **Inhouse / private**: add the row (`id`, `input`, tags, and `"expect": "no_lattice"` for a
+  control), then run `battery.py refs --arm inhouse --write` to fill in `ref` from the
+  `CORRECT.LP` beside the input. Without `--write`, `refs` only shows what would change.
+  A reference measured by hand goes in `ref_override`, which `refs` leaves alone.
+- **Renamed data directories**: `battery.py remap --arm inhouse MAP.json --write`, where
+  `MAP.json` is `{"old": "new"}` (renames the set and its directory) or
+  `{"old id": {"id": "...", "input": "..."}}`. Each old id is recorded under `aliases` in the
+  manifest, so runs made before the rename still compare set by set. Without `--write`, the
+  command only shows the result and flags inputs that do not exist.
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 97899f090..ceed6ed20 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -10,18 +10,25 @@ Arms and where their truth comes from:
   private  user data, scored like inhouse. Its manifest lives OUTSIDE the repository (path in the
            site config) and a private run gets its own run directory and report.
 
-Usage:
-  battery.py run --rugnux BIN --label L [--arm open,inhouse|private] [--only a,b | --tier smoke]
-                 [--build-dir DIR] [--gpulock] [--threads N] [--unforced] [--baseline RUN]
+Usage (README.md in this directory is the full guide):
+  battery.py run --rugnux BIN [--label L] [--arm open,inhouse|private] [--only a,b | --tier smoke]
+                 [--build-dir DIR] [--gpulock] [--threads N] [--unforced] [--baseline RUN|none]
+  battery.py list                                 runs under the runs root, with their state
   battery.py compare RUN_A RUN_B [--all] [--rerun-changed]
-  battery.py report RUN --out DIR [--baseline RUN] re-render a run's report
+  battery.py report RUN --out DIR [--baseline RUN] re-render a run's report into DIR/<run>.{md,html}
+  battery.py abort RUN [--reason TEXT]            mark an unfinished run as aborted
   battery.py discover [--refresh]                 open arm: propose inputs for new directories
   battery.py refs --arm inhouse|private [--write] re-read the XDS references from CORRECT.LP
+  battery.py remap --arm A MAP.json [--write]     follow a rename of the data directories
+
+The site config (data roots, runs root, lock, gpulock, private manifest, baselines) is --site, else
+$JFJOCH_BATTERY_SITE, else site.json beside this script (not committed; site.example.json is).
 
 A run writes <runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_<label>/ holding a copy of the binary,
 manifest.json (what was run, on what, with which references), results.json (one row per set),
 report.md + report.html and work/<arm>/<set>/ (log, report, cif). It is made read-only when done.
 A full-arm run (no --only / --tier) takes the site lock and refuses to start if another holds it.
+A run that did not finish is never compared or reported on unless asked (--allow-incomplete).
 """
 import argparse
 import datetime
@@ -31,6 +38,7 @@ import json
 import os
 import re
 import shutil
+import signal
 import socket
 import stat
 import subprocess
@@ -44,12 +52,24 @@ import inputs  # noqa: E402
 import report  # noqa: E402
 import score   # noqa: E402
 
-DEFAULT_SITE = os.path.join(HERE, "site.json")
+try:
+    import model_check   # optional: R-free of the deposited model against our merge (open arm)
+except ImportError:
+    model_check = None
+
+PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
+
+LOCAL_SITE = os.path.join(HERE, "site.json")
 
 
 # ------------------------------------------------------------------ configuration and manifests
 
 def load_site(path):
+    path = path or os.environ.get("JFJOCH_BATTERY_SITE") or LOCAL_SITE
+    if not os.path.exists(path):
+        sys.exit(f"no site config at {path}: copy {os.path.join(HERE, 'site.example.json')} to "
+                 f"{LOCAL_SITE} (or anywhere, and point JFJOCH_BATTERY_SITE or --site at it) and "
+                 "fill in this machine's paths")
     site = json.load(open(path))
     for arm in site["arms"].values():
         arm["manifest"] = os.path.join(HERE, arm["manifest"])   # an absolute path stays as it is
@@ -170,7 +190,8 @@ def run_one(run_dir, binary, e, opts):
     wd = os.path.join(run_dir, "work", e["arm"], e["id"])
     os.makedirs(wd)
     row = {"set": e["id"], "arm": e["arm"], "tags": e.get("tags", []), "input": e["input_path"],
-           "gpu_others": gpu_others()}
+           "gpu_others": gpu_others(), "rfree": None, "rwork": None, "rfree_deposited": None,
+           "rfree_ratio": None, "model_status": None, "model_reason": None}
     if not os.path.exists(e["input_path"]):
         row.update(score.judge(e, {}, "no input"), exit_code=None, elapsed_s=None, wall_s=None, cmd=None)
         return row
@@ -192,9 +213,32 @@ def run_one(run_dir, binary, e, opts):
     # rugnux's own WALL_TIME where it wrote one: the runner's clock also counts the wait for a
     # GPU slot under --gpulock
     row["wall_s"] = row["rugnux_wall_s"] if row["rugnux_wall_s"] is not None else row["elapsed_s"]
+    if opts.get("model_check") and e["arm"] == "open":
+        row.update(check_model(e, wd))
     return row
 
 
+def check_model(e, wd):
+    """R-free of the deposited model against this run's merge (model_check.py). A set id may
+    carry a suffix (6h2p_native); the PDB entry is the part before it."""
+    out = {"rfree": None, "rwork": None, "rfree_deposited": None, "rfree_ratio": None}
+    pdb = e["id"].split("_")[0]
+    mtz = os.path.join(wd, "p.mtz")
+    if not PDB_ID.match(pdb):
+        return dict(out, model_status="skipped", model_reason="not a PDB entry")
+    if not os.path.exists(mtz):
+        return dict(out, model_status="skipped", model_reason="no merged MTZ")
+    try:
+        res = model_check.check(mtz, pdb, os.path.join(wd, "model_check"))
+    except Exception as ex:          # a failing check must not lose the set's processing result
+        return dict(out, model_status="error", model_reason=f"{type(ex).__name__}: {ex}"[:300])
+    out.update({k: res.get(k) for k in ("rfree", "rwork", "rfree_deposited")},
+               model_status=res.get("status"), model_reason=res.get("reason"))
+    if out["rfree"] and out["rfree_deposited"]:
+        out["rfree_ratio"] = round(out["rfree"] / out["rfree_deposited"], 4)
+    return out
+
+
 def make_read_only(path):
     for dp, dirs, files in os.walk(path):
         for fn in files:
@@ -219,12 +263,13 @@ def write_manifest(path, man):
         fh.write(head + ', "sets": [\n ' + ",\n ".join(lines) + "\n]}\n")
 
 
-def write_report(run_dir, baseline=None, out_dir=None):
-    """report.md and report.html (report_PRIVATE.* for a private run) into out_dir, by default
-    the run directory itself."""
+def write_report(run_dir, baseline=None, out_dir=None, allow_incomplete=False):
+    """report.md and report.html (report_PRIVATE.* for a private run) in the run directory, or
+    <run name>.md/.html (with _PRIVATE) in out_dir."""
     man = json.load(open(os.path.join(run_dir, "manifest.json")))
-    base = os.path.join(out_dir or run_dir, "report_PRIVATE" if man.get("private") else "report")
-    doc = report.build(run_dir, baseline)
+    name = os.path.basename(os.path.normpath(run_dir)) if out_dir else "report"
+    base = os.path.join(out_dir or run_dir, name + ("_PRIVATE" if man.get("private") else ""))
+    doc = report.build(run_dir, baseline, allow_incomplete=allow_incomplete or not out_dir)
     open(base + ".md", "w").write(doc.markdown())
     open(base + ".html", "w").write(doc.html())
     return base + ".html"
@@ -235,6 +280,8 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     private = any(site["arms"][a].get("private") for a in arms)
     if private and len(arms) > 1:
         sys.exit("the private arm runs on its own: its results must not share a run or a report")
+    if baseline:
+        report.check_baseline(baseline, private)
     lock_fh = None
     if lock:
         os.makedirs(os.path.dirname(lock), exist_ok=True)
@@ -245,6 +292,7 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
             sys.exit(f"another full battery run holds {lock}; refusing to start a second one")
 
     info = binary_info(binary_src, build_dir)
+    label = label or info.get("version") or "run"
     stamp = datetime.datetime.now().strftime("%Y%m%d-%H%M")
     run_dir = os.path.join(opts["runs_root"],
                            f"{stamp}_{info['git']}_{label}" + ("_private" if private else ""))
@@ -261,22 +309,28 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
            "binary": info,
            "runner_git": git(HERE, "rev-parse", "--short", "HEAD") or "unknown",
            "runner_dirty": bool(git(HERE, "status", "--porcelain", "--", ".")),
-           "host": socket.gethostname(), "start": datetime.datetime.now().isoformat(timespec="seconds"),
-           "end": None, "complete": False, "options": {k: v for k, v in opts.items() if k != "runs_root"},
+           "host": socket.gethostname(), "pid": os.getpid(), "start": datetime.datetime.now().isoformat(timespec="seconds"),
+           "end": None, "complete": False, "results_schema": report.RESULTS_SCHEMA, "options": {k: v for k, v in opts.items() if k != "runs_root"},
            "gpu_shared": bool(opts["gpulock"]), "sets": sets}
     write_json(os.path.join(run_dir, "manifest.json"), man)
     print(f"run directory {run_dir}", flush=True)
 
     results = []
-    for n, e in enumerate(sets, 1):
-        row = run_one(run_dir, binary, e, opts)
-        results.append(row)
-        if row.get("gpu_others"):
-            man["gpu_shared"] = True
-        write_json(os.path.join(run_dir, "results.json"), results)
-        print(f"[{n}/{len(sets)}] {e['arm']:8s} {e['id']:24s} {row['verdict']:8s} "
-              f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
-              f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
+    # a kill by SIGTERM is recorded like Ctrl-C: the run directory then says it was aborted
+    signal.signal(signal.SIGTERM, interrupted)
+    try:
+        for n, e in enumerate(sets, 1):
+            row = run_one(run_dir, binary, e, opts)
+            results.append(row)
+            if row.get("gpu_others"):
+                man["gpu_shared"] = True
+            write_json(os.path.join(run_dir, "results.json"), results)
+            print(f"[{n}/{len(sets)}] {e['arm']:8s} {e['id']:24s} {row['verdict']:8s} "
+                  f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
+                  f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
+    except KeyboardInterrupt:
+        mark_aborted(run_dir, f"interrupted after {len(results)} of {len(sets)} sets")
+        sys.exit(f"aborted; {run_dir} is marked as such")
 
     man.update(end=datetime.datetime.now().isoformat(timespec="seconds"), complete=True)
     write_json(os.path.join(run_dir, "manifest.json"), man)
@@ -287,6 +341,25 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     return run_dir
 
 
+def interrupted(*_):
+    raise KeyboardInterrupt
+
+
+def mark_aborted(run_dir, reason):
+    man = json.load(open(os.path.join(run_dir, "manifest.json")))
+    man["aborted"] = {"at": datetime.datetime.now().isoformat(timespec="seconds"), "reason": reason}
+    write_json(os.path.join(run_dir, "manifest.json"), man)
+    make_read_only(run_dir)
+
+
+def default_baseline(site, arms, given):
+    """--baseline, else the site's persisted baseline for this kind of run ('none' = no delta)."""
+    if given:
+        return None if given == "none" else given
+    private = any(site["arms"][a].get("private") for a in arms)
+    return site.get("baseline_private" if private else "baseline") or None
+
+
 # ------------------------------------------------------------------ subcommands
 
 def cmd_run(a, site):
@@ -298,16 +371,47 @@ def cmd_run(a, site):
     if not sets:
         sys.exit("nothing selected")
     subset = a.only or (f"tier {a.tier}" if a.tier else None)
+    if a.model_check and not model_check:
+        sys.exit("--model-check: tools/battery/model_check.py is not there")
+    use_model = a.model_check if a.model_check is not None else bool(model_check)
     opts = {"threads": a.threads, "xds_range": not a.unforced, "timeout": a.timeout,
+            "model_check": use_model and "open" in arms,
             "gpulock": site["gpulock"] if a.gpulock else None, "extra_args": a.extra.split(),
             "runs_root": a.runs_root or site["runs_root"]}
-    run_sets(site, sets, arms, a.rugnux, a.build_dir, a.label, opts, subset, a.baseline,
-             lock=None if subset else site["lock_file"])
+    if a.gpulock and not site.get("gpulock"):
+        sys.exit("--gpulock: the site config names no gpulock")
+    run_sets(site, sets, arms, a.rugnux, a.build_dir, a.label, opts, subset,
+             default_baseline(site, arms, a.baseline), lock=None if subset else site["lock_file"])
+
+
+def cmd_list(a, site):
+    root = a.runs_root or site["runs_root"]
+    for d in sorted(os.listdir(root)):
+        run = os.path.join(root, d)
+        if not os.path.exists(os.path.join(run, "manifest.json")):
+            continue
+        man = json.load(open(os.path.join(run, "manifest.json")))
+        state = report.run_state(man)
+        n = len(json.load(open(os.path.join(run, "results.json")))) \
+            if os.path.exists(os.path.join(run, "results.json")) else 0
+        mark = " <- baseline" if run in (site.get("baseline"), site.get("baseline_private")) else ""
+        print(f"{d:48s} {state:10s} {n:3d}/{len(man['sets']):3d} sets  "
+              f"{man.get('subset') or 'full arm':20.20s} {','.join(man['arms'])}{mark}")
+
+
+def cmd_abort(a, site):
+    man = json.load(open(os.path.join(a.run, "manifest.json")))
+    state = report.run_state(man)
+    if state not in ("unfinished", "running") or (state == "running" and not a.force):
+        sys.exit(f"{a.run} is {state}; only an unfinished run can be marked aborted "
+                 "(a live one needs --force)")
+    mark_aborted(a.run, a.reason)
+    print(f"{a.run}: marked aborted ({a.reason})")
 
 
 def cmd_compare(a, site):
-    man_a, res_a = report.load_run(a.run_a)
-    man_b, res_b = report.load_run(a.run_b)
+    man_a, res_a = report.load_run(a.run_a, a.allow_incomplete)
+    man_b, res_b = report.load_run(a.run_b, a.allow_incomplete)
     rows = report.compare_rows(res_a, res_b)
     doc = report.Doc(f"{os.path.basename(os.path.normpath(a.run_a))}  vs  "
                      f"{os.path.basename(os.path.normpath(a.run_b))}")
@@ -326,6 +430,7 @@ def cmd_compare(a, site):
         return
     sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in changed]
     opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"])
+    opts["gpulock"] = opts["gpulock"] and site.get("gpulock")
     label = "rerunA-" + man_a["label"]
     rerun = run_sets(site, sets, man_a["arms"], os.path.join(a.run_a, "bin", "rugnux"), None, label,
                      opts, ",".join(e["id"] for e in sets))
@@ -346,9 +451,14 @@ def cmd_compare(a, site):
 
 
 def cmd_report(a, site):
-    # a finished run directory is read-only, so a re-render goes elsewhere
+    # a finished run directory is read-only, so a re-render goes elsewhere, named after the run
+    man, _ = report.load_run(a.run, a.allow_incomplete)
+    repo = git(HERE, "rev-parse", "--show-toplevel")
+    out = os.path.realpath(a.out)
+    if man.get("private") and repo and (out + os.sep).startswith(os.path.realpath(repo) + os.sep):
+        sys.exit("a private run's report must not be written into the repository")
     os.makedirs(a.out, exist_ok=True)
-    print(write_report(a.run, a.baseline, a.out))
+    print(write_report(a.run, a.baseline, a.out, a.allow_incomplete))
 
 
 def cmd_discover(a, site):
@@ -356,20 +466,22 @@ def cmd_discover(a, site):
     --refresh, also show where today's discovery disagrees with the manifest's (unpinned) input."""
     cfg = site["arms"]["open"]
     root = cfg["data_root"]
-    sets = {e["id"]: e for e in load_sets(site, "open")}
+    by_dir = {}                       # a directory can hold several sets (6h2p_native, 6h2p_1p89A)
+    for e in load_sets(site, "open"):
+        by_dir.setdefault(e["input"].split("/")[0], []).append(e)
     for d in sorted(os.listdir(root)):
         if d.startswith(".") or not os.path.isdir(os.path.join(root, d)):
             continue
-        e = sets.get(d)
-        if e and (not a.refresh or e.get("pinned")):
+        sets = by_dir.get(d, [])
+        if (sets and not a.refresh) or len(sets) > 1 or (sets and sets[0].get("pinned")):
             continue
         path, fmt, note = inputs.find_input(os.path.join(root, d))
         rel = os.path.relpath(path, root) if path else None
-        if not e:
+        if not sets:
             print(f"NEW   {d:10s} {rel}   [{note}]")
-        elif rel != e["input"]:
-            print(f"DIFF  {d:10s} manifest {e['input']}\n      {'':10s} discover {rel}   [{note}]")
-    for d in sorted(set(sets) - set(os.listdir(root))):
+        elif rel != sets[0]["input"]:
+            print(f"DIFF  {d:10s} manifest {sets[0]['input']}\n      {'':10s} discover {rel}   [{note}]")
+    for d in sorted(set(by_dir) - set(os.listdir(root))):
         print(f"GONE  {d:10s} in the manifest, not on disk")
 
 
@@ -385,22 +497,65 @@ def cmd_refs(a, site):
             print(f"{e['id']:24s} no CORRECT.LP")
             continue
         new = inputs.parse_correct_lp(lp)
-        if new != e.get("ref"):
-            print(f"{e['id']:24s} {e.get('ref')}\n{'':24s} -> {new}")
+        old = e.get("ref") or {}
+        diff = [f"{k} {old.get(k)} -> {new.get(k)}" for k in sorted(set(old) | set(new))
+                if old.get(k) != new.get(k)]
+        if diff:
+            print(f"{e['id']:24s} " + "; ".join(diff))
             e["ref"] = new
     if a.write:
         write_manifest(cfg["manifest"], man)
 
 
+def cmd_remap(a, site):
+    """Follow a rename of data directories. MAP is a JSON object {old: new}: a string renames the
+    set of that id and, wherever it is the first directory of an input, that directory; an object
+    {"id": ..., "input": ...} gives one set's new id and input outright. A renamed set's old id is
+    kept under "aliases", so runs made before the rename still compare set by set."""
+    cfg = site["arms"][a.arm]
+    man = json.load(open(cfg["manifest"]))
+    mp = json.load(open(a.map))
+    aliases = man.setdefault("aliases", {})
+    for e in man["sets"]:
+        new = mp.get(e["id"])
+        head, _, rest = e["input"].partition("/")
+        if isinstance(new, dict):
+            new_id, new_input = new.get("id", e["id"]), new.get("input", e["input"])
+        else:
+            new_id = new or e["id"]
+            new_input = (mp[head] if isinstance(mp.get(head), str) else head) + "/" + rest
+        if (new_id, new_input) == (e["id"], e["input"]):
+            continue
+        there = os.path.exists(os.path.join(cfg["data_root"], new_input))
+        print(f"{e['id']:24s} -> {new_id:24s} {new_input}" + ("" if there else "   NOT FOUND"))
+        if new_id != e["id"]:
+            for old in [k for k, v in aliases.items() if v == e["id"]]:
+                aliases[old] = new_id
+            aliases[e["id"]] = new_id
+        e["id"], e["input"] = new_id, new_input
+    if a.write:
+        write_manifest(cfg["manifest"], man)
+
+
+def load_aliases(site):
+    """{arm: {old set id: current id}} from the manifests, applied when runs are compared."""
+    out = {}
+    for arm, cfg in site["arms"].items():
+        if os.path.exists(cfg["manifest"]):
+            out[arm] = json.load(open(cfg["manifest"])).get("aliases", {})
+    return out
+
+
 def main():
     ap = argparse.ArgumentParser(description=__doc__.split("\n")[0])
-    ap.add_argument("--site", default=os.environ.get("BATTERY_SITE", DEFAULT_SITE),
-                    help="site config (data roots, runs root, private manifest, lock file)")
+    ap.add_argument("--site", help="site config (default: $JFJOCH_BATTERY_SITE, else site.json "
+                                   "beside this script)")
     sub = ap.add_subparsers(dest="cmd", required=True)
 
     r = sub.add_parser("run")
     r.add_argument("--rugnux", required=True)
-    r.add_argument("--label", required=True, help="short name, part of the run directory's name")
+    r.add_argument("--label", help="short name, part of the run directory's name "
+                                   "(default: the rugnux version)")
     r.add_argument("--arm", default="open,inhouse", help="comma-separated (default: open,inhouse)")
     r.add_argument("--only", help="comma-separated set ids")
     r.add_argument("--tier", help="named subset from the manifests, e.g. smoke")
@@ -411,8 +566,12 @@ def main():
     r.add_argument("--unforced", action="store_true",
                    help="do not force XDS's resolution range on the XDS-referenced arms")
     r.add_argument("--timeout", type=int, default=10800)
+    r.add_argument("--model-check", action=argparse.BooleanOptionalAction, default=None,
+                   help="open arm: R-free of the deposited model against each merge "
+                        "(default: on when model_check.py is present)")
     r.add_argument("--extra", default="", help="extra rugnux arguments, applied to every set")
-    r.add_argument("--baseline", help="earlier run directory to report the delta against")
+    r.add_argument("--baseline", help="earlier run directory to report the delta against (default: "
+                                      "the site's persisted baseline; 'none' for no delta)")
     r.add_argument("--runs-root")
 
     c = sub.add_parser("compare")
@@ -422,23 +581,41 @@ def main():
     c.add_argument("--rerun-changed", action="store_true",
                    help="rerun the changed sets with A's saved binary to separate real change from noise")
     c.add_argument("--runs-root")
+    c.add_argument("--allow-incomplete", action="store_true",
+                   help="compare a run that did not finish (aborted, killed or still running)")
 
     p = sub.add_parser("report")
     p.add_argument("run")
     p.add_argument("--baseline")
     p.add_argument("--out", required=True, help="directory for the re-rendered report")
+    p.add_argument("--allow-incomplete", action="store_true",
+                   help="render a run that did not finish; the report says so")
+
+    ls = sub.add_parser("list")
+    ls.add_argument("--runs-root")
+
+    ab = sub.add_parser("abort")
+    ab.add_argument("run")
+    ab.add_argument("--reason", default="aborted by hand")
+    ab.add_argument("--force", action="store_true", help="even if its runner still seems alive")
 
     d = sub.add_parser("discover")
     d.add_argument("--refresh", action="store_true")
 
+    m = sub.add_parser("remap")
+    m.add_argument("--arm", required=True)
+    m.add_argument("map", help="JSON file {old: new}")
+    m.add_argument("--write", action="store_true")
+
     f = sub.add_parser("refs")
     f.add_argument("--arm", required=True)
     f.add_argument("--write", action="store_true")
 
     a = ap.parse_args()
     site = load_site(a.site)
-    {"run": cmd_run, "compare": cmd_compare, "report": cmd_report,
-     "discover": cmd_discover, "refs": cmd_refs}[a.cmd](a, site)
+    report.ALIASES = load_aliases(site)
+    {"run": cmd_run, "list": cmd_list, "compare": cmd_compare, "report": cmd_report,
+     "abort": cmd_abort, "discover": cmd_discover, "refs": cmd_refs, "remap": cmd_remap}[a.cmd](a, site)
 
 
 if __name__ == "__main__":
diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index f9cb11b12..e2a38ade5 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -1,38 +1,38 @@
-{"arm": "inhouse", "sets": [
- {"id": "E08_lyso_2_006", "input": "E08_lyso_2_006/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "E08_lyso_2_007", "input": "E08_lyso_2_007/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_2", "input": "lyso_2/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_6_5keV", "input": "lyso_6_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
- {"id": "lysoC_14_f46f0a", "input": "lysoC_14_f46f0a/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_ref", "input": "lyso_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
- {"id": "lyso_strong", "input": "lyso_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_half_image", "input": "lyso_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "thau_16keV", "input": "thau_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "Thau_9", "input": "Thau_9/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_BL1A_1p9A", "input": "thau_BL1A_1p9A/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_BL1A_2p7A", "input": "thau_BL1A_2p7A/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_BL1A_3p3A", "input": "thau_BL1A_3p3A/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
- {"id": "thau_injection", "input": "thau_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_pink", "input": "thau_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
- {"id": "Ins_H_2_fa9841", "input": "Ins_H_2_fa9841/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "Ins_H_3_d05684", "input": "Ins_H_3_d05684/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
- {"id": "Ins_I_16", "input": "Ins_I_16/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
- {"id": "Ins_I_2_1a530d", "input": "Ins_I_2_1a530d/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "Ins_I_3_5e90e3", "input": "Ins_I_3_5e90e3/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "Ins_I_6_13keV", "input": "Ins_I_6_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "Ins_I_6_5keV", "input": "Ins_I_6_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "Ins_I_6_6keV", "input": "Ins_I_6_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "Ins_I_7_5keV", "input": "Ins_I_7_5keV/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
- {"id": "cytC_10", "input": "cytC_10/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytC_2_0770b5", "input": "cytC_2_0770b5/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytC_3_874285", "input": "cytC_3_874285/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "MyoB_13", "input": "MyoB_13/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
- {"id": "MyoB_9_446b70", "input": "MyoB_9_446b70/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
- {"id": "MyoB2-1", "input": "MyoB2-1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
- {"id": "MyoB2-2", "input": "MyoB2-2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "MyoB2-4", "input": "MyoB2-4/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "MyoB2-5", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "onlyice", "input": "onlyice/onlyice_master.h5", "expect": "no_lattice", "tags": ["h5", "control"], "tiers": {"smoke": "no-crystal control (ice rings only): must refuse"}},
- {"id": "nothing_3400ac", "input": "nothing/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
- {"id": "nothing_9bf604", "input": "nothing/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
+{"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_90deg_1", "E08_lyso_2_007": "lyso_90deg_2", "lyso_2": "lyso_atten_wedge", "lyso_6_5keV": "lyso_5keV", "lysoC_14_f46f0a": "lyso_ice", "Thau_9": "thau_0p1deg", "thau_BL1A_1p9A": "thau_1p9A", "thau_BL1A_2p7A": "thau_2p7A", "thau_BL1A_3p3A": "thau_3p3A", "Ins_H_2_fa9841": "insu_H_twin", "Ins_H_3_d05684": "insu_H_notwin", "Ins_I_16": "insu_I_weak", "Ins_I_2_1a530d": "insu_I_low_isa", "Ins_I_3_5e90e3": "insu_I_ref", "Ins_I_6_13keV": "insu_I_13keV", "Ins_I_6_5keV": "insu_I_5keV", "Ins_I_6_6keV": "insu_I_6keV", "Ins_I_7_5keV": "insu_I_5keV_2", "cytC_10": "cytc_eiger", "cytC_2_0770b5": "cytc_pilatus_1", "cytC_3_874285": "cytc_pilatus_2", "MyoB_13": "myob_eiger", "MyoB_9_446b70": "myob_pilatus", "MyoB2-1": "myob_powder_1", "MyoB2-2": "myob_powder_2", "MyoB2-4": "myob_split", "MyoB2-5": "myob_aggregate", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1"}, "sets": [
+ {"id": "lyso_90deg_1", "input": "lyso_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_90deg_2", "input": "lyso_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_atten_wedge", "input": "lyso_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_5keV", "input": "lyso_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
+ {"id": "lyso_ice", "input": "lyso_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_ref", "input": "lyso_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
+ {"id": "lyso_strong", "input": "lyso_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_half_image", "input": "lyso_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 2.602, "dmin_rule": "cc_half_0.30", "dmin_xds": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "thau_16keV", "input": "thau_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_0p1deg", "input": "thau_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_1p9A", "input": "thau_1p9A/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_2p7A", "input": "thau_2p7A/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_3p3A", "input": "thau_3p3A/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
+ {"id": "thau_injection", "input": "thau_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_pink", "input": "thau_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
+ {"id": "insu_H_twin", "input": "insu_H_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_H_notwin", "input": "insu_H_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
+ {"id": "insu_I_weak", "input": "insu_I_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_low_isa", "input": "insu_I_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_ref", "input": "insu_I_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_13keV", "input": "insu_I_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_5keV", "input": "insu_I_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_6keV", "input": "insu_I_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_5keV_2", "input": "insu_I_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
+ {"id": "cytc_eiger", "input": "cytc_eiger/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_pilatus_1", "input": "cytc_pilatus_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_pilatus_2", "input": "cytc_pilatus_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "myob_eiger", "input": "myob_eiger/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
+ {"id": "myob_pilatus", "input": "myob_pilatus/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
+ {"id": "myob_powder_1", "input": "myob_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
+ {"id": "myob_powder_2", "input": "myob_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_split", "input": "myob_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_aggregate", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmin_rule": "xds_range", "dmin_xds": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "nothing_ice", "input": "nothing_ice/onlyice_master.h5", "expect": "no_lattice", "tags": ["h5", "control"], "tiers": {"smoke": "no-crystal control (ice rings only): must refuse"}},
+ {"id": "nothing_2", "input": "nothing_2/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
+ {"id": "nothing_1", "input": "nothing_1/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
 ]}
diff --git a/tools/battery/inputs.py b/tools/battery/inputs.py
index 9f1ee9daa..9d37cef7a 100644
--- a/tools/battery/inputs.py
+++ b/tools/battery/inputs.py
@@ -106,7 +106,8 @@ def input_format(path):
 
 def parse_correct_lp(path):
     """Reference values from an XDS CORRECT.LP: the space group and cell CORRECT refined, the
-    resolution range it merged, and its overall merging statistics.
+    resolution range it merged (dmin_xds, dmax), the reference d_min read off its statistics
+    (dmin, dmin_rule - see reference_dmin) and its overall merging statistics.
 
     CORRECT.LP states the group and cell twice - first as the INPUT to INTEGRATE (routinely P1),
     then as CORRECT's own answer. The last SPACE_GROUP_NUMBER and the refined UNIT CELL PARAMETERS
@@ -143,12 +144,47 @@ def parse_correct_lp(path):
         ref["cc_half"] = round(num(total[10]) / 100, 4)
         ref["multiplicity"] = round(int(total[1]) / int(total[2]), 2) if int(total[2]) else None
 
-    # The resolution range to hand to rugnux so both programs merge the same reflections: the
-    # explicit INCLUDE_RESOLUTION_RANGE, or - when XDS.INP left the high limit at 0.0, "the whole
-    # detector" - the finest shell actually tabulated.
+    # The range XDS merged: the explicit INCLUDE_RESOLUTION_RANGE, or - when XDS.INP left the high
+    # limit at 0.0, "the whole detector" - the finest shell actually tabulated. The pooled statistics
+    # above are over this range.
     m = re.search(r"INCLUDE_RESOLUTION_RANGE=\s*([\d.]+)\s+([\d.]+)", txt)
     include_low, include_high = (float(m.group(1)), float(m.group(2))) if m else (0.0, 0.0)
     table_high = float(shells[-1][0]) if shells else 0.0
-    ref["dmin"] = (include_high if include_high > 0 else table_high) or None
+    dmin_xds = (include_high if include_high > 0 else table_high) or None
+    ref["dmin"], ref["dmin_rule"] = reference_dmin(
+        [(float(f[0]), num(f[10]) / 100, f[10].endswith("*")) for f in shells], include_low, dmin_xds)
+    ref["dmin_xds"] = dmin_xds
     ref["dmax"] = include_low or None
     return ref
+
+
+# The CC1/2 target rugnux's own resolution cutoff uses (--resolution-cc-target, default 0.30)
+CC_TARGET = 0.30
+
+
+def reference_dmin(shells, dmax, dmin_xds):
+    """(reference d_min, rule) from XDS's shell table [(shell high-resolution limit, CC1/2,
+    CC1/2 significant)], low to high resolution.
+
+    XDS's merged range is a resolution only when someone chose it. Left at "the whole detector"
+    (INCLUDE_RESOLUTION_RANGE 0.0, or a limit at the detector edge) it is the detector's reach, not
+    the crystal's: scored against, it is a meaningless number, and forced on rugnux it makes rugnux
+    merge shells of pure noise. XDS itself says which case it is - it marks each shell's CC1/2 with
+    '*' when it is significant at the 0.1% level:
+
+      xds_range      the finest shell's CC1/2 is significant: XDS's limit stands.
+      cc_half_0.30   it is not - XDS merged past its own signal. The reference is then where CC1/2
+                     falls through the target rugnux's own cutoff uses, interpolated in 1/d^2
+                     between the centres of the last shell above it and the first below it."""
+    if not shells or shells[-1][2]:
+        return dmin_xds, "xds_range"
+    below = next((i for i, (_, cc, _) in enumerate(shells) if cc < CC_TARGET), None)
+    if not below:                        # None, or already the first shell: no fall-off to read
+        return dmin_xds, "xds_range"
+    s = [1 / d ** 2 for d, _, _ in shells]
+    edges = [1 / dmax ** 2 if dmax else 0.0] + s
+    centre = [(edges[i] + edges[i + 1]) / 2 for i in range(len(s))]
+    cc_hi, cc_lo = shells[below - 1][1], shells[below][1]
+    frac = (cc_hi - CC_TARGET) / (cc_hi - cc_lo)
+    s_cross = centre[below - 1] + frac * (centre[below] - centre[below - 1])
+    return round(1 / s_cross ** 0.5, 3), f"cc_half_{CC_TARGET:.2f}"
diff --git a/tools/battery/render.py b/tools/battery/render.py
index 6cd7cd23c..f54d1fa30 100644
--- a/tools/battery/render.py
+++ b/tools/battery/render.py
@@ -7,11 +7,19 @@ import html
 
 CSS = """
 :root { --bg:#fff; --fg:#1d1d1f; --mute:#6e6e73; --line:#d9d9de; --head:#f3f3f5;
-        --pass:#1a7f37; --fail:#c62828; --warn:#9a6700; --passbg:#e8f5ec; --failbg:#fdecea; }
+        --pass:#1a7f37; --fail:#c62828; --warn:#9a6700; --passbg:#e8f5ec; --failbg:#fdecea;
+        --series1:#2a78d6; --good:#0ca30c; --critical:#d03b3b; --warning:#fab219;
+        --neutral:#898781; --grid:#e1e0d9; --axis:#c3c2b7; }
 @media (prefers-color-scheme: dark) {
   :root { --bg:#161618; --fg:#e8e8ea; --mute:#9a9aa0; --line:#3a3a3e; --head:#232326;
-          --pass:#5cc97a; --fail:#ff7b72; --warn:#e3b341; --passbg:#16301f; --failbg:#3a1a1a; }
+          --pass:#5cc97a; --fail:#ff7b72; --warn:#e3b341; --passbg:#16301f; --failbg:#3a1a1a;
+          --series1:#3987e5; --grid:#2c2c2a; --axis:#383835; }
 }
+figure { margin:12px 0 20px; max-width:900px; } figcaption { color:var(--mute); font-size:13px; }
+svg.plot { width:100%; height:auto; display:block; }
+svg.plot text { fill:var(--mute); font:11px system-ui, sans-serif; }
+svg.plot .grid { stroke:var(--grid); stroke-width:1; } svg.plot .ref { stroke:var(--axis); stroke-width:2; }
+svg.plot circle:hover, svg.plot rect:hover { stroke:var(--fg); stroke-width:2; }
 body { background:var(--bg); color:var(--fg); margin:0 auto; max-width:1400px; padding:16px;
        font:14px/1.45 system-ui, -apple-system, "Segoe UI", sans-serif; }
 h1 { font-size:22px; margin:8px 0 4px; } h2 { font-size:18px; margin:28px 0 8px; }
@@ -43,6 +51,10 @@ class Doc:
     def ul(self, items):
         self.blocks.append(("ul", list(items)))
 
+    def svg(self, markup, caption):
+        """An inline SVG plot (HTML only; the Markdown names it and points at the HTML)."""
+        self.blocks.append(("svg", markup, caption))
+
     def table(self, head, rows, num=(), row_class=None, cell_class=None):
         """head: column titles; rows: lists of str; num: indices of right-aligned columns;
         row_class(row) and cell_class(i, value) give optional CSS classes (HTML only)."""
@@ -57,6 +69,8 @@ class Doc:
                 out += [b[1], ""]
             elif b[0] == "ul":
                 out += ["- " + x for x in b[1]] + [""]
+            elif b[0] == "svg":
+                out += [f"_Plot in report.html: {b[2]}_", ""]
             else:
                 _, head, rows, num, _, _ = b
                 if not rows:
@@ -82,6 +96,8 @@ class Doc:
                 out.append(f"<p>{e(b[1])}</p>")
             elif b[0] == "ul":
                 out.append("<ul>" + "".join(f"<li>{e(x)}</li>" for x in b[1]) + "</ul>")
+            elif b[0] == "svg":
+                out.append(f"<figure>{b[1]}<figcaption>{e(b[2])}</figcaption></figure>")
             else:
                 _, head, rows, num, row_class, cell_class = b
                 if not rows:
@@ -105,3 +121,67 @@ class Doc:
                 out.append("".join(t))
         out.append("</body></html>")
         return "\n".join(out)
+
+
+# ------------------------------------------------------------------ plots (inline SVG, no libraries)
+
+STATUS = {"pass": "var(--good)", "fail": "var(--critical)", "unscored": "var(--neutral)",
+          "not_run": "var(--warning)"}
+
+
+def verdict_bars(rows):
+    """One horizontal bar per arm, split pass / fail / unscored / not run.
+    rows: [(arm, {verdict: count})]."""
+    e = html.escape
+    w, left, bar, gap = 900, 90, 22, 14
+    h = 30 + len(rows) * (bar + gap)
+    total = max(sum(c.values()) for _, c in rows) or 1
+    out = [f'<svg class="plot" viewBox="0 0 {w} {h}" role="img" aria-label="verdicts per arm">']
+    x = left
+    for v, col in STATUS.items():                         # legend, above the bars
+        out.append(f'<rect x="{x}" y="4" width="10" height="10" rx="2" fill="{col}"/>'
+                   f'<text x="{x + 14}" y="13">{v.replace("_", " ")}</text>')
+        x += 90
+    for i, (arm, cnt) in enumerate(rows):
+        y = 26 + i * (bar + gap)
+        out.append(f'<text x="0" y="{y + bar / 2 + 4}">{e(arm)}</text>')
+        x = left
+        for v, col in STATUS.items():
+            n = cnt.get(v, 0)
+            if not n:
+                continue
+            bw = (w - left - 10) * n / total
+            out.append(f'<rect x="{x:.1f}" y="{y}" width="{max(bw - 2, 1):.1f}" height="{bar}" rx="4" '
+                       f'fill="{col}"><title>{e(arm)}: {n} {v.replace("_", " ")}</title></rect>')
+            if bw > 28:
+                out.append(f'<text x="{x + 6:.1f}" y="{y + bar / 2 + 4}" style="fill:#fff">{n}</text>')
+            x += bw
+    out.append("</svg>")
+    return "".join(out)
+
+
+def ratio_dots(points, what):
+    """Sets sorted by a ratio (ours / reference), on a log axis clipped to 0.5..2, with the line
+    at 1. points: [(set, ratio, verdict, tooltip)]. Failed sets are drawn in the fail colour."""
+    e = html.escape
+    import math
+    w, h, left, top, bottom = 900, 240, 44, 22, 18
+    lo, hi = math.log(0.5), math.log(2.0)
+    y = lambda r: top + (hi - math.log(min(max(r, 0.5), 2.0))) / (hi - lo) * (h - top - bottom)
+    pts = sorted(points, key=lambda p: p[1])
+    step = (w - left - 10) / max(len(pts), 1)
+    out = [f'<svg class="plot" viewBox="0 0 {w} {h}" role="img" aria-label="{e(what)}">']
+    for t in (0.5, 0.75, 1.0, 1.5, 2.0):
+        out.append(f'<line class="{"ref" if t == 1.0 else "grid"}" x1="{left}" x2="{w}" '
+                   f'y1="{y(t):.1f}" y2="{y(t):.1f}"/><text x="0" y="{y(t) + 4:.1f}">{t:g}</text>')
+    out.append(f'<circle cx="{left + 6}" cy="10" r="4" fill="var(--series1)"/>'
+               f'<text x="{left + 14}" y="14">pass or unscored</text>'
+               f'<circle cx="{left + 136}" cy="10" r="4" fill="var(--critical)"/>'
+               f'<text x="{left + 144}" y="14">fail</text>'
+               f'<text x="{left + 190}" y="14">(clipped to 0.5-2; hover a point for the set)</text>')
+    for i, (name, r, verdict, tip) in enumerate(pts):
+        col = "var(--critical)" if verdict == "fail" else "var(--series1)"
+        out.append(f'<circle cx="{left + step * (i + 0.5):.1f}" cy="{y(r):.1f}" r="4" fill="{col}">'
+                   f'<title>{e(name)}: {r:.3f} - {e(tip)}</title></circle>')
+    out.append("</svg>")
+    return "".join(out)
diff --git a/tools/battery/report.py b/tools/battery/report.py
index 6199dbfba..fb4f6eef6 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -1,9 +1,11 @@
 """The per-run report and the run-to-run comparison."""
 import json
 import os
+import socket
 import statistics
+import sys
 
-from render import Doc
+from render import Doc, ratio_dots, verdict_bars
 
 # A change smaller than these is treated as run-to-run noise. They are a starting point, to be
 # re-calibrated from `compare --rerun-changed`, which measures the noise directly.
@@ -14,18 +16,59 @@ NOISE = {
     "cc_half": ("abs", 0.005),
     "completeness": ("abs", 1.0),   # percentage points
     "cell_dev_pct": ("abs", 0.2),   # percentage points
+    "rfree": ("abs", 0.005),
     "wall_s": ("rel", 0.25),        # and at least 10 s - see beyond_noise()
 }
 
 
-def load_run(run_dir):
+def run_state(man):
+    """complete, aborted (marked so), running (its runner is alive), or unfinished (killed
+    without a trace - treat as aborted)."""
+    if man.get("complete"):
+        return "complete"
+    if man.get("aborted"):
+        return "aborted"
+    if man.get("pid") and man.get("host") == socket.gethostname():
+        try:
+            os.kill(man["pid"], 0)
+            return "running"
+        except OSError:
+            pass
+    return "unfinished"
+
+
+def load_run(run_dir, allow_incomplete=False):
+    """A run's manifest and results. A run that did not finish covers an arbitrary part of its
+    sets and is refused unless asked for."""
     man = json.load(open(os.path.join(run_dir, "manifest.json")))
-    res = json.load(open(os.path.join(run_dir, "results.json")))
+    state = run_state(man)
+    if state != "complete" and not allow_incomplete:
+        sys.exit(f"{run_dir} is {state}, not a finished run; pass --allow-incomplete to use it anyway")
+    path = os.path.join(run_dir, "results.json")
+    res = json.load(open(path)) if os.path.exists(path) else []
     return man, res
 
 
+def check_baseline(baseline, private):
+    """A baseline must have finished, and be as private as the run it is compared with: the delta
+    table names its sets."""
+    man, _ = load_run(baseline)
+    if bool(man.get("private")) != bool(private):
+        sys.exit(f"baseline {baseline} is {'' if man.get('private') else 'not '}a private run; "
+                 "a report may only be compared with a run of its own kind")
+
+
+# Version of the results.json row schema (README.md, "results.json"). Bump it when a field changes
+# meaning or is removed; adding a field does not need it.
+RESULTS_SCHEMA = 1
+
+# {arm: {old set id: current id}} from the manifests (battery.py sets it), so a run made before a
+# dataset was renamed still pairs with one made after
+ALIASES = {}
+
+
 def key(r):
-    return (r["arm"], r["set"])
+    return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]))
 
 
 def f(x, fmt="{:.2f}", dash="-"):
@@ -71,7 +114,7 @@ def changes(ra, rb):
     if ra.get("volume_ratio") and rb.get("volume_ratio") and \
             abs(ra["volume_ratio"] - rb["volume_ratio"]) > 0.05:
         out.append("lattice")
-    for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct"):
+    for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct", "rfree"):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
     if beyond_noise("wall_s", ra.get("wall_s"), rb.get("wall_s")):
@@ -97,7 +140,7 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 def compare_table(doc, rows, only_changed=True):
     head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "time s", "beyond noise"]
+            "cell dev %", "R_free", "time s", "beyond noise"]
     out = []
     for (arm, s), ra, rb, ch in rows:
         if only_changed and not ch:
@@ -110,6 +153,7 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("r_meas"), rb.get("r_meas"), lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("cc_half"), rb.get("cc_half"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
+                    arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("wall_s"), rb.get("wall_s"), lambda v: f"{v:.0f}"),
                     ", ".join(ch)])
     doc.table(head, out, row_class=lambda r: "fail" if "verdict" in r[-1] else "")
@@ -130,14 +174,21 @@ def rate(rs):
     return f"{n}/{len(s)} ({100 * n / len(s):.0f}%)" if s else "-"
 
 
-def build(run_dir, baseline=None):
+def build(run_dir, baseline=None, allow_incomplete=False):
     """Markdown and HTML report of one run, with the delta against a baseline run if given."""
-    man, res = load_run(run_dir)
+    man, res = load_run(run_dir, allow_incomplete)
+    if baseline:
+        check_baseline(baseline, man.get("private"))
     b = man["binary"]
     doc = Doc(f"Rugnux battery - {os.path.basename(os.path.normpath(run_dir))}")
     if man.get("private"):
         doc.p("PRIVATE ARM - confidential user data. This report stays in the run directory; it "
               "must not be copied into the repository, an issue or any public report.")
+    state = run_state(man)
+    if state != "complete":
+        why = f" ({man['aborted']['reason']})" if man.get("aborted") else ""
+        doc.p(f"RUN {state.upper()}{why}: {len(res)} of {len(man['sets'])} sets have a result. "
+              "Not a reference and not comparable with a finished run.")
     doc.ul([
         f"rugnux {b.get('version', '?')}, sha256 {b['sha256'][:16]}, build flags: {b.get('flags') or 'unknown'}",
         f"runner {man['runner_git']}, host {man['host']}, {man['start']} -> {man.get('end') or 'NOT FINISHED'}",
@@ -171,6 +222,9 @@ def build(run_dir, baseline=None):
                      f(median(r.get("wall_s") for r in rs), "{:.0f}"),
                      f(sum(r.get("wall_s") or 0 for r in rs) / 60, "{:.1f}")])
     doc.table(head, rows, num=range(1, 12))
+    doc.svg(verdict_bars([(arm, {v: sum(r["verdict"] == v and r["arm"] == arm for r in res)
+                                 for v in ("pass", "fail", "unscored", "not_run")})
+                          for arm in man["arms"]]), "verdicts per arm")
     doc.p("Pass rate is over the scored sets (pass + fail). Resolution gain is (reference d_min - "
           "our d_min) / reference d_min: positive = finer than the deposition, or than XDS; 'forced' "
           "where XDS's resolution range was imposed, which makes it zero by construction. Medians "
@@ -201,6 +255,35 @@ def build(run_dir, baseline=None):
                 rows.append([arm, lab, sum(r.get(name) is not None for r in rs)] + cells)
     doc.table(["arm", "metric", "n", "min", "q1", "median", "q3", "max"], rows, num=range(2, 8))
 
+    doc.h(3, "Per set, against the reference")
+    for arm in man["arms"]:
+        if arm in forced:
+            doc.p(f"{arm}: d_min forced to the reference's, so its ratio is 1 by construction.")
+            continue
+        pts = [(r["set"], r["d_min"] / r["d_min_ref"], r["verdict"],
+                f"d_min {r['d_min']:.2f} vs {r['d_min_ref']:.2f} A, {r['verdict']}")
+               for r in res if r["arm"] == arm and r.get("d_min") and r.get("d_min_ref")]
+        if pts:
+            doc.svg(ratio_dots(pts, f"{arm}: d_min ratio"),
+                    f"{arm}: d_min(rugnux) / d_min(reference), one point per set, sorted; below 1 = "
+                    "finer than the reference")
+    pts = [(r["set"], r["rfree_ratio"], r["verdict"],
+            f"R_free {r['rfree']:.3f} vs deposited {r['rfree_deposited']:.3f}")
+           for r in res if r.get("rfree_ratio")]
+    if pts:
+        doc.svg(ratio_dots(pts, "R_free ratio"),
+                "open: R_free of the deposited model against our merge / the deposited R_free, one "
+                "point per set, sorted; below 1 = our data fit the model better")
+
+    derived = [r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"]
+    if derived:
+        doc.p("XDS merged past its own signal (CC1/2 of its finest shell not significant), so the "
+              "reference d_min is where XDS's CC1/2 falls through 0.30 (rule "
+              f"{derived[0]['d_min_ref_rule']}), and that is also the range forced on rugnux: "
+              + "; ".join(f"{r['set']} (XDS range {f(r.get('d_min_xds'))} A, reference "
+                          f"{f(r.get('d_min_ref'))} A)" for r in derived)
+              + ". XDS's pooled R_meas, CC1/2 and completeness are over its whole range.")
+
     doc.h(2, "Failures")
     fails = [r for r in res if r["verdict"] == "fail"]
     doc.table(["set", "arm", "cause", "reason"],
@@ -227,7 +310,8 @@ def build(run_dir, baseline=None):
 
     doc.h(2, "Per set")
     head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
-            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx", "time s", "note"]
+            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx", "R_free", "dep R_free",
+            "time s", "note"]
     rows = []
     for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
         rows.append([r["set"], r["arm"], r["verdict"], r.get("sg") or "-", r.get("sg_ref") or "-",
@@ -236,8 +320,9 @@ def build(run_dir, baseline=None):
                      f(r.get("completeness"), "{:.1f}"), f(r.get("multiplicity"), "{:.1f}"),
                      pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
                      f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0),
+                     f(r.get("rfree"), "{:.3f}"), f(r.get("rfree_deposited"), "{:.3f}"),
                      f(r.get("wall_s"), "{:.0f}"), r.get("reason") or ""])
-    doc.table(head, rows, num=range(5, 18),
+    doc.table(head, rows, num=range(5, 20),
               row_class=lambda row: "fail" if row[2] == "fail" else "",
               cell_class=lambda i, v: {"pass": "pass", "fail": "fail"}.get(v) if i == 2 else None)
     return doc
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 1384b53df..14f471034 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -87,14 +87,15 @@ def judge(entry, rep, run_note):
         "sgno_ref": ref.get("sgno"), "sg_ref": ref.get("sg") or sg_name(ref.get("sgno")),
         "pg_ref": point_group(ref["sgno"]) if ref.get("sgno") else None,
         "cell": None, "cell_ref": ref.get("cell"), "cell_dev_pct": None, "volume_ratio": None,
-        "d_min": None, "d_min_ref": ref.get("dmin"), "res_gain_pct": None,
+        "d_min": None, "d_min_ref": ref.get("dmin"), "d_min_ref_rule": ref.get("dmin_rule"),
+        "d_min_xds": ref.get("dmin_xds"), "res_gain_pct": None,
         "r_meas": fnum(rep.get("R_MEAS")), "cc_half": fnum(rep.get("CC_HALF")),
         "isa": fnum(rep.get("ISA")), "completeness": fnum(rep.get("COMPLETENESS")),
         "multiplicity": fnum(rep.get("MULTIPLICITY")), "i_over_sigma": fnum(rep.get("I_OVER_SIGMA")),
         "indexing_rate": fnum(rep.get("INDEXING_RATE")), "images": fnum(rep.get("IMAGES_PROCESSED")),
         "rugnux_wall_s": fnum(rep.get("WALL_TIME")), "rugnux_verdict": rep.get("VERDICT_TEXT"),
         "r_meas_ref": ref.get("r_meas"), "cc_half_ref": ref.get("cc_half"), "isa_ref": ref.get("isa"),
-        "completeness_ref": ref.get("completeness"),
+        "completeness_ref": ref.get("completeness"), "sg_relation": None,
     }
     if rep.get("SPACE_GROUP_NUMBER"):
         r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
diff --git a/tools/battery/site.example.json b/tools/battery/site.example.json
new file mode 100644
index 000000000..7f75edb43
--- /dev/null
+++ b/tools/battery/site.example.json
@@ -0,0 +1,12 @@
+{
+ "_comment": "Copy to site.json beside battery.py (not committed), or anywhere and point JFJOCH_BATTERY_SITE at it. Paths are absolute; a relative manifest resolves against tools/battery/.",
+ "runs_root": "/path/to/battery/runs",
+ "lock_file": "/path/to/battery/full_run.lock",
+ "gpulock": null,
+ "baseline": null,
+ "baseline_private": null,
+ "arms": {
+  "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/path/to/battery/open"},
+  "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/path/to/battery/inhouse"}
+ }
+}
diff --git a/tools/battery/site.json b/tools/battery/site.json
deleted file mode 100644
index 0edaaffb5..000000000
--- a/tools/battery/site.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
- "runs_root": "/data/battery/runs",
- "lock_file": "/data/battery/full_run.lock",
- "gpulock": "/data/tmp/gpulock",
- "arms": {
-  "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/home/data/nonsls/raw"},
-  "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/data/rotation_test"},
-  "private": {"manifest": "/data/battery/private.json", "reference": "xds", "data_root": "/data/rotation_test",
-              "private": true}
- }
-}
-- 
2.54.0


From e8fd659e212b06b0f871834870f24c2c0eb9e983 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:15:45 +0200
Subject: [PATCH 005/122] Retire the scattered battery scripts in favour of
 tools/battery

- rugnux_vs_xds.py: deleted. The inhouse and private arms of tools/battery run the
  same comparison against CORRECT.LP, from a fixed manifest instead of a directory
  scan, with persisted runs and a standard report.
- lyso_test/anomalous_scoreboard.sh: deleted. A one-dataset SHELXC/ANODE scoreboard
  with hard-coded personal paths, superseded by rugnux_anomalous.py.
- rugnux_vs_pdb.py -> tools/battery/model_sweep.py. The rugnux --model sweep is
  not superseded, but it now takes its inputs from the open arm's manifest and the
  battery site config, so both tools process the same files.
- docs/TESTS.md and rugnux_stills_ab.py point at the battery.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/TESTS.md                                 |  25 +-
 lyso_test/anomalous_scoreboard.sh             | 100 ----
 rugnux_stills_ab.py                           |   6 +-
 rugnux_vs_xds.py                              | 503 ------------------
 .../battery/model_sweep.py                    |  71 ++-
 5 files changed, 46 insertions(+), 659 deletions(-)
 delete mode 100755 lyso_test/anomalous_scoreboard.sh
 delete mode 100755 rugnux_vs_xds.py
 rename rugnux_vs_pdb.py => tools/battery/model_sweep.py (82%)

diff --git a/docs/TESTS.md b/docs/TESTS.md
index 3cc40935e..e9372bc61 100644
--- a/docs/TESTS.md
+++ b/docs/TESTS.md
@@ -32,20 +32,19 @@ exact commands; the CrystFEL fixtures are run by hand rather than in the pipelin
 
 ## Judging a change to the analysis itself
 
-Four harnesses in the repository root run `rugnux` over stored datasets and score
-the result. None is part of CI - run them when a change plausibly moves merged results, not as
-a reflex. All take their dataset list from **outside** the repository, because dataset and sample
-identities are not committed. The public datasets the pipeline is exercised on, and the DOI to
-cite for each, are listed in [External test data](EXTERNAL_TEST_DATA.md).
+The harnesses below run `rugnux` over stored datasets and score the result. None is part of CI -
+run them when a change plausibly moves merged results, not as a reflex. The public datasets the
+pipeline is exercised on, and the DOI to cite for each, are listed in
+[External test data](EXTERNAL_TEST_DATA.md).
 
-* `rugnux_vs_xds.py` - the rotation battery. Runs Rugnux de novo over every crystal under a data
-  root and tabulates reflections, observations, space group, R_meas, CC1/2, ISa and wall-clock
-  time against the XDS `CORRECT.LP` beside each dataset.
-* `rugnux_vs_pdb.py` - de-novo runs over raw data deposited beside PDB entries, each merge
-  validated against the depositor's own model and compared with the published resolution and
-  R-work/R-free.
-* `rugnux_stills_ab.py` - the stills analogue of `rugnux_vs_xds.py`: scores a change on a serial
-  dataset by what it does to the merge.
+* `tools/battery/battery.py` - the rotation battery, the one canonical way to judge a rotation
+  change: public PDB depositions scored against the deposition, in-house standard crystals and
+  no-crystal controls scored against XDS, and a local-only private arm. Its manifests, the run
+  and compare protocol and the report are described in `tools/battery/README.md`.
+* `tools/battery/model_sweep.py` - the battery's open arm run with `--model`: each merge validated
+  against the depositor's own model and compared with the published resolution and R-work/R-free.
+* `rugnux_stills_ab.py` - the stills analogue of the battery: scores a change on a serial
+  dataset by what it does to the merge. Takes its dataset list from outside the repository.
 * `rugnux_anomalous.py` - the anomalous-peak-height arbiter, below.
 
 ### The anomalous-peak-height arbiter
diff --git a/lyso_test/anomalous_scoreboard.sh b/lyso_test/anomalous_scoreboard.sh
deleted file mode 100755
index f65670d22..000000000
--- a/lyso_test/anomalous_scoreboard.sh
+++ /dev/null
@@ -1,100 +0,0 @@
-#!/usr/bin/env bash
-# Anomalous-accuracy scoreboard: score a jfjoch anomalous merge against XDS on the S/Cl
-# anomalous signal. Accuracy (not just precision): ANODE puts the anomalous density peaks at the
-# model's real anomalous atoms, and the peak height (sigma) is how strongly the data sees them.
-#
-#   ./anomalous_scoreboard.sh <jfjoch_anomalous.hkl> [label]
-#
-# <jfjoch_anomalous.hkl> is a jfjoch `--scaling-output txt` file produced with -A (anomalous):
-# whitespace-separated "h k l I sigma [rfree]". Prints <d"/sig> per shell (SHELXC) and the averaged
-# anomalous peak height at SD_MET / SG_CYS / CL_CL for the input vs XDS, with the XDS/input ratio
-# (1.0 = matched XDS). The XDS reference is computed once and cached (delete .anom_xds_cache to redo).
-#
-# The SHELX binaries are run under qemu-user because this WSL2 kernel sets vsyscall=none, which the
-# old static SHELX builds need (otherwise they exit 174 silently). Paths are overridable via env.
-# (No set -e/-u: sourcing CCP4's setup trips -u, and many greps below legitimately find nothing.)
-set -o pipefail
-
-INPUT="${1:?usage: anomalous_scoreboard.sh <jfjoch_anomalous.hkl> [label]}"
-LABEL="${2:-jfjoch}"
-HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-
-SHELXC="${SHELXC_BIN:-/home/leonarski_f/shelxc}"
-ANODE="${ANODE_BIN:-/home/leonarski_f/anode}"
-QEMU="${QEMU_BIN:-/usr/bin/qemu-x86_64-static}"
-CCP4_SETUP="${CCP4_SETUP:-/opt/xtal/ccp4-9/bin/ccp4.setup-sh}"
-MODEL_CIF="${MODEL_CIF:-$HERE/6G8A_refine_001.cif}"
-XDS_REF="${XDS_REF:-$HERE/XDS_ASCII.HKL}"
-CELL="${CELL:-78.22 78.22 37.76 90 90 90}"
-SG="${SG:-P43212}"
-WAVELENGTH="${WAVELENGTH:-0.95329}"
-
-# shellcheck disable=SC1090
-source "$CCP4_SETUP" 2>/dev/null || true
-WORK="$(mktemp -d)"; trap 'rm -rf "$WORK"' EXIT
-
-# Model PDB for ANODE (cached): add the wavelength REMARK, drop ANISOU.
-MODEL_PDB="$HERE/6G8A_anode.pdb"
-if [ ! -s "$MODEL_PDB" ]; then
-    gemmi convert "$MODEL_CIF" "$WORK/m.pdb"
-    { echo "REMARK 200  WAVELENGTH OR RANGE        (A) : $WAVELENGTH"
-      grep -E '^CRYST1|^ATOM|^HETATM|^TER|^END' "$WORK/m.pdb"; } > "$MODEL_PDB"
-fi
-
-# run_one <name> <datafile> <is_xds 0|1> : SHELXC + ANODE; echoes "SD_MET SG_CYS CL_CL" densities,
-# leaves <name>.shelxc / <name>.lsa in $WORK.
-run_one() {
-    local name="$1" data="$2" is_xds="$3" sadfile="$2"
-    cp "$MODEL_PDB" "$WORK/$name.pdb"
-    if [ "$is_xds" = 0 ]; then   # jfjoch txt -> SHELX HKLF4 (3I4,2F8.2) + terminator
-        awk '{printf "%4d%4d%4d%8.2f%8.2f\n",$1,$2,$3,$4,$5}' "$data" > "$WORK/${name}_in.hkl"
-        printf "%4d%4d%4d%8.2f%8.2f\n" 0 0 0 0 0 >> "$WORK/${name}_in.hkl"
-        sadfile="$WORK/${name}_in.hkl"
-    fi
-    ( cd "$WORK"
-      "$QEMU" "$SHELXC" "$name" > "$name.shelxc" 2>&1 <<EOF
-CELL $CELL
-SPAG $SG
-SAD $sadfile
-FIND 10
-SFAC S
-EOF
-      "$QEMU" "$ANODE" "$name" > "$name.anode" 2>&1 )
-    local sd sg cl
-    sd=$(grep -E ' SD_MET *$' "$WORK/$name.lsa" | awk '{print $1}')
-    sg=$(grep -E ' SG_CYS *$' "$WORK/$name.lsa" | awk '{print $1}')
-    cl=$(grep -E ' CL_CL *$'  "$WORK/$name.lsa" | awk '{print $1}')
-    echo "${sd:-NA} ${sg:-NA} ${cl:-NA}"
-}
-
-echo "Scoring '$LABEL' ($INPUT) vs XDS ..."
-read -r O_SD O_SG O_CL < <(run_one ours "$INPUT" 0)
-O_DSIG=$(grep -E '<d"/sig>' "$WORK/ours.shelxc" | head -1 | sed 's/.*<d"\/sig>//')
-O_RESL=$(grep -E '^ Resl' "$WORK/ours.shelxc" | head -1)
-
-XDS_CACHE="$HERE/.anom_xds_cache"
-if [ -s "$XDS_CACHE" ]; then
-    # shellcheck disable=SC1090
-    source "$XDS_CACHE"
-else
-    read -r X_SD X_SG X_CL < <(run_one xds "$XDS_REF" 1)
-    X_DSIG=$(grep -E '<d"/sig>' "$WORK/xds.shelxc" | head -1 | sed 's/.*<d"\/sig>//')
-    { echo "X_SD='$X_SD'"; echo "X_SG='$X_SG'"; echo "X_CL='$X_CL'"; echo "X_DSIG='$X_DSIG'"; } > "$XDS_CACHE"
-fi
-
-ratio() { awk -v a="$1" -v b="$2" 'BEGIN{ if(a+0>0) printf "%.2fx", b/a; else print "NA" }'; }
-echo
-echo "=== <d\"/sig> per resolution shell  (0.80 = no anomalous signal) ==="
-echo "          $O_RESL" | sed 's/Resl\./Resl./'
-printf "%-8s %s\n" "$LABEL" "$O_DSIG"
-printf "%-8s %s\n" "XDS" "$X_DSIG"
-echo
-echo "=== averaged anomalous peak height at the model atoms (sigma) ==="
-printf "%-8s %9s %9s %8s\n" "atom" "$LABEL" "XDS" "XDS/in"
-printf "%-8s %9s %9s %8s\n" "SD_MET" "$O_SD" "$X_SD" "$(ratio "$O_SD" "$X_SD")"
-printf "%-8s %9s %9s %8s\n" "SG_CYS" "$O_SG" "$X_SG" "$(ratio "$O_SG" "$X_SG")"
-printf "%-8s %9s %9s %8s\n" "CL_CL"  "$O_CL" "$X_CL" "$(ratio "$O_CL" "$X_CL")"
-echo
-awk -v a="$O_SD" -v b="$O_SG" -v xa="$X_SD" -v xb="$X_SG" 'BEGIN{
-    if(a+0>0 && b+0>0) printf "Summary: S peak height = %.2fx XDS (SD_MET %.2f, SG_CYS %.2f vs %.2f, %.2f). 1.0x = matched XDS.\n", \
-        (a+b)/(xa+xb), a, b, xa, xb }'
diff --git a/rugnux_stills_ab.py b/rugnux_stills_ab.py
index c67e2f76f..eb8fa0366 100755
--- a/rugnux_stills_ab.py
+++ b/rugnux_stills_ab.py
@@ -1,9 +1,9 @@
 #!/usr/bin/env python3
 """
-rugnux_stills_ab.py -- the stills analogue of rugnux_vs_xds.py.
+rugnux_stills_ab.py -- the stills analogue of the rotation battery (tools/battery/).
 
-rugnux_vs_xds.py scores a ROTATION change against an XDS reference: one crystal per
-directory, one CORRECT.LP to compare with, space-group agreement as the headline. None of
+The battery scores a ROTATION change against a reference: one crystal per directory, one
+deposition or CORRECT.LP to compare with, space-group agreement as the headline. None of
 that transfers to serial stills. A stills dataset is one 100k-500k image file with no
 per-crystal reference, the space group is known in advance and never in question, and the
 thing a change moves is the merge: how many frames indexed, how many observations survived
diff --git a/rugnux_vs_xds.py b/rugnux_vs_xds.py
deleted file mode 100755
index 43ab88b74..000000000
--- a/rugnux_vs_xds.py
+++ /dev/null
@@ -1,503 +0,0 @@
-#!/usr/bin/env python3
-"""
-rugnux_vs_xds.py -- run rugnux over a directory of test crystals and tabulate its
-merging statistics against the XDS reference (CORRECT.LP) next to each dataset.
-
-For every <data-root>/<crystal>/ that has both a *_master.h5 and an XDS CORRECT.LP it:
-  * reads the XDS reference (space group, resolution range, Friedel setting, merge
-    stats, ISa);
-  * runs rugnux de-novo with the SAME high-resolution limit and Friedel/anomalous
-    setting as XDS, so the two are comparable -- the space group is NOT forced, it is
-    the thing we compare;
-  * parses rugnux's own mmCIF output (the stable interface -- NOT the console log,
-    which is meant for humans and may be trimmed/reformatted);
-  * prints one compact table: reflections, observations, space group (H-M + number),
-    R_meas / CC1/2 overall, R_meas low shell, CC1/2 high shell, ISa -- XDS vs rugnux.
-
-Self-contained: on first run it builds a private venv, pip-installs gemmi and re-execs.
-All rugnux console output goes to a per-crystal log; only the table is printed.
-"""
-
-import os
-import sys
-import subprocess
-import pathlib
-import venv
-
-_SELF = os.path.abspath(__file__)
-
-
-# --------------------------------------------------------------------------- #
-#  venv bootstrap (gemmi is the only third-party dependency)
-# --------------------------------------------------------------------------- #
-def _venv_dir():
-    if os.environ.get("RUGNUX_CMP_VENV"):
-        return pathlib.Path(os.environ["RUGNUX_CMP_VENV"])
-    cache = os.environ.get("XDG_CACHE_HOME") or os.path.join(os.path.expanduser("~"), ".cache")
-    return pathlib.Path(cache) / "rugnux_vs_xds" / "venv"
-
-
-def _bootstrap():
-    vdir = _venv_dir()
-    py = vdir / "bin" / "python"
-    if not py.exists():
-        venv.create(vdir, with_pip=True)
-    have_gemmi = subprocess.run([str(py), "-c", "import gemmi"],
-                                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0
-    if not have_gemmi:
-        subprocess.run([str(py), "-m", "pip", "install", "-q", "--disable-pip-version-check", "gemmi"],
-                       check=True)
-    os.environ["RUGNUX_CMP_BOOTSTRAPPED"] = "1"
-    os.execv(str(py), [str(py), _SELF, *sys.argv[1:]])
-
-
-if __name__ == "__main__" and not os.environ.get("RUGNUX_CMP_BOOTSTRAPPED"):
-    _bootstrap()
-
-# ---- past this point we are running inside the venv -----------------------
-import argparse
-import re
-import shutil
-import time
-import datetime
-import gemmi
-
-
-# --------------------------------------------------------------------------- #
-#  XDS reference (CORRECT.LP)
-# --------------------------------------------------------------------------- #
-def parse_xds(correct_lp):
-    """Pull the final merge statistics out of an XDS CORRECT.LP."""
-    txt = pathlib.Path(correct_lp).read_text(errors="replace")
-    r = {}
-
-    # The first SPACE_GROUP_NUMBER is only the INTEGRATE-step group (often P1); the LAST one is
-    # the symmetry CORRECT actually merged/scaled in and wrote to XDS_ASCII.HKL -- that is the
-    # XDS space group we compare (and the one the stats below are computed in).
-    sgs = re.findall(r"SPACE_GROUP_NUMBER=\s*(\d+)", txt)
-    r["sg"] = int(sgs[-1]) if sgs else None
-
-    m = re.search(r"FRIEDEL'S_LAW=\s*(TRUE|FALSE)", txt)
-    r["anomalous"] = (m.group(1) == "FALSE") if m else False
-
-    m = re.search(r"INCLUDE_RESOLUTION_RANGE=\s*([\d.]+)\s+([\d.]+)", txt)
-    include_low = float(m.group(1)) if m else 0.0
-    include_high = float(m.group(2)) if m else 0.0
-
-    m = re.search(r"^\s*a\s+b\s+ISa\s*\n\s*[\d.Ee+-]+\s+[\d.Ee+-]+\s+([\d.]+)", txt, re.M)
-    r["isa"] = float(m.group(1)) if m else None
-
-    # Final "... AS FUNCTION OF RESOLUTION" table (last occurrence); rows run from the
-    # lowest-resolution shell down to the highest, then a "total" line.
-    seg = txt[txt.rfind("AS FUNCTION OF RESOLUTION"):]
-    num = lambda x: float(x.rstrip("*%"))
-    shells, total = [], None
-    for line in seg.splitlines():
-        f = line.split()
-        if not f:
-            continue
-        if f[0] == "total" and len(f) >= 11:
-            total = f
-            break
-        if re.match(r"^\d+\.\d+$", f[0]) and len(f) >= 11:
-            shells.append(f)
-    if total:
-        r["obs"], r["uniq"] = int(total[1]), int(total[2])
-        r["rmeas"], r["cc"] = num(total[9]), num(total[10])
-    if shells:
-        r["rmeas_lo"] = num(shells[0][9])    # first row  = lowest resolution
-        r["cc_hi"] = num(shells[-1][10])     # last row   = highest resolution
-    # Effective XDS high-resolution limit to hand to rugnux: prefer the explicit
-    # INCLUDE_RESOLUTION_RANGE, but fall back to the finest shell actually tabulated
-    # (XDS.INP often leaves the high limit at 0.0 = "use the full detector range").
-    table_high = float(shells[-1][0]) if shells else 0.0
-    r["dmin"] = (include_high if include_high > 0 else table_high) or None
-    # Same for the LOW-resolution limit. XDS configurations normally cut at 50 A while rugnux
-    # cuts at its own default, so without matching this the "lowest shell" columns below are not
-    # the same shell in the two programs and R_meas_lo is not comparable.
-    r["dmax"] = include_low or None
-
-    # Mosaicity for comparison only. XDS refines this per run and the last value is the one it
-    # settled on; it is a useful sanity check on rugnux's own estimate but NOT ground truth --
-    # XDS produces outliers here too, so read a big disagreement as "look at this crystal",
-    # not as "rugnux is wrong".
-    mos = re.findall(r"REFLECTING_RANGE_E\.S\.D\.=\s*([0-9.]+)", txt)
-    r["mosaicity"] = float(mos[-1]) if mos else None
-    return r
-
-
-def xds_integrate_mosaicity(integrate_lp):
-    """Mean per-batch SIGMAR from INTEGRATE.LP - XDS's INTEGRATION-STAGE estimate.
-
-    This, not CORRECT.LP's REFLECTING_RANGE_E.S.D., is the apples-to-apples comparison for
-    rugnux's per-image mosaicity: both are fitted from the images during integration. The
-    CORRECT.LP value is XDS's POST-REFINED mosaicity, and the two can differ by more than 2x.
-    """
-    if not integrate_lp.exists():
-        return None
-    vals = []
-    for line in integrate_lp.read_text(errors="replace").splitlines():
-        if line.strip().startswith("SIGMAR (degree)"):
-            for f in line.split()[2:]:
-                try:
-                    vals.append(float(f))
-                except ValueError:
-                    pass
-    return sum(vals) / len(vals) if vals else None
-
-
-# --------------------------------------------------------------------------- #
-#  rugnux result (mmCIF)
-# --------------------------------------------------------------------------- #
-def rugnux_mosaicity(workdir, name):
-    """Median per-image mosaicity (deg) from rugnux's <prefix>_image.dat, or None."""
-    import statistics
-    hits = sorted(workdir.glob(f"{name}*_image.dat"))
-    if not hits:
-        return None
-    vals = []
-    for line in hits[-1].read_text(errors="replace").splitlines():
-        if line.startswith("#"):
-            continue
-        f = line.split()
-        if len(f) >= 3:
-            try:
-                v = float(f[2])
-            except ValueError:
-                continue
-            if v == v and v > 0:          # skip nan / unfitted frames
-                vals.append(v)
-    return statistics.median(vals) if vals else None
-
-
-def parse_rugnux_cif(cif_path):
-    """Pull the same statistics out of rugnux's mmCIF (fractions -> percent)."""
-    block = gemmi.cif.read(str(cif_path)).sole_block()
-
-    def val(tag):
-        v = block.find_value(tag)
-        return gemmi.cif.as_string(v) if v is not None else None
-
-    def fnum(tag, scale=1.0):
-        v = val(tag)
-        try:
-            return float(v) * scale
-        except (TypeError, ValueError):
-            return None
-
-    def inum(tag):
-        v = val(tag)
-        try:
-            return int(float(v))
-        except (TypeError, ValueError):
-            return None
-
-    r = {
-        "sg": inum("_symmetry.Int_Tables_number"),
-        "uniq": inum("_reflns.number_obs"),
-        "obs": inum("_reflns.pdbx_number_measured_all"),
-        "rmeas": fnum("_reflns.pdbx_Rrim_I_all", 100.0),
-        "cc": fnum("_reflns.pdbx_CC_half", 100.0),
-        "isa": fnum("_reflns.jfjoch_diffrn_ISa"),
-    }
-
-    # One unreadable column must not discard the whole shell. An outer shell whose R_meas is
-    # undefined - which happens exactly when the mean intensity there has gone non-positive, i.e. on
-    # the WORST arm - used to take its CC1/2 down with it, so the comparison silently fell back to
-    # the next shell in and reported that arm's high-resolution CC1/2 as better than it is. Each
-    # column is now read on its own, and each statistic comes from the outermost (or innermost)
-    # shell that actually has it.
-    def maybe(v):
-        try:
-            return float(v)
-        except (TypeError, ValueError):
-            return None
-
-    shells = []
-    for row in block.find("_reflns_shell.", ["d_res_high", "pdbx_Rrim_I_all", "pdbx_CC_half"]):
-        d = maybe(row[0])
-        if d is not None:
-            shells.append((d, maybe(row[1]), maybe(row[2])))
-    if shells:
-        shells.sort(key=lambda s: s[0])
-        cc = next((s[2] for s in shells if s[2] is not None), None)          # highest resolution
-        rmeas = next((s[1] for s in reversed(shells) if s[1] is not None), None)   # lowest
-        if cc is not None:
-            r["cc_hi"] = cc * 100.0
-        if rmeas is not None:
-            r["rmeas_lo"] = rmeas * 100.0
-    return r
-
-
-# --------------------------------------------------------------------------- #
-#  running rugnux
-# --------------------------------------------------------------------------- #
-def find_rugnux(explicit):
-    for cand in (explicit, os.environ.get("RUGNUX")):
-        if cand and (shutil.which(cand) or os.path.exists(cand)):
-            return shutil.which(cand) or cand
-    if shutil.which("rugnux"):
-        return shutil.which("rugnux")
-    repo = pathlib.Path(_SELF).parent
-    # The rugnux CLI target builds to build*/rugnux/rugnux. The old build*/tools/rugnux paths are
-    # stale leftovers from a previous layout that cmake no longer updates, so pick the most recently
-    # built binary among the candidates rather than a fixed order (avoids silently running old code).
-    cands = [repo / rel for rel in ("build_gpu/rugnux/rugnux", "build/rugnux/rugnux",
-                                    "cmake-build-release-nogpu/rugnux/rugnux")]
-    existing = [c for c in cands if c.exists()]
-    if existing:
-        return str(max(existing, key=lambda p: p.stat().st_mtime))
-    return None
-
-
-def run_rugnux(master, workdir, name, xds, rugnux_bin, threads, timeout, reuse, extra_args="", force_sg=False):
-    """Run rugnux; return (cif_path, error). Resolution + anomalous matched to XDS."""
-    workdir.mkdir(parents=True, exist_ok=True)
-    cif = workdir / f"{name}.cif"
-    if reuse and cif.exists():
-        return cif, None, None   # no fresh timing when we skip the run
-
-    # rugnux always writes both MTZ and CIF now (the old --scaling-output flag was removed).
-    # --no-export-unmerged: the unmerged MTZ is written by default, is the largest file a run
-    # produces, and nothing in this comparison reads it. It comes before --extra-args, so an
-    # --extra-args --export-unmerged still turns it back on.
-    cmd = [rugnux_bin, "-o", name, "--no-export-unmerged"]
-    if xds.get("anomalous"):
-        cmd.append("-A")
-    if xds.get("dmin"):
-        cmd += ["--scaling-high-resolution", f"{xds['dmin']:.3f}"]
-    if xds.get("dmax"):
-        cmd += ["--scaling-low-resolution", f"{xds['dmax']:.3f}"]
-    if threads:
-        cmd += ["-N", str(threads)]
-    if force_sg and xds.get("sg"):
-        cmd += ["-S", str(xds["sg"])]
-    if extra_args:
-        import shlex
-        cmd += shlex.split(extra_args)
-    cmd.append(str(master))
-
-    log = workdir / "rugnux.log"
-    t0 = time.monotonic()
-    with open(log, "w") as lf:
-        lf.write("$ " + " ".join(cmd) + "\n\n")
-        lf.flush()
-        try:
-            p = subprocess.run(cmd, cwd=str(workdir), stdout=lf,
-                               stderr=subprocess.STDOUT, timeout=timeout)
-        except subprocess.TimeoutExpired:
-            return None, f"timeout after {timeout}s", float(timeout)
-    dt = time.monotonic() - t0
-    if p.returncode != 0:
-        return None, f"exit {p.returncode} (see {log})", dt
-    if cif.exists():
-        return cif, None, dt
-    hits = sorted(workdir.glob("*.cif"))
-    return (hits[-1], None, dt) if hits else (None, f"no .cif produced (see {log})", dt)
-
-
-# --------------------------------------------------------------------------- #
-#  rendering
-# --------------------------------------------------------------------------- #
-def sg_name(n):
-    sg = gemmi.find_spacegroup_by_number(n) if n else None
-    if not sg:
-        return "?"
-    try:
-        return sg.short_name()
-    except Exception:
-        return sg.hm.replace(" ", "")
-
-
-def sym_key(n):
-    """Merge-relevant symmetry key = point group + lattice centring. Treats screw-axis /
-    enantiomorph variants as equal (XDS reports e.g. P422=89 where rugnux finds P4_3 2_1 2=96;
-    I23=197 vs I2_1 3=199) while keeping genuinely different lattices (P2 vs C2) distinct."""
-    sg = gemmi.find_spacegroup_by_number(n) if n else None
-    return f"{sg.point_group_hm()}{sg.hm[0]}" if sg else None
-
-
-W = dict(src=6, refl=8, obs=9, sg=14, rmeas=7, cc=6, rlo=8, chi=7, isa=6, mos=15, time=8)
-
-
-def fmt_dur(s):
-    """Compact wall-clock: 42s / 2m05s / 1h03m."""
-    if s is None:
-        return None
-    s = int(round(s))
-    if s < 60:
-        return f"{s}s"
-    if s < 3600:
-        return f"{s // 60}m{s % 60:02d}s"
-    return f"{s // 3600}h{(s % 3600) // 60:02d}m"
-
-
-def _int(v, w):
-    return "-".rjust(w) if v is None else f"{v:>{w}d}"
-
-
-def _pct(v, w):
-    return "-".rjust(w) if v is None else f"{v:.1f}%".rjust(w)
-
-
-def _isa(v, w):
-    return "-".rjust(w) if v is None else f"{v:.2f}".rjust(w)
-
-
-def _sg(n, w):
-    return (f"{sg_name(n)} ({n})" if n else "-").ljust(w)
-
-
-def _mos(v, w, v2=None):
-    a = "-" if v is None else f"{v:.4f}"
-    if v2 is not None:
-        a += f"|{v2:.4f}"
-    return a.rjust(w)
-
-
-def _dur(v, w):
-    return (fmt_dur(v) or "-").rjust(w)
-
-
-def row_line(src, d, elapsed=None):
-    d = d or {}
-    return (f"  {src:<{W['src']}} "
-            f"{_int(d.get('uniq'), W['refl'])} "
-            f"{_int(d.get('obs'), W['obs'])}  "
-            f"{_sg(d.get('sg'), W['sg'])} "
-            f"{_pct(d.get('rmeas'), W['rmeas'])} "
-            f"{_pct(d.get('cc'), W['cc'])} "
-            f"{_pct(d.get('rmeas_lo'), W['rlo'])} "
-            f"{_pct(d.get('cc_hi'), W['chi'])} "
-            f"{_isa(d.get('isa'), W['isa'])} "
-            f"{_mos(d.get('mosaicity'), W['mos'], d.get('mosaicity_mle'))} "
-            f"{_dur(elapsed, W['time'])}")
-
-
-def header_line():
-    return (f"  {'Source':<{W['src']}} {'Refl':>{W['refl']}} {'Obs':>{W['obs']}}  "
-            f"{'Space group':<{W['sg']}} {'Rmeas':>{W['rmeas']}} {'CC1/2':>{W['cc']}} "
-            f"{'Rmeas_lo':>{W['rlo']}} {'CC1/2_hi':>{W['chi']}} {'ISa':>{W['isa']}} "
-            f"{'Mosaic':>{W['mos']}} {'Time':>{W['time']}}")
-
-
-# --------------------------------------------------------------------------- #
-#  main
-# --------------------------------------------------------------------------- #
-def main():
-    ap = argparse.ArgumentParser(description="Compare rugnux merge stats against XDS CORRECT.LP.")
-    ap.add_argument("data_root", nargs="?", default="/data/rotation_test",
-                    help="directory of <crystal>/ subdirs (default: /data/rotation_test)")
-    ap.add_argument("--rugnux", help="path to the rugnux binary (else $RUGNUX / PATH / build*/tools)")
-    ap.add_argument("--workdir", default="rugnux_cmp", help="where rugnux outputs go (default: ./rugnux_cmp)")
-    ap.add_argument("--only", help="comma-separated substrings; only matching crystals are run")
-    ap.add_argument("--threads", type=int, help="rugnux -N (default: all hardware threads)")
-    ap.add_argument("--timeout", type=int, default=3600, help="per-crystal timeout, seconds (default: 3600)")
-    ap.add_argument("--reuse", action="store_true", help="skip rugnux where its .cif already exists")
-    ap.add_argument("--xds-only", action="store_true", help="only parse+print the XDS side (no rugnux run)")
-    ap.add_argument("--progress", action="store_true", help="print per-crystal progress to stderr")
-    ap.add_argument("--force-xds-sg", action="store_true",
-                    help="pin each crystal to the XDS reference space group with -S, instead of "
-                         "letting rugnux determine it de novo (exercises the fixed-group path)")
-    ap.add_argument("--extra-args", default="", help="extra args appended to every rugnux command (e.g. '--rotation-refine-geometry')")
-    args = ap.parse_args()
-
-    root = pathlib.Path(args.data_root)
-    if not root.is_dir():
-        sys.exit(f"data root not found: {root}")
-
-    rugnux_bin = None if args.xds_only else find_rugnux(args.rugnux)
-    if not args.xds_only and not rugnux_bin:
-        sys.exit("rugnux binary not found -- pass --rugnux PATH or set $RUGNUX")
-
-    filters = [s for s in (args.only or "").split(",") if s]
-    workdir = pathlib.Path(args.workdir)
-
-    crystals, skipped = [], []
-    for name in sorted(os.listdir(root)):
-        d = root / name
-        if not d.is_dir():
-            continue
-        if filters and not any(f in name for f in filters):
-            continue
-        correct = d / "CORRECT.LP"
-        master = sorted(d.glob("*_master.h5"))
-        if not correct.exists() or not master:
-            skipped.append(name)
-            continue
-        crystals.append((name, master[0], correct))
-
-    results = []
-    for i, (name, master, correct) in enumerate(crystals, 1):
-        xds = parse_xds(correct)
-        xds["mosaicity_mle"] = xds_integrate_mosaicity(correct.parent / "INTEGRATE.LP")
-        rug, err, elapsed = ({}, None, None)
-        if not args.xds_only:
-            if args.progress:
-                print(f"[{i}/{len(crystals)}] rugnux {name} "
-                      f"(dmin={xds.get('dmin')}, dmax={xds.get('dmax')}, "
-                      f"anom={xds.get('anomalous')}) ...",
-                      file=sys.stderr, flush=True)
-            cif, err, elapsed = run_rugnux(master, workdir / name, name, xds,
-                                           rugnux_bin, args.threads, args.timeout, args.reuse,
-                                           args.extra_args, args.force_xds_sg)
-            if cif:
-                try:
-                    rug = parse_rugnux_cif(cif)
-                    rug["mosaicity"] = rugnux_mosaicity(workdir / name, name)
-                except Exception as e:  # keep the table alive if one cif is unreadable
-                    err = f"cif parse failed: {e}"
-        results.append((name, xds, rug, err, elapsed))
-
-    # -------- print the table --------
-    hdr = header_line()
-    rule = "  " + "-" * (len(hdr) - 2)
-    today = datetime.date.today().isoformat()
-    print()
-    print(f"  rugnux vs XDS   ·   {root}   ·   {today}")
-    if not args.xds_only:
-        print(f"  rugnux: {rugnux_bin}")
-    print(f"  rugnux run de-novo, resolution range (both limits) + Friedel matched to XDS.")
-    print(f"  XDS SG = symmetry")
-    print(f"  CORRECT merged in; match is point-group level (screw/enantiomorph ignored).  [ - = missing ]")
-    print(f"  Mosaic (deg): XDS cell = post-refined (CORRECT.LP) | integration-stage MLE (INTEGRATE.LP);")
-    print(f"  rugnux cell = median per-image mosaicity.  Compare rugnux against the INTEGRATION-STAGE")
-    print(f"  number - the post-refined one measures something else and can differ by >2x.")
-    print(f"  Reference only: XDS produces outliers here too, badly so on weak / low-resolution data.")
-    print()
-    print(hdr)
-    print(rule)
-
-    n_match = 0
-    for name, xds, rug, err, elapsed in results:
-        if args.xds_only:
-            mark = ""
-        elif err:
-            mark = "  FAIL"
-        else:
-            xk, rk = sym_key(xds.get("sg")), sym_key(rug.get("sg"))
-            same = xk is not None and xk == rk
-            n_match += same
-            mark = "  SG OK  ✅" if same else "  SG DIFF ❌"
-        print(f"● {name}{mark}")
-        print(row_line("XDS", xds))
-        if args.xds_only:
-            continue
-        if err:
-            print(f"  {'rugnux':<{W['src']}} (failed: {err})  [{fmt_dur(elapsed) or '-'}]")
-        else:
-            print(row_line("rugnux", rug, elapsed))
-    print(rule)
-
-    if not args.xds_only:
-        n_fail = sum(1 for *_, e, _ in results if e)
-        total = sum(e for *_, e in results if e)
-        print(f"  {len(results)} crystals   ·   space group OK {n_match}/{len(results)}"
-              f"   ·   rugnux failed {n_fail}   ·   total rugnux time {fmt_dur(total) or '-'}")
-    if skipped:
-        print(f"  skipped (no CORRECT.LP or no *_master.h5): {', '.join(skipped)}")
-    print()
-
-
-if __name__ == "__main__":
-    main()
diff --git a/rugnux_vs_pdb.py b/tools/battery/model_sweep.py
similarity index 82%
rename from rugnux_vs_pdb.py
rename to tools/battery/model_sweep.py
index 3de073204..d7f96aae2 100755
--- a/rugnux_vs_pdb.py
+++ b/tools/battery/model_sweep.py
@@ -1,8 +1,12 @@
 #!/usr/bin/env python3
 """
-rugnux_vs_pdb.py -- process a set of crystals whose data are deposited in the PDB, validate
+model_sweep.py -- process a set of crystals whose data are deposited in the PDB, validate
 each merge against the depositor's own model, and compare the result with what they published.
 
+It runs the open arm of the battery (the same inputs, from open.json and the site config), but
+separately from battery.py: --model places the deposited coordinates, which needs network access
+to the RCSB and adds R-free, maps and model placement to every run.
+
 For every dataset given it:
   * looks the entry up in the RCSB data API and records the deposited high-resolution limit,
     R-work and R-free;
@@ -22,11 +26,12 @@ the depositor's model explains data this pipeline produced from their images. It
 the depositor's published R-free, which came from full refinement against their own reduction --
 a harder target, and deliberately so.
 
-Datasets are identified by directory name, which must be the four-character PDB entry ID.
-Small-molecule sets and anything without a deposited model are skipped with a reason.
+Datasets are the open-arm sets whose id is a four-character PDB entry ID (optionally with a
+suffix, as in 6h2p_native); small-molecule sets and anything without a deposited model are
+skipped with a reason.
 
-  ./rugnux_vs_pdb.py --rugnux build/rugnux/rugnux --data /data/raw --work /tmp/modelrun
-  ./rugnux_vs_pdb.py --work /tmp/modelrun --score-only        # re-score without re-running
+  tools/battery/model_sweep.py --rugnux build/rugnux/rugnux --work /tmp/modelrun [--only 5reo,9jzo]
+  tools/battery/model_sweep.py --work /tmp/modelrun --score-only    # re-score without re-running
 """
 
 import argparse
@@ -36,6 +41,9 @@ import re
 import subprocess
 import sys
 
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import battery  # noqa: E402
+
 RCSB_ENTRY = "https://data.rcsb.org/rest/v1/core/entry/{}"
 RCSB_MODEL = "https://files.rcsb.org/download/{}.cif.gz"
 PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
@@ -80,22 +88,6 @@ def deposited(pdb, models_dir):
     return rec
 
 
-def find_input(directory):
-    """The image file to hand rugnux: a master file wins, otherwise the first frame of the
-    lowest-numbered template, which is how the readers pick up a numbered series."""
-    best = None
-    for root, _, files in os.walk(directory):
-        for fn in sorted(files):
-            p = os.path.join(root, fn)
-            if fn.endswith(".h5") and "master" in fn:
-                return p
-            if fn.endswith(".nxs"):
-                best = best or p
-            elif best is None and (fn.endswith(".cbf") or fn.endswith(".h5")):
-                best = p
-    return best
-
-
 def parse_report(path):
     rec = {}
     with open(path, errors="replace") as fh:
@@ -115,10 +107,9 @@ def num(rec, key):
 
 def run_one(rugnux, model, image, outdir, threads, gpulock):
     os.makedirs(outdir, exist_ok=True)
-    cmd = []
-    if gpulock:
-        cmd += ["flock", gpulock]
-    cmd += [rugnux, "-o", "p", "-N", str(threads), "--no-export-unmerged",
+    cmd = [gpulock] if gpulock else []
+    # threads=0 -> no -N: rugnux picks its own thread count
+    cmd += [rugnux, "-o", "p"] + (["-N", str(threads)] if threads else []) + ["--no-export-unmerged",
             "--spot-low-resolution", "50", "--scaling-low-resolution", "50",
             "--model", model, image]
     with open(os.path.join(outdir, "run.log"), "w") as log:
@@ -217,10 +208,13 @@ def main():
         description="Process deposited datasets with --model and compare with the deposition.")
     ap.add_argument("--work", required=True, help="working directory (models, runs, results)")
     ap.add_argument("--rugnux", help="rugnux binary (required unless --score-only)")
-    ap.add_argument("--data", help="directory whose subdirectories are named by PDB entry ID")
-    ap.add_argument("--datasets", help="JSON file mapping entry ID to image file, instead of --data")
-    ap.add_argument("--threads", type=int, default=6)
-    ap.add_argument("--gpulock", help="lock file to serialise GPU use with other runs")
+    ap.add_argument("--site", help="battery site config (default as for battery.py)")
+    ap.add_argument("--only", help="comma-separated open-arm set ids")
+    ap.add_argument("--datasets", help="JSON file mapping entry ID to image file, instead of the "
+                                       "open arm")
+    ap.add_argument("--threads", type=int, default=0)
+    ap.add_argument("--gpulock", action="store_true",
+                    help="queue each rugnux behind the site's GPU lock")
     ap.add_argument("--score-only", action="store_true", help="re-score existing runs, run nothing")
     args = ap.parse_args()
 
@@ -233,23 +227,20 @@ def main():
     if not args.score_only:
         if not args.rugnux:
             ap.error("--rugnux is required unless --score-only")
+        site = battery.load_site(args.site)
+        gpulock = site.get("gpulock") if args.gpulock else None
         if args.datasets:
             inputs = json.load(open(args.datasets))
-        elif args.data:
-            inputs = {}
-            for name in sorted(os.listdir(args.data)):
-                d = os.path.join(args.data, name)
-                if os.path.isdir(d) and PDB_ID.match(name):
-                    image = find_input(d)
-                    if image:
-                        inputs[name.lower()] = image
         else:
-            ap.error("one of --data or --datasets is required")
+            root = site["arms"]["open"]["data_root"]
+            inputs = {e["id"].lower(): os.path.join(root, e["input"])
+                      for e in battery.select(site, ["open"], args.only, None) if PDB_ID.match(e["id"].split("_")[0])}
 
         print(f"{len(inputs)} datasets with a PDB-shaped name and an image file")
         for i, (pdb, image) in enumerate(sorted(inputs.items()), 1):
             if pdb not in meta or "model" not in meta[pdb]:
-                meta[pdb] = deposited(pdb, os.path.join(work, "models"))
+                # a set id may carry a suffix (6h2p_native): the entry is the part before it
+                meta[pdb] = deposited(pdb.split("_")[0], os.path.join(work, "models"))
                 json.dump(meta, open(meta_path, "w"), indent=1)
             if "model" not in meta[pdb]:
                 print(f"[{i}/{len(inputs)}] {pdb}: {meta[pdb].get('model_error', 'no model')}")
@@ -258,7 +249,7 @@ def main():
             if os.path.exists(os.path.join(outdir, "p_report.txt")):
                 continue                      # resumable: an interrupted sweep picks up here
             print(f"[{i}/{len(inputs)}] {pdb}", flush=True)
-            rc = run_one(args.rugnux, meta[pdb]["model"], image, outdir, args.threads, args.gpulock)
+            rc = run_one(args.rugnux, meta[pdb]["model"], image, outdir, args.threads, gpulock)
             if rc != 0:
                 print(f"         exited {rc}")
 
-- 
2.54.0


From e51df4de2f69452f287ad3eea3f93b92626f4544 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:15:45 +0200
Subject: [PATCH 006/122] CLAUDE.md: the battery is tools/battery, with its
 rules

Replaces the mention of the retired rugnux_vs_xds.py with a short Battery section:
the canonical commands, never a full run without the owner's go-ahead, judge
against a persisted baseline, the private arm stays out of the repository.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md | 23 +++++++++++++++++++++--
 1 file changed, 21 insertions(+), 2 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index b8110a9bd..407dfb80b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -92,8 +92,27 @@ cd tests
 **Do not run the whole suite** (`./jfjoch_test` with no filter). It takes far too long to be worth
 running locally, and **CI runs it on every push anyway**. Run only the cases or tags covering the
 code you changed and stop there; a bare `./jfjoch_test` is justified only for a genuinely sweeping
-change. The same applies to the 37-crystal rotation battery (`rugnux_vs_xds.py`) — run it when a
-change plausibly moves merged results, not as a reflex.
+change. The same applies to the validation battery (below) — run it when a change plausibly moves
+merged results, not as a reflex.
+
+### Battery
+
+`tools/battery/battery.py` is the one canonical way to validate rugnux on the rotation datasets
+(open arm: public PDB depositions vs the deposition; inhouse: standard crystals + no-crystal
+controls vs XDS; private: local-only). `tools/battery/README.md` is the guide: data layout, site
+config, run directory, results schema, report, protocol. Do not write or revive ad-hoc runner
+scripts.
+
+```
+tools/battery/battery.py run --rugnux build/rugnux/rugnux --only 5reo,lyso_ref   # named sets
+tools/battery/battery.py run --rugnux build/rugnux/rugnux --tier smoke           # smoke tier
+tools/battery/battery.py compare RUN_A RUN_B [--rerun-changed]
+```
+
+- **Never start a full battery run (no `--only`/`--tier`) without the owner's go-ahead.**
+- Judge a change against a **persisted baseline run** (the site config's `baseline`) with
+  `compare`, never against numbers remembered from an earlier session.
+- The private arm's names, paths and values never enter the repository or a public report.
 
 `make jfjoch_hdf5_test` builds the HDF5 write-speed benchmark (it lives in `tools/`, so the binary
 is `build/tools/jfjoch_hdf5_test`); CI also uses it to produce files that are validated against XDS
-- 
2.54.0


From 47efa2d71f90f7faaadec0ea52619b740cab8e73 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:18:19 +0200
Subject: [PATCH 007/122] tools/battery: in-house sets named by protein,
 beamline and feature

Directories follow <protein>_<beamline>_<feature> (e.g. lyso_x10sa_90deg_1,
thau_bl1a_6p5keV, thau_micromax_pink); previous ids stay as aliases so older
runs still pair up in compare. The ice-only control moved out of the in-house
arm.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/inhouse.json | 69 +++++++++++++++++++-------------------
 1 file changed, 34 insertions(+), 35 deletions(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index e2a38ade5..a10b82c65 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -1,38 +1,37 @@
-{"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_90deg_1", "E08_lyso_2_007": "lyso_90deg_2", "lyso_2": "lyso_atten_wedge", "lyso_6_5keV": "lyso_5keV", "lysoC_14_f46f0a": "lyso_ice", "Thau_9": "thau_0p1deg", "thau_BL1A_1p9A": "thau_1p9A", "thau_BL1A_2p7A": "thau_2p7A", "thau_BL1A_3p3A": "thau_3p3A", "Ins_H_2_fa9841": "insu_H_twin", "Ins_H_3_d05684": "insu_H_notwin", "Ins_I_16": "insu_I_weak", "Ins_I_2_1a530d": "insu_I_low_isa", "Ins_I_3_5e90e3": "insu_I_ref", "Ins_I_6_13keV": "insu_I_13keV", "Ins_I_6_5keV": "insu_I_5keV", "Ins_I_6_6keV": "insu_I_6keV", "Ins_I_7_5keV": "insu_I_5keV_2", "cytC_10": "cytc_eiger", "cytC_2_0770b5": "cytc_pilatus_1", "cytC_3_874285": "cytc_pilatus_2", "MyoB_13": "myob_eiger", "MyoB_9_446b70": "myob_pilatus", "MyoB2-1": "myob_powder_1", "MyoB2-2": "myob_powder_2", "MyoB2-4": "myob_split", "MyoB2-5": "myob_aggregate", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1"}, "sets": [
- {"id": "lyso_90deg_1", "input": "lyso_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_90deg_2", "input": "lyso_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_atten_wedge", "input": "lyso_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_5keV", "input": "lyso_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
- {"id": "lyso_ice", "input": "lyso_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_ref", "input": "lyso_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
- {"id": "lyso_strong", "input": "lyso_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_half_image", "input": "lyso_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 2.602, "dmin_rule": "cc_half_0.30", "dmin_xds": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "thau_16keV", "input": "thau_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_0p1deg", "input": "thau_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_1p9A", "input": "thau_1p9A/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_2p7A", "input": "thau_2p7A/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_3p3A", "input": "thau_3p3A/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
- {"id": "thau_injection", "input": "thau_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_pink", "input": "thau_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
- {"id": "insu_H_twin", "input": "insu_H_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_H_notwin", "input": "insu_H_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
- {"id": "insu_I_weak", "input": "insu_I_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_low_isa", "input": "insu_I_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_ref", "input": "insu_I_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_13keV", "input": "insu_I_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_5keV", "input": "insu_I_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_6keV", "input": "insu_I_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_5keV_2", "input": "insu_I_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
- {"id": "cytc_eiger", "input": "cytc_eiger/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_pilatus_1", "input": "cytc_pilatus_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_pilatus_2", "input": "cytc_pilatus_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "myob_eiger", "input": "myob_eiger/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
- {"id": "myob_pilatus", "input": "myob_pilatus/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
- {"id": "myob_powder_1", "input": "myob_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
- {"id": "myob_powder_2", "input": "myob_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_split", "input": "myob_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_aggregate", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmin_rule": "xds_range", "dmin_xds": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "nothing_ice", "input": "nothing_ice/onlyice_master.h5", "expect": "no_lattice", "tags": ["h5", "control"], "tiers": {"smoke": "no-crystal control (ice rings only): must refuse"}},
+{"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_x10sa_90deg_1", "E08_lyso_2_007": "lyso_x10sa_90deg_2", "lyso_2": "lyso_x06da_atten_wedge", "lyso_6_5keV": "lyso_x06da_5keV", "lysoC_14_f46f0a": "lyso_x06da_ice", "Thau_9": "thau_x10sa_0p1deg", "thau_BL1A_1p9A": "thau_bl1a_6p5keV", "thau_BL1A_2p7A": "thau_bl1a_4p6keV", "thau_BL1A_3p3A": "thau_bl1a_3p8keV", "Ins_H_2_fa9841": "insu_H_x06da_twin", "Ins_H_3_d05684": "insu_H_x06da_notwin", "Ins_I_16": "insu_I_x06da_weak", "Ins_I_2_1a530d": "insu_I_x06da_low_isa", "Ins_I_3_5e90e3": "insu_I_x06da_ref", "Ins_I_6_13keV": "insu_I_x06da_13keV", "Ins_I_6_5keV": "insu_I_x06da_5keV", "Ins_I_6_6keV": "insu_I_x06da_6keV", "Ins_I_7_5keV": "insu_I_x06da_5keV_2", "cytC_10": "cytc_x10sa", "cytC_2_0770b5": "cytc_x06da_1", "cytC_3_874285": "cytc_x06da_2", "MyoB_13": "myob_x10sa", "MyoB_9_446b70": "myob_x06da", "MyoB2-1": "myob_x06da_powder_1", "MyoB2-2": "myob_x06da_powder_2", "MyoB2-4": "myob_x06da_split", "MyoB2-5": "myob_x06da_aggregate", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1", "lyso_90deg_1": "lyso_x10sa_90deg_1", "lyso_90deg_2": "lyso_x10sa_90deg_2", "lyso_atten_wedge": "lyso_x06da_atten_wedge", "lyso_5keV": "lyso_x06da_5keV", "lyso_ice": "lyso_x06da_ice", "lyso_ref": "lyso_x06da_ref", "lyso_strong": "lyso_x10sa_strong", "lyso_half_image": "lyso_x06da_half_image", "thau_16keV": "thau_x10sa_16keV", "thau_0p1deg": "thau_x10sa_0p1deg", "thau_1p9A": "thau_bl1a_6p5keV", "thau_2p7A": "thau_bl1a_4p6keV", "thau_3p3A": "thau_bl1a_3p8keV", "thau_injection": "thau_x10sa_injection", "thau_pink": "thau_micromax_pink", "insu_H_twin": "insu_H_x06da_twin", "insu_H_notwin": "insu_H_x06da_notwin", "insu_I_weak": "insu_I_x06da_weak", "insu_I_low_isa": "insu_I_x06da_low_isa", "insu_I_ref": "insu_I_x06da_ref", "insu_I_13keV": "insu_I_x06da_13keV", "insu_I_5keV": "insu_I_x06da_5keV", "insu_I_6keV": "insu_I_x06da_6keV", "insu_I_5keV_2": "insu_I_x06da_5keV_2", "cytc_eiger": "cytc_x10sa", "cytc_pilatus_1": "cytc_x06da_1", "cytc_pilatus_2": "cytc_x06da_2", "myob_eiger": "myob_x10sa", "myob_pilatus": "myob_x06da", "myob_powder_1": "myob_x06da_powder_1", "myob_powder_2": "myob_x06da_powder_2", "myob_split": "myob_x06da_split", "myob_aggregate": "myob_x06da_aggregate"}, "sets": [
+ {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_5keV", "input": "lyso_x06da_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
+ {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
+ {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 2.602, "dmin_rule": "cc_half_0.30", "dmin_xds": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_3p8keV", "input": "thau_bl1a_3p8keV/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
+ {"id": "thau_x10sa_injection", "input": "thau_x10sa_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_micromax_pink", "input": "thau_micromax_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
+ {"id": "insu_H_x06da_twin", "input": "insu_H_x06da_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_H_x06da_notwin", "input": "insu_H_x06da_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
+ {"id": "insu_I_x06da_weak", "input": "insu_I_x06da_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_low_isa", "input": "insu_I_x06da_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_ref", "input": "insu_I_x06da_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_13keV", "input": "insu_I_x06da_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_5keV", "input": "insu_I_x06da_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_6keV", "input": "insu_I_x06da_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_5keV_2", "input": "insu_I_x06da_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
+ {"id": "cytc_x10sa", "input": "cytc_x10sa/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_1", "input": "cytc_x06da_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_2", "input": "cytc_x06da_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "myob_x10sa", "input": "myob_x10sa/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
+ {"id": "myob_x06da", "input": "myob_x06da/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
+ {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
+ {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_aggregate", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmin_rule": "xds_range", "dmin_xds": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
  {"id": "nothing_2", "input": "nothing_2/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
  {"id": "nothing_1", "input": "nothing_1/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
 ]}
-- 
2.54.0


From c244b0bc201998ba208531c57733d741101599e7 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:20:02 +0200
Subject: [PATCH 008/122] tools/battery: model_check.py, R-factors of the
 deposited model against the merged data

Run after rugnux has written its MTZ, so processing never sees the model. Fetches the
entry (cached), matches the data to the model's setting by trying every Niggli-cell
change of basis and keeping the one that best fits the model's Fcalc on a mid-resolution
shell, re-expresses the data in the deposited space group and cell, and has REFMAC compute
R-work/R-free of the unmodified model (rigid-body mode read at its first cycle: no
dictionaries, no ligand stripped, no refinement). Baseline: the same protocol on the
depositor's own structure factors and free set, plus rugnux's data on the depositor's flags.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/model_check.py | 468 +++++++++++++++++++++++++++++++++++
 1 file changed, 468 insertions(+)
 create mode 100644 tools/battery/model_check.py

diff --git a/tools/battery/model_check.py b/tools/battery/model_check.py
new file mode 100644
index 000000000..85c0b71cd
--- /dev/null
+++ b/tools/battery/model_check.py
@@ -0,0 +1,468 @@
+#!/usr/bin/env python3
+"""model_check.py -- R-factors of the deposited model against Rugnux's merged data.
+
+An external check for the open arm, run AFTER Rugnux has written its MTZ, so it cannot bias the
+processing (Rugnux is never given the model). For one set it:
+
+  * fetches the entry's mmCIF (and, for the baseline, its structure factors) from RCSB into a
+    cache, and reads the published R-work / R-free / d_min from the entry's `_refine`;
+  * matches the data to the model's setting: the two lattices are compared through their Niggli
+    cells, every change of basis that carries one onto the other is tried (this covers an
+    alternative setting, a permuted or centred-vs-primitive description and the merohedral
+    indexing ambiguity), and the one whose reindexed data agree best with the model's Fcalc on a
+    mid-resolution shell is taken;
+  * re-expresses the data in the DEPOSITED space group: expanded to P1 with Rugnux's own group,
+    reindexed, reduced to the deposited group's asymmetric unit (an over-call just splits
+    equivalents apart, an under-call averages them) and given the DEPOSITED cell;
+  * has REFMAC compute R-work / R-free of the model AS DEPOSITED, with its bulk solvent and
+    overall anisotropic scaling, at the lower of the two high-resolution limits. This is REFMAC's
+    rigid-body mode read at its first cycle, before any shift is applied: rigid body reads no
+    restraint dictionaries, so no ligand is stripped, no atom is moved and no cell is imposed on
+    the model. Refining is deliberately not done - the data were moved into the model's frame, so
+    there is nothing for a rigid body to correct, and at low resolution REFMAC's rigid body can
+    walk a correct model away (R 0.30 -> 0.49 over ten cycles on one 5 A set);
+  * scores the SAME model with the SAME protocol against the depositor's own structure factors
+    and free set, as the baseline for "same method, other data", and - when that free set can be
+    carried over - also scores Rugnux's data on the depositor's free reflections.
+
+On free sets: the depositor's model was refined against every reflection except THEIR free set,
+so most of Rugnux's free reflections were work reflections to it. `rfree` (Rugnux's own flags)
+therefore reads like a work R. `rfree_depflags` (depositor's flags on Rugnux's data) is the
+number that is comparable with `rfree_depdata` and, loosely, with `rfree_deposited`.
+
+  model_check.py rugnux.mtz 1abc [--workdir DIR] [--cache DIR] [--no-baseline]
+"""
+import argparse
+import itertools
+import json
+import os
+import re
+import subprocess
+import time
+
+import gemmi
+import numpy as np
+
+DEFAULT_CACHE = "/data/battery/pdb_cache"
+CCP4_SETUP = os.environ.get("CCP4_SETUP", "/opt/xtal/ccp4-9/bin/ccp4.setup-sh")
+RCSB = "https://files.rcsb.org/download/"
+PDB_ID = re.compile(r"^[0-9][a-z0-9]{3}$")
+MAX_ATOMS = 200000          # REFMAC time grows with atoms x reflections
+CELL_TOL = 0.05             # Niggli cells compared loosely on purpose; the R score decides
+ANGLE_TOL = 3.0
+
+
+# ------------------------------------------------------------------ deposition
+
+def fetch(url, dest):
+    if not os.path.exists(dest) or os.path.getsize(dest) == 0:
+        tmp = dest + ".part"
+        r = subprocess.run(["curl", "-sfL", "--max-time", "300", "-o", tmp, url])
+        if r.returncode != 0 or not os.path.exists(tmp):
+            if os.path.exists(tmp):
+                os.remove(tmp)
+            return None
+        os.replace(tmp, dest)
+    return dest
+
+
+def deposition(pdb_id, cache_dir):
+    """Coordinates path and the published refinement statistics, cached as <id>.json."""
+    os.makedirs(cache_dir, exist_ok=True)
+    meta_path = os.path.join(cache_dir, pdb_id + ".json")
+    xyz = fetch(RCSB + pdb_id + ".cif.gz", os.path.join(cache_dir, pdb_id + ".cif.gz"))
+    if xyz is None:
+        return None
+    if os.path.exists(meta_path):
+        return json.load(open(meta_path))
+    block = gemmi.cif.read(xyz).sole_block()
+    methods = [m.strip("'\"") for m in block.find_values("_exptl.method")]
+    rows = block.find("_refine.", ["pdbx_refine_id", "?ls_R_factor_R_free", "?ls_R_factor_R_work",
+                                   "?ls_d_res_high"])
+    ref = {}
+    for row in rows:       # a joint X-ray/neutron entry has one row per method; take the X-ray one
+        if "X-RAY" in row.str(0).upper():
+            ref = {k: (float(row[i]) if row.has(i) and gemmi.cif.is_null(row[i]) is False else None)
+                   for k, i in (("rfree", 1), ("rwork", 2), ("dmin", 3))}
+    meta = {"id": pdb_id, "methods": methods, "rfree": ref.get("rfree"), "rwork": ref.get("rwork"),
+            "dmin": ref.get("dmin"), "xyz": xyz}
+    json.dump(meta, open(meta_path, "w"), indent=1)
+    return meta
+
+
+# ------------------------------------------------------------------ lattice / setting matching
+
+def metric(cell):
+    a, b, c, al, be, ga = cell.parameters
+    ca, cb, cg = np.cos(np.radians([al, be, ga]))
+    return np.array([[a * a, a * b * cg, a * c * cb],
+                     [a * b * cg, b * b, b * c * ca],
+                     [a * c * cb, b * c * ca, c * c]])
+
+
+def niggli(cell, sg):
+    """Matrix M with (reduced primitive basis) = (conventional basis) @ M, and the reduced cell."""
+    gv = gemmi.GruberVector(cell, sg.centring_type(), True)
+    gv.niggli_reduce()
+    op = gv.change_of_basis
+    return np.array(op.rot, float) / op.DEN, gv.get_cell()
+
+
+UNIMODULAR = np.array([u for u in itertools.product((-1, 0, 1), repeat=9)
+                       if round(np.linalg.det(np.reshape(u, (3, 3)))) == 1], float).reshape(-1, 3, 3)
+
+
+def basis_changes(cell_d, sg_d, cell_m, sg_m):
+    """Every T (hkl_model = hkl_data @ T) whose lattice matches the model's, one per distinct
+    reindexing modulo the model's point group (the member nearest the identity names it)."""
+    md, red_d = niggli(cell_d, sg_d)
+    mm, red_m = niggli(cell_m, sg_m)
+    gd, gm = metric(red_d), metric(red_m)
+    g = np.einsum("nji,jk,nkl->nil", UNIMODULAR, gd, UNIMODULAR)
+    lengths = np.sqrt(np.einsum("nii->ni", g))
+    lm = np.sqrt(np.diag(gm))
+    ok = np.all(np.abs(lengths / lm - 1) < CELL_TOL, axis=1)
+    cos = lambda g_, i, j, l_: g_[..., i, j] / (l_[..., i] * l_[..., j])
+    for i, j in ((1, 2), (0, 2), (0, 1)):
+        ang = np.degrees(np.arccos(np.clip(cos(g, i, j, lengths), -1, 1)))
+        ok &= np.abs(ang - np.degrees(np.arccos(cos(gm, i, j, lm)))) < ANGLE_TOL
+    asu, gops = gemmi.ReciprocalAsu(sg_m), sg_m.operations()
+    probe = np.array([[1, 2, 3], [3, 1, 7], [5, 11, 2]]) * 12
+    found = {}
+    for u in UNIMODULAR[ok]:
+        t = md @ u @ np.linalg.inv(mm)
+        key = tuple(tuple(asu.to_asu([int(round(x)) for x in h], gops)[0]) for h in probe @ t)
+        key = tuple(sorted(key))
+        if key not in found or np.abs(t - np.eye(3)).sum() < np.abs(found[key] - np.eye(3)).sum():
+            found[key] = t
+    return list(found.values())
+
+
+def op_string(t):
+    """hkl_model = hkl_data @ T written as the usual h,k,l triplet."""
+    from fractions import Fraction
+    out = []
+    for j in range(3):
+        terms = ""
+        for i, name in enumerate("hkl"):
+            f = Fraction(t[i, j]).limit_denominator(12)
+            if f == 0:
+                continue
+            sign = "-" if f < 0 else ("+" if terms else "")
+            mag = abs(f)
+            terms += sign + (name if mag == 1 else f"{mag}{name}" if mag.denominator == 1
+                             else f"{mag.numerator}{name}/{mag.denominator}")
+        out.append(terms)
+    return ",".join(out)
+
+
+# ------------------------------------------------------------------ reflection data
+
+def hkl_key(hkl):
+    h = hkl.astype(np.int64) + 1024
+    return (h[:, 0] * 2048 + h[:, 1]) * 2048 + h[:, 2]
+
+
+def to_group(hkl, f, sigf, flags, cell, sg, src):
+    """Reduce reflections to the asymmetric unit of sg; independent measurements of one
+    reflection are averaged (1/sigma^2), copies of the same one (same `src`) are not. A reflection
+    is free if any contributor is."""
+    mtz = gemmi.Mtz()
+    mtz.spacegroup, mtz.cell = sg, cell
+    mtz.add_dataset("d")
+    for lab, typ in (("H", "H"), ("K", "H"), ("L", "H"), ("S", "R")):
+        mtz.add_column(lab, typ)
+    mtz.set_data(np.column_stack([hkl, np.arange(len(hkl))]).astype(np.float32))
+    mtz.ensure_asu()
+    a = np.array(mtz, copy=False)
+    order = a[:, 3].astype(np.int64)
+    hkl, f, sigf, flags, src = a[:, :3].astype(int), f[order], sigf[order], flags[order], src[order]
+    keep = ~sg.operations().systematic_absences(hkl)
+    hkl, f, sigf, flags, src = hkl[keep], f[keep], sigf[keep], flags[keep], src[keep]
+    key = hkl_key(hkl)
+    _, first = np.unique(np.column_stack([key, src]), axis=0, return_index=True)
+    hkl, f, sigf, flags, key = hkl[first], f[first], sigf[first], flags[first], key[first]
+    _, idx, inv = np.unique(key, return_index=True, return_inverse=True)
+    w = 1.0 / np.maximum(sigf, 1e-6) ** 2
+    sw = np.bincount(inv, w)
+    fm = np.bincount(inv, w * f) / sw
+    flag = np.minimum.reduceat(flags[np.argsort(inv, kind="stable")],
+                               np.r_[0, np.cumsum(np.bincount(inv))[:-1]])
+    return hkl[idx], fm, 1.0 / np.sqrt(sw), flag
+
+
+def read_rugnux(mtz_path):
+    mtz = gemmi.read_mtz_file(mtz_path)
+    labels = mtz.column_labels()
+    need = ("F", "SIGF", "FreeR_flag")
+    if not all(l in labels for l in need):
+        raise RuntimeError(f"MTZ lacks one of {need}")
+    return mtz
+
+
+def expand_p1(mtz):
+    """Rugnux's merge expanded to P1 (one hemisphere), with each row's source index."""
+    m = gemmi.Mtz()
+    m.spacegroup, m.cell = mtz.spacegroup, mtz.cell
+    m.add_dataset("d")
+    for lab, typ in (("H", "H"), ("K", "H"), ("L", "H"), ("S", "R")):
+        m.add_column(lab, typ)
+    m.set_data(np.column_stack([mtz.make_miller_array(), np.arange(mtz.nreflections)]).astype(np.float32))
+    m.expand_to_p1()
+    a = np.array(m, copy=False)
+    return a[:, :3].astype(int), a[:, 3].astype(int)
+
+
+def reindexed(mtz, t, cell_m, sg_m):
+    f = np.array(mtz.column_with_label("F"), copy=False).astype(float)
+    s = np.array(mtz.column_with_label("SIGF"), copy=False).astype(float)
+    fl = np.array(mtz.column_with_label("FreeR_flag"), copy=False).astype(int)
+    good = np.isfinite(f) & np.isfinite(s) & (s > 0)
+    hkl, src = expand_p1(mtz)
+    hm = hkl @ t
+    integral = np.all(np.abs(hm - np.round(hm)) < 1e-3, axis=1) & good[src]
+    hm, src = np.round(hm[integral]).astype(int), src[integral]
+    return to_group(hm, f[src], s[src], fl[src], cell_m, sg_m, src), integral.mean()
+
+
+def fcalc(st, d_min):
+    dc = gemmi.DensityCalculatorX()
+    dc.d_min = d_min
+    dc.grid.setup_from(st)
+    dc.set_refmac_compatible_blur(st[0])
+    dc.put_model_density_on_grid(st[0])
+    asu = gemmi.transform_map_to_f_phi(dc.grid).prepare_asu_data(dmin=d_min, unblur=dc.blur)
+    return asu.miller_array, np.abs(asu.value_array)
+
+
+def shell_r(hkl, fo, fc_hkl, fc, cell, d_lo, d_hi):
+    """R after an overall scale and B, on the shell used only to choose the setting (low
+    resolution excluded: unmodelled bulk solvent dominates there)."""
+    _, i, j = np.intersect1d(hkl_key(hkl), hkl_key(fc_hkl), return_indices=True)
+    fo, fc = fo[i], fc[j]
+    d = cell.calculate_d_array(hkl[i])
+    sel = (d <= d_lo) & (d >= d_hi) & (fo > 0) & (fc > 0)
+    if sel.sum() < 50:
+        return None
+    fo, fc, s2 = fo[sel], fc[sel], 1.0 / d[sel] ** 2
+    slope, lnk = np.polyfit(s2, np.log(fo / fc), 1)
+    fm = np.exp(lnk + slope * s2) * fc
+    return float(np.sum(np.abs(fo - fm)) / np.sum(fo))
+
+
+# ------------------------------------------------------------------ REFMAC
+
+_ENV = None
+
+
+def ccp4_env():
+    global _ENV
+    if _ENV is None:
+        out = subprocess.run(["bash", "-c", f"source {CCP4_SETUP} >/dev/null 2>&1; env -0"],
+                             capture_output=True).stdout
+        _ENV = dict(kv.split("=", 1) for kv in out.decode().split("\0") if "=" in kv)
+    return _ENV
+
+
+def write_mtz(path, hkl, f, sigf, flags, cell, sg, dep_flags=None):
+    mtz = gemmi.Mtz(with_base=True)
+    mtz.spacegroup, mtz.cell = sg, cell
+    mtz.add_dataset("data")
+    cols = [hkl.astype(float), f, sigf, flags]
+    for lab, typ in (("F", "F"), ("SIGF", "Q"), ("FreeR_flag", "I")):
+        mtz.add_column(lab, typ)
+    if dep_flags is not None:
+        mtz.add_column("FreeR_dep", "I")
+        cols.append(dep_flags)
+    mtz.set_data(np.column_stack(cols).astype(np.float32))
+    mtz.write_to_file(path)
+
+
+def refmac(workdir, tag, mtz, xyz, d_min, free_label="FreeR_flag"):
+    """R-work, R-free of the model as given: the first cycle of REFMAC's rigid body, whose
+    R-factors come before any shift is applied (bulk solvent + anisotropic overall scale are
+    REFMAC's defaults)."""
+    log = os.path.join(workdir, tag + ".log")
+    keywords = (f"labin FP=F SIGFP=SIGF FREE={free_label}\nrefi type rigid\n"
+                f"rigid ncycle 1\nreso 999 {d_min:.3f}\nend\n")
+    with open(log, "w") as fh:
+        subprocess.run(["refmac5", "hklin", mtz, "xyzin", xyz,
+                        "hklout", os.path.join(workdir, tag + "_out.mtz"),
+                        "xyzout", os.path.join(workdir, tag + "_out.pdb")],
+                       input=keywords.encode(), stdout=fh, stderr=subprocess.STDOUT,
+                       cwd=workdir, env=ccp4_env())
+    text = open(log, errors="replace").read()
+    rw = [float(x) for x in re.findall(r"^Overall R factor\s+=\s+([\d.]+)", text, re.M)]
+    rf = [float(x) for x in re.findall(r"^Free R factor\s+=\s+([\d.]+)", text, re.M)]
+    if not rw or not rf:
+        err = [l.strip() for l in text.splitlines() if "ERROR" in l.upper() or "Stop" in l]
+        raise RuntimeError("REFMAC gave no R factors: " + (err[-1] if err else "see " + log))
+    return rw[0], rf[0]
+
+
+# ------------------------------------------------------------------ depositor's structure factors
+
+def depositor_data(pdb_id, cache_dir, cell_m, sg_m):
+    """The first reflection block of the entry's -sf.cif, reduced to the model group's ASU.
+    Free flags from _refln.status ('f' free) or a numeric _refln.pdbx_r_free_flag (minority
+    value = free). Returns None, reason when there is nothing usable."""
+    path = fetch(RCSB + pdb_id + "-sf.cif.gz", os.path.join(cache_dir, pdb_id + "-sf.cif.gz"))
+    if path is None:
+        return None, "no deposited structure factors"
+    rb = gemmi.as_refln_blocks(gemmi.cif.read(path))
+    if not rb:
+        return None, "no reflection block"
+    b = rb[0]
+    labels = b.column_labels()
+    hkl = b.make_miller_array()
+    if "F_meas_au" in labels and "F_meas_sigma_au" in labels:
+        f, s = b.make_float_array("F_meas_au"), b.make_float_array("F_meas_sigma_au")
+    else:     # intensities only: no amplitude conversion here that could bias the baseline
+        return None, "deposited structure factors carry no amplitudes"
+    if "status" in labels:
+        st = np.array(list(b.block.find_values("_refln.status")) if b.block.find_values("_refln.status")
+                      else [], dtype=object)
+        st = np.array([x.strip("'\"") for x in st])
+        if len(st) != len(hkl) or not np.any(st == "f"):
+            return None, "deposited structure factors carry no free set"
+        use = (st == "f") | (st == "o")
+        flags = np.where(st == "f", 0, 1)
+    elif "pdbx_r_free_flag" in labels:
+        v = b.make_int_array("pdbx_r_free_flag", -1)
+        vals, counts = np.unique(v[v >= 0], return_counts=True)
+        if len(vals) < 2:
+            return None, "deposited structure factors carry no free set"
+        free = vals[np.argmin(counts)]
+        use = v >= 0
+        flags = np.where(v == free, 0, 1)
+    else:
+        return None, "deposited structure factors carry no free set"
+    use &= np.isfinite(f) & np.isfinite(s) & (s > 0)
+    if not np.allclose(b.cell.parameters, cell_m.parameters, rtol=0.02, atol=0.5):
+        return None, "deposited structure factors in another cell"
+    hkl, f, s, flags = hkl[use], f[use], s[use], flags[use]
+    return to_group(hkl, f, s, flags, cell_m, sg_m, np.arange(len(hkl))), None
+
+
+# ------------------------------------------------------------------ the check
+
+def check(mtz_path, pdb_id, workdir, cache_dir=DEFAULT_CACHE, baseline=True):
+    t0 = time.time()
+    res = {"status": "failed", "reason": "", "rwork": None, "rfree": None,
+           "rfree_deposited": None, "rwork_deposited": None, "d_min_used": None, "sg_used": None,
+           "reindex_op": None, "cycles": 0, "seconds": None,
+           "rfree_depflags": None,
+           "rwork_depdata": None, "rfree_depdata": None, "baseline_note": None,
+           "sg_data": None, "d_min_data": None, "d_min_deposited": None, "cell_diff_pct": None,
+           "setting_r": None, "setting_r_next": None, "fraction_indexed": None,
+           "model_modification": "none", "protocol": "REFMAC R-factors of the model as deposited, bulk solvent, no refinement"}
+
+    def done(status, reason=""):
+        res["status"], res["reason"] = status, reason
+        res["seconds"] = round(time.time() - t0, 1)
+        return res
+
+    pdb_id = pdb_id.lower()
+    if not PDB_ID.match(pdb_id):
+        return done("n/a", "not a PDB entry (small molecule or unpublished set)")
+    try:
+        os.makedirs(workdir, exist_ok=True)
+        meta = deposition(pdb_id, cache_dir)
+        if meta is None:
+            return done("failed", "entry could not be downloaded")
+        res["rfree_deposited"], res["rwork_deposited"] = meta["rfree"], meta["rwork"]
+        res["d_min_deposited"] = meta["dmin"]
+        if not any("X-RAY" in m.upper() for m in meta["methods"]):
+            return done("n/a", "not an X-ray structure: " + ", ".join(meta["methods"]))
+        if meta["rfree"] is None:
+            return done("n/a", "no deposited R-free")
+        st = gemmi.read_structure(meta["xyz"])
+        if len(st) > 1:
+            return done("skipped", f"{len(st)} models in the entry")
+        natoms = st[0].count_atom_sites()
+        if natoms > MAX_ATOMS:
+            return done("skipped", f"{natoms} atoms, above {MAX_ATOMS}")
+        sg_m, cell_m = st.find_spacegroup(), st.cell
+        if sg_m is None:
+            return done("failed", f"model space group '{st.spacegroup_hm}' not recognised")
+
+        mtz = read_rugnux(mtz_path)
+        res["sg_data"] = mtz.spacegroup.hm
+        res["d_min_data"] = round(mtz.resolution_high(), 3)
+        d_used = max(mtz.resolution_high(), meta["dmin"] or 0)
+        res["d_min_used"] = round(d_used, 3)
+        res["sg_used"] = sg_m.hm
+
+        # choose the setting on a mid-resolution shell against the model's Fcalc
+        d_hi = max(3.0, d_used)
+        d_lo = max(8.0, 1.6 * d_hi)
+        fc_hkl, fc = fcalc(st, d_hi)
+        scored = []
+        for t in basis_changes(mtz.cell, mtz.spacegroup, cell_m, sg_m):
+            (hkl, f, s, fl), frac = reindexed(mtz, t, cell_m, sg_m)
+            r = shell_r(hkl, f, fc_hkl, fc, cell_m, d_lo, d_hi)
+            if r is not None:
+                scored.append((r, frac, t))
+        if not scored:
+            return done("failed", "no change of basis carries the data lattice onto the model's")
+        scored.sort(key=lambda x: x[0])
+        r_best, frac, t = scored[0]
+        res["setting_r"] = round(r_best, 4)
+        res["setting_r_next"] = round(scored[1][0], 4) if len(scored) > 1 else None
+        res["fraction_indexed"] = round(float(frac), 4)
+        res["reindex_op"] = op_string(t)
+        gd = t.T @ metric(mtz.cell) @ t
+        res["cell_diff_pct"] = round(100 * float(np.max(np.abs(
+            np.sqrt(np.diag(gd)) / np.array(cell_m.parameters[:3]) - 1))), 2)
+
+        (hkl, f, s, fl), _ = reindexed(mtz, t, cell_m, sg_m)
+        dep = None
+        if baseline:
+            dep, why = depositor_data(pdb_id, cache_dir, cell_m, sg_m)
+            res["baseline_note"] = why
+        dep_flags = None
+        if dep is not None:
+            _, i, j = np.intersect1d(hkl_key(hkl), hkl_key(dep[0]), return_indices=True)
+            dep_flags = np.full(len(hkl), -1)        # -1: absent from the deposited set -> work
+            dep_flags[i] = dep[3][j]
+            dep_flags[dep_flags < 0] = 1
+        data_mtz = os.path.join(workdir, "data.mtz")
+        write_mtz(data_mtz, hkl, f, s, fl, cell_m, sg_m, dep_flags)
+        xyz = os.path.join(workdir, "model.cif")
+        st.setup_entities()
+        st.make_mmcif_document().write_file(xyz)
+
+        res["rwork"], res["rfree"] = refmac(workdir, "rugnux", data_mtz, xyz, d_used)
+        if dep is not None:
+            res["rfree_depflags"] = refmac(workdir, "rugnux_depflags", data_mtz, xyz, d_used,
+                                           "FreeR_dep")[1]
+            dep_mtz = os.path.join(workdir, "deposited.mtz")
+            write_mtz(dep_mtz, *dep, cell_m, sg_m)
+            res["rwork_depdata"], res["rfree_depdata"] = refmac(workdir, "deposited", dep_mtz, xyz,
+                                                                d_used)
+        for k in ("rwork", "rfree", "rfree_depflags",
+                  "rwork_depdata", "rfree_depdata"):
+            if res[k] is not None:
+                res[k] = round(res[k], 4)
+        return done("ok")
+    except Exception as e:                           # one bad entry must not stop a battery
+        if os.environ.get("MODEL_CHECK_RAISE"):
+            raise
+        return done("failed", f"{type(e).__name__}: {e}")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    ap.add_argument("mtz", help="Rugnux merged MTZ (needs F, SIGF, FreeR_flag)")
+    ap.add_argument("pdb_id")
+    ap.add_argument("--workdir", default=None, help="default: model_check_<id> beside the MTZ")
+    ap.add_argument("--cache", default=DEFAULT_CACHE)
+    ap.add_argument("--no-baseline", action="store_true",
+                    help="skip the depositor's structure factors")
+    a = ap.parse_args()
+    wd = a.workdir or os.path.join(os.path.dirname(os.path.abspath(a.mtz)), "model_check_" + a.pdb_id)
+    print(json.dumps(check(a.mtz, a.pdb_id, wd, a.cache, baseline=not a.no_baseline), indent=1))
+
+
+if __name__ == "__main__":
+    main()
-- 
2.54.0


From adecb8557c71f7298d75f95c83259d0fdddc9fce Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:22:20 +0200
Subject: [PATCH 009/122] tools/battery: the R-free ratio compares like with
 like

Our merge and the depositor's structure factors are both scored on the
depositor's free set by the same protocol, and the report plots that ratio.
R-free on our own free set reads low, because those reflections were mostly
work reflections in the deposited refinement.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/README.md  | 20 ++++++++++++--------
 tools/battery/battery.py | 15 ++++++++++-----
 tools/battery/report.py  |  7 ++++---
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 18bec5d32..6b31188fa 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -130,13 +130,17 @@ everything else on the machine competes with it.
 
 ### The model check (open arm)
 
-If `tools/battery/model_check.py` is present, each open-arm merge (`p.mtz`) is also scored
-against the deposited model: `model_check.check(mtz, pdb_id, workdir)` returns R-free and R-work
-of the deposited model against our data, plus the deposited R-free. The runner records these as
-`rfree`, `rwork`, `rfree_deposited`, `rfree_ratio`, `model_status` and `model_reason`, and the
-report plots their ratio. The check is on by default when the module exists. Without the module
-the fields stay null. The PDB entry is the set id up to the first `_`, so `6h2p_native` is checked
-as `6h2p`. Small-molecule sets are skipped.
+`tools/battery/model_check.py` scores each open-arm merge (`p.mtz`) against the deposited model,
+unmodified (ligands, waters and hydrogens kept): REFMAC's rigid-body mode, R-factors taken before
+any shift, the data reindexed into the model's setting and reduced to the deposited space group.
+Our own free set was mostly work reflections for the depositor, so `rfree` reads low. The fair
+comparison is `rfree_depflags` (our data on the depositor's free set) against `rfree_depdata` (the
+depositor's structure factors, same free set, same protocol); `rfree_ratio` is that ratio, and the
+report plots it. It is null when the entry deposited no structure factors with a free set.
+`rfree_deposited` is the value in the entry, often from twin or full refinement. The runner records
+`rfree`, `rwork`, `rfree_deposited`, `rfree_depflags`, `rfree_depdata`, `rfree_ratio`,
+`model_status` and `model_reason`. The check is on by default when the module exists. The PDB entry
+is the set id up to the first `_`, so `6h2p_native` is checked as `6h2p`. Small-molecule sets are skipped.
 
 `model_sweep.py` is a different tool: it runs `rugnux --model` over the open arm (same inputs, same
 site config) and compares the R-free that rugnux itself reports with the published value. It needs
@@ -179,7 +183,7 @@ This is a flat list with one object per set, and every arm uses the same keys. M
 | `d_min_ref_rule`, `d_min_xds` | XDS arms: how `d_min_ref` was derived (below), and the range XDS merged |
 | `r_meas`, `cc_half`, `isa`, `completeness`, `multiplicity`, `i_over_sigma`, `indexing_rate`, `images` | from rugnux's `_report.txt` |
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref` | XDS's overall values, over XDS's own range |
-| `rfree`, `rwork`, `rfree_deposited`, `rfree_ratio`, `model_status`, `model_reason` | the model check (open arm) |
+| `rfree`, `rwork`, `rfree_deposited`, `rfree_depflags`, `rfree_depdata`, `rfree_ratio`, `model_status`, `model_reason` | the model check (open arm) |
 | `wall_s`, `rugnux_wall_s`, `elapsed_s`, `exit_code`, `gpu_others`, `rugnux_verdict` | timing (`wall_s` is rugnux's own WALL_TIME, not the time spent waiting for the GPU queue), the exit code, other GPU processes seen before the set, and rugnux's own verdict line |
 
 ## The report
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index ceed6ed20..b369d949e 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -191,7 +191,7 @@ def run_one(run_dir, binary, e, opts):
     os.makedirs(wd)
     row = {"set": e["id"], "arm": e["arm"], "tags": e.get("tags", []), "input": e["input_path"],
            "gpu_others": gpu_others(), "rfree": None, "rwork": None, "rfree_deposited": None,
-           "rfree_ratio": None, "model_status": None, "model_reason": None}
+           "rfree_depflags": None, "rfree_depdata": None, "rfree_ratio": None, "model_status": None, "model_reason": None}
     if not os.path.exists(e["input_path"]):
         row.update(score.judge(e, {}, "no input"), exit_code=None, elapsed_s=None, wall_s=None, cmd=None)
         return row
@@ -221,7 +221,8 @@ def run_one(run_dir, binary, e, opts):
 def check_model(e, wd):
     """R-free of the deposited model against this run's merge (model_check.py). A set id may
     carry a suffix (6h2p_native); the PDB entry is the part before it."""
-    out = {"rfree": None, "rwork": None, "rfree_deposited": None, "rfree_ratio": None}
+    out = {"rfree": None, "rwork": None, "rfree_deposited": None, "rfree_depflags": None,
+           "rfree_depdata": None, "rfree_ratio": None}
     pdb = e["id"].split("_")[0]
     mtz = os.path.join(wd, "p.mtz")
     if not PDB_ID.match(pdb):
@@ -232,10 +233,14 @@ def check_model(e, wd):
         res = model_check.check(mtz, pdb, os.path.join(wd, "model_check"))
     except Exception as ex:          # a failing check must not lose the set's processing result
         return dict(out, model_status="error", model_reason=f"{type(ex).__name__}: {ex}"[:300])
-    out.update({k: res.get(k) for k in ("rfree", "rwork", "rfree_deposited")},
+    out.update({k: res.get(k) for k in ("rfree", "rwork", "rfree_deposited", "rfree_depflags",
+                                        "rfree_depdata")},
                model_status=res.get("status"), model_reason=res.get("reason"))
-    if out["rfree"] and out["rfree_deposited"]:
-        out["rfree_ratio"] = round(out["rfree"] / out["rfree_deposited"], 4)
+    # The fair ratio: our merge and the depositor's structure factors, both scored on the
+    # depositor's free set by the same protocol. Our own free set was mostly work reflections
+    # for the depositor, so R_free on it reads low.
+    if out["rfree_depflags"] and out["rfree_depdata"]:
+        out["rfree_ratio"] = round(out["rfree_depflags"] / out["rfree_depdata"], 4)
     return out
 
 
diff --git a/tools/battery/report.py b/tools/battery/report.py
index fb4f6eef6..0acad8427 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -268,12 +268,13 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                     f"{arm}: d_min(rugnux) / d_min(reference), one point per set, sorted; below 1 = "
                     "finer than the reference")
     pts = [(r["set"], r["rfree_ratio"], r["verdict"],
-            f"R_free {r['rfree']:.3f} vs deposited {r['rfree_deposited']:.3f}")
+            f"R_free {r['rfree_depflags']:.3f} vs {r['rfree_depdata']:.3f} on the deposited data")
            for r in res if r.get("rfree_ratio")]
     if pts:
         doc.svg(ratio_dots(pts, "R_free ratio"),
-                "open: R_free of the deposited model against our merge / the deposited R_free, one "
-                "point per set, sorted; below 1 = our data fit the model better")
+                "open: R_free of the deposited model against our merge / against the deposited structure "
+                "factors, both on the depositor's free set with the same protocol, one point per set, "
+                "sorted; below 1 = our data fit the model better")
 
     derived = [r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"]
     if derived:
-- 
2.54.0


From 99123f33df5130b7725ed4d726ee96d4ac058277 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:48:12 +0200
Subject: [PATCH 010/122] Twinning: normalised L-test, and one verdict read in
 every Laue class

The L-test now divides each intensity by its resolution-shell mean before
forming pairs, over the shells whose <I/sigma> reaches 1 (the floor the
second moment already used). Two index steps are not the same resolution,
and on a small cell with a steep fall-off the raw pairs read <|L|> up to
0.08 high: an untwinned crystal 0.568 and a partial twin 0.427 where
phenix.xtriage reads 0.486 and 0.360. Normalised, the four reference merges
(6toc, 6iu9, 5j23, a lysozyme) agree with xtriage within 0.02 (0.487,
0.376, 0.374, 0.480). Selection stays by shell, never by the reflection's
own I/sigma, which biases <|L|> down. Equal-count shells were tried for
the second moment and widen its gap to xtriage, so the shells are kept.

The L-test is no longer switched off in holohedral Laue classes. Merging
I(h) with I(Th) under a false operator gives (I(h)+I(Th))/2 for every twin
fraction, the perfect-twin distribution, so <|L|> < 0.42 there is reported
as an adopted operator averaging unequal intensities (promotion suspect, or
a twin law absorbed into the point group) - a warning, not a veto. Over 42
holohedral merges of the corpus the genuine ones read 0.436-0.513, the
over-promoted H3 twin 0.374, and one ~490 A-axis crystal 0.365.

The verdict is one line (TwinningVerdictLine) used by the stats text, the
report prose, the summary row, the warning and the viewer; a new
TWINNING_VERDICT key names it. The twin fraction comes from the statistic
that carries the verdict (the L-test unless the call rests on the second
moment alone), is not quoted from a second moment under a detected
pseudo-translation, and is not quoted at all on a merge under a suspect
operator.

The pre-search numbers (measured on the P1 search merge) are user-visible,
are measured with that merge's own pseudo-translation declared, and leave
out the reflections the lattice centring extinguishes - an R lattice in
its hexagonal cell otherwise pairs present with absent reflections (5j23:
0.633 with them, 0.40 without).

Report-only: no space-group decision, merge or intensity changes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/CPU_DATA_ANALYSIS_DECISIONS.md           |   2 +-
 .../scale_merge/TwinningAnalysis.cpp          | 380 ++++++++++++------
 image_analysis/scale_merge/TwinningAnalysis.h |  37 +-
 rugnux/ResultReport.cpp                       | 110 ++---
 rugnux/Rugnux.cpp                             |  15 +-
 rugnux/Rugnux.h                               |   3 +
 tests/TwinningAnalysisTest.cpp                | 100 ++++-
 viewer/windows/JFJochMergeStatsWindow.cpp     |   6 +-
 8 files changed, 459 insertions(+), 194 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_DECISIONS.md b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
index 27181699b..7ab356908 100644
--- a/docs/CPU_DATA_ANALYSIS_DECISIONS.md
+++ b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
@@ -52,7 +52,7 @@ Both search merges also drop the **frames whose fitted per-frame scale came out
 
 ### 13.2 Twinning check, and translational pseudo-symmetry
 
-A Padilla–Yeates $L$-test ($\langle|L|\rangle$, $\langle L^2\rangle$ — 0.500 and 0.333 untwinned, 0.375 and 0.200 for a perfect twin) and the second moment $\langle I^2\rangle/\langle I\rangle^2$ (2.0 for untwinned acentric data, 1.5 for a perfect twin; taken per resolution shell with noise-only shells skipped and Wilson outliers rejected, so a single strong reflection in a collapsed-mean shell cannot skew it) are written to the merged mmCIF as a twinning diagnostic. A merohedral twin law exists only where the Laue class is a proper subgroup of the lattice holohedry, so in the high-symmetry holohedral classes ($4/mmm$, $6/mmm$, $m\bar{3}m$, and $\bar{3}m$ on a rhombohedral lattice) twinning is never flagged, and a low $\langle|L|\rangle$ there is reported as a statistical artefact instead. The low-symmetry holohedral classes ($\bar{1}$, $2/m$, $mmm$) also admit no strictly merohedral law, but they stay eligible for the flag on purpose: *pseudo*-merohedral twinning through an accidentally special metric cannot be ruled out from the symmetry alone, and those are the classes it happens in.
+A Padilla–Yeates $L$-test ($\langle|L|\rangle$, $\langle L^2\rangle$ — 0.500 and 0.333 untwinned, 0.375 and 0.200 for a perfect twin) and the second moment $\langle I^2\rangle/\langle I\rangle^2$ (2.0 for untwinned acentric data, 1.5 for a perfect twin) are written to the merged mmCIF as a twinning diagnostic. Both are taken on intensities divided by their resolution-shell mean, over the shells whose $\langle I/\sigma\rangle$ reaches 1, with Wilson outliers rejected; the $L$-test pairs are therefore compared on one scale even where two index steps span a steep fall-off, as in phenix.xtriage and ctruncate, and the selection is by shell, never by the individual reflection's $I/\sigma$, which would cut the weak tail and bias $\langle|L|\rangle$ down. The twin fraction is quoted from the statistic that carries the verdict — the $L$-test unless the call rests on the second moment alone — and a second moment is not turned into a fraction under a detected pseudo-translation, which inflates it. A merohedral twin law exists only where the Laue class is a proper subgroup of the lattice holohedry, so in the high-symmetry holohedral classes ($4/mmm$, $6/mmm$, $m\bar{3}m$, and $\bar{3}m$ on a rhombohedral lattice) no twin is called. The $L$-test is still read there, for a different question: merging $I(h)$ with $I(Th)$ under a false operator $T$ gives $(I(h)+I(Th))/2$ whatever the twin fraction, which has the perfect-twin distribution, so $\langle|L|\rangle$ below 0.42 in a holohedral class is reported as **an adopted operator averaging unequal intensities** — the space group is too high, or a twin law was absorbed into the point group — a warning, never a change to the space group. A genuine operator leaves the untwinned 0.5. Reflections that overlap along a very long axis narrow the distribution the same way, which is one reason it stays a warning. The same numbers measured on the P1 merge the space-group search was given, before any point group was adopted, are reported beside them (`_BEFORE_SEARCH`), with that merge's own pseudo-translation declared and the reflections its lattice centring extinguishes left out. The low-symmetry holohedral classes ($\bar{1}$, $2/m$, $mmm$) also admit no strictly merohedral law, but they stay eligible for the twin call on purpose: *pseudo*-merohedral twinning through an accidentally special metric cannot be ruled out from the symmetry alone, and those are the classes it happens in.
 
 **Translational pseudo-symmetry** — two copies of the contents of the asymmetric unit related by a pure translation that is not a lattice vector — is looked for on every merging run, because it is the classic predictor of a failed molecular replacement, and because it raises the second moment where twinning lowers it, so each can mask the other's test. The detection is the native-Patterson route of Read, Adams & McCoy (see the [references](CPU_DATA_ANALYSIS.md#references)): the largest off-origin peak of a Patterson computed from the merged intensities, as a fraction of the origin peak, with the peak vector then refined against the intensity modulation it should produce — the ratio of the strongest to the weakest bin mean of $\langle E^2\rangle$ over the phase $\mathrm{frac}(\mathbf{h}\cdot\mathbf{u})$. Both halves are scored against a null computed for the crystal at hand rather than against a fixed bound — both against the same intensities **permuted within resolution shells** — the peak against that map, the modulation against the same measurement made on the shuffled intensities and started where the measurement starts — because the noise floor of the peak statistic spans an order of magnitude across data sets, so no fixed percentage means the same thing twice. The shuffle leaves the reflection count, the $E^2$ distribution and the phase-bin populations untouched and removes only the correlation between a reflection's intensity and $\mathbf{h}\cdot\mathbf{u}$, which is the thing the modulation claims to see. Re-running the greedy search from random starting vectors over the *same* intensities does not work as a control: a greedy search started anywhere walks into a real modulation's basin, so it measures the search **and** whatever modulation the crystal carries — measured over 110 merged datasets, single draws of that control reached 199× and 6162× on crystals whose own modulation reads 4.0× and 67×, and on 28 of the 110 it came out at or above the signal it is subtracted from. Requiring both halves is what keeps the false-positive rate down; either alone over-calls by about a factor of two. A translation the merged data are **exactly** invariant under is reported as an undeclared lattice translation instead — a translation the data are exactly invariant under is a lattice vector by definition, so the centring or the cell is wrong, not the packing — and the pseudo-symmetry search continues underneath it, so a real pseudo-translation sitting under an undeclared centring is still found. The finding itself is report-only (the `TNCS_*` keys of `<prefix>_report.txt`): it gates nothing and changes no reflection, no scale and no group — but the axial-absence test (§13.1) and the $L$-test here both correct themselves against the modulation it measures.
 
diff --git a/image_analysis/scale_merge/TwinningAnalysis.cpp b/image_analysis/scale_merge/TwinningAnalysis.cpp
index 0a16c3cde..6f96e9ab2 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.cpp
+++ b/image_analysis/scale_merge/TwinningAnalysis.cpp
@@ -29,6 +29,33 @@ namespace {
     // admit no such operation, so twinning is geometrically impossible and the intensity statistics
     // cannot be indicating it. Low-symmetry classes stay eligible because pseudo-merohedral twinning
     // through an accidental metric specialisation cannot be excluded from the symmetry alone.
+    // <|L|> of a partial twin with fraction a: I = (1-a) X + a Y for independent Wilson X, Y, and the
+    // expectation of |I1 - I2|/(I1 + I2) over two independent such intensities, integrated in closed
+    // form (0.500 at a = 0, 0.440 at 0.1, 0.408 at 0.2, 0.375 at 0.5; checked by simulation, and
+    // the relation ctruncate tabulates).
+    double MeanAbsLForTwinFraction(double a) {
+        const double p = 1.0 - a, q = a;
+        const double A = 1.0 / q, B = 1.0 / p - 1.0 / q;
+        auto F = [&](double t) { return 2.0 / (B * B) * std::log(A + B * t) + (2.0 * A / B + 1.0) / (B * (A + B * t)); };
+        const double J = F(1.0) + F(0.0) - 2.0 * F(0.5);
+        return ((p * p + q * q) / 2.0 - 2.0 * J) / ((p - q) * (p - q));
+    }
+
+    // The inverse, by bisection: the relation is monotonic, and flat near a = 0.5, where <|L|> can no
+    // longer tell 0.4 from 0.5.
+    double TwinFractionFromMeanAbsL(double mean_abs_l) {
+        double lo = 1e-4, hi = 0.4999;
+        if (mean_abs_l >= MeanAbsLForTwinFraction(lo))
+            return 0.0;
+        if (mean_abs_l <= MeanAbsLForTwinFraction(hi))
+            return 0.5;
+        for (int i = 0; i < 50; ++i) {
+            const double mid = 0.5 * (lo + hi);
+            (MeanAbsLForTwinFraction(mid) > mean_abs_l ? lo : hi) = mid;
+        }
+        return 0.5 * (lo + hi);
+    }
+
     bool MerohedralTwinningPossible(const gemmi::SpaceGroup* sg) {
         if (!sg)
             return true;                    // P1 / unknown symmetry: cannot rule twinning out
@@ -47,7 +74,7 @@ namespace {
 
 TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merged,
                                        const gemmi::SpaceGroup* space_group, int resolution_shells,
-                                       const std::array<double, 3>* tncs_vector) {
+                                       const std::array<double, 3>* tncs_vector, char lattice_centring) {
     TwinningAnalysisResult result;
     if (merged.empty())
         return result;
@@ -58,6 +85,108 @@ TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merg
     auto acentric = [&](const MergedReflection& r) {
         return !space_group || !gops.is_reflection_centric(gemmi::Op::Miller{{r.h, r.k, r.l}});
     };
+    // A merge in P1 of a centred lattice still holds the reflections the centring extinguishes (an
+    // R lattice indexed in its hexagonal cell keeps the two thirds with -h+k+l != 3n). They are
+    // noise, not intensities, and an L-test partner step that crosses into them pairs a real
+    // reflection with an absent one. So they are left out of both statistics.
+    gemmi::GroupOps centring;
+    centring.sym_ops = {gemmi::Op::identity()};
+    centring.cen_ops = gemmi::centring_vectors(lattice_centring);
+    auto used = [&](const MergedReflection& r) {
+        return UsableIntensity(r) && acentric(r)
+               && !centring.is_systematically_absent(gemmi::Op::Miller{{r.h, r.k, r.l}});
+    };
+
+    // --- Resolution shells: the normalising mean of both statistics ---
+    // Binning by 1/d^2 removes the resolution fall-off, so the second moment is 2.0 (untwinned) or 1.5
+    // (perfect twin) regardless of the overall B-factor, and an L-test pair compares two intensities
+    // on the same scale. The moment divides by the *square* of the shell-mean intensity, so it is not
+    // robust: on weak or mis-integrated data a shell mean can collapse to the noise floor and one
+    // outlier reflection then dominates (I/mean)^2 (a single I=158 in a mean~1 shell contributed 78% of
+    // a whole dataset's value). To keep these twinning indicators rather than data-quality artefacts -
+    // as phenix.xtriage does - we skip noise-only shells (<I/sigma> below 1) and reject Wilson outliers
+    // (E^2 above 8, ~exp(-8) upper tail) with one shell-mean re-iteration so the outlier does not
+    // corrupt the normalising mean either.
+    //
+    // The shells are equal in width in 1/d^2. Equal-COUNT shells were measured as the alternative
+    // (the first equal-width shell spans a wide range of d, and its fall-off inflates the moment):
+    // they move the moment the wrong way on the same data, widening its gap to phenix.xtriage by
+    // 0.01-0.04 rather than closing it, so the shells were kept as they are.
+    constexpr double min_shell_isig = 1.0;     // shells below this are noise, not signal
+    constexpr double wilson_outlier_e2 = 8.0;  // reject improbably strong reflections (P ~ e^-8)
+    const int n_shells = std::max(1, resolution_shells);
+    double min_s = std::numeric_limits<double>::infinity();
+    double max_s = -std::numeric_limits<double>::infinity();
+    for (const auto& r : merged) {
+        if (!used(r))
+            continue;
+        const double s = 1.0 / (r.d * r.d);
+        min_s = std::min(min_s, s);
+        max_s = std::max(max_s, s);
+    }
+    if (!std::isfinite(min_s) || !(max_s > min_s))
+        return result;
+    auto shell_of = [&](double d) {
+        const double t = (1.0 / (d * d) - min_s) / (max_s - min_s);
+        return std::min(n_shells - 1, std::max(0, static_cast<int>(t * n_shells)));
+    };
+    // Group intensities by shell, and accumulate <I/sigma> to gauge each shell's signal.
+    std::vector<std::vector<double>> shell_I(n_shells);
+    std::vector<double> shell_isig_sum(n_shells, 0.0);
+    std::vector<int> shell_isig_n(n_shells, 0);
+    for (const auto& r : merged) {
+        if (!used(r))
+            continue;
+        const int b = shell_of(r.d);
+        shell_I[b].push_back(r.I);
+        if (std::isfinite(r.sigma) && r.sigma > 0.0) {
+            shell_isig_sum[b] += r.I / r.sigma;
+            shell_isig_n[b] += 1;
+        }
+    }
+    // The mean intensity of each shell that carries signal; 0 marks a shell that does not.
+    std::vector<double> shell_mean(n_shells, 0.0);
+    for (int b = 0; b < n_shells; ++b) {
+        const auto& intensities = shell_I[b];
+        if (intensities.empty() || shell_isig_n[b] == 0
+            || shell_isig_sum[b] / shell_isig_n[b] < min_shell_isig)
+            continue;
+        double sum = 0.0;
+        for (double I : intensities)
+            sum += I;
+        const double mean = sum / intensities.size();
+        if (mean <= 0.0)
+            continue;
+        // Re-fit the mean over the reflections that pass the outlier cut, so the outlier does not
+        // inflate the very mean it is measured against.
+        sum = 0.0;
+        int n_kept = 0;
+        for (double I : intensities)
+            if (I / mean <= wilson_outlier_e2) {
+                sum += I;
+                ++n_kept;
+            }
+        if (n_kept > 0 && sum > 0.0)
+            shell_mean[b] = sum / n_kept;
+    }
+
+    // --- Second moment <I^2>/<I>^2 of acentric intensities, normalised per resolution shell ---
+    double sum_e4 = 0.0;
+    int n_moment = 0;
+    for (int b = 0; b < n_shells; ++b) {
+        if (shell_mean[b] <= 0.0)
+            continue;
+        for (double I : shell_I[b]) {
+            const double e2 = I / shell_mean[b];
+            if (e2 > wilson_outlier_e2)
+                continue;
+            sum_e4 += e2 * e2;
+            ++n_moment;
+        }
+    }
+    result.moment_reflections = n_moment;
+    if (n_moment > 0)
+        result.second_moment = sum_e4 / n_moment;
 
     // --- L-test ---
     // Following Padilla & Yeates (2003) Acta Cryst. D59, 1124-1130
@@ -66,11 +195,24 @@ TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merg
     // merged reflections are unique in the asymmetric unit, so any other merged reflection is
     // genuinely non-equivalent - exactly the pairing the L-test wants. Only acentric reflections
     // with positive intensity enter, which also keeps L = (I1-I2)/(I1+I2) bounded in [-1, 1].
+    //
+    // The test assumes the two members of a pair have the same EXPECTED intensity, and two index
+    // steps are not the same resolution: on a small cell with a large B the pair's expected
+    // intensities differ by up to a factor ~3 at 2 A, which pushes <|L|> up by as much as 0.08 (an
+    // untwinned crystal read 0.568, a partial twin 0.427 where phenix.xtriage reads 0.486 and 0.360).
+    // So each intensity is divided by its shell mean first, as xtriage and ctruncate do, and only the
+    // shells the second moment reads enter. The selection stays on the SHELL: cutting individual
+    // reflections on their own I/sigma removes the weak tail of every shell and biases <|L|> down
+    // (the same untwinned crystal reads 0.423 with I/sigma > 2).
     std::unordered_map<int64_t, double> intensity;
     intensity.reserve(merged.size() * 2);
-    for (const auto& r : merged)
-        if (UsableIntensity(r) && r.I > 0.0 && acentric(r))
-            intensity.emplace(PackHKL(r.h, r.k, r.l), r.I);
+    for (const auto& r : merged) {
+        if (!used(r) || r.I <= 0.0)
+            continue;
+        const double mean = shell_mean[shell_of(r.d)];
+        if (mean > 0.0)
+            intensity.emplace(PackHKL(r.h, r.k, r.l), r.I / mean);
+    }
 
     // Step to a nearby, symmetry-independent partner. The axis step of 2 is load-bearing for TWO
     // reasons, and only the first was ever written down.
@@ -165,98 +307,20 @@ TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merg
         run_l_test(all_steps);
     }
 
-    // --- Second moment <I^2>/<I>^2 of acentric intensities, normalised per resolution shell ---
-    // Binning by 1/d^2 removes the resolution fall-off, so the moment is 2.0 (untwinned) or 1.5
-    // (perfect twin) regardless of the overall B-factor. The moment divides by the *square* of the
-    // shell-mean intensity, so it is not robust: on weak or mis-integrated data a shell mean can
-    // collapse to the noise floor and one outlier reflection then dominates (I/mean)^2 (a single
-    // I=158 in a mean~1 shell contributed 78% of a whole dataset's value). To keep this a twinning
-    // indicator rather than a data-quality artefact - as phenix.xtriage does - we skip noise-only
-    // shells (<I/sigma> below 1) and reject Wilson outliers (E^2 above 8, ~exp(-8) upper tail) with
-    // one shell-mean re-iteration so the outlier does not corrupt the normalising mean either.
-    constexpr double min_shell_isig = 1.0;     // shells below this are noise, not signal
-    constexpr double wilson_outlier_e2 = 8.0;  // reject improbably strong reflections (P ~ e^-8)
-    int n_shells = std::max(1, resolution_shells);
-    double min_s = std::numeric_limits<double>::infinity();
-    double max_s = -std::numeric_limits<double>::infinity();
-    for (const auto& r : merged) {
-        if (!UsableIntensity(r) || !acentric(r))
-            continue;
-        const double s = 1.0 / (r.d * r.d);
-        min_s = std::min(min_s, s);
-        max_s = std::max(max_s, s);
-    }
-    if (std::isfinite(min_s) && max_s > min_s) {
-        auto shell_of = [&](double d) {
-            const double t = (1.0 / (d * d) - min_s) / (max_s - min_s);
-            return std::min(n_shells - 1, std::max(0, static_cast<int>(t * n_shells)));
-        };
-        // Group acentric intensities by shell, and accumulate <I/sigma> to gauge each shell's signal.
-        std::vector<std::vector<double>> shell_I(n_shells);
-        std::vector<double> shell_isig_sum(n_shells, 0.0);
-        std::vector<int> shell_isig_n(n_shells, 0);
-        for (const auto& r : merged) {
-            if (!UsableIntensity(r) || !acentric(r))
-                continue;
-            const int b = shell_of(r.d);
-            shell_I[b].push_back(r.I);
-            if (std::isfinite(r.sigma) && r.sigma > 0.0) {
-                shell_isig_sum[b] += r.I / r.sigma;
-                shell_isig_n[b] += 1;
-            }
-        }
-
-        double sum_e4 = 0.0;
-        int n_moment = 0;
-        for (int b = 0; b < n_shells; ++b) {
-            const auto& intensities = shell_I[b];
-            if (intensities.empty() || shell_isig_n[b] == 0
-                || shell_isig_sum[b] / shell_isig_n[b] < min_shell_isig)
-                continue;
-
-            double sum = 0.0;
-            for (double I : intensities)
-                sum += I;
-            double mean = sum / intensities.size();
-            if (mean <= 0.0)
-                continue;
-            // Re-fit the mean over the reflections that pass the outlier cut, so the outlier does not
-            // inflate the very mean it is measured against.
-            sum = 0.0;
-            int n_kept = 0;
-            for (double I : intensities)
-                if (I / mean <= wilson_outlier_e2) {
-                    sum += I;
-                    ++n_kept;
-                }
-            if (n_kept == 0)
-                continue;
-            mean = sum / n_kept;
-            if (mean <= 0.0)
-                continue;
-
-            for (double I : intensities) {
-                const double e2 = I / mean;
-                if (e2 > wilson_outlier_e2)
-                    continue;
-                sum_e4 += e2 * e2;
-                ++n_moment;
-            }
-        }
-        result.moment_reflections = n_moment;
-        if (n_moment > 0)
-            result.second_moment = sum_e4 / n_moment;
-    }
-
-    // Twin fraction from the second moment M = 2(1 - a + a^2): a = (1 - sqrt(2M-3))/2.
-    if (result.second_moment > 0.0) {
-        const double m = std::clamp(result.second_moment, 1.5, 2.0);
-        result.estimated_twin_fraction = (1.0 - std::sqrt(std::max(0.0, 2.0 * m - 3.0))) / 2.0;
-    }
-    // Either indicator dropping clearly below its untwinned value is suspicious - but only where a twin
-    // law can actually exist. In a holohedral Laue class (e.g. 422) no merohedral twinning is
-    // possible, so a low <|L|> is a statistical artefact (correlated near-neighbours) rather than a
-    // twin, and must not be flagged.
+    // Either indicator dropping clearly below its untwinned value is suspicious - in every Laue
+    // class, holohedral ones included. A holohedral class admits no twin law WITHIN it, so there a low
+    // reading does not mean "twinned in this group"; it means an operator of the group averages
+    // intensities that are not equal. Merging I(h) with I(Th) under a false operator T gives
+    // (I(h) + I(Th))/2 for every twin fraction - the fraction cancels - so a merge under a false
+    // operator has the perfect-twin distribution by construction, whether the crystal is an untwinned
+    // pseudo-symmetric one, a partial twin or a perfect twin, and only a genuine operator leaves it
+    // at the untwinned 0.5. Noise cannot fake it (with the I > 0 selection it pushes <|L|> towards
+    // ~0.43, not 0.375) and a pseudo-translation pushes the second moment UP. Measured over 42
+    // holohedral merges of the corpus, the genuine ones read <|L|> 0.436-0.513 and the one
+    // over-promotion (an H3 twin merged in R32) 0.374. One more reads low, 0.365: a crystal with a
+    // ~490 A axis, whose neighbouring reflections overlap and share counts - averaging of another
+    // kind, which narrows the distribution the same way. That is why this is a warning and never a
+    // veto on the space group.
     result.merohedral_twinning_possible = MerohedralTwinningPossible(space_group);
     // The two indicators can only move one way under twinning: <|L|> down from 0.500 towards 0.375,
     // the second moment down from 2.0 towards 1.5. A narrow intensity distribution sitting next to an
@@ -282,9 +346,39 @@ TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merg
     // alone, and the text says the L-test could not be read. This REMOVES a veto; it never adds one.
     const bool l_test_usable = result.l_test_pairs > 0 && !result.l_test_contaminated_by_tncs;
     const bool l_test_contradicts_twin = l_test_usable && result.mean_abs_l >= 0.50;
-    result.twinning_suspected = result.merohedral_twinning_possible && !l_test_contradicts_twin &&
-                                ((l_test_usable && result.mean_abs_l < 0.44) ||
-                                 (result.moment_reflections > 0 && result.second_moment < 1.85));
+    const bool l_test_low = l_test_usable && result.mean_abs_l < 0.44;
+    const bool moment_low = result.moment_reflections > 0 && result.second_moment < 1.85;
+    if (result.merohedral_twinning_possible)
+        result.twinning_suspected = !l_test_contradicts_twin && (l_test_low || moment_low);
+    else {
+        // In a holohedral class the alternative is not a partial twin anywhere between 0.5 and 0.375
+        // but a false operator, which puts <|L|> at the perfect-twin 0.375 itself - so the bar sits
+        // nearer that value. Measured on the corpus (normalised L-test): the weakest genuine
+        // holohedral crystal reads 0.436, the over-promoted twin 0.374. The second moment does not
+        // enter here: it is the statistic a pseudo-translation inflates (that same twin read 2.08,
+        // the untwinned value), and it is the one a pseudo-cubic lattice in a 4/mmm group, whose twin
+        // law lies OUTSIDE the Laue class, pulls down (1.66 beside an untwinned <|L|>).
+        result.adopted_operators_suspect = l_test_usable && result.mean_abs_l < 0.42;
+        result.twinning_suspected = result.adopted_operators_suspect;
+    }
+
+    // The twin fraction, from the statistic that carries the verdict. Merged under a false operator
+    // the fraction is lost (see above), so none is quoted there. Otherwise the L-test, which is local
+    // and so indifferent to anisotropy and to a pseudo-translation it has been repaired for, unless
+    // the call rests on the second moment alone. The second moment is not quoted under a detected
+    // pseudo-translation, which inflates it: an H3 twin with tNCS read 2.08, the untwinned value,
+    // beside a perfect-twin <|L|>.
+    if (!result.adopted_operators_suspect) {
+        if (l_test_usable && (l_test_low || !moment_low)) {
+            result.estimated_twin_fraction = TwinFractionFromMeanAbsL(result.mean_abs_l);
+            result.twin_fraction_source = TwinFractionSource::LTest;
+        } else if (result.moment_reflections > 0 && tncs_vector == nullptr) {
+            // M = 2(1 - a + a^2): a = (1 - sqrt(2M-3))/2.
+            const double m = std::clamp(result.second_moment, 1.5, 2.0);
+            result.estimated_twin_fraction = (1.0 - std::sqrt(std::max(0.0, 2.0 * m - 3.0))) / 2.0;
+            result.twin_fraction_source = TwinFractionSource::SecondMoment;
+        }
+    }
     return result;
 }
 
@@ -310,34 +404,46 @@ std::string TwinningAnalysisToText(const TwinningAnalysisResult& result) {
     if (result.moment_reflections > 0)
         os << "  Second moment <I^2>/<I>^2 = " << result.second_moment
            << "  [untwinned 2.00, perfect twin 1.50]\n";
-    if (result.twinning_suspected && result.estimated_twin_fraction > 0.01)
-        os << "  => Twinning suspected (estimated twin fraction ~"
-           << result.estimated_twin_fraction << "). Statistics flag the presence of twinning, not\n"
-           << "     the twin law; the law itself is a question for a dedicated twin-law analysis.\n";
-    else if (result.twinning_suspected)
-        // The fraction is derived from the second moment alone, so a twin called by the L-test on a
-        // crystal whose second moment sits at or above its untwinned value has no fraction to quote -
-        // printing the 0.000 the formula returns would contradict the sentence it sits in. The
-        // disagreement is worth stating, and where a pseudo-symmetry is present it has a named cause.
-        os << "  => Twinning suspected on the L-test. The second moment does not agree ("
-           << result.second_moment << ", at or\n"
-           << "     above its untwinned 2.00), so no twin fraction is quoted"
-           << (result.l_test_tncs_step_restricted
-                       ? " - and this\n"
-                         "     crystal's translational pseudo-symmetry is a known reason for the second\n"
-                         "     moment to run high, so the L-test carries the verdict here.\n"
-                       : ".\n")
-           << "     Statistics flag the presence of twinning, not the twin law; the law itself is\n"
-           << "     a question for a dedicated twin-law analysis.\n";
-    else if (!result.merohedral_twinning_possible && result.laue_class_was_chosen_by_promotion)
-        os << "  => Cannot rule out twinning from these numbers: the Laue class is holohedral, so no\n"
-           << "     merohedral twin law exists WITHIN it - but this Laue class was chosen by the\n"
-           << "     space-group search itself, and promoting into a twin's holohedry is precisely what\n"
-           << "     a merohedral twin looks like. The subgroup statistics reported by the search,\n"
-           << "     not these numbers, are where the twinning is decided.\n";
+    const bool l_test_read = result.l_test_pairs > 0 && !result.l_test_contaminated_by_tncs;
+    if (result.adopted_operators_suspect)
+        os << "  => An adopted operator relates UNEQUAL intensities. The Laue class is holohedral, so no\n"
+           << "     twin law exists within it - yet the intensities read like a twin's, and merging under\n"
+           << "     a false operator produces exactly that distribution, whatever the twin fraction.\n"
+           << (result.laue_class_was_chosen_by_promotion
+                       ? "     This class was chosen by the space-group search: the promotion is suspect.\n"
+                       : "     The space group in use is higher than these intensities support.\n")
+           << "     Either the crystal has lower symmetry, or it is a twin whose law the point group has\n"
+           << "     absorbed; either way it has to be refined in a subgroup. The twin fraction cannot be\n"
+           << "     measured on this merge.\n";
+    else if (result.twinning_suspected) {
+        os << "  => Twinning suspected";
+        if (result.twin_fraction_source == TwinFractionSource::LTest)
+            os << " (estimated twin fraction ~" << result.estimated_twin_fraction << ", from the L-test)";
+        else if (result.twin_fraction_source == TwinFractionSource::SecondMoment)
+            os << " (estimated twin fraction ~" << result.estimated_twin_fraction
+               << ", from the second moment)";
+        else
+            os << " on the second moment; no twin fraction is quoted, because this crystal's\n"
+               << "     pseudo-translation inflates the second moment and <|L|> does not agree";
+        os << ".\n";
+        if (l_test_read && result.mean_abs_l < 0.44 && result.moment_reflections > 0
+            && result.second_moment >= 1.85)
+            os << "     The second moment does not agree (" << result.second_moment << ")"
+               << (result.l_test_tncs_step_restricted
+                           ? " - this crystal's translational pseudo-symmetry is a known reason for it\n"
+                             "     to run high, so the L-test carries the verdict here.\n"
+                           : ".\n");
+        os << "     Statistics flag the presence of twinning, not the twin law; the law itself is a\n"
+           << "     question for a dedicated twin-law analysis.\n";
+    } else if (!result.merohedral_twinning_possible && result.laue_class_was_chosen_by_promotion)
+        os << "  => No twinning indicated. The Laue class is holohedral, so no twin law exists within it,\n"
+           << "     and it was chosen by the space-group search - but its operators read as genuine: a\n"
+           << "     merge under a false operator has the perfect-twin distribution, not the untwinned one\n"
+           << "     measured here. An operator that is only APPROXIMATE (non-crystallographic symmetry\n"
+           << "     along it) also passes; the subgroup statistics reported by the search speak to that.\n";
     else if (!result.merohedral_twinning_possible)
-        os << "  => No twinning: the Laue class is holohedral, so no merohedral twin law exists\n"
-           << "     (any <|L|> below 0.5 here is a statistical artefact, not twinning).\n";
+        os << "  => No twinning: the Laue class is holohedral, so no merohedral twin law exists, and no\n"
+           << "     operator of it averages unequal intensities.\n";
     else if (result.l_test_contaminated_by_tncs)
         os << "  => No twinning indicated by the second moment. The L-test, which is normally the\n"
            << "     stronger of the two, could not be read on this crystal (see above), so this is a\n"
@@ -347,3 +453,25 @@ std::string TwinningAnalysisToText(const TwinningAnalysisResult& result) {
         os << "  => No twinning indicated.\n";
     return os.str();
 }
+
+std::string TwinningVerdictLine(const TwinningAnalysisResult& result) {
+    std::ostringstream os;
+    os << std::fixed << std::setprecision(3);
+    const bool l_test_read = result.l_test_pairs > 0 && !result.l_test_contaminated_by_tncs;
+    if (result.adopted_operators_suspect)
+        os << "SYMMETRY SUSPECT (<|L|> " << result.mean_abs_l << ", second moment "
+           << std::setprecision(2) << result.second_moment
+           << ": an adopted operator averages unequal intensities)";
+    else if (result.twinning_suspected) {
+        os << "INDICATED (<|L|> " << result.mean_abs_l;
+        if (result.twin_fraction_source != TwinFractionSource::None)
+            os << std::setprecision(2) << ", twin fraction ~" << result.estimated_twin_fraction << " from the "
+               << (result.twin_fraction_source == TwinFractionSource::LTest ? "L-test" : "second moment");
+        os << ")";
+    } else if (l_test_read)
+        os << "no indication (<|L|> " << result.mean_abs_l << ")";
+    else
+        os << "no indication (second moment " << std::setprecision(2) << result.second_moment
+           << "; <|L|> not readable)";
+    return os.str();
+}
diff --git a/image_analysis/scale_merge/TwinningAnalysis.h b/image_analysis/scale_merge/TwinningAnalysis.h
index 538f9a1ff..965c4da89 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.h
+++ b/image_analysis/scale_merge/TwinningAnalysis.h
@@ -10,18 +10,23 @@
 #include "../../common/Reflection.h"
 #include "gemmi/symmetry.hpp"
 
-// Intensity-statistics test for merohedral twinning, in the spirit of phenix.xtriage. Two robust,
-// normalisation-free indicators on the merged intensities:
+// Intensity-statistics test for merohedral twinning, in the spirit of phenix.xtriage. Two
+// indicators on the merged intensities, both normalised per resolution shell:
 //
 //   - Padilla & Yeates L-test (Acta Cryst D59, 2003): for pairs of nearby but symmetry-independent
 //     reflections, L = (I1 - I2)/(I1 + I2). Untwinned acentric data give <|L|> = 0.5, <L^2> = 1/3;
 //     a perfect merohedral twin narrows this to <|L|> = 0.375, <L^2> = 0.2. Insensitive to
-//     anisotropy and overall scale because it is a local ratio.
+//     anisotropy and overall scale because it is a local ratio of shell-normalised intensities.
 //
 //   - Second moment <I^2>/<I>^2 of acentric intensities, normalised per resolution shell so it is
 //     2.0 for untwinned data and 1.5 for a perfect twin (= 2(1 - a + a^2) for twin fraction a).
 //
-// These flag the *presence* of twinning; they do not by themselves identify the twin law.
+// These flag the *presence* of twinning; they do not by themselves identify the twin law. In a
+// holohedral Laue class, where no twin law exists, the same low reading says instead that an operator
+// of the group averages unequal intensities - the group is too high, or a twin law was absorbed into
+// it (adopted_operators_suspect).
+
+enum class TwinFractionSource { None, LTest, SecondMoment };
 
 struct TwinningAnalysisResult {
     int l_test_pairs = 0;
@@ -31,14 +36,25 @@ struct TwinningAnalysisResult {
     int moment_reflections = 0;
     double second_moment = 0.0;   // <I^2>/<I>^2 (shell-normalised): 2.0 untwinned, 1.5 perfect twin
 
-    // Twin fraction estimated from the second moment, a = (1 - sqrt(2M-3))/2, clamped to [0, 0.5].
+    // Twin fraction in [0, 0.5], from the statistic named by twin_fraction_source: the L-test unless
+    // the verdict rests on the second moment alone, a = (1 - sqrt(2M-3))/2. None where it cannot be
+    // measured - merged under a false operator, or a second moment under a pseudo-translation.
     double estimated_twin_fraction = 0.0;
+    TwinFractionSource twin_fraction_source = TwinFractionSource::None;
+
+    // An indicator reads twin-like (<|L|> < 0.44 or second moment < 1.85, and <|L|> not at or above
+    // 0.5). Set in every Laue class; what it means depends on the next two fields.
     bool twinning_suspected = false;
 
     // False when the Laue class is holohedral (4/mmm, 6/mmm, m-3m, rhombohedral -3m): no merohedral
-    // twin law can exist, so a low <|L|> / second moment there is a statistical artefact, not twinning.
+    // twin law can exist WITHIN it.
     bool merohedral_twinning_possible = true;
 
+    // twinning_suspected in a holohedral class: an operator of the group averages intensities that
+    // are not equal, so the group is too high or it has absorbed a twin law. A warning about the
+    // symmetry, not a twin call - and the twin fraction is not measurable on such a merge.
+    bool adopted_operators_suspect = false;
+
     // How the L-test coped with a translational pseudo-symmetry, when one was declared (see the
     // partner-step note in the .cpp). Exactly one of these can be set:
     //   - `l_test_tncs_step_restricted`: partners were taken only along steps that preserve the
@@ -58,6 +74,8 @@ struct TwinningAnalysisResult {
 
 // The space group (when known) is used to drop centric reflections, which follow different
 // statistics (<|L|>, <I^2>/<I>^2 = 3 not 2); pass nullptr for P1 data, where none are centric.
+// `lattice_centring` drops the reflections the lattice centring extinguishes, for a P1 merge of a
+// centred lattice (whose space_group is nullptr and so says nothing about them).
 // `tncs_vector` is the fractional pseudo-translation of a DETECTED translational pseudo-symmetry on
 // this same merge (TranslationalNCSVectorForLTest), or nullptr. It changes which partner reflections
 // the L-test pairs with, so it has to be an argument rather than a flag set on the result afterwards:
@@ -65,6 +83,11 @@ struct TwinningAnalysisResult {
 TwinningAnalysisResult AnalyzeTwinning(const std::vector<MergedReflection>& merged,
                                        const gemmi::SpaceGroup* space_group = nullptr,
                                        int resolution_shells = 20,
-                                       const std::array<double, 3>* tncs_vector = nullptr);
+                                       const std::array<double, 3>* tncs_vector = nullptr,
+                                       char lattice_centring = 'P');
 
 std::string TwinningAnalysisToText(const TwinningAnalysisResult& result);
+
+// The verdict in one line - "INDICATED (...)", "SYMMETRY SUSPECT (...)" or "no indication (...)" -
+// so the report's summary row, its prose and the viewer all say the same thing.
+std::string TwinningVerdictLine(const TwinningAnalysisResult& result);
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index f3d6b25e4..bb48a625c 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -1054,59 +1054,79 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                                                             : "UNAFFECTED",
                            {"UNAFFECTED", "REPAIRED", "UNREADABLE"}));
             Add(s, KeyReal("SECOND_MOMENT_I", tw.second_moment, "{:.4f}"));
-            Add(s, KeyReal("ESTIMATED_TWIN_FRACTION", tw.estimated_twin_fraction, "{:.3f}"));
-            // Which statistic the fraction came from. The L-test in the same block can imply a much
-            // larger fraction, and printing the two side by side with no label made the headline key
-            // look like a reconciliation of both when it is derived from one of them.
-            Add(s, KeyEnum("ESTIMATED_TWIN_FRACTION_FROM", "SECOND_MOMENT",
-                           {"SECOND_MOMENT", "L_TEST"}));
+            // One verdict, in the words every other place uses (TwinningVerdictLine): INDICATED is a twin
+            // in a class that admits one; SYMMETRY_SUSPECT is the same low reading in a holohedral class,
+            // where it says an adopted operator averages unequal intensities.
+            Add(s, KeyEnum("TWINNING_VERDICT",
+                           tw.adopted_operators_suspect ? "SYMMETRY_SUSPECT"
+                           : tw.twinning_suspected      ? "INDICATED"
+                                                        : "NO_INDICATION",
+                           {"NO_INDICATION", "INDICATED", "SYMMETRY_SUSPECT"}));
+            // The fraction comes from the statistic that carries the verdict, and the key beside it says
+            // which. None is quoted where it cannot be measured: merged under a false operator, or from a
+            // second moment a pseudo-translation inflates.
+            if (tw.twin_fraction_source != TwinFractionSource::None)
+                Add(s, KeyReal("ESTIMATED_TWIN_FRACTION", tw.estimated_twin_fraction, "{:.3f}"));
+            Add(s, KeyEnum("ESTIMATED_TWIN_FRACTION_FROM",
+                           tw.twin_fraction_source == TwinFractionSource::LTest          ? "L_TEST"
+                           : tw.twin_fraction_source == TwinFractionSource::SecondMoment ? "SECOND_MOMENT"
+                                                                                         : "NONE",
+                           {"SECOND_MOMENT", "L_TEST", "NONE"}));
             Add(s, KeyReal("L_TEST_MEAN_L_SQUARED", tw.mean_l_squared, "{:.4f}", true));
             if (result.pre_promotion_twinning) {
-                Add(s, KeyReal("L_TEST_MEAN_ABS_L_BEFORE_SEARCH",
-                               result.pre_promotion_twinning->mean_abs_l, "{:.4f}", true));
-                Add(s, KeyReal("SECOND_MOMENT_I_BEFORE_SEARCH",
-                               result.pre_promotion_twinning->second_moment, "{:.4f}", true));
+                const auto &pre = *result.pre_promotion_twinning;
+                Add(s, KeyReal("L_TEST_MEAN_ABS_L_BEFORE_SEARCH", pre.mean_abs_l, "{:.4f}"));
+                Add(s, KeyReal("SECOND_MOMENT_I_BEFORE_SEARCH", pre.second_moment, "{:.4f}"));
+                Add(s, KeyEnum("L_TEST_BEFORE_SEARCH_VS_TNCS",
+                               pre.l_test_contaminated_by_tncs   ? "UNREADABLE"
+                               : pre.l_test_tncs_step_restricted ? "REPAIRED"
+                               : result.pre_promotion_tncs_measured ? "UNAFFECTED"
+                                                                  : "NOT_MEASURED",
+                               {"UNAFFECTED", "REPAIRED", "UNREADABLE", "NOT_MEASURED"}));
             }
             Add(s, Blank());
-            // One calm sentence, in the same terms in both branches. The old prose opened "Cannot rule
-            // out twinning from these numbers" on runs whose own key said FALSE - a property of the
-            // symmetry stated as if it were a finding about these data.
-            if (tw.twinning_suspected)
+            Add(s, Prose(" Twinning: " + TwinningVerdictLine(tw) + "."));
+            if (tw.adopted_operators_suspect)
                 Add(s, Prose(fmt::format(
-                        " Twinning: INDICATED. <|L|> is {:.3f}, where an untwinned crystal reads about 0.5 and\n"
-                        " a perfect twin about 0.375. The estimated fraction {:.2f} is derived from the second\n"
-                        " moment alone and the L-test may imply a larger one. Refinement against these data\n"
-                        " needs a twin law.",
-                        tw.mean_abs_l, tw.estimated_twin_fraction)));
+                        " The Laue class is holohedral, so no twin law exists within it - but merging under a\n"
+                        " false operator gives exactly this distribution, whatever the twin fraction. {} Either\n"
+                        " the crystal has lower symmetry or it is a twin whose law the point group absorbed;\n"
+                        " refinement belongs in a subgroup.",
+                        tw.laue_class_was_chosen_by_promotion
+                                ? "The class was chosen by the space-group search, so that promotion is suspect."
+                                : "The space group in use is higher than these intensities support.")));
+            else if (tw.twinning_suspected)
+                Add(s, Prose(" Refinement against these data needs a twin law."));
             else if (tw.l_test_contaminated_by_tncs)
                 // <|L|> is the number this sentence would otherwise rest on, and on this crystal it is
-                // biased by the pseudo-translation above. Saying "no indication (<|L|> 0.529)" here
-                // would be the same silent veto in a different place.
-                Add(s, Prose(fmt::format(
-                        " Twinning: no indication from the second moment ({:.3f}, against 2.00 for an untwinned\n"
-                        " crystal and 1.50 for a perfect twin). The L-test, normally the stronger of the two, could\n"
-                        " not be read here: this crystal's translational pseudo-symmetry biases <|L|> and no partner\n"
-                        " reflection available to the test escapes that bias. A weaker statement than usual.",
-                        tw.second_moment)));
-            else
-                Add(s, Prose(fmt::format(
-                        " Twinning: no indication (<|L|> {:.3f}, against about 0.5 for an untwinned crystal\n"
-                        " and 0.375 for a perfect twin).", tw.mean_abs_l)));
+                // biased by the pseudo-translation above.
+                Add(s, Prose(" The L-test, normally the stronger of the two statistics, could not be read here:\n"
+                             " this crystal's translational pseudo-symmetry biases <|L|> and no partner reflection\n"
+                             " available to the test escapes that bias. A weaker statement than usual."));
             Add(s, Prose("\n" + TwinningAnalysisToText(tw), true));
-            if (result.pre_promotion_twinning)
+            if (result.pre_promotion_twinning) {
+                const auto &pre = *result.pre_promotion_twinning;
+                Add(s, Prose(fmt::format(
+                        " Before the space-group search (P1 merge{}): {}.",
+                        result.pre_promotion_tncs_measured ? "" : ", not corrected for a pseudo-translation",
+                        TwinningVerdictLine(pre))));
                 Add(s, Prose(" The _BEFORE_SEARCH pair was measured on the merge the space-group search was given,\n"
-                             " before any point group was adopted. That ordering is the whole point: the statistics\n"
-                             " above are computed in the Laue class this run ADOPTED, so if the search promoted the\n"
-                             " point group they can only report that no twin law exists inside the class it chose -\n"
-                             " and a twin is precisely what would have caused that promotion. Where the two pairs\n"
-                             " disagree, the _BEFORE_SEARCH pair is the one that answers whether the crystal is\n"
-                             " twinned.", true));
-            if (tw.twinning_suspected)
+                             " before any point group was adopted. The statistics above are computed in the Laue\n"
+                             " class this run ADOPTED; where the search promoted the point group, a twin law it\n"
+                             " absorbed can only show there as an operator averaging unequal intensities. These\n"
+                             " numbers are not circular in that way.", true));
+            }
+            if (tw.adopted_operators_suspect)
                 Warn(doc, PathologyCode::TWINNING, fmt::format(
-                        "Twinning is indicated (<|L|> = {:.3f}, <I^2>/<I>^2 = {:.3f}, estimated twin "
-                        "fraction {:.2f} from the second moment) - refinement against the merged data "
-                        "needs a twin law",
-                        tw.mean_abs_l, tw.second_moment, tw.estimated_twin_fraction));
+                        "An adopted symmetry operator relates unequal intensities (<|L|> = {:.3f} in a holohedral "
+                        "Laue class, where a genuine operator reads about 0.5 and a false one 0.375): the "
+                        "space group may be too high, or the crystal is a twin whose law the point group "
+                        "absorbed - refine in a subgroup",
+                        tw.mean_abs_l));
+            else if (tw.twinning_suspected)
+                Warn(doc, PathologyCode::TWINNING, fmt::format(
+                        "Twinning is indicated ({}) - refinement against the merged data needs a twin law",
+                        TwinningVerdictLine(tw)));
         }
 
         // ---- radiation damage
@@ -1725,9 +1745,7 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                                           result.tncs.peak_percent, result.tncs.vector_length_A)
                             : std::string("no indication"));
                 if (result.twinning.l_test_pairs > 0)
-                    row("Twinning", result.twinning.twinning_suspected
-                            ? fmt::format("INDICATED (<|L|> {:.3f})", result.twinning.mean_abs_l)
-                            : std::string("no indication"));
+                    row("Twinning", TwinningVerdictLine(result.twinning));
                 const double db = result.merge_statistics.radiation_damage_delta_b;
                 if (std::isfinite(db))
                     row("Radiation damage", fmt::format("relative B {:+.2f} A^2 over the sweep", db));
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index baa964214..60942321b 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -5383,7 +5383,20 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // given. Reported alongside the post-adoption analysis: once a higher Laue class has been
             // adopted, its own twinning test can only say "no twin law exists within this class", which
             // is circular - the promotion is what a twin would have caused. These numbers are not.
-            const auto pre_promotion_twinning = AnalyzeTwinning(sm.merged, nullptr);
+            //
+            // Measured as the post-adoption test is: with the pseudo-translation of this same merge
+            // declared, so the L-test can be repaired for it, and - the merge being in P1 - without the
+            // reflections the lattice centring extinguishes, which an R lattice in its hexagonal cell
+            // still carries (two thirds of them, and every axis step lands on one).
+            TranslationalNCSResult pre_tncs;
+            if (result.consensus_cell) {
+                pre_tncs = AnalyzeTranslationalNCS(sm.merged, gemmi::UnitCell(*result.consensus_cell));
+                result.pre_promotion_tncs_measured = pre_tncs.measurable;
+            }
+            const char lattice_centring = end_msg.rotation_lattice_type.has_value()
+                                          ? end_msg.rotation_lattice_type->centering : 'P';
+            const auto pre_promotion_twinning = AnalyzeTwinning(
+                    sm.merged, nullptr, 20, TranslationalNCSVectorForLTest(pre_tncs), lattice_centring);
             result.pre_promotion_twinning = pre_promotion_twinning;
             if (pre_promotion_twinning.twinning_suspected)
                 logger.Warning("Twinning indicators BEFORE the space-group decision (subgroup merge): "
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index e992ffa3b..54ab34074 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -313,6 +313,9 @@ struct ProcessResult {
     // class is adopted, its own twinning test can say no more than "no twin law exists inside this
     // class", and the promotion is what a twin would have caused. Empty when no de-novo search ran.
     std::optional<TwinningAnalysisResult> pre_promotion_twinning;
+    // Whether a pseudo-translation was looked for on that same merge, so its L-test could be repaired
+    // for one. False when there was no cell to run the Patterson on.
+    bool pre_promotion_tncs_measured = false;
 
     // What --model found, when one was given. Set even when the validation could not run - its
     // failure_reason then says why - so the report can report the failure rather than leave a run
diff --git a/tests/TwinningAnalysisTest.cpp b/tests/TwinningAnalysisTest.cpp
index e4999781b..006f9a2b6 100644
--- a/tests/TwinningAnalysisTest.cpp
+++ b/tests/TwinningAnalysisTest.cpp
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <cmath>
+#include <map>
 #include <numbers>
 #include <vector>
 
@@ -118,17 +119,100 @@ TEST_CASE("A pseudo-translation can hide a twin, and declaring it restores the c
     CHECK(declared.twinning_suspected);                   // and restored
 }
 
-// Standing behaviour that had no test at all. A holohedral Laue class admits no merohedral twin law,
-// so whatever the intensity statistics do there they must not be reported as twinning.
-TEST_CASE("No twin is called in a holohedral Laue class", "[twinning]") {
+namespace {
+    // The merge of a synthetic crystal in `group`: one row per reflection of that group's asymmetric
+    // unit, the average of the P1 intensities of its orbit - which is what merging under the group
+    // does, whether or not its operators are real.
+    std::vector<MergedReflection> MergedIn(const std::vector<MergedReflection> &p1, const char *group) {
+        const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name(group);
+        const gemmi::GroupOps gops = sg->operations();
+        const gemmi::ReciprocalAsu asu(sg);
+        std::map<std::array<int, 3>, std::pair<MergedReflection, int>> sum;
+        for (const auto &r : p1) {
+            const auto key = asu.to_asu(gemmi::Op::Miller{{r.h, r.k, r.l}}, gops).first;
+            auto [it, fresh] = sum.try_emplace({key[0], key[1], key[2]}, r, 0);
+            if (!fresh)
+                it->second.first.I += r.I;
+            it->second.second += 1;
+        }
+        std::vector<MergedReflection> out;
+        for (auto &[key, v] : sum) {
+            MergedReflection r = v.first;
+            r.h = key[0];
+            r.k = key[1];
+            r.l = key[2];
+            r.I /= static_cast<float>(v.second);
+            out.push_back(r);
+        }
+        return out;
+    }
+
+    std::vector<MergedReflection> Tetragonal(const char *true_group, double twin_fraction) {
+        jfjoch_test::SyntheticMergeParams p;
+        p.true_space_group = true_group;
+        p.twin_supergroup = "P 4 2 2";
+        p.twin_fraction = twin_fraction;
+        p.d_min_A = 2.5;
+        return jfjoch_test::GenerateSyntheticMerged(p);
+    }
+}
+
+// The L-test compares two intensities as if they had the same expected value, and two index steps are
+// not the same resolution: on a small cell with a steep fall-off the raw pair differs systematically,
+// which reads as an untwinned crystal being "more untwinned" than 0.5. The shell normalisation removes
+// that, and the fraction quoted is the L-test's own.
+TEST_CASE("L-test on shell-normalised intensities", "[twinning]") {
     jfjoch_test::SyntheticMergeParams p;
-    p.true_space_group = "P 4 21 2";
-    p.twin_supergroup = "P 4 21 2";
+    p.true_space_group = "P 1";
+    p.twin_supergroup = "P 1";
+    p.wilson_b_A2 = 60.0;
+    p.d_min_A = 2.5;
+    const auto r = AnalyzeTwinning(jfjoch_test::GenerateSyntheticMerged(p), nullptr);
+    INFO("<|L|> " << r.mean_abs_l);
+    CHECK(r.mean_abs_l == Catch::Approx(0.5).margin(0.02));
+    CHECK_FALSE(r.twinning_suspected);
+
+    const auto twin = AnalyzeTwinning(Crystal(0.2), nullptr);
+    CHECK(twin.twin_fraction_source == TwinFractionSource::LTest);
+    CHECK(twin.estimated_twin_fraction == Catch::Approx(0.2).margin(0.05));
+}
+
+// A P1 merge of a centred lattice holds the reflections the centring extinguishes. Told the centring,
+// the test leaves them out and reads the crystal; not told, it pairs present with absent ones.
+TEST_CASE("L-test on a P1 merge of a centred lattice", "[twinning]") {
+    jfjoch_test::SyntheticMergeParams p;
+    p.true_space_group = "R 3 :H";
+    p.twin_supergroup = "R 3 :H";
     p.d_min_A = 3.0;
     const auto merged = jfjoch_test::GenerateSyntheticMerged(p);
-    const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name("P 4 21 2");
-    REQUIRE(sg != nullptr);
-    const auto r = AnalyzeTwinning(merged, sg);
+    const auto told = AnalyzeTwinning(merged, nullptr, 20, nullptr, 'R');
+    CHECK(told.mean_abs_l == Catch::Approx(0.5).margin(0.02));
+    const auto not_told = AnalyzeTwinning(merged, nullptr);
+    CHECK(std::fabs(not_told.mean_abs_l - 0.5) > 0.05);
+}
+
+// A genuine holohedral crystal: no twin law exists, and its operators read as real.
+TEST_CASE("No twin is called in a genuine holohedral Laue class", "[twinning]") {
+    const auto merged = MergedIn(Tetragonal("P 4 2 2", 0.0), "P 4 2 2");
+    const auto r = AnalyzeTwinning(merged, gemmi::find_spacegroup_by_name("P 4 2 2"));
     CHECK_FALSE(r.merohedral_twinning_possible);
+    CHECK(r.mean_abs_l == Catch::Approx(0.5).margin(0.03));
     CHECK_FALSE(r.twinning_suspected);
+    CHECK_FALSE(r.adopted_operators_suspect);
+}
+
+// Merging under a false operator averages I(h) with I(Th), and (I(h) + I(Th))/2 has the perfect-twin
+// distribution whatever the twin fraction - so a subgroup crystal merged in its lattice's holohedry
+// reads <|L|> ~0.375 at every fraction, and the holohedral class must say so rather than "no twin
+// law exists".
+TEST_CASE("A holohedral merge under a false operator is called suspect", "[twinning]") {
+    const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name("P 4 2 2");
+    for (double alpha : {0.0, 0.2, 0.5}) {
+        const auto r = AnalyzeTwinning(MergedIn(Tetragonal("P 4", alpha), "P 4 2 2"), sg);
+        CAPTURE(alpha);
+        CHECK(r.mean_abs_l == Catch::Approx(0.375).margin(0.02));
+        CHECK(r.adopted_operators_suspect);
+        CHECK(r.twin_fraction_source == TwinFractionSource::None);   // lost in the merge
+        CHECK(TwinningVerdictLine(r).rfind("SYMMETRY SUSPECT", 0) == 0);
+    }
 }
diff --git a/viewer/windows/JFJochMergeStatsWindow.cpp b/viewer/windows/JFJochMergeStatsWindow.cpp
index c6260e622..d04de09a0 100644
--- a/viewer/windows/JFJochMergeStatsWindow.cpp
+++ b/viewer/windows/JFJochMergeStatsWindow.cpp
@@ -165,11 +165,7 @@ JFJochMergeStatsWindow::JFJochMergeStatsWindow(const QString &title, const Merge
         QString text = QString("Twinning:  ⟨|L|⟩ = %1   ⟨I²⟩/⟨I⟩² = %2")
                            .arg(twinning.mean_abs_l, 0, 'f', 3)
                            .arg(twinning.second_moment, 0, 'f', 2);
-        if (twinning.twinning_suspected)
-            text += QString("   —  twinning suspected (estimated fraction ≈ %1)")
-                        .arg(twinning.estimated_twin_fraction, 0, 'f', 2);
-        else
-            text += "   —  no twinning indicated";
+        text += "   —  " + QString::fromStdString(TwinningVerdictLine(twinning));
 
         auto *banner = new QLabel(text, this);
         banner->setContentsMargins(10, 6, 10, 6);
-- 
2.54.0


From 5200177d67ff901b33492d529c6a0ad1d1bbe950 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:48:22 +0200
Subject: [PATCH 011/122] Space-group search: log the refusal the two-merge
 rule overrides

When the all-observation and Lorentz-filtered search merges disagree, the
higher point group is adopted. The losing arm's answer was dropped, so a
promotion one arm refused on its twin gates (H ratio, added-operator R)
went through with nothing in the output saying a gate had fired - and the
report printed the adopted group's failing H ratio ("2.02 against a bound
of 1.85") as if it were a margin. Seen on an H3 partial twin (5j23),
refused on both twin gates by the all-observation merge and promoted to
R32 by the filtered one.

Now the losing arm's refusal (group and reason), or the fact that it never
confirmed the operators, is logged as a warning and written to the report
(SPACE_GROUP_ARM_OVERRIDE). A bound the adopted group exceeds is printed as
"EXCEEDS its bound - that gate fired and was overridden", for the H ratio
and for the best-operator R. The comment that claimed both arms keep their
vetoes now describes the rule as implemented. The rule itself is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 rugnux/ResultReport.cpp | 21 +++++++++++++++++++--
 rugnux/Rugnux.cpp       | 31 +++++++++++++++++++++++++++----
 rugnux/Rugnux.h         |  4 ++++
 3 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index bb48a625c..4106b22e4 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -528,9 +528,21 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             // operator and candidate tables that justify it.
             std::string line = fmt::format(" Point group {} from the intensity correlations",
                                            search.point_group_hm);
+            // A bound the adopted group EXCEEDS is a gate that fired and was overridden - the point group
+            // was taken from the other search arm - and must not read as the margin of a pass.
             if (std::isfinite(search.h_ratio))
-                line += fmt::format(";\n twin-law H ratio {:.2f} against a bound of {:.2f}",
-                                    search.h_ratio, search.h_ratio_bound);
+                line += search.h_ratio > search.h_ratio_bound
+                        ? fmt::format(";\n twin-law H ratio {:.2f} EXCEEDS its bound of {:.2f} - that gate fired "
+                                      "and was overridden", search.h_ratio, search.h_ratio_bound)
+                        : fmt::format(";\n twin-law H ratio {:.2f} against a bound of {:.2f}",
+                                      search.h_ratio, search.h_ratio_bound);
+            // The best-operator R gate is the one that applies once two operators are confirmed, i.e.
+            // above order 2 (the first step out of P1 is judged on the noise floor instead).
+            if (search.point_group_order > 2 && std::isfinite(search.r_over_best)
+                && search.r_over_best_bound > 0.0 && search.r_over_best > search.r_over_best_bound)
+                line += fmt::format(";\n added-operator R {:.2f}x the best operator EXCEEDS its bound of {:.2f}x - "
+                                    "that gate fired and was overridden", search.r_over_best,
+                                    search.r_over_best_bound);
             line += ".\n The space group follows from the systematic absences.";
             if (!alts.empty())
                 line += fmt::format("\n These data cannot separate it from {} - both are consistent with"
@@ -541,6 +553,11 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                              " cannot name. Molecular replacement settles it: one of the two refines and the\n"
                              " other does not - the normal outcome for a chiral group, not a failure of the\n"
                              " run."));
+            if (!result.space_group_arm_override.empty()) {
+                Add(s, KeyText("SPACE_GROUP_ARM_OVERRIDE", result.space_group_arm_override));
+                Add(s, Prose(fmt::format(" The two search merges disagreed and the higher point group was taken:\n {}.",
+                                         result.space_group_arm_override)));
+            }
             if (refused)
                 Add(s, Prose(fmt::format(
                         " A promotion to {} was refused: {}.\n"
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 60942321b..20d4d0063 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -5280,9 +5280,12 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // rotations are real, because a promotion is refused by the most damning statistic it can
             // be shown and only one arm has to be starved for that to happen, while the ABSENCES are
             // always judged on the all-observation merge, which is the only one holding the weak
-            // reflections a systematic absence is made of. Both searches keep their vetoes, so a merohedral twin
-            // stays refused in each (verified on a real twin at the three frame ranges where it
-            // over-promotes: refused in both arms every time).
+            // reflections a systematic absence is made of. The vetoes are NOT kept per arm: a promotion
+            // one arm refused on its twin gates (H ratio, added-operator R) is adopted when the other arm
+            // confirms it, because the higher order wins. That held on one real twin at three frame
+            // ranges, where both arms refused, but an H3 partial twin has been seen refused by the
+            // all-observation arm on both twin gates and promoted to R32 by the filtered one. So the
+            // losing arm's refusal is logged and carried to the report below; the rule is unchanged.
             if (rsm && rsm->GetSearchMinZeta() > 0.0 && !sg_search.point_group_hm.empty()) {
                 const double zeta = rsm->GetSearchMinZeta();
                 rsm->SetSearchMinZeta(0.0);
@@ -5341,10 +5344,29 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     stats_text << "  !! " << msg << "\n\n";
                     result.warnings.push_back({PathologyCode::SYMMETRY_AMBIGUITY, msg});
                 }
-                if (order_of(alt) > order_of(sg_search))
+                // The arm whose lower answer is about to be overridden, and why it stopped there. A
+                // refusal by a consistency gate is the case that matters: the higher group is adopted
+                // anyway, and without this nothing in the output says a gate ever fired.
+                const auto overridden = [&](const SearchSpaceGroupResult &lower, const char *lower_name,
+                                            const char *higher_name) {
+                    std::string msg;
+                    if (!lower.refused_point_group_hm.empty())
+                        msg = fmt::format("the {} merge REFUSED {} ({}); overridden, because the {} merge "
+                                          "confirmed the higher point group", lower_name,
+                                          lower.refused_point_group_hm, lower.refused_reason, higher_name);
+                    else
+                        msg = fmt::format("the {} merge did not confirm the operators of the higher point "
+                                          "group (no gate refused it); the {} merge did", lower_name,
+                                          higher_name);
+                    logger.Warning("Space-group search: {}", msg);
+                    result.space_group_arm_override = msg;
+                };
+                if (order_of(alt) > order_of(sg_search)) {
                     logger.Info("Space-group search: all-observation merge supports {} where the "
                                 "Lorentz-filtered one supports {} - taking the higher symmetry",
                                 alt.point_group_hm, sg_search.point_group_hm);
+                    overridden(sg_search, "Lorentz-filtered", "all-observation");
+                }
                 if (order_of(alt) < order_of(sg_search)) {
                     // The filtered arm found symmetry the all-observation arm did not. Discarding it
                     // was costing real point groups: over the corpus the two arms disagree on eight
@@ -5359,6 +5381,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     // that found it and the absences are re-judged here, on every observation. That
                     // is what fixed_point_group is for: Stage A still runs and still reports what it
                     // would have refused, only the choice is overridden.
+                    overridden(alt, "all-observation", "Lorentz-filtered");
                     sg_opts.fixed_point_group = sg_search.point_group_representative;
                     auto split = SearchSpaceGroup(sm_all.merged, sg_opts);
                     sg_opts.fixed_point_group.reset();
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 54ab34074..b6e8d67bc 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -334,6 +334,10 @@ struct ProcessResult {
     // populated only when a search ran (no space group was fixed). The library no longer renders it to
     // text - the CLI formats it for stdout, the viewer draws it as a table.
     std::optional<SearchSpaceGroupResult> space_group_search;
+    // When the two search arms (all observations / Lorentz-filtered) disagreed and the higher point
+    // group was taken from one of them: what the other arm said - which gate refused the promotion,
+    // or that it never confirmed the operators. Empty when the arms agreed.
+    std::string space_group_arm_override;
 
     // ---- Material for the results report (<prefix>_report.txt, see rugnux/ResultReport.h) ----
 
-- 
2.54.0


From 54fcb3cbcbc6185158f611b8915c4bbbea5ee1ac Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:06:52 +0200
Subject: [PATCH 012/122] R-free flags keyed on the lattice holohedry

The free-set hash was keyed on the Laue ASU of the merging group, so a twin
law - a lattice symmetry the crystal lacks - put nearly every free
reflection's twin mate in the working set (measured: 97-98% of the
free-touching twin pairs mixed, on the main P3121 output of 6iu9 and on
every law of the 6toc P1 cross-check), and each file of one crystal carried
a different free set (P1 vs merged agreed on 88-92% of reflections).

With the cell given, the key is now the reflection's orbit, Friedel mate
included, under the lattice holohedry: the metric point group of the cell
(gemmi Le Page two-folds, 3 deg obliquity, lattice of the cell's own basis
vectors so every file gets the same group; this contains the merging
group). Twin mates share a flag, and the merged MTZ/mmCIF, the P1
cross-check and any subgroup re-merge carry one free set (nested where the
small-data floor lifts the fraction of one file more than another). This is
phenix.refine's default (use_lattice_symmetry). Where the cell does not
carry the merging group, the merging group's key is used as before. The
small-data floor still counts reflections of the merging group, so the free
fraction is unchanged. Reference free sets are untouched.

On 6toc, 6iu9, 5j23: mixed twin pairs 0 for every law; P1 and merged flags
agree on 100% (6iu9, 5j23) and nested on 6toc; free fraction 0.050-0.051 as
before (6toc merged 0.086, floor unchanged). Intensities and space groups
identical to rc171.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/CPU_DATA_ANALYSIS_INTEGRATION.md         |  3 +-
 image_analysis/scale_merge/Merge.cpp          |  2 +-
 image_analysis/scale_merge/RfreeFlags.cpp     | 59 +++++++++++++++++--
 image_analysis/scale_merge/RfreeFlags.h       | 13 +++-
 .../scale_merge/RotationScaleMerge.cpp        |  2 +-
 tests/RfreeFlagsTest.cpp                      | 32 ++++++++++
 6 files changed, 101 insertions(+), 10 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_INTEGRATION.md b/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
index 1d8bd3450..61b4bf3a1 100644
--- a/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
+++ b/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
@@ -382,9 +382,10 @@ Each batch's $B$ is fitted on **resolution-shell means**, not on single observat
 
 ### 10.7 R-free test-set flags
 
-A fraction of the unique reflections (`rfree_fraction`, default 0.05) is flagged as a **free (test) set**, written to the output (MTZ `FreeR_flag`, mmCIF `_refln.status` = `f`, a text-HKL column) for model validation (§14) and for downstream refinement. The flag is a pure function of the reflection's **Friedel-merged (Laue) ASU index**, which gives three properties:
+A fraction of the unique reflections (`rfree_fraction`, default 0.05) is flagged as a **free (test) set**, written to the output (MTZ `FreeR_flag`, mmCIF `_refln.status` = `f`, a text-HKL column) for model validation (§14) and for downstream refinement. The flag is a pure function of the reflection's orbit under the **lattice holohedry** — the point group of the cell's metric, found as twin laws are (Le Page two-folds within 3° obliquity, taking the lattice of the cell's own basis vectors), which contains the merging group — together with its Friedel mate. Where the cell does not carry the merging group (a space group forced on a metric without it), the Friedel-merged (Laue) ASU index of the merging group is used instead. That gives four properties:
 
 - all symmetry- and Friedel-equivalent reflections share one flag — in particular a Bijvoet pair $I(+)/I(-)$, kept as two separate merged rows in anomalous mode, is **never split** across the work and free sets (which would bias R-free);
+- **twin-law mates share one flag too**, since a twin law is a lattice symmetry the crystal lacks. Keyed on the merging group instead, nearly every free reflection's twin mate lands in the working set, and in twin refinement the free reflection's calculated intensity then carries the working-set fit. The same set is what phenix.refine generates by default (`use_lattice_symmetry`). It also makes the free set independent of the space group a file is merged in: the merged file, the P1 cross-check and a re-merge in any subgroup carry one free set (nested, where the small-data floor below lifts the fraction of one of them more than another's);
 - the free/work decision is a deterministic hash of that key, so the same reflection always lands in the same set — reproducible run-to-run and independent of the order in which observations were merged;
 - the hash depends only on the reflection index, **not** on this dataset's resolution range or which reflections it happens to contain, so a uniform draw takes ~`rfree_fraction` of the distinct reflections free and — crucially — **every dataset of one crystal form gets the same free set**. That cross-dataset consistency is what a multi-dataset campaign (ensemble refinement, PanDDA) requires; a per-shell stratification tied to each dataset's own $d_\mathrm{min}$ would break it.
 
diff --git a/image_analysis/scale_merge/Merge.cpp b/image_analysis/scale_merge/Merge.cpp
index ce7b87f2e..2945ce2f7 100644
--- a/image_analysis/scale_merge/Merge.cpp
+++ b/image_analysis/scale_merge/Merge.cpp
@@ -389,7 +389,7 @@ std::vector<MergedReflection> MergeOnTheFly::ExportReflections() {
         out.emplace_back(mr);
     }
 
-    AssignRfreeFlags(out, space_group, scaling_settings.GetRfreeFraction());
+    AssignRfreeFlags(out, space_group, scaling_settings.GetRfreeFraction(), 500, reference_cell);
     ApplyFrenchWilson(out, space_group);
     return out;
 }
diff --git a/image_analysis/scale_merge/RfreeFlags.cpp b/image_analysis/scale_merge/RfreeFlags.cpp
index 6b7b17cd2..cfc099d6e 100644
--- a/image_analysis/scale_merge/RfreeFlags.cpp
+++ b/image_analysis/scale_merge/RfreeFlags.cpp
@@ -8,6 +8,7 @@
 #include <unordered_set>
 
 #include "HKLKey.h"
+#include "gemmi/twin.hpp"
 
 namespace {
     // splitmix64 bit-mix of a key -> uniform double in [0, 1). Same key -> same value, so all
@@ -20,10 +21,36 @@ namespace {
         z = z ^ (z >> 31);
         return static_cast<double>(z >> 11) * (1.0 / 9007199254740992.0);
     }
+
+
+    // The rotations of the lattice's own point group - its holohedry - found from the metric as for
+    // twin laws (Le Page two-folds, with phenix.xtriage's default obliquity of 3 degrees, so a
+    // pseudo-merohedral lattice counts as its higher metric; grouping too much only clusters the
+    // free set, grouping too little splits twin mates). The centring is taken as P: the lattice of
+    // the cell's own basis vectors, the same whatever group a merge is in, so the merged file, the P1
+    // cross-check and any re-merge get one holohedry. On an R lattice in its hexagonal cell that is
+    // 6/mmm rather than -3m, which groups each present reflection with exactly its -3m mates, the
+    // extra ones being centring-absent. Empty when the cell does not carry the merging group itself
+    // (a space group forced on a metric that does not have it): there is no holohedry to key on.
+    std::vector<gemmi::Op> LatticeHolohedry(const UnitCell &cell, const gemmi::SpaceGroup &space_group) {
+        std::vector<gemmi::Op> rots;
+        for (const auto &op : gemmi::find_lattice_symmetry(static_cast<gemmi::UnitCell>(cell), 'P', 3.0).sym_ops)
+            rots.push_back(gemmi::Op{op.rot, {0, 0, 0}, 'x'});
+        for (const auto &op : space_group.operations().sym_ops)
+            if (std::none_of(rots.begin(), rots.end(), [&](const gemmi::Op &r) { return r.rot == op.rot; }))
+                return {};
+        return rots;
+    }
+
+    uint64_t PackIndex(const gemmi::Op::Miller &h) {
+        constexpr int64_t bias = 1 << 20;
+        return (static_cast<uint64_t>(h[0] + bias) << 42) | (static_cast<uint64_t>(h[1] + bias) << 21)
+               | static_cast<uint64_t>(h[2] + bias);
+    }
 }
 
 void AssignRfreeFlags(std::vector<MergedReflection> &merged, const gemmi::SpaceGroup &space_group,
-                      double rfree_fraction, int min_free_reflections) {
+                      double rfree_fraction, int min_free_reflections, const std::optional<UnitCell> &cell) {
     for (auto &r : merged)
         r.rfree_flag = false;
     if (rfree_fraction <= 0.0 || merged.empty())
@@ -36,10 +63,34 @@ void AssignRfreeFlags(std::vector<MergedReflection> &merged, const gemmi::SpaceG
     // dataset of one crystal form gets the SAME free set, which is what a multi-dataset campaign
     // (ensemble refinement, PanDDA) needs. A uniform hash draws ~rfree_fraction of the distinct
     // reflections free; a stratified per-shell draw would be tied to the dataset and break that.
+    //
+    // The key is the orbit of the reflection under the LATTICE HOLOHEDRY, not under the merging group.
+    // A twin law is a lattice symmetry that the crystal lacks, so keying on the merging group puts a
+    // free reflection's twin mate in the working set almost every time (measured: 97-98% of the free
+    // reflections that have a mate), and a twin-refined R-free then reads the working set through
+    // I_calc. Keyed on the holohedry, twin mates share a flag, and the free set no longer depends on
+    // the space group a file is merged in - the merged MTZ, the P1 cross-check and a re-merge in any
+    // subgroup carry one free set (where the small-data floor below lifts the fraction differently in
+    // two of them, the smaller set is contained in the larger: each orbit has one draw). As
+    // phenix.refine does by default (use_lattice_symmetry).
     const HKLKeyGenerator laue_key(/*merge_friedel=*/true, space_group);
+    const std::vector<gemmi::Op> holohedry = cell ? LatticeHolohedry(*cell, space_group) : std::vector<gemmi::Op>{};
+    auto key_of = [&](const MergedReflection &r) -> uint64_t {
+        if (holohedry.empty())
+            return laue_key(r).pack();
+        // The largest index of the orbit, Friedel mates included, names it.
+        gemmi::Op::Miller best{{r.h, r.k, r.l}};
+        for (const auto &op : holohedry) {
+            const gemmi::Op::Miller h = op.apply_to_hkl({{r.h, r.k, r.l}});
+            best = std::max({best, h, gemmi::Op::Miller{{-h[0], -h[1], -h[2]}}});
+        }
+        return PackIndex(best);
+    };
 
-    // Count the distinct test-eligible reflections (distinct Laue-ASU keys; mates collapse to one) so
-    // the fraction can be floored to a usable test-set size on small data.
+    // Count the distinct test-eligible reflections (distinct Laue-ASU keys of the merging group; mates
+    // collapse to one) so the fraction can be floored to a usable test-set size on small data. Counted
+    // in the merging group, not in holohedral orbits: R-free is a sum over the reflections of this file,
+    // and counting orbits would lift the fraction on every dataset below its holohedry.
     std::unordered_set<uint64_t> distinct;
     distinct.reserve(merged.size());
     for (const auto &r : merged)
@@ -54,7 +105,7 @@ void AssignRfreeFlags(std::vector<MergedReflection> &merged, const gemmi::SpaceG
     const double eff_fraction = std::max(rfree_fraction, floor_fraction);
 
     for (auto &r : merged)
-        r.rfree_flag = UniformFromKey(laue_key(r).pack()) < eff_fraction;
+        r.rfree_flag = UniformFromKey(key_of(r)) < eff_fraction;
 }
 
 size_t ApplyReferenceFreeFlags(std::vector<MergedReflection> &merged, const gemmi::SpaceGroup &space_group,
diff --git a/image_analysis/scale_merge/RfreeFlags.h b/image_analysis/scale_merge/RfreeFlags.h
index fd0402577..6b00f6f7d 100644
--- a/image_analysis/scale_merge/RfreeFlags.h
+++ b/image_analysis/scale_merge/RfreeFlags.h
@@ -5,15 +5,21 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <optional>
 #include <vector>
 
 #include "../../common/Reflection.h"
+#include "../../common/UnitCell.h"
 #include "gemmi/symmetry.hpp"
 
-// Assign R-free (test-set) flags to merged reflections. The flag is a pure function of the
-// Friedel-merged (Laue) ASU key, which gives three properties:
+// Assign R-free (test-set) flags to merged reflections. With the cell given, the flag is a pure
+// function of the reflection's orbit under the LATTICE HOLOHEDRY (the metric symmetry of the cell,
+// which contains the merging group); without one, or when the cell does not carry the merging group,
+// of its Friedel-merged (Laue) ASU key in space_group. That gives four properties:
 //  - all symmetry- and Friedel-equivalent reflections share one flag, so a Bijvoet pair I(+)/I(-)
 //    is never split across the work and free sets;
+//  - with the cell, twin-law mates share one too, and every file of one crystal - whatever space
+//    group it is merged in - carries the same free set;
 //  - the assignment is reproducible run-to-run and independent of merge/call order;
 //  - it depends only on the reflection index, not on the dataset's resolution range or contents, so
 //    every dataset of one crystal form gets the SAME free set (needed for multi-dataset campaigns:
@@ -28,7 +34,8 @@
 // matters more than cross-dataset identity (and a shared reference/ApplyReferenceFreeFlags is the way
 // to keep exact identity there). Pass 0 to disable the floor.
 void AssignRfreeFlags(std::vector<MergedReflection> &merged, const gemmi::SpaceGroup &space_group,
-                      double rfree_fraction, int min_free_reflections = 500);
+                      double rfree_fraction, int min_free_reflections = 500,
+                      const std::optional<UnitCell> &cell = std::nullopt);
 
 // Override the R-free flags on `merged` from a reference set (e.g. a reference MTZ's FreeR_flag
 // column), so an entire campaign shares one test set. A merged reflection whose Friedel-merged
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 39db29683..e651313f3 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -4077,7 +4077,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     // is not written needs neither. French-Wilson is deferred until after the anomalous accumulator
     // below has attached I(+)/I(-), so the two hands get their amplitudes in one pass.
     if (full_stats)
-        AssignRfreeFlags(result.merged, x.GetSpaceGroupOrP1(), rfree_fraction);
+        AssignRfreeFlags(result.merged, x.GetSpaceGroupOrP1(), rfree_fraction, 500, reference_cell);
 
     if (reject_count > 0)
         logger.Info("Merge outlier rejection: dropped {} observations", reject_count);
diff --git a/tests/RfreeFlagsTest.cpp b/tests/RfreeFlagsTest.cpp
index bb78a8f8b..b267034e2 100644
--- a/tests/RfreeFlagsTest.cpp
+++ b/tests/RfreeFlagsTest.cpp
@@ -182,3 +182,35 @@ TEST_CASE("R-free fraction of zero flags nothing", "[rfree]") {
     AssignRfreeFlags(v, SG(1), 0.0);
     for (const auto& r : v) CHECK(!r.rfree_flag);
 }
+
+TEST_CASE("R-free flags keyed on the lattice holohedry keep twin mates together", "[rfree]") {
+    // A P4 crystal on a tetragonal cell: the lattice is 4/mmm, and (h,k,l) -> (k,h,-l) is a twin law.
+    // Keyed on the holohedry, a reflection and its twin mate share a flag, and the P1 merge of the same
+    // crystal flags every reflection exactly as the P4 merge does. Synthetic cell.
+    const std::optional<UnitCell> cell = UnitCell{47.0f, 47.0f, 63.0f, 90.0f, 90.0f, 90.0f};
+    std::vector<MergedReflection> p4, p1;
+    for (int h = -10; h <= 10; ++h)
+        for (int k = -10; k <= 10; ++k)
+            for (int l = -10; l <= 10; ++l) {
+                if (h == 0 && k == 0 && l == 0) continue;
+                const float d = 60.0f / (1 + h * h + k * k + l * l);
+                p1.push_back(Refl(h, k, l, d));
+                p4.push_back(Refl(h, k, l, d));
+            }
+    AssignRfreeFlags(p4, SG(75), 0.05, /*min_free=*/0, cell);
+    AssignRfreeFlags(p1, SG(1), 0.05, /*min_free=*/0, cell);
+
+    std::map<std::tuple<int, int, int>, bool> flag;
+    for (const auto& r : p4) flag[{r.h, r.k, r.l}] = r.rfree_flag;
+    int twin_pairs = 0;
+    for (const auto& r : p4) {
+        CHECK(flag[{r.k, r.h, -r.l}] == r.rfree_flag);      // twin mate
+        CHECK(flag[{-r.k, r.h, r.l}] == r.rfree_flag);      // P4 mate
+        ++twin_pairs;
+    }
+    CHECK(twin_pairs > 0);
+    for (const auto& r : p1)
+        CHECK(flag[{r.h, r.k, r.l}] == r.rfree_flag);       // one free set whatever the merging group
+    CHECK(FreeFraction(p4) > 0.03);
+    CHECK(FreeFraction(p4) < 0.08);
+}
-- 
2.54.0


From 3d6238846788b20f7a373172f6a41add41289c00 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:07:01 +0200
Subject: [PATCH 013/122] Twin-immune zone evidence for the operators a
 promotion adds (report-only)

Under a twin law T a reflection whose twin mate is itself (up to the true
group and Friedel) is untouched at every twin fraction. For each index-2
subgroup H of the adopted point group, those are the reflections centric in
the group and acentric in H: centric if the operators the group adds over H
are real, acentric if they are a twin law or a pseudo-symmetry - the one
intensity statistic that still separates the two at fraction 0.5, where
every operator statistic reads "real".

Read on the P1 cross-check merge: epsilon-1 reflections in shells with
<I/sigma> >= 5 (noise inflates every class towards centric), each class
normalised against its own mean in bins of ~100 reflections and within the
two phase classes of a detected pseudo-translation, Wilson outliers above
E^2 = 20 dropped. Reported per subgroup: the added operators, n,
<|E^2-1|> +- SE read absolutely against 0.968 / 0.736, and the centric-over-
acentric Wilson log-likelihood in nats with both densities convolved with
each reflection's error (flooring E^2 at its sigma instead read a genuine
1.2 A lysozyme zone as acentric), with the acentric control beside it.
Log, report prose and TWIN_ZONE_n keys. Nothing reads it back; no decision
changes.

On the reference sets: 6toc P4222, all three subgroups centric (1.04-1.07,
+253 to +534 nats); 6iu9 P3121 over P31 acentric (0.789, -294 nats); 5j23
R32 over R3 acentric (0.805, -304 nats, tNCS-class normalised); lysozyme
P41212 centric (0.90, +476 to +1297); a P21 myoglobin centric (0.930, +135).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/CPU_DATA_ANALYSIS_DECISIONS.md           |   2 +
 .../scale_merge/TwinningAnalysis.cpp          | 238 ++++++++++++++++++
 image_analysis/scale_merge/TwinningAnalysis.h |  38 +++
 rugnux/ResultReport.cpp                       |  15 ++
 rugnux/Rugnux.cpp                             |  10 +
 rugnux/Rugnux.h                               |   4 +
 tests/TwinningAnalysisTest.cpp                |  72 ++++++
 7 files changed, 379 insertions(+)

diff --git a/docs/CPU_DATA_ANALYSIS_DECISIONS.md b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
index 7ab356908..8718102f0 100644
--- a/docs/CPU_DATA_ANALYSIS_DECISIONS.md
+++ b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
@@ -54,6 +54,8 @@ Both search merges also drop the **frames whose fitted per-frame scale came out
 
 A Padilla–Yeates $L$-test ($\langle|L|\rangle$, $\langle L^2\rangle$ — 0.500 and 0.333 untwinned, 0.375 and 0.200 for a perfect twin) and the second moment $\langle I^2\rangle/\langle I\rangle^2$ (2.0 for untwinned acentric data, 1.5 for a perfect twin) are written to the merged mmCIF as a twinning diagnostic. Both are taken on intensities divided by their resolution-shell mean, over the shells whose $\langle I/\sigma\rangle$ reaches 1, with Wilson outliers rejected; the $L$-test pairs are therefore compared on one scale even where two index steps span a steep fall-off, as in phenix.xtriage and ctruncate, and the selection is by shell, never by the individual reflection's $I/\sigma$, which would cut the weak tail and bias $\langle|L|\rangle$ down. The twin fraction is quoted from the statistic that carries the verdict — the $L$-test unless the call rests on the second moment alone — and a second moment is not turned into a fraction under a detected pseudo-translation, which inflates it. A merohedral twin law exists only where the Laue class is a proper subgroup of the lattice holohedry, so in the high-symmetry holohedral classes ($4/mmm$, $6/mmm$, $m\bar{3}m$, and $\bar{3}m$ on a rhombohedral lattice) no twin is called. The $L$-test is still read there, for a different question: merging $I(h)$ with $I(Th)$ under a false operator $T$ gives $(I(h)+I(Th))/2$ whatever the twin fraction, which has the perfect-twin distribution, so $\langle|L|\rangle$ below 0.42 in a holohedral class is reported as **an adopted operator averaging unequal intensities** — the space group is too high, or a twin law was absorbed into the point group — a warning, never a change to the space group. A genuine operator leaves the untwinned 0.5. Reflections that overlap along a very long axis narrow the distribution the same way, which is one reason it stays a warning. The same numbers measured on the P1 merge the space-group search was given, before any point group was adopted, are reported beside them (`_BEFORE_SEARCH`), with that merge's own pseudo-translation declared and the reflections its lattice centring extinguishes left out. The low-symmetry holohedral classes ($\bar{1}$, $2/m$, $mmm$) also admit no strictly merohedral law, but they stay eligible for the twin call on purpose: *pseudo*-merohedral twinning through an accidentally special metric cannot be ruled out from the symmetry alone, and those are the classes it happens in.
 
+Beside them, on rotation data, the run reports **twin-immune zone evidence** for the operators the adopted point group adds over each of its index-2 subgroups, read on the P1 cross-check merge. Under a twin law $T$, $I_\mathrm{obs}(h)=(1-\alpha)I(h)+\alpha I(Th)$; a reflection whose twin mate is itself up to the subgroup and Friedel is untouched at every $\alpha$, and those are exactly the reflections centric in the group but acentric in the subgroup. They read centric ($\langle|E^2-1|\rangle = 0.968$) if the added operators are real and acentric (0.736) if they are a twin law or a pseudo-symmetry — the one intensity statistic that still separates the two at $\alpha = 0.5$, where every operator statistic reads "real". Each zone is normalised against its own mean in resolution bins (and within the two phase classes of a detected pseudo-translation), read only in shells with $\langle I/\sigma\rangle \ge 5$ because noise inflates every class towards centric, and reported with $n$, a standard error and the centric-over-acentric Wilson log-likelihood ratio in nats (both densities convolved with each reflection's measurement error), beside the acentric control. It is read absolutely, never as the difference to the control: a perfect twin's control (0.541) plus noise inflation would otherwise look like true symmetry. It is **report-only** — nothing in the space-group decision reads it. It is an in-house method: published practice (Yeates' $H$-test, xtriage) excludes these reflections as uninformative about the twin fraction, and no published test was found that uses them positively; the one precedent here is a trigonal crystal whose twin-immune zone read centric and whose higher group was then confirmed by refinement.
+
 **Translational pseudo-symmetry** — two copies of the contents of the asymmetric unit related by a pure translation that is not a lattice vector — is looked for on every merging run, because it is the classic predictor of a failed molecular replacement, and because it raises the second moment where twinning lowers it, so each can mask the other's test. The detection is the native-Patterson route of Read, Adams & McCoy (see the [references](CPU_DATA_ANALYSIS.md#references)): the largest off-origin peak of a Patterson computed from the merged intensities, as a fraction of the origin peak, with the peak vector then refined against the intensity modulation it should produce — the ratio of the strongest to the weakest bin mean of $\langle E^2\rangle$ over the phase $\mathrm{frac}(\mathbf{h}\cdot\mathbf{u})$. Both halves are scored against a null computed for the crystal at hand rather than against a fixed bound — both against the same intensities **permuted within resolution shells** — the peak against that map, the modulation against the same measurement made on the shuffled intensities and started where the measurement starts — because the noise floor of the peak statistic spans an order of magnitude across data sets, so no fixed percentage means the same thing twice. The shuffle leaves the reflection count, the $E^2$ distribution and the phase-bin populations untouched and removes only the correlation between a reflection's intensity and $\mathbf{h}\cdot\mathbf{u}$, which is the thing the modulation claims to see. Re-running the greedy search from random starting vectors over the *same* intensities does not work as a control: a greedy search started anywhere walks into a real modulation's basin, so it measures the search **and** whatever modulation the crystal carries — measured over 110 merged datasets, single draws of that control reached 199× and 6162× on crystals whose own modulation reads 4.0× and 67×, and on 28 of the 110 it came out at or above the signal it is subtracted from. Requiring both halves is what keeps the false-positive rate down; either alone over-calls by about a factor of two. A translation the merged data are **exactly** invariant under is reported as an undeclared lattice translation instead — a translation the data are exactly invariant under is a lattice vector by definition, so the centring or the cell is wrong, not the packing — and the pseudo-symmetry search continues underneath it, so a real pseudo-translation sitting under an undeclared centring is still found. The finding itself is report-only (the `TNCS_*` keys of `<prefix>_report.txt`): it gates nothing and changes no reflection, no scale and no group — but the axial-absence test (§13.1) and the $L$-test here both correct themselves against the modulation it measures.
 
 **The $L$-test partners are chosen so a pseudo-translation cannot silence it.** The test compares each reflection with a partner a fixed index step away, and a pseudo-translation biases $\langle|L|\rangle$ upwards unless the partner shares its modulation class. The ordinary step of 2 preserves the class of a half-integer translation — the pseudo-centering the statistic's authors call it robust to — but not of one of a third, which inflates $\langle|L|\rangle$ past the bound that is read as evidence *against* twinning and silently loses the twin call on a crystal that has one. Where a pseudo-translation is detected, the partner steps are restricted to those that preserve its class; where no step does, the statistic is dropped from the twin verdict **in both directions** — it can no longer indicate a twin and can no longer be read as proof that there is none — and the second moment decides alone. `L_TEST_VS_TNCS=` in the report says which of the three happened.
diff --git a/image_analysis/scale_merge/TwinningAnalysis.cpp b/image_analysis/scale_merge/TwinningAnalysis.cpp
index 6f96e9ab2..488470f84 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.cpp
+++ b/image_analysis/scale_merge/TwinningAnalysis.cpp
@@ -9,6 +9,7 @@
 #include <cstdint>
 #include <iomanip>
 #include <limits>
+#include <numbers>
 #include <sstream>
 #include <unordered_map>
 #include <vector>
@@ -475,3 +476,240 @@ std::string TwinningVerdictLine(const TwinningAnalysisResult& result) {
            << "; <|L|> not readable)";
     return os.str();
 }
+
+namespace {
+    // Measurement noise inflates <|E^2-1|> towards centric in every class (by +0.44 at a shell
+    // <I/sigma> of 2.5 and ~0 at 16, measured), so only shells above this are read. At 5 the acentric
+    // control of four reference merges reads 0.65-0.74.
+    constexpr double ZONE_MIN_SHELL_ISIG = 5.0;
+    // Each class is normalised against its own mean in resolution bins of this many reflections, so a
+    // zone that is a plane through reciprocal space is not judged on another direction's fall-off.
+    constexpr size_t ZONE_BIN = 100;
+    // A reflection this far above its bin mean is not a Wilson draw (centric P ~ 1e-5): one such
+    // reflection read 2.33 for a whole zone.
+    constexpr double ZONE_OUTLIER_E2 = 20.0;
+
+    // ln p_centric(E^2) - ln p_acentric(E^2) for a measured E^2 with error s: both Wilson densities
+    // convolved with the measurement error. Without the convolution the centric density, infinite at
+    // zero, reads every noisy weak reflection as decisive; flooring E^2 at s instead turns the centric
+    // excess of weak reflections into moderate values and read a genuine centric zone of a 1.2 A
+    // crystal as acentric. Integrated over u = sqrt(E^2_true), where neither density is singular,
+    // across +-6 s of the measurement (trapezoid).
+    double CentricOverAcentric(double e2, double s) {
+        constexpr int n = 200;
+        const double u_lo = std::sqrt(std::max(0.0, e2 - 6.0 * s));
+        const double u_hi = std::sqrt(std::max(0.0, e2 + 6.0 * s));
+        if (!(u_hi > u_lo))
+            return 0.0;
+        const double du = (u_hi - u_lo) / n;
+        double p_centric = 0.0, p_acentric = 0.0;
+        for (int i = 0; i <= n; ++i) {
+            const double u = u_lo + i * du;
+            const double w = (i == 0 || i == n ? 0.5 : 1.0) * std::exp(-0.5 * std::pow((e2 - u * u) / s, 2));
+            p_centric += w * std::sqrt(2.0 / std::numbers::pi) * std::exp(-0.5 * u * u);
+            p_acentric += w * 2.0 * u * std::exp(-u * u);
+        }
+        return p_centric > 0.0 && p_acentric > 0.0 ? std::log(p_centric / p_acentric) : 0.0;
+    }
+
+    TwinImmuneZone ReadZone(std::vector<const MergedReflection*> refl, const std::array<double, 3>* tncs) {
+        TwinImmuneZone z;
+        // A pseudo-translation u multiplies the intensity by 1 + f cos(2 pi h.u): normalising within
+        // each sign of the cosine keeps the two populations from reading as one broad distribution.
+        std::vector<const MergedReflection*> classes[2];
+        for (const auto* r : refl) {
+            const double c = tncs == nullptr ? 1.0
+                    : std::cos(2.0 * std::numbers::pi * (r->h * (*tncs)[0] + r->k * (*tncs)[1] + r->l * (*tncs)[2]));
+            classes[c >= 0.0 ? 0 : 1].push_back(r);
+        }
+        double sum = 0.0, sum2 = 0.0;
+        for (auto& cls : classes) {
+            std::sort(cls.begin(), cls.end(), [](const auto* a, const auto* b) { return a->d > b->d; });
+            const size_t n_bins = std::max<size_t>(1, cls.size() / ZONE_BIN);
+            for (size_t b = 0; b < n_bins; ++b) {
+                const size_t first = b * cls.size() / n_bins, last = (b + 1) * cls.size() / n_bins;
+                double mean = 0.0;
+                for (size_t i = first; i < last; ++i)
+                    mean += cls[i]->I;
+                mean /= static_cast<double>(last - first);
+                if (mean <= 0.0)
+                    continue;
+                double kept = 0.0;
+                int n_kept = 0;
+                for (size_t i = first; i < last; ++i)
+                    if (cls[i]->I / mean <= ZONE_OUTLIER_E2) {
+                        kept += cls[i]->I;
+                        ++n_kept;
+                    }
+                if (n_kept == 0 || kept <= 0.0)
+                    continue;
+                mean = kept / n_kept;
+                for (size_t i = first; i < last; ++i) {
+                    const double e2 = cls[i]->I / mean;
+                    if (e2 > ZONE_OUTLIER_E2)
+                        continue;
+                    const double v = std::fabs(e2 - 1.0);
+                    sum += v;
+                    sum2 += v * v;
+                    ++z.n;
+                    z.evidence_nats += CentricOverAcentric(e2, cls[i]->sigma / mean);
+                }
+            }
+        }
+        if (z.n > 0) {
+            z.mean_abs_e2_minus_1 = sum / z.n;
+            const double var = std::max(0.0, sum2 / z.n - z.mean_abs_e2_minus_1 * z.mean_abs_e2_minus_1);
+            z.standard_error = std::sqrt(var / z.n);
+        }
+        return z;
+    }
+}
+
+TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>& p1_merged,
+                                            const gemmi::SpaceGroup& group,
+                                            const std::array<double, 3>* tncs_vector) {
+    TwinImmuneZoneResult result;
+    result.tncs_normalised = tncs_vector != nullptr;
+    const gemmi::GroupOps gops = group.operations();
+
+    // The index-2 subgroups H of the group's rotations: each is a hypothesis "the crystal is H, and the
+    // rest of the group (G minus H, one coset) is a twin law or a pseudo-symmetry". H holds every square
+    // of G, so it is the subgroup the squares generate, or that plus one more rotation; for a proper
+    // point group that finds them all (G over its squares is at most a four-group).
+    auto same = [](const gemmi::Op& a, const gemmi::Op& b) { return a.rot == b.rot; };
+    auto contains = [&](const std::vector<gemmi::Op>& set, const gemmi::Op& op) {
+        return std::any_of(set.begin(), set.end(), [&](const gemmi::Op& o) { return same(o, op); });
+    };
+    auto closure = [&](const std::vector<gemmi::Op>& generators) {
+        std::vector<gemmi::Op> ops;
+        for (const auto& g : generators)
+            if (!contains(ops, g))
+                ops.push_back(g);
+        for (size_t i = 0; i < ops.size(); ++i)
+            for (size_t j = 0; j <= i; ++j)
+                for (const gemmi::Op& p : {ops[i] * ops[j], ops[j] * ops[i]})
+                    if (!contains(ops, p))
+                        ops.push_back(p);
+        return ops;
+    };
+    std::vector<gemmi::Op> rotations;
+    for (const auto& op : gops.derive_symmorphic().sym_ops)
+        if (op.det_rot() > 0)
+            rotations.push_back(gemmi::Op{op.rot, {0, 0, 0}, 'x'});
+    std::vector<gemmi::Op> squares{gemmi::Op::identity()};
+    for (const auto& g : rotations)
+        squares.push_back(g * g);
+    const auto square_group = closure(squares);
+    std::vector<std::vector<gemmi::Op>> subgroups;
+    auto add_subgroup = [&](const std::vector<gemmi::Op>& h) {
+        if (2 * h.size() != rotations.size())
+            return;
+        for (const auto& known : subgroups)
+            if (known.size() == h.size()
+                && std::all_of(h.begin(), h.end(), [&](const gemmi::Op& o) { return contains(known, o); }))
+                return;
+        subgroups.push_back(h);
+    };
+    add_subgroup(square_group);
+    for (const auto& g : rotations) {
+        auto gen = square_group;
+        gen.push_back(g);
+        add_subgroup(closure(gen));
+    }
+    if (subgroups.empty())
+        return result;
+
+    // Reflections present in the group and in general position (epsilon 1): an axial row is fixed by
+    // more than one operator and follows neither distribution.
+    std::vector<const MergedReflection*> usable;
+    for (const auto& r : p1_merged) {
+        const gemmi::Op::Miller h{{r.h, r.k, r.l}};
+        if (UsableIntensity(r) && std::isfinite(r.sigma) && r.sigma > 0.0
+            && !gops.is_systematically_absent(h) && gops.epsilon_factor_without_centering(h) == 1)
+            usable.push_back(&r);
+    }
+    // The shells with signal enough to read (ZONE_MIN_SHELL_ISIG), 20 equal in 1/d^2.
+    constexpr int n_shells = 20;
+    double min_s = std::numeric_limits<double>::infinity(), max_s = 0.0;
+    for (const auto* r : usable) {
+        min_s = std::min(min_s, 1.0 / (r->d * r->d));
+        max_s = std::max(max_s, 1.0 / (r->d * r->d));
+    }
+    if (!(max_s > min_s))
+        return result;
+    auto shell_of = [&](const MergedReflection* r) {
+        const double t = (1.0 / (r->d * r->d) - min_s) / (max_s - min_s);
+        return std::min(n_shells - 1, std::max(0, static_cast<int>(t * n_shells)));
+    };
+    std::vector<double> isig_sum(n_shells, 0.0);
+    std::vector<int> isig_n(n_shells, 0);
+    for (const auto* r : usable) {
+        isig_sum[shell_of(r)] += r->I / r->sigma;
+        isig_n[shell_of(r)] += 1;
+    }
+    std::vector<const MergedReflection*> strong;
+    for (const auto* r : usable) {
+        const int b = shell_of(r);
+        if (isig_n[b] > 0 && isig_sum[b] / isig_n[b] >= ZONE_MIN_SHELL_ISIG)
+            strong.push_back(r);
+    }
+    if (strong.empty())
+        return result;
+    result.d_max_A = 0.0;
+    result.d_min_A = std::numeric_limits<double>::infinity();
+    for (const auto* r : strong) {
+        result.d_max_A = std::max<double>(result.d_max_A, r->d);
+        result.d_min_A = std::min<double>(result.d_min_A, r->d);
+    }
+
+    std::vector<const MergedReflection*> control;
+    for (const auto* r : strong)
+        if (!gops.is_reflection_centric(gemmi::Op::Miller{{r->h, r->k, r->l}}))
+            control.push_back(r);
+    result.control = ReadZone(control, tncs_vector);
+    result.control.operators = "acentric";
+
+    // Per hypothesis H, the zone: centric in the group, acentric in H - the reflections some added
+    // operator sends to -h, i.e. the self-mates of that coset read as a twin law.
+    for (const auto& h_ops : subgroups) {
+        std::vector<const MergedReflection*> zone;
+        for (const auto* r : strong) {
+            const gemmi::Op::Miller h{{r->h, r->k, r->l}};
+            const gemmi::Op::Miller minus{{-gemmi::Op::DEN * r->h, -gemmi::Op::DEN * r->k, -gemmi::Op::DEN * r->l}};
+            const bool centric_in_h = std::any_of(h_ops.begin(), h_ops.end(), [&](const gemmi::Op& op) {
+                return op.apply_to_hkl_without_division(h) == minus;
+            });
+            if (gops.is_reflection_centric(h) && !centric_in_h)
+                zone.push_back(r);
+        }
+        TwinImmuneZone z = ReadZone(zone, tncs_vector);
+        for (const auto& op : rotations)
+            if (!contains(h_ops, op))
+                z.operators += (z.operators.empty() ? "" : " ") + op.as_hkl().triplet();
+        result.zones.push_back(z);
+    }
+    return result;
+}
+
+std::string TwinImmuneZonesToText(const TwinImmuneZoneResult& result) {
+    std::ostringstream os;
+    os << std::fixed;
+    os << "Twin-immune zones of the operators the adopted group adds over each index-2 subgroup (P1 merge, " << std::setprecision(2) << result.d_max_A
+       << "-" << result.d_min_A << " A, shells with <I/sigma> >= " << std::setprecision(0)
+       << ZONE_MIN_SHELL_ISIG << (result.tncs_normalised ? ", normalised per pseudo-translation class" : "")
+       << ")\n"
+       << "  Reflections centric in the group but not in the subgroup are their own twin mates: centric if\n"
+       << "  the added operators are real, acentric if they are a twin law or a pseudo-symmetry. <|E^2-1|>\n"
+       << "  reads 0.968 centric, 0.736 acentric; evidence is the centric/acentric log-likelihood ratio\n"
+       << "  (> 0: the added operators are real).\n";
+    auto row = [&](const TwinImmuneZone& z) {
+        os << "  " << std::left << std::setw(34) << z.operators << std::right << " n " << std::setw(6) << z.n
+           << "  <|E^2-1|> " << std::setprecision(3) << z.mean_abs_e2_minus_1 << " +- " << z.standard_error
+           << "  evidence " << std::showpos << std::setprecision(1) << z.evidence_nats << std::noshowpos
+           << " nats\n";
+    };
+    for (const auto& z : result.zones)
+        row(z);
+    row(result.control);
+    return os.str();
+}
diff --git a/image_analysis/scale_merge/TwinningAnalysis.h b/image_analysis/scale_merge/TwinningAnalysis.h
index 965c4da89..259d89cdb 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.h
+++ b/image_analysis/scale_merge/TwinningAnalysis.h
@@ -91,3 +91,41 @@ std::string TwinningAnalysisToText(const TwinningAnalysisResult& result);
 // The verdict in one line - "INDICATED (...)", "SYMMETRY SUSPECT (...)" or "no indication (...)" -
 // so the report's summary row, its prose and the viewer all say the same thing.
 std::string TwinningVerdictLine(const TwinningAnalysisResult& result);
+
+// Twin-immune zone evidence for the operators a point group adds over each of its index-2 subgroups,
+// read on a P1 merge. REPORT-ONLY.
+//
+// Under a twin law T, I_obs(h) = (1-a) I(h) + a I(Th); a reflection whose twin mate Th is h itself, up
+// to the true group and Friedel, is untouched by twinning at every fraction a. For an index-2 subgroup
+// H of the adopted group G those are the reflections centric in G but acentric in H: centric if the
+// operators G adds over H are real, acentric if they are a twin law or a pseudo-symmetry the promotion
+// took for real. So their intensity distribution says which, and does so where every operator
+// statistic is blind - at a = 0.5, where I(h) = I(Th) exactly. Read ABSOLUTELY, <|E^2-1|> against
+// 0.968 (centric) and 0.736 (acentric); never as the difference to the control, because noise, a
+// pseudo-translation and anisotropy all inflate every class towards centric, and a perfect twin's
+// control (0.541) plus that inflation looks like true symmetry's.
+struct TwinImmuneZone {
+    std::string operators;              // the operators G adds over H, as h,k,l triplets
+    int n = 0;
+    double mean_abs_e2_minus_1 = 0.0;   // 0.968 centric (operator real), 0.736 acentric (not)
+    double standard_error = 0.0;
+    // Log-likelihood ratio, centric over acentric Wilson (each convolved with the reflection's error),
+    // summed over the zone: > 0 favours the operators being real symmetry, < 0 a twin law or
+    // pseudo-symmetry. About +0.2 nats per reflection for a centric zone and -0.13 for an acentric one
+    // on error-free data; less either way as the errors grow.
+    double evidence_nats = 0.0;
+};
+
+struct TwinImmuneZoneResult {
+    std::vector<TwinImmuneZone> zones;  // one per index-2 subgroup of the group
+    TwinImmuneZone control;             // the reflections acentric in the group
+    double d_max_A = 0.0;               // resolution range of the shells read
+    double d_min_A = 0.0;
+    bool tncs_normalised = false;       // normalised within the pseudo-translation's two phase classes
+};
+
+TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>& p1_merged,
+                                            const gemmi::SpaceGroup& group,
+                                            const std::array<double, 3>* tncs_vector = nullptr);
+
+std::string TwinImmuneZonesToText(const TwinImmuneZoneResult& result);
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 4106b22e4..552b7380f 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -1133,6 +1133,21 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                              " absorbed can only show there as an operator averaging unequal intensities. These\n"
                              " numbers are not circular in that way.", true));
             }
+            if (result.twin_immune_zones && !result.twin_immune_zones->zones.empty()) {
+                // Report-only evidence, one row per class of 2-folds of the adopted group. Not a decision:
+                // the space group above was chosen without it.
+                const auto &tz = *result.twin_immune_zones;
+                for (size_t i = 0; i < tz.zones.size(); ++i) {
+                    const auto &z = tz.zones[i];
+                    Add(s, KeyText(fmt::format("TWIN_ZONE_{}", i + 1).c_str(),
+                                   fmt::format("{}; n={} <|E2-1|>={:.3f}+-{:.3f} evidence={:+.1f} nats", z.operators,
+                                               z.n, z.mean_abs_e2_minus_1, z.standard_error, z.evidence_nats)));
+                }
+                Add(s, KeyText("TWIN_ZONE_CONTROL",
+                               fmt::format("n={} <|E2-1|>={:.3f}+-{:.3f}", tz.control.n,
+                                           tz.control.mean_abs_e2_minus_1, tz.control.standard_error)));
+                Add(s, Prose("\n" + TwinImmuneZonesToText(tz)));
+            }
             if (tw.adopted_operators_suspect)
                 Warn(doc, PathologyCode::TWINNING, fmt::format(
                         "An adopted symmetry operator relates unequal intensities (<|L|> = {:.3f} in a holohedral "
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 20d4d0063..44a16b013 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6784,6 +6784,16 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 experiment_.SpaceGroupNumber(1);
                 const auto p1 = scale_and_merge("P1 cross-check", false);
 
+                // Twin-immune zone evidence for each 2-fold the adopted group holds, read on this merge
+                // because it is folded under no symmetry, at full resolution and production-scaled.
+                // Report-only: nothing reads it back.
+                if (determined != nullptr && determined->number > 1) {
+                    result.twin_immune_zones = AnalyzeTwinImmuneZones(
+                            p1.merged, *determined, TranslationalNCSVectorForLTest(result.tncs));
+                    if (!result.twin_immune_zones->zones.empty())
+                        logger.Info("{}", TwinImmuneZonesToText(*result.twin_immune_zones));
+                }
+
                 // FINALIST LEDGER (--finalist-ledger), report-only and deliberately behind a flag: these
                 // numbers are an instrument, and reading them as a decision before they are calibrated
                 // is the one way this can do harm.
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index b6e8d67bc..2dc87f29f 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -317,6 +317,10 @@ struct ProcessResult {
     // for one. False when there was no cell to run the Patterson on.
     bool pre_promotion_tncs_measured = false;
 
+    // Twin-immune zone evidence for the 2-folds of the adopted group, on the P1 cross-check merge
+    // (AnalyzeTwinImmuneZones). Report-only. Unset when no P1 cross-check merge was built.
+    std::optional<TwinImmuneZoneResult> twin_immune_zones;
+
     // What --model found, when one was given. Set even when the validation could not run - its
     // failure_reason then says why - so the report can report the failure rather than leave a run
     // that was asked to validate looking like one that was not. Unset when no model was asked for.
diff --git a/tests/TwinningAnalysisTest.cpp b/tests/TwinningAnalysisTest.cpp
index 006f9a2b6..06c6b8d60 100644
--- a/tests/TwinningAnalysisTest.cpp
+++ b/tests/TwinningAnalysisTest.cpp
@@ -6,6 +6,7 @@
 #include <array>
 #include <cmath>
 #include <map>
+#include <tuple>
 #include <numbers>
 #include <vector>
 
@@ -216,3 +217,74 @@ TEST_CASE("A holohedral merge under a false operator is called suspect", "[twinn
         CHECK(TwinningVerdictLine(r).rfind("SYMMETRY SUSPECT", 0) == 0);
     }
 }
+
+namespace {
+    // A P1 merge whose centric reflections are centric: SyntheticMergedReflections draws every
+    // intensity from the acentric distribution, which is all the searches it was written for need, but
+    // the zone test reads exactly the difference. E^2 is chi^2 with one degree of freedom for a
+    // reflection centric in the true group (a squared Box-Muller normal), exponential otherwise, keyed
+    // on the asymmetric-unit index so the true group's symmetry is exact.
+    std::vector<MergedReflection> WilsonTetragonal(const char *true_group, double twin_fraction) {
+        const gemmi::SpaceGroup &sub = gemmi::get_spacegroup_by_name(true_group);
+        const gemmi::SpaceGroup &super = gemmi::get_spacegroup_by_name("P 4 2 2");
+        const gemmi::Op twin = jfjoch_test::TwinLaw(sub, super);
+        const gemmi::GroupOps gops = sub.operations();
+        const gemmi::ReciprocalAsu rasu(&sub);
+        const gemmi::UnitCell cell(47, 47, 63, 90, 90, 90);
+        auto true_intensity = [&](const gemmi::Op::Miller &hkl) {
+            const auto asu = rasu.to_asu(hkl, gops).first;
+            const double u1 = jfjoch_test::detail::UniformFromHkl(asu);
+            const double u2 = jfjoch_test::detail::UniformFromHkl({{asu[0] + 300, asu[1] + 300, asu[2] + 300}});
+            const double c = std::cos(2.0 * std::numbers::pi * u2);
+            const double e2 = gops.is_reflection_centric(hkl) ? -2.0 * std::log(u1) * c * c : -std::log(u1);
+            return 1000.0 * e2 * std::exp(-20.0 / (2.0 * std::pow(cell.calculate_d(hkl), 2)));
+        };
+        std::vector<MergedReflection> out;
+        for (int h = -19; h <= 19; ++h)
+            for (int k = -19; k <= 19; ++k)
+                for (int l = -26; l <= 26; ++l) {
+                    if (std::make_tuple(h, k, l) <= std::make_tuple(-h, -k, -l))
+                        continue;
+                    const gemmi::Op::Miller hkl{{h, k, l}};
+                    const double d = cell.calculate_d(hkl);
+                    if (d < 2.5)
+                        continue;
+                    MergedReflection r;
+                    r.h = h;
+                    r.k = k;
+                    r.l = l;
+                    r.d = static_cast<float>(d);
+                    r.I = static_cast<float>((1.0 - twin_fraction) * true_intensity(hkl)
+                                             + twin_fraction * true_intensity(twin.apply_to_hkl(hkl)));
+                    r.sigma = static_cast<float>(0.01 * r.I + 1.0);
+                    out.push_back(r);
+                }
+        return out;
+    }
+}
+
+// Reflections centric in the adopted group but acentric in a subgroup are their own twin mates under
+// the operators the group adds. A perfect twin makes every operator statistic read "real", but these
+// stay acentric under it and are centric only where the added operators are real.
+TEST_CASE("Twin-immune zones tell a perfect twin from real symmetry", "[twinning]") {
+    const gemmi::SpaceGroup &p422 = gemmi::get_spacegroup_by_name("P 4 2 2");
+
+    const auto real = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4 2 2", 0.0), p422);
+    REQUIRE(real.zones.size() == 3);                       // over 4, over 222, over the diagonal 222
+    for (const auto &z : real.zones) {
+        CAPTURE(z.operators);
+        CHECK(z.mean_abs_e2_minus_1 == Catch::Approx(0.968).margin(0.08));
+        CHECK(z.evidence_nats > 0.0);
+    }
+    CHECK(real.control.mean_abs_e2_minus_1 == Catch::Approx(0.736).margin(0.05));
+
+    // A perfect P4 twin: whichever subgroup is taken as the parent, the operators added over it are
+    // not all real, and the zone reads acentric.
+    const auto twin = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4", 0.5), p422);
+    REQUIRE(twin.zones.size() == 3);
+    for (const auto &z : twin.zones) {
+        CAPTURE(z.operators);
+        CHECK(z.mean_abs_e2_minus_1 == Catch::Approx(0.736).margin(0.08));
+        CHECK(z.evidence_nats < 0.0);
+    }
+}
-- 
2.54.0


From c25042ffa9300563948220cab9351c899d278154 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:06:05 +0200
Subject: [PATCH 014/122] rugnux: the report's shell check compares the fit
 with the shell the crossing lies in

FITTED_RESOLUTION was withheld whenever the fit was finer than the d_min of
the last shell whose CC1/2 still reached the target. A shell's CC1/2 is an
average over the shell, so on every ordinary fall-off the crossing lies
inside the first shell whose average is below the target - 0.01-0.1 A finer
than the number the check allowed - and the report said "no resolution could
be fitted" on data whose fall-off is textbook: 68 of 100 battery datasets,
with the fit 0.01-0.02 A inside the first sub-target shell. The comparison is
now against that shell's d_min, and the RESOLUTION_FIT flag fires only where
the fit is finer than the shell the crossing can lie in.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 rugnux/ResultReport.cpp    | 35 +++++++++++++++++++++++++++--------
 tests/ResultReportTest.cpp |  7 +++++++
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 552b7380f..f2f76ab82 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -204,9 +204,8 @@ namespace {
         return o.str();
     }
 
-    // The finest shell whose CC1/2 still reaches the cut's own target. A fitted resolution finer than
-    // this was read off a curve that never behaved like a fall-off, and asserting it states a
-    // resolution the shell table on the same page refutes.
+    // The finest shell whose CC1/2 still reaches the cut's own target: where the table says the signal
+    // is, for the completeness quoted beside the written range.
     double FinestSupportedShell(const MergeStatistics &ms, double target) {
         double finest = 0.0;
         for (const auto &sh : ms.shells)
@@ -215,6 +214,25 @@ namespace {
         return finest;   // 0.0 = no shell reaches the target at all
     }
 
+    // The finest resolution the shell table supports a fitted crossing at. A shell's CC1/2 is an
+    // average over the shell, so the crossing sits INSIDE the first shell whose average falls below the
+    // target, between its d_max and its d_min: a fit anywhere down to that shell's d_min is what the
+    // table shows, and only a fit finer than it is one the table refutes. Comparing against the last
+    // shell ABOVE the target instead withheld the number on 68 of 100 battery datasets whose fit sat
+    // 0.01-0.02 A inside the first sub-target shell. 0.0 when no shell reaches the target; the finest
+    // shell when none falls below it.
+    double CrossingShellLimit(const MergeStatistics &ms, double target) {
+        double finest = 0.0;
+        for (const auto &sh : ms.shells) {
+            if (!std::isfinite(sh.cc_half))
+                continue;
+            if (sh.cc_half < target)
+                return finest == 0.0 ? 0.0 : sh.d_min;
+            finest = sh.d_min;
+        }
+        return finest;
+    }
+
     // Where CC1/2 climbs back above the cut's target after it has already fallen below it. Below the
     // target a shell carries no signal the cut would keep, so a shell past that point which
     // correlates again is noise correlating with noise: the curve is not a fall-off, and no single
@@ -619,6 +637,7 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             // than the finest shell that still reaches the target asserts a resolution the shell
             // table on this very page refutes.
             const double finest_supported = FinestSupportedShell(ms, cc_target);
+            const double crossing_limit = CrossingShellLimit(ms, cc_target);
             const double climbs_back = CCHalfClimbsBackAboveTarget(ms, cc_target);
             std::string fit_suppressed;
             // Only where there are shells to judge the fit against; with no table there is no
@@ -630,15 +649,15 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                             " at {:.2f} A, so this curve is not a fall-off and no one resolution can be"
                             " read off it", cc_target, climbs_back);
                 else if (result.resolution_fit_A) {
-                    if (finest_supported == 0.0)
+                    if (crossing_limit == 0.0)
                         fit_suppressed = fmt::format(
                                 "CC1/2 never reaches the cut's target of {:.2f} in any shell, so there is"
                                 " no fall-off to fit", cc_target);
-                    else if (*result.resolution_fit_A < finest_supported - 1e-6)
+                    else if (*result.resolution_fit_A < crossing_limit - 1e-6)
                         fit_suppressed = fmt::format(
-                                "the fit reads {:.2f} A, finer than the finest shell whose CC1/2 still"
-                                " reaches {:.2f} ({:.2f} A), so the curve it was read off is not a"
-                                " fall-off", *result.resolution_fit_A, cc_target, finest_supported);
+                                "the fit reads {:.2f} A, finer than the shell where CC1/2 falls below"
+                                " {:.2f} ({:.2f} A), so the curve it was read off is not a fall-off",
+                                *result.resolution_fit_A, cc_target, crossing_limit);
                     else
                         fitted_resolution = *result.resolution_fit_A;
                 }
diff --git a/tests/ResultReportTest.cpp b/tests/ResultReportTest.cpp
index 5bafc0525..9a246edb8 100644
--- a/tests/ResultReportTest.cpp
+++ b/tests/ResultReportTest.cpp
@@ -628,6 +628,13 @@ TEST_CASE("ResultReport_FittedResolutionSuppressed", "[Diagnostics]") {
     CHECK(RenderResultReport("p", "in.h5", x, result).find("\nFITTED_RESOLUTION= 0.95\n")
           != std::string::npos);
 
+    // A shell's CC1/2 is its average, so the crossing lies inside the first shell below the target:
+    // a fit there is what the table shows, not something it refutes.
+    result.resolution_fit_A = 0.85;
+    CHECK(RenderResultReport("p", "in.h5", x, result).find("\nFITTED_RESOLUTION= 0.85\n")
+          != std::string::npos);
+    result.resolution_fit_A = 0.95;
+
     // CC1/2 that drops through the target and climbs back above it is not a fall-off either, and the
     // finest shell reaching the target is then noise correlating with noise - so a fit the test above
     // accepts must still be suppressed, and the user told so in the default report.
-- 
2.54.0


From eaf9dbdf2d23b58ab49ac3104a1a5d5703a27947 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 08:39:27 +0200
Subject: [PATCH 015/122] rugnux: weighted median for the rot3d merge outlier
 test

The per-reflection median the merge rejects outliers against was an
unweighted median of the scaled intensities. On a sweep where the crystal
barely diffracts over a long stretch, observations from those frames are
scaled up by 1/G together with their sigmas, and in P1 at multiplicity ~3
two of them outvote one well-measured observation: the median becomes
noise and the well-measured observation is rejected against its own small
sigma. On one P1 sweep with ~44% such frames this rejected 52,574
observations (2,131 once those frames are dropped) and took the
correlation of the merged intensities with an external reference from
0.92 to 0.68 at low resolution. The median is now weighted by
1/(sigma*corr)^2, which leaves it unchanged where the observations are
comparably precise: rejections 3,932, correlation 0.92.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../scale_merge/RotationScaleMerge.cpp        | 24 +++++++++++++++----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index e651313f3..7bb72e504 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3752,21 +3752,35 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             std::vector<int32_t> start(n_groups + 1, 0);
             for (int g = 0; g < n_groups; ++g)
                 start[g + 1] = start[g] + (cnt[g] >= 3 ? cnt[g] : 0);
-            std::vector<float> iv(start[n_groups]);
+            // Inverse-variance WEIGHTED median: a frame the crystal barely diffracted on is scaled up by
+            // 1/G together with its sigma, so a plain median lets two such observations outvote one
+            // well-measured one - and the test below then rejects the well-measured one against its
+            // own small sigma.
+            std::vector<std::pair<float, float>> iv(start[n_groups]);   // (I*corr, 1/(sigma*corr)^2)
             {
                 std::vector<int32_t> fill(start.begin(), start.end() - 1);
                 for (int i = 0; i < n_full; ++i) {
                     const int g = mf.group[i];
-                    if (g >= 0 && cnt[g] >= 3) iv[fill[g]++] = mf.I[i] * mf.corr[i];
+                    if (g >= 0 && cnt[g] >= 3) {
+                        const float sc = mf.sigma[i] * mf.corr[i];
+                        iv[fill[g]++] = {mf.I[i] * mf.corr[i], sc > 0.0f ? 1.0f / (sc * sc) : 0.0f};
+                    }
                 }
             }
             ParallelChunks(n_groups, ThreadsForWork(iv.size(), nthreads), [&](int glo, int ghi) {
                 for (int g = glo; g < ghi; ++g) {
                     const int lo = start[g], hi = start[g + 1];
                     if (lo == hi) continue;
-                    const auto mid = iv.begin() + lo + (hi - lo) / 2;
-                    std::nth_element(iv.begin() + lo, mid, iv.begin() + hi);
-                    reject_median[g] = *mid;
+                    std::sort(iv.begin() + lo, iv.begin() + hi);
+                    double total = 0.0;
+                    for (int j = lo; j < hi; ++j) total += iv[j].second;
+                    double run = 0.0;
+                    int j = lo;
+                    for (; j < hi - 1; ++j) {
+                        run += iv[j].second;
+                        if (run >= 0.5 * total) break;
+                    }
+                    reject_median[g] = iv[j].first;
                 }
             });
         }
-- 
2.54.0


From 3d7891c347c3ec8ef81cbc90e0b54d8ae9f1e037 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:34:48 +0200
Subject: [PATCH 016/122] rugnux: weight every CC1/2 by the information a
 reflection carries

The resolution cutoff, the shell table and the overall CC1/2 counted every
unique reflection equally. The merge itself is inverse-variance weighted, so
an observation from a frame the crystal barely diffracted on enters it at
1/G^2 of a good one - honestly, with its sigma - but a reflection measured
only on such frames is scaled-up noise that then counts as much as a
well-measured pair in every Pearson CC1/2 read off the merge. On a sweep
where half the frames are weak the curve collapses at every resolution: the
cut lands at 3.7 A on a P1 crystal whose good frames reach 1.5 A, and the
UNUSABLE verdict fires (CC1/2 0.40 beside I/sigma 10).

Each merged reflection now carries cc_weight: the precision its half-sets
would have had with every observation at the run's typical frame scale, over
the precision they have. G_ref = sum G^3 / sum G^2 over the usable
observations is the precision-weighted typical scale, which the dead frames
cannot drag down however many there are; the factor per observation is
max(1, (G_ref/G)^2), with G the frame's total scale (partial scale, flux and
the fulls' own G) taken before the correction surfaces and before collapsed
frames are dropped, so nothing intensity- or resolution-dependent enters it.
On a sweep without a weak stretch every weight is 1 and the CC1/2 is the
plain Pearson it was. The cutoff fit, the shell table and the overall CC1/2
(and so the UNUSABLE verdict and the report's shell checks) all read the same
weighted statistic.

The two extra per-group sums are accumulated on both merge paths, the host
loop and MergeAccumKernel, from one per-frame factor array; a host recompute
of the device sums agrees to 1e-15 relative on every merge after the
corrected corr is uploaded, and a host-merge run gives the same cut, space
group, CC1/2 and ISa on five sets.

Weighting by the half-set error variance alone (1/(v0+v1)) is not this: v
grows with the intensity, so it weights the weak end of the intensity
distribution and biases homogeneous data coarser.

Measured (written resolution, together with the weighted outlier median):
a P1 sweep with a long weak stretch 3.73 -> 1.40 A against a 1.63 A XDS
reference, UNUSABLE withdrawn (overall CC1/2 0.40 -> 0.97); a second 3.61 ->
3.00 A; one with most of the sweep out of beam 7.35 -> 5.20 A. Lysozyme,
thaumatin and two insulin sets unchanged to 0.01 A (one lysozyme sweep with a
weak wedge 1.13 -> 1.16 A, from the median), same space groups throughout.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 common/CorrelationCoefficient.cpp             | 17 +++---
 common/CorrelationCoefficient.h               |  5 +-
 common/Reflection.h                           |  5 ++
 .../scale_merge/ResolutionCutoff.cpp          | 22 +++++++-
 image_analysis/scale_merge/ResolutionCutoff.h |  8 +++
 .../scale_merge/RotationScaleMerge.cpp        | 39 ++++++++++++-
 .../scale_merge/RotationScaleMerge.h          | 10 +++-
 .../scale_merge/RotationScaleMergeGPU.cu      | 31 +++++++----
 .../scale_merge/RotationScaleMergeGPU.h       |  8 ++-
 tests/MergeScaleTest.cpp                      | 55 ++++++++++++++++++-
 10 files changed, 168 insertions(+), 32 deletions(-)

diff --git a/common/CorrelationCoefficient.cpp b/common/CorrelationCoefficient.cpp
index 24925571c..7c21dbb26 100644
--- a/common/CorrelationCoefficient.cpp
+++ b/common/CorrelationCoefficient.cpp
@@ -6,19 +6,20 @@
 
 #include "CorrelationCoefficient.h"
 
-void CorrelationCoefficient::Add(double x, double y) {
-        sum_x += x;
-        sum_y += y;
-        sum_x2 += x * x;
-        sum_y2 += y * y;
-        sum_xy += x * y;
+void CorrelationCoefficient::Add(double x, double y, double w) {
+        sum_x += w * x;
+        sum_y += w * y;
+        sum_x2 += w * x * x;
+        sum_y2 += w * y * y;
+        sum_xy += w * x * y;
+        sum_w += w;
         n_cc++;
 }
 
 double CorrelationCoefficient::GetCC() const {
-         if (n_cc < 2)
+         if (n_cc < 2 || !(sum_w > 0.0))
             return NAN;
-        const double n = static_cast<double>(n_cc);
+        const double n = sum_w;
         const double mean_x = sum_x / n;
         const double mean_y = sum_y / n;
 
diff --git a/common/CorrelationCoefficient.h b/common/CorrelationCoefficient.h
index 711284226..943a3936a 100644
--- a/common/CorrelationCoefficient.h
+++ b/common/CorrelationCoefficient.h
@@ -9,9 +9,12 @@ class CorrelationCoefficient {
     double sum_x2 = 0.0;
     double sum_y2 = 0.0;
     double sum_xy = 0.0;
+    double sum_w = 0.0;
     int n_cc = 0;
 public:
-    void Add(double x, double y);
+    void Add(double x, double y) { Add(x, y, 1.0); }
+    // Weighted pair: a plain Pearson when every weight is the same.
+    void Add(double x, double y, double w);
     [[nodiscard]] double GetCC() const;
 };
 
diff --git a/common/Reflection.h b/common/Reflection.h
index 5e4f86321..2e304cd79 100644
--- a/common/Reflection.h
+++ b/common/Reflection.h
@@ -64,6 +64,11 @@ struct MergedReflection {
     float sigma = NAN;
     float I_half[2] = {NAN, NAN};
     float sigma_half[2] = {NAN, NAN};
+    // Weight of this reflection in a CC1/2: the precision its half-sets would have had with every
+    // observation at the run's typical frame scale, over the precision they have. 1 on a sweep
+    // without a weak stretch; small for a reflection measured only where the crystal barely
+    // diffracted, whose scaled-up noise would otherwise count as much as a well-measured pair.
+    float cc_weight = 1.0f;
     float d = 0.0;
     // Any observation of this reflection sat on an ice ring. The intensity is still merged and
     // written - the ring contaminates it, it does not make it absent - and this only marks it so
diff --git a/image_analysis/scale_merge/ResolutionCutoff.cpp b/image_analysis/scale_merge/ResolutionCutoff.cpp
index 071a32b56..236a0323c 100644
--- a/image_analysis/scale_merge/ResolutionCutoff.cpp
+++ b/image_analysis/scale_merge/ResolutionCutoff.cpp
@@ -33,6 +33,26 @@ namespace {
     }
 }
 
+std::vector<double> CCHalfFrameFactors(const std::vector<double> &frame_scale,
+                                       const std::vector<int64_t> &n_obs) {
+    auto g_of = [&](size_t f) {
+        return std::isfinite(frame_scale[f]) && frame_scale[f] > 0.0 ? frame_scale[f] : 1.0;
+    };
+    double s3 = 0.0, s2 = 0.0;
+    for (size_t f = 0; f < frame_scale.size(); ++f) {
+        const double g = g_of(f);
+        s3 += n_obs[f] * g * g * g;
+        s2 += n_obs[f] * g * g;
+    }
+    const double g_ref = s2 > 0.0 ? s3 / s2 : 1.0;
+    std::vector<double> factor(frame_scale.size());
+    for (size_t f = 0; f < frame_scale.size(); ++f) {
+        const double r = g_ref / g_of(f);
+        factor[f] = std::max(1.0, r * r);
+    }
+    return factor;
+}
+
 ResolutionCutoffResult ComputeCCHalfLogisticCutoff(const std::vector<MergedReflection> &merged,
                                                    double cc_target, Logger &logger) {
     ResolutionCutoffResult result;
@@ -82,7 +102,7 @@ ResolutionCutoffResult ComputeCCHalfLogisticCutoff(const std::vector<MergedRefle
         const double s = 1.0 / (static_cast<double>(m.d) * m.d);
         int b = static_cast<int>((s - s_lo) / bin_w);
         b = std::clamp(b, 0, N_FIT_BINS - 1);
-        bin_cc[b].Add(m.I_half[0], m.I_half[1]);
+        bin_cc[b].Add(m.I_half[0], m.I_half[1], m.cc_weight);
         ++bin_n[b];
     }
 
diff --git a/image_analysis/scale_merge/ResolutionCutoff.h b/image_analysis/scale_merge/ResolutionCutoff.h
index b6913aea3..730013d97 100644
--- a/image_analysis/scale_merge/ResolutionCutoff.h
+++ b/image_analysis/scale_merge/ResolutionCutoff.h
@@ -34,6 +34,14 @@ struct ResolutionCutoffResult {
     std::string note;              // human-readable description of the decision (for logging)
 };
 
+// The per-frame factor of the CC1/2 weight (MergedReflection::cc_weight): max(1, (G_ref/G)^2), the
+// variance an observation from a frame at scale G carries over the same observation at the typical
+// scale G_ref = sum G^3 / sum G^2 over the observations (n_obs[f] of them on frame f). Precision-
+// weighted, so frames the crystal barely diffracted on cannot drag the typical scale down however many
+// of them there are. A frame without a finite positive scale counts as G = 1.
+std::vector<double> CCHalfFrameFactors(const std::vector<double> &frame_scale,
+                                       const std::vector<int64_t> &n_obs);
+
 ResolutionCutoffResult ComputeCCHalfLogisticCutoff(const std::vector<MergedReflection> &merged,
                                                    double cc_target, Logger &logger);
 
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 7bb72e504..7457c5c05 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3819,6 +3819,22 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     // above, on all threads, so a second serial walk over the fat records only rebuilds it.
     AssignHalvesByRank(obs_key, mf.group, n_groups, merge_half, nthreads);
 
+    // ---- CC1/2 weight (MergedReflection::cc_weight): the precision each half-set WOULD have had with
+    //      every observation at the run's typical frame scale, over the precision it has. An observation
+    //      from a frame the crystal barely diffracted on was scaled up by G_ref/G, so it carries
+    //      (G_ref/G)^2 more counting variance than the same observation at the typical scale; that
+    //      factor, and nothing intensity-dependent, is what the pair is discounted by. G_ref =
+    //      sum G^3 / sum G^2 over the usable observations: the precision-weighted typical scale, which
+    //      the dead frames cannot drag down however many of them there are. A frame brighter than
+    //      typical earns nothing (the factor is floored at 1), so on a sweep without a weak stretch
+    //      every weight is 1 and the CC1/2 is the plain Pearson it was. G is the frame's scale taken
+    //      before the correction surfaces (frame_scale_fulls), which are per-observation and
+    //      resolution-dependent and are not a property of the frame. ----
+    std::vector<int64_t> n_obs_frame(frame_scale_fulls.size(), 0);
+    for (int i = 0; i < n_full; ++i)
+        if (mf.group[i] >= 0) ++n_obs_frame[fulls[i].frame];
+    const std::vector<double> frame_cc_factor = CCHalfFrameFactors(frame_scale_fulls, n_obs_frame);
+
     // ---- Merge: per-group inverse-variance sums with corrected sigma + deterministic half sets, then
     //      export. In a lambda because the automatic resolution cutoff below re-runs it once the error
     //      model has been refitted on the reflections that survive the cut. ----
@@ -3852,8 +3868,10 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             ms.Resize(n_groups);
             gpu_->MergeAccum(error_model_a, error_model_b, error_model_active,
                              reject_outliers, reject_nsigma, reject_median.data(), merge_half.data(),
+                             frame_cc_factor.data(),
                              ms.swI.data(), ms.sw.data(), ms.swIh0.data(), ms.swIh1.data(),
-                             ms.swh0.data(), ms.swh1.data(), ms.nh0.data(), ms.nh1.data(),
+                             ms.swh0.data(), ms.swh1.data(), ms.swh_typ0.data(), ms.swh_typ1.data(),
+                             ms.nh0.data(), ms.nh1.data(),
                              ms.d.data(), ms.rej.data(), ms.on_ice.data(), rejected_obs.data());
             // Per-group and independent, so the unpack splits; the rejected count is an integer sum and
             // does not care in which order the chunks add theirs in.
@@ -3864,6 +3882,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                     Accum &a = acc[g];
                     a.swI = ms.swI[g]; a.sw = ms.sw[g]; a.swIh[0] = ms.swIh0[g]; a.swIh[1] = ms.swIh1[g];
                     a.swh[0] = ms.swh0[g]; a.swh[1] = ms.swh1[g];
+                    a.swh_typ[0] = ms.swh_typ0[g]; a.swh_typ[1] = ms.swh_typ1[g];
                     a.nh[0] = static_cast<size_t>(ms.nh0[g]); a.nh[1] = static_cast<size_t>(ms.nh1[g]);
                     a.d = static_cast<float>(ms.d[g]);
                     a.on_ice = ms.on_ice[g] != 0;
@@ -3893,6 +3912,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                 const int half = merge_half[&o - fulls.data()];
                 a.swI += wI; a.sw += w;
                 a.swIh[half] += wI; a.swh[half] += w; a.nh[half]++;
+                a.swh_typ[half] += w * frame_cc_factor[o.frame];
                 // Any contributing observation on an ice ring marks the merged reflection (as
                 // MergeOnTheFly does on the stills path): the intensity is still merged and written,
                 // the flag only lets a consumer that must not read ring signal as crystal signal -
@@ -3922,6 +3942,8 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                     mr.I_half[i] = static_cast<float>(a.swIh[i] / a.swh[i]);
                     mr.sigma_half[i] = static_cast<float>(1.0 / std::sqrt(a.swh[i]));
                 }
+                mr.cc_weight = static_cast<float>((1.0 / a.swh_typ[0] + 1.0 / a.swh_typ[1])
+                                                  / (1.0 / a.swh[0] + 1.0 / a.swh[1]));
             }
             if (!std::isfinite(a.d) || a.d <= 0.0f) continue;
             merged_I[g] = mr.I;
@@ -4142,8 +4164,8 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                 s.unique++;
                 s.sum_i_over_sigma += m.I / m.sigma; s.n_i_over_sigma++;
                 if (std::isfinite(m.I_half[0]) && std::isfinite(m.I_half[1])) {
-                    s.cc_half.Add(m.I_half[0], m.I_half[1]);
-                    cc_half_overall.Add(m.I_half[0], m.I_half[1]);
+                    s.cc_half.Add(m.I_half[0], m.I_half[1], m.cc_weight);
+                    cc_half_overall.Add(m.I_half[0], m.I_half[1], m.cc_weight);
                 }
             }
         }
@@ -4792,6 +4814,17 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         }
         logger.Info("Scaled fulls (XDS order, Unity model)");
     }
+    // The total scale each frame's fulls were amplified by - partial scale, incident flux and the fulls'
+    // own G (corr = 1/G here) - taken BEFORE the correction surfaces fold per-observation terms into
+    // corr, and before a collapsed frame's fulls are zeroed: the resident fulls only get that zero with
+    // the corrected corr, so a merge on the device before then still sees them, and must weigh them by
+    // their own scale. Read by MergeAndStats for the CC1/2 weight.
+    frame_scale_fulls.assign(n_frames, NAN);
+    for (const auto &o : fulls)
+        if (std::isfinite(o.corr) && o.corr > 0.0f && !std::isfinite(frame_scale_fulls[o.frame])) {
+            const double gp = g_partial[o.frame] * frame_flux[o.frame];
+            frame_scale_fulls[o.frame] = (std::isfinite(gp) && gp > 0.0 ? gp : 1.0) / o.corr;
+        }
     const bool rejected_full_scales =
             scale_fulls && DropCollapsedFullScales(combined_on_gpu && scaled_fulls_on_gpu);
 
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 24a1fed00..3855f1a0f 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -273,6 +273,7 @@ private:
     std::vector<Obs> fulls;                       // combined fulls (rebuilt each Run), sorted by frame
     std::vector<int32_t> fulls_frame_start, fulls_frame_count;  // CSR ranges of `fulls` per frame
     std::vector<double> g_full;                   // per-frame scale on the fulls
+    std::vector<double> frame_scale_fulls;        // per-frame total scale of the fulls before the surfaces (cc_weight)
 
     // The five fields the host-side walks over the fulls actually read, pulled out of the 80-byte record
     // once per merge (see MergeAndStats). `group` carries the usability decision: -1 means the full is
@@ -306,15 +307,18 @@ private:
     // The merge accumulators (see MergeAndStats' run_merge): one entry per ASU group, plus the arrays
     // the device kernel fills that the host unpacks into them. Members for the same reason as
     // FullsStaging - a merge runs several times per run and this is a hundred megabytes between them.
-    struct Accum { double swI = 0, sw = 0, swIh[2] = {0, 0}, swh[2] = {0, 0}; size_t nh[2] = {0, 0}; float d = NAN;
-                   bool on_ice = false; };
+    // swh_typ: each half-set's precision had every observation been at the run's typical frame scale
+    // (see MergeAndStats, cc_weight).
+    struct Accum { double swI = 0, sw = 0, swIh[2] = {0, 0}, swh[2] = {0, 0}, swh_typ[2] = {0, 0};
+                   size_t nh[2] = {0, 0}; float d = NAN; bool on_ice = false; };
     std::vector<Accum> merge_acc;
     struct MergeAccumStaging {
-        std::vector<double> swI, sw, swIh0, swIh1, swh0, swh1, d;
+        std::vector<double> swI, sw, swIh0, swIh1, swh0, swh1, swh_typ0, swh_typ1, d;
         std::vector<int32_t> nh0, nh1, rej;
         std::vector<uint8_t> on_ice;
         void Resize(int n) {
             swI.resize(n); sw.resize(n); swIh0.resize(n); swIh1.resize(n); swh0.resize(n); swh1.resize(n);
+            swh_typ0.resize(n); swh_typ1.resize(n);
             d.resize(n); nh0.resize(n); nh1.resize(n); rej.resize(n); on_ice.resize(n);
         }
     };
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.cu b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
index 40e146dc5..2f51def78 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.cu
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
@@ -464,13 +464,13 @@ namespace {
         const int32_t *group, *frame;
         const uint8_t *on_ice, *frame_cell_ok, *half;
         const int32_t *gperm, *gstart, *gcount;
-        const double *em_mean, *merged_I;
+        const double *em_mean, *merged_I, *cc_factor;
         // outputs
         double *sw, *swI, *em_mean_out;
         int32_t *cnt;
         double *s2, *I2, *dev2;
         uint8_t *valid;
-        double *a_swI, *a_sw, *a_swIh0, *a_swIh1, *a_swh0, *a_swh1, *a_d;
+        double *a_swI, *a_sw, *a_swIh0, *a_swIh1, *a_swh0, *a_swh1, *a_swht0, *a_swht1, *a_d;
         int32_t *a_nh0, *a_nh1, *a_rejected;
         uint8_t *a_on_ice;
         double *r_absdev, *r_sumI;
@@ -544,7 +544,7 @@ namespace {
     __global__ void MergeAccumKernel(MergeParams p) {
         for (int g = blockIdx.x * blockDim.x + threadIdx.x; g < p.n_groups; g += gridDim.x * blockDim.x) {
             const int lo = p.gstart[g], hi = lo + p.gcount[g];
-            double swI = 0, sw = 0, swIh0 = 0, swIh1 = 0, swh0 = 0, swh1 = 0, dd = NAN;
+            double swI = 0, sw = 0, swIh0 = 0, swIh1 = 0, swh0 = 0, swh1 = 0, swht0 = 0, swht1 = 0, dd = NAN;
             int nh0 = 0, nh1 = 0, rejected = 0, onice = 0;
             const float rmed = p.reject_median[g];
             for (int q = lo; q < hi; ++q) {
@@ -574,13 +574,16 @@ namespace {
                 // a rank within the reflection cannot be read off a running count, and computing it
                 // in one place is what makes this kernel and the host merge loop agree exactly.
                 const int half = p.half[i];
+                const double wt = w * p.cc_factor[p.frame[i]];   // see the host merge loop (cc_weight)
                 swI += wI; sw += w;
-                if (half) { swIh1 += wI; swh1 += w; ++nh1; } else { swIh0 += wI; swh0 += w; ++nh0; }
+                if (half) { swIh1 += wI; swh1 += w; swht1 += wt; ++nh1; }
+                else { swIh0 += wI; swh0 += w; swht0 += wt; ++nh0; }
                 if (p.on_ice[i]) onice = 1;   // see the host merge loop
                 if (!isfinite(dd) && isfinite(p.d[i]) && p.d[i] > 0.0f) dd = p.d[i];
             }
             p.a_swI[g] = swI; p.a_sw[g] = sw; p.a_swIh0[g] = swIh0; p.a_swIh1[g] = swIh1;
-            p.a_swh0[g] = swh0; p.a_swh1[g] = swh1; p.a_nh0[g] = nh0; p.a_nh1[g] = nh1; p.a_d[g] = dd;
+            p.a_swh0[g] = swh0; p.a_swh1[g] = swh1; p.a_swht0[g] = swht0; p.a_swht1[g] = swht1;
+            p.a_nh0[g] = nh0; p.a_nh1[g] = nh1; p.a_d[g] = dd;
             p.a_rejected[g] = rejected; p.a_on_ice[g] = uint8_t(onice);
         }
     }
@@ -657,7 +660,8 @@ struct RotationScaleMergeGPU::Impl {
     CudaDevicePtr<uint8_t> m_valid;
     CudaDevicePtr<uint8_t> m_rejected;   // per-full outlier-rejected flag (MergeAccum -> MergeRmeas)
     CudaDevicePtr<uint8_t> m_half;       // per-full CC1/2 half-set, assigned on the host
-    CudaDevicePtr<double> a_swI, a_sw, a_swIh0, a_swIh1, a_swh0, a_swh1, a_d;   // merge accum per group
+    CudaDevicePtr<double> a_swI, a_sw, a_swIh0, a_swIh1, a_swh0, a_swh1, a_swht0, a_swht1, a_d;   // merge accum per group
+    CudaDevicePtr<double> cc_factor;     // per-frame CC1/2 weight factor (length n_frames)
     CudaDevicePtr<int32_t> a_nh0, a_nh1, a_rejected;
     CudaDevicePtr<uint8_t> a_on_ice;     // per group: any contributing full on an ice ring
     CudaDevicePtr<float> reject_median;
@@ -902,9 +906,10 @@ void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partialit
 
 void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                                        bool reject_outliers, double reject_nsigma, const float *reject_median,
-                                       const uint8_t *half,
+                                       const uint8_t *half, const double *frame_cc_factor,
                                        double *swI, double *sw, double *swIh0, double *swIh1,
-                                       double *swh0, double *swh1, int32_t *nh0, int32_t *nh1, double *d_out,
+                                       double *swh0, double *swh1, double *swh_typ0, double *swh_typ1,
+                                       int32_t *nh0, int32_t *nh1, double *d_out,
                                        int32_t *rejected, uint8_t *on_ice_out, uint8_t *rejected_obs) {
     DeviceGuard guard(impl_->device, impl_->available);
     auto &d = *impl_;
@@ -912,6 +917,7 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     d.a_swI = CudaDevicePtr<double>(std::max(1, ng)); d.a_sw = CudaDevicePtr<double>(std::max(1, ng));
     d.a_swIh0 = CudaDevicePtr<double>(std::max(1, ng)); d.a_swIh1 = CudaDevicePtr<double>(std::max(1, ng));
     d.a_swh0 = CudaDevicePtr<double>(std::max(1, ng)); d.a_swh1 = CudaDevicePtr<double>(std::max(1, ng));
+    d.a_swht0 = CudaDevicePtr<double>(std::max(1, ng)); d.a_swht1 = CudaDevicePtr<double>(std::max(1, ng));
     d.a_nh0 = CudaDevicePtr<int32_t>(std::max(1, ng)); d.a_nh1 = CudaDevicePtr<int32_t>(std::max(1, ng));
     d.a_d = CudaDevicePtr<double>(std::max(1, ng)); d.a_rejected = CudaDevicePtr<int32_t>(std::max(1, ng));
     d.a_on_ice = CudaDevicePtr<uint8_t>(std::max(1, ng));
@@ -920,6 +926,7 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
               "zero m_rejected");
     Upload(d.reject_median, reject_median, ng);
     Upload(d.m_half, half, d.n_fulls);
+    Upload(d.cc_factor, frame_cc_factor, d.n_frames);
 
     MergeParams p{};
     p.n_groups = ng; p.min_partiality = d.merge_min_part;
@@ -934,9 +941,10 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     p.half = d.m_half.get();
     p.var_bkg = d.f_var_bkg.get(); p.var_per_I = d.f_var_per_I.get();
     p.gperm = d.f_gperm.get(); p.gstart = d.f_gstart.get(); p.gcount = d.f_gcount.get();
-    p.em_mean = d.m_em_mean.get();
+    p.em_mean = d.m_em_mean.get(); p.cc_factor = d.cc_factor.get();
     p.a_swI = d.a_swI.get(); p.a_sw = d.a_sw.get(); p.a_swIh0 = d.a_swIh0.get(); p.a_swIh1 = d.a_swIh1.get();
-    p.a_swh0 = d.a_swh0.get(); p.a_swh1 = d.a_swh1.get(); p.a_nh0 = d.a_nh0.get(); p.a_nh1 = d.a_nh1.get();
+    p.a_swh0 = d.a_swh0.get(); p.a_swh1 = d.a_swh1.get();
+    p.a_swht0 = d.a_swht0.get(); p.a_swht1 = d.a_swht1.get(); p.a_nh0 = d.a_nh0.get(); p.a_nh1 = d.a_nh1.get();
     p.a_d = d.a_d.get(); p.a_rejected = d.a_rejected.get(); p.a_on_ice = d.a_on_ice.get();
     p.rejected_obs = d.m_rejected.get();
 
@@ -947,7 +955,8 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     auto dl = [&](void *h, const CudaDevicePtr<double> &s) {
         CudaCheck(cudaMemcpy(h, s.get(), size_t(ng) * sizeof(double), cudaMemcpyDeviceToHost), "dl accum"); };
     dl(swI, d.a_swI); dl(sw, d.a_sw); dl(swIh0, d.a_swIh0); dl(swIh1, d.a_swIh1);
-    dl(swh0, d.a_swh0); dl(swh1, d.a_swh1); dl(d_out, d.a_d);
+    dl(swh0, d.a_swh0); dl(swh1, d.a_swh1); dl(swh_typ0, d.a_swht0); dl(swh_typ1, d.a_swht1);
+    dl(d_out, d.a_d);
     CudaCheck(cudaMemcpy(nh0, d.a_nh0.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl nh0");
     CudaCheck(cudaMemcpy(nh1, d.a_nh1.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl nh1");
     CudaCheck(cudaMemcpy(rejected, d.a_rejected.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl rej");
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.h b/image_analysis/scale_merge/RotationScaleMergeGPU.h
index cd4ac9464..fb853b016 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.h
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.h
@@ -93,13 +93,15 @@ public:
     // kernel and the host merge loop cannot disagree about it.
     // Outputs length n_groups; rejected[g] counts outliers dropped (reject_median uploaded, NAN
     // where none). rejected_obs is the per-full flag (length n_fulls): the host needs it for the reductions
-    // it still does itself, above all the anomalous I(+)/I(-) split.
+    // it still does itself, above all the anomalous I(+)/I(-) split. frame_cc_factor (length n_frames) is
+    // each frame's (G_ref/G)^2 floored at 1; swh_typ0/1 are the half-set weights multiplied by it.
     // Requires MergeEmSamples first (em_mean resident).
     void MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                     bool reject_outliers, double reject_nsigma, const float *reject_median,
-                    const uint8_t *half,
+                    const uint8_t *half, const double *frame_cc_factor,
                     double *swI, double *sw, double *swIh0, double *swIh1,
-                    double *swh0, double *swh1, int32_t *nh0, int32_t *nh1, double *d_out,
+                    double *swh0, double *swh1, double *swh_typ0, double *swh_typ1,
+                    int32_t *nh0, int32_t *nh1, double *d_out,
                     int32_t *rejected, uint8_t *on_ice_out, uint8_t *rejected_obs);
 
     // Per-group R_meas accumulators (sum|I_corr-merged_I|, sum_I, n, and the count this looser walk
diff --git a/tests/MergeScaleTest.cpp b/tests/MergeScaleTest.cpp
index 31dd7676a..4794b6a7e 100644
--- a/tests/MergeScaleTest.cpp
+++ b/tests/MergeScaleTest.cpp
@@ -306,14 +306,17 @@ namespace {
     // other (signal) or drawn independently (noise, CC1/2 ~ 0), so a whole CC1/2 curve can be built
     // band by band.
     void AddBand(std::vector<MergedReflection> &v, std::mt19937 &rng,
-                 double s_from, double s_to, int n, bool correlated) {
-        std::normal_distribution<double> g(0.0, 1.0);
+                 double s_from, double s_to, int n, bool correlated, double sigma = 1.0) {
+        std::normal_distribution<double> g(0.0, sigma);
         for (int j = 0; j < n; ++j) {
             MergedReflection m;
             m.d = static_cast<float>(1.0 / std::sqrt(s_from + (j + 0.5) * (s_to - s_from) / n));
             const double a = g(rng), b = g(rng);
             m.I_half[0] = static_cast<float>(a);
             m.I_half[1] = static_cast<float>(correlated ? a : b);
+            // The pair's weight in a CC1/2: the precision it would have had at the typical frame scale
+            // over the precision it has - 1/sigma^2 for a band scaled up by sigma from dead frames.
+            m.cc_weight = static_cast<float>(1.0 / (sigma * sigma));
             v.push_back(m);
         }
     }
@@ -336,6 +339,54 @@ TEST_CASE("ResolutionCutoff_CleanFallOff") {
     CHECK(*rc.d_cut == Catch::Approx(1.92).margin(0.15));
 }
 
+// A sweep with a long stretch where the crystal barely diffracted: the reflections measured only there
+// are noise scaled up by 1/G, sigmas with them, and there are many of them at every resolution. Counted
+// by the information they carry they must not hide where the well-measured reflections stop.
+TEST_CASE("ResolutionCutoff_ScaledUpNoiseDoesNotHideTheFallOff") {
+    Logger logger("test");
+    std::mt19937 rng(12345);
+    std::vector<MergedReflection> merged;
+    AddBand(merged, rng, 0.01, 0.25, 480, true);
+    AddBand(merged, rng, 0.25, 0.51, 520, false);
+    AddBand(merged, rng, 0.01, 0.51, 300, false, 50.0);
+
+    const auto rc = ComputeCCHalfLogisticCutoff(merged, 0.30, logger);
+    REQUIRE(rc.d_fit);
+    CHECK(*rc.d_fit == Catch::Approx(2.0).margin(0.15));
+
+    // Counted as equals, the same reflections hide it: the curve reads noise from the first bin on.
+    for (auto &m : merged) m.cc_weight = 1.0f;
+    const auto unweighted = ComputeCCHalfLogisticCutoff(merged, 0.30, logger);
+    CHECK((!unweighted.d_fit || *unweighted.d_fit > 3.0));
+}
+
+// The frame factor of the CC1/2 weight is 1 on a sweep whose frames all sit at one scale, however that
+// scale is spread over the frames, and 1 for any frame brighter than typical.
+TEST_CASE("CCHalfFrameFactors_UniformScaleIsOne") {
+    const auto f = CCHalfFrameFactors({1.7, 1.7, 1.7, 1.7}, {100, 3, 250, 0});
+    for (double x : f) CHECK(x == 1.0);
+    const auto g = CCHalfFrameFactors({1.0, 2.0}, {100, 100});
+    CHECK(g[1] == 1.0);
+    CHECK(g[0] == Catch::Approx(9.0 / 5.0 * 9.0 / 5.0));   // G_ref = (1 + 8) / (1 + 4)
+}
+
+// Most of the sweep at 2% of the good frames' scale: the typical scale is still the good frames', not
+// the run median, and an observation from a dead frame carries 2500x the variance of a good one.
+TEST_CASE("CCHalfFrameFactors_DeadStretchDoesNotSetTheTypicalScale") {
+    std::vector<double> scale;
+    std::vector<int64_t> n;
+    for (int f = 0; f < 100; ++f) {
+        scale.push_back(f < 60 ? 0.02 : 1.0);
+        n.push_back(50);
+    }
+    scale.push_back(NAN);   // a frame without a scale counts as G = 1
+    n.push_back(50);
+    const auto factor = CCHalfFrameFactors(scale, n);
+    CHECK(factor[0] == Catch::Approx(2500.0).epsilon(0.01));
+    CHECK(factor[99] == Catch::Approx(1.0).epsilon(1e-3));
+    CHECK(factor[100] == Catch::Approx(1.0).epsilon(1e-3));
+}
+
 // A fall-off region a logistic cannot follow: CC1/2 drops through the target and comes straight back
 // up. The fitted crossing is then an extrapolation far past the bins it was made over, and reading
 // the cut off it writes the data deep into the noise; the crossing the bins themselves show is where
-- 
2.54.0


From aa87fb8bdefc73139bc7b2e6087e7d2d9e9bf4cf Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:36:09 +0200
Subject: [PATCH 017/122] rugnux: print ISa as undetermined when the error
 model's b is not resolved from zero

The (a, b) error-model fit already refuses to report ISa when its top intensity
bin has no leverage on b. It still printed 1/b when b had leverage but came out
at zero within its own error - the strongest bins scatter no more than
counting statistics say (the fitted b^2 is negative and clamps to 0), or there
are too few samples for the bin medians to mean anything. ISa then reports the
noise in b as an I/sigma: on one low-resolution sweep consecutive merges of the
same data gave ISa 0, 28, 46, 113 and 130.

The standard error of b^2 is taken from the 16 bins' own scatter about the
fitted line, and when b^2 is less than two standard errors above zero the
merge result carries isa_resolved = false. Only what is printed follows it:
the report's ISA key reads "undetermined", the summary line says so, the
asymptote is not printed and the mmCIF carries "?". The fitted ISa itself is
unchanged and is still what the space-group search's present-reflection cut
and the refused-point-group arbitration read, so no decision moves.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../scale_merge/RotationScaleMerge.cpp        | 29 +++++++++++++++++--
 .../scale_merge/RotationScaleMerge.h          |  4 +++
 rugnux/ResultReport.cpp                       | 12 ++++++--
 rugnux/Rugnux.cpp                             | 12 ++++++--
 rugnux/Rugnux.h                               |  1 +
 rugnux/rugnux_cli.cpp                         | 10 +++++--
 tests/ResultReportTest.cpp                    | 24 +++++++++++++++
 7 files changed, 81 insertions(+), 11 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 7457c5c05..bfde3cd48 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3548,6 +3548,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     const std::vector<Sample> *chi2_pool = nullptr;
     double chi2_a = 0.0, chi2_b2 = 0.0;
     bool error_model_b_unmeasured = false;   // b had no leverage; ISa is not reported
+    bool error_model_b_resolved = true;      // b^2 stood clear of its own standard error
     std::vector<Sample> &samples = em_samples;
     samples.clear();
     constexpr int n_bins = 16;
@@ -3659,10 +3660,29 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                     chi2_pool = &in; chi2_a = error_model_a; chi2_b2 = 0.0;
                 }
             } else if (det > 1e-10 * Ass * AII) {
-                error_model_a = std::clamp((Bs * AII - BI * AsI) / det, 0.25, 100.0);
-                const double b2 = std::max((Ass * BI - AsI * Bs) / det, 0.0);
+                const double a_fit = (Bs * AII - BI * AsI) / det;
+                const double b2_fit = (Ass * BI - AsI * Bs) / det;
+                error_model_a = std::clamp(a_fit, 0.25, 100.0);
+                const double b2 = std::max(b2_fit, 0.0);
                 error_model_b = std::sqrt(b2);
                 error_model_b_unmeasured = false;
+                // Leverage is not enough: b^2 can have it and still come out at zero within its own error -
+                // the strong bins scatter no more than counting says, or there are too few samples for a
+                // bin median to mean anything. 1/b then reads the noise in b as an I/sigma, any value from
+                // ~30 to infinity between merges of the same data. The standard error of b^2 is taken from
+                // the bins' own scatter about the fitted line; the fit and the sigmas are left as they are,
+                // and so is the fitted ISa every decision reads - this only decides what is printed.
+                // Measured: z = 13.6 and 22 on two crystals whose b is plainly visible, 0.1-0.5 on a
+                // 3000-sample low-multiplicity set and -1.2 to -6 on one whose strongest bins scatter
+                // LESS than counting says (both printed ISa 96-130).
+                double chi = 0.0;
+                for (int bin = 0; bin < n_bins; ++bin) {
+                    const double d2w = std::max(bd2[bin], dev2_floor);
+                    const double r = bd2[bin] - a_fit * bs2[bin] - b2_fit * bI2[bin];
+                    chi += r * r / (d2w * d2w);
+                }
+                const double b2_se = std::sqrt(chi / (n_bins - 2) * Ass / det);
+                error_model_b_resolved = b2_fit >= 2.0 * b2_se;
                 error_model_active = true;
                 chi2_pool = &in; chi2_a = error_model_a; chi2_b2 = b2;
             }
@@ -4069,6 +4089,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     {
         const auto em = ToXdsErrorModel(error_model_a, error_model_b);
         result.isa = em.isa;
+        result.isa_resolved = error_model_b_resolved;
         result.error_model_a = em.a;
         result.error_model_b = em.b;
     }
@@ -4099,6 +4120,10 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                            "not reach far enough for a systematic error to be seen, not that there is "
                            "none; a resolution range matched to the signal would measure it",
                            em.a, error_model_chi2);
+        else if (!error_model_b_resolved)
+            logger.Info("Error model (XDS convention): a={:.3f} b={:.3e} - b is not resolved from zero "
+                        "(under two standard errors), so ISa is undetermined (1/b = {:.1f})",
+                        em.a, em.b, em.isa);
         else if (!full_stats)
             // Neither the asymptote nor the chi2 median was measured on this merge, so neither is
             // reported for it.
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 3855f1a0f..533242ad3 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -49,6 +49,10 @@ public:
         // only ever be the more optimistic of the two. Both 0 if the model stayed at identity.
         double isa = 0.0;
         double isa_asymptotic = 0.0;
+        // b^2 stood at least two standard errors clear of zero. When it did not, `isa` is still the
+        // fitted 1/b and every decision reads it as before; only what is PRINTED says "undetermined",
+        // since 1/b of a b that is zero within its error is the noise in b, not an I/sigma.
+        bool isa_resolved = true;
         double error_model_a = 0.0;   // XDS convention: sigma^2 = a*(sigma0^2 + b*I^2)
         double error_model_b = 0.0;
         // The overall CC1/2 as it stood BEFORE the correction surfaces were folded in. That is what the
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index f2f76ab82..cbb2ae8ba 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -695,8 +695,12 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             // CORRECT.LP. Kept in the default report because beamline monitoring scripts read them.
             Add(s, KeyReal("ERROR_MODEL_A", result.error_model_a, "{:.4f}"));
             Add(s, KeyReal("ERROR_MODEL_B", result.error_model_b, "{:.4e}"));
-            Add(s, KeyReal("ISA", result.error_model_isa, "{:.2f}"));
-            if (result.error_model_isa_asymptotic > 0.0)
+            // A b that is zero within its error gives a 1/b that is the noise in b, not an I/sigma.
+            if (result.error_model_isa_resolved)
+                Add(s, KeyReal("ISA", result.error_model_isa, "{:.2f}"));
+            else
+                Add(s, KeyText("ISA", "undetermined"));
+            if (result.error_model_isa_resolved && result.error_model_isa_asymptotic > 0.0)
                 Add(s, KeyReal("ISA_ASYMPTOTIC", result.error_model_isa_asymptotic, "{:.2f}", true));
             // Only when TRUE: FALSE is the ordinary case and says nothing.
             if (result.has_reference)
@@ -1763,7 +1767,9 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                     sig += fmt::format("   R_meas {:.1f} %", 100.0 * o.r_meas);
                 if (std::isfinite(o.cc_half))
                     sig += fmt::format("   CC1/2 {:.3f}", o.cc_half);
-                if (result.error_model_isa > 0.0)
+                if (!result.error_model_isa_resolved)
+                    sig += "   ISa undetermined";
+                else if (result.error_model_isa > 0.0)
                     sig += fmt::format("   ISa {:.1f}", result.error_model_isa);
                 row("Signal", sig);
                 if (std::isfinite(o.cc_anom))
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 44a16b013..4d97df765 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -4916,6 +4916,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                   /*measure_cc_before_corrections=*/true);
                 result.error_model_isa = r.isa;
                 result.error_model_isa_asymptotic = r.isa_asymptotic;
+                result.error_model_isa_resolved = r.isa_resolved;
                 if (r.resolution_fit_A) result.resolution_fit_A = r.resolution_fit_A;
                 result.error_model_a = r.error_model_a;
                 result.error_model_b = r.error_model_b;
@@ -6135,6 +6136,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                         // comparison merges are not the run's answer, so it goes back if they lose.
                         const double em_isa = result.error_model_isa;
                         const double em_isa_asymptotic = result.error_model_isa_asymptotic;
+                        const bool em_isa_resolved = result.error_model_isa_resolved;
                         const double em_a = result.error_model_a;
                         const double em_b = result.error_model_b;
                         const auto res_fit = result.resolution_fit_A;
@@ -6201,6 +6203,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                             experiment_.SetSpaceGroup(sg);
                             result.error_model_isa = em_isa;
                             result.error_model_isa_asymptotic = em_isa_asymptotic;
+                            result.error_model_isa_resolved = em_isa_resolved;
                             result.error_model_a = em_a;
                             result.error_model_b = em_b;
                             result.resolution_fit_A = res_fit;
@@ -6697,9 +6700,10 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             && !superseded) {
             phase("Writing reflections");
         const ErrorModelReport em_report{
-                result.error_model_isa > 0 ? fmt::format("{:.2f}", result.error_model_isa) : "?",
-                result.error_model_isa_asymptotic > 0 ? fmt::format("{:.2f}", result.error_model_isa_asymptotic)
-                                                   : std::string(),
+                result.error_model_isa > 0 && result.error_model_isa_resolved
+                        ? fmt::format("{:.2f}", result.error_model_isa) : "?",
+                result.error_model_isa_asymptotic > 0 && result.error_model_isa_resolved
+                        ? fmt::format("{:.2f}", result.error_model_isa_asymptotic) : std::string(),
                 result.error_model_a > 0 ? fmt::format("{:.3f}", result.error_model_a) : std::string(),
                 result.error_model_b > 0 ? fmt::format("{:.4e}", result.error_model_b) : std::string()};
             WriteReflections(sm.merged, *result.consensus_cell, experiment_, sm.statistics,
@@ -6776,6 +6780,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 // multiplicity, so its fall-off is not this crystal's.
                 const double em_isa = result.error_model_isa;
                 const double em_isa_asymptotic = result.error_model_isa_asymptotic;
+                const bool em_isa_resolved = result.error_model_isa_resolved;
                 const double em_a = result.error_model_a;
                 const double em_b = result.error_model_b;
                 const auto res_fit = result.resolution_fit_A;
@@ -6825,6 +6830,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 experiment_.SetSpaceGroup(determined_group);
                 result.error_model_isa = em_isa;
                 result.error_model_isa_asymptotic = em_isa_asymptotic;
+                result.error_model_isa_resolved = em_isa_resolved;
                 result.error_model_a = em_a;
                 result.error_model_b = em_b;
                 result.resolution_fit_A = res_fit;
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 2dc87f29f..d56907983 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -239,6 +239,7 @@ struct ProcessResult {
     MergeStatistics merge_statistics;
     double error_model_isa = 0.0;            // whole-range 1/sqrt(a*b), XDS's meaning
     double error_model_isa_asymptotic = 0.0;  // strong-reflection tier; rotation path only, 0 on stills
+    bool error_model_isa_resolved = true;     // false: b is zero within its error, ISa printed "undetermined"
     double error_model_a = 0.0;               // XDS convention: sigma^2 = a*(sigma0^2 + b*I^2)
     double error_model_b = 0.0;
     bool has_reference = false;
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index ecd6e07cc..6ffbc469d 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -1727,6 +1727,7 @@ static int RunRugnux(int argc, char **argv) {
         MergeStatistics merged_statistics;
         double error_model_isa = 0.0;
         double error_model_isa_asymptotic = 0.0;
+        bool error_model_isa_resolved = true;
         std::optional<double> resolution_fit_A;   // CC1/2 crossing, without the one-shell extension
         double error_model_a = 0.0;
         double error_model_b = 0.0;
@@ -1755,6 +1756,7 @@ static int RunRugnux(int argc, char **argv) {
             merged_statistics = std::move(r.statistics);
             error_model_isa = r.isa;
             error_model_isa_asymptotic = r.isa_asymptotic;
+            error_model_isa_resolved = r.isa_resolved;
             error_model_a = r.error_model_a;
             error_model_b = r.error_model_b;
             resolution_fit_A = r.resolution_fit_A;
@@ -1952,9 +1954,10 @@ static int RunRugnux(int argc, char **argv) {
 
         if (!output_prefix.empty()) {
             const ErrorModelReport em_report{
-                    error_model_isa > 0 ? fmt::format("{:.2f}", error_model_isa) : "?",
-                    error_model_isa_asymptotic > 0 ? fmt::format("{:.2f}", error_model_isa_asymptotic)
-                                                   : std::string(),
+                    error_model_isa > 0 && error_model_isa_resolved
+                            ? fmt::format("{:.2f}", error_model_isa) : "?",
+                    error_model_isa_asymptotic > 0 && error_model_isa_resolved
+                            ? fmt::format("{:.2f}", error_model_isa_asymptotic) : std::string(),
                     error_model_a > 0 ? fmt::format("{:.3f}", error_model_a) : std::string(),
                     error_model_b > 0 ? fmt::format("{:.4e}", error_model_b) : std::string()};
             WriteReflections(merged_reflections, *experiment.GetUnitCell(), experiment, merged_statistics,
@@ -1990,6 +1993,7 @@ static int RunRugnux(int argc, char **argv) {
         { std::ostringstream s; s << merged_statistics; scale_result.merge_statistics_text = s.str(); }
         scale_result.error_model_isa = error_model_isa;
         scale_result.error_model_isa_asymptotic = error_model_isa_asymptotic;
+        scale_result.error_model_isa_resolved = error_model_isa_resolved;
         scale_result.error_model_a = error_model_a;
         scale_result.error_model_b = error_model_b;
         scale_result.resolution_fit_A = resolution_fit_A;
diff --git a/tests/ResultReportTest.cpp b/tests/ResultReportTest.cpp
index 9a246edb8..594306c74 100644
--- a/tests/ResultReportTest.cpp
+++ b/tests/ResultReportTest.cpp
@@ -651,6 +651,30 @@ TEST_CASE("ResultReport_FittedResolutionSuppressed", "[Diagnostics]") {
     CHECK(climbs_text.find("RESOLUTION_FIT") != std::string::npos);
 }
 
+// ISa of a b that is zero within its error is the noise in b; the report says undetermined, not a number.
+TEST_CASE("ResultReport_IsaUndetermined", "[Diagnostics]") {
+    DiffractionExperiment x(DetJF(1));
+    ProcessResult result;
+    result.consensus_cell = UnitCell{.a = 79.0f, .b = 79.0f, .c = 38.0f,
+                                     .alpha = 90.0f, .beta = 90.0f, .gamma = 90.0f};
+    result.has_merge_statistics = true;
+    result.merge_statistics.overall.d_max = 50.0f;
+    result.merge_statistics.overall.d_min = 1.50f;
+    result.merge_statistics.overall.cc_half = 0.99;
+    result.error_model_a = 1.1;
+    result.error_model_b = 1e-4;
+    result.error_model_isa = 95.0;
+    result.error_model_isa_asymptotic = 120.0;
+
+    const auto resolved = RenderResultReport("p", "in.h5", x, result);
+    CHECK(resolved.find("\nISA= 95.00\n") != std::string::npos);
+
+    result.error_model_isa_resolved = false;
+    const auto text = RenderResultReport("p", "in.h5", x, result);
+    CHECK(text.find("\nISA= undetermined\n") != std::string::npos);
+    CHECK(text.find("ISA_ASYMPTOTIC") == std::string::npos);
+}
+
 // The completeness of the range where the signal is, beside the completeness of the range that was
 // written. Users compare the single overall figure against another program's and conclude the run
 // lost data, when it is the deliberately generous cut diluting the denominator - so the report says
-- 
2.54.0


From d5220014b38a4e1280754f305542b20bdbef287b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:59:58 +0200
Subject: [PATCH 018/122] rugnux: integrate a sparse rotation lattice the
 pooled spots accept

A weak crystal inside a powder of its own microcrystals plus ice puts only
~5% of each frame's spots on its lattice. The pooled first-pass test accepted
that lattice (5.5% of validation spots against 0.6% at a wrong spindle angle),
but then:

- every frame failed the 20% per-frame floor (LATTICE_MIN_INDEXED_FRACTION),
  so nothing was integrated and the merge was skipped (indexing rate 0);
- the background-measured beam centre, ~3 px from the file's and correct,
  was not adopted because the arbiter counts validation frames, which are 0/60
  at every centre.

Changes:
- When fewer than 1/6 of the validation frames clear the per-frame floor AND
  the sweep's pooled on-lattice fraction is itself below that floor, integrate
  every frame from the sweep's lattice (as XDS/DIALS do) and leave frame
  selection to scaling. Sweeps sparse only in spots per frame keep the floor.
- Merge when a rotation lattice was found even if no frame "indexed" on its own.
- When neither centre indexes a validation frame, adopt the measured centre if
  its pooled excess over chance beats the file's by 3.29 sigma.

On the case above: P2 at the XDS cell, merged to 1.77 A, CC1/2 0.95, ISa 3.4
(XDS with the same lattice: ISa 3.3-5.5). Three healthy/partially-indexing
rotation sets are bit-identical; a two-wavelength CBF set that currently
merges 42 frames on a wrong cell moves (beam centre adopted, 755 frames).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 image_analysis/IndexAndRefine.cpp           |  2 +-
 image_analysis/IndexAndRefine.h             |  4 ++
 image_analysis/indexing/AnalyzeIndexing.cpp |  6 +-
 image_analysis/indexing/AnalyzeIndexing.h   |  6 +-
 rugnux/Rugnux.cpp                           | 66 +++++++++++++++++++--
 5 files changed, 74 insertions(+), 10 deletions(-)

diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp
index 39e42da2b..6d48a4b82 100644
--- a/image_analysis/IndexAndRefine.cpp
+++ b/image_analysis/IndexAndRefine.cpp
@@ -632,7 +632,7 @@ IndexAndRefine::DetermineRefineAnalyze(DataMessage &msg, const SpotFindingSettin
     // AnalyzeIndexing answers "is this frame worth integrating"; msg.indexing_result carries the
     // stricter "does this frame index on its own", which on rotation is not the same question.
     if (!AnalyzeIndexing(msg, outcome.experiment, *outcome.lattice_candidate, outcome.extra_lattice_candidates,
-                         spots_on_lattice))
+                         spots_on_lattice, integrate_every_frame_))
         return std::nullopt;
 
     {
diff --git a/image_analysis/IndexAndRefine.h b/image_analysis/IndexAndRefine.h
index ec901ea27..0fb0d1fdd 100644
--- a/image_analysis/IndexAndRefine.h
+++ b/image_analysis/IndexAndRefine.h
@@ -85,6 +85,8 @@ class IndexAndRefine {
     // the retained outcome instead - and it is a copy of every reflection of every image, so a caller
     // that writes no per-image file switches it off.
     bool keep_reflections_in_message_ = true;
+    // Integrate every rotation frame from the sweep's lattice, whatever fraction of its spots lie on it.
+    bool integrate_every_frame_ = false;
     std::vector<float> scale_cc;
     std::vector<std::optional<UnitCell> > unit_cells;
 
@@ -129,6 +131,8 @@ public:
     char GetPredictionCentring() const { return prediction_centring_; }
     // Whether the outgoing message keeps its own copy of the reflections - see the member.
     void KeepReflectionsInMessage(bool on) { keep_reflections_in_message_ = on; }
+    // See the member.
+    void IntegrateEveryFrame(bool on) { integrate_every_frame_ = on; }
 
     // Returns whether the frame indexed (a lattice was found and refined). Integration, when it runs,
     // is a further step gated on quick_integration.
diff --git a/image_analysis/indexing/AnalyzeIndexing.cpp b/image_analysis/indexing/AnalyzeIndexing.cpp
index 5b39c192e..0272e97c4 100644
--- a/image_analysis/indexing/AnalyzeIndexing.cpp
+++ b/image_analysis/indexing/AnalyzeIndexing.cpp
@@ -342,7 +342,8 @@ bool AnalyzeIndexing(DataMessage &message,
                      const DiffractionExperiment &experiment,
                      const CrystalLattice &latt,
                      const std::vector<CrystalLattice> &extra_lattices,
-                     int64_t *spots_on_lattice) {
+                     int64_t *spots_on_lattice,
+                     bool integrate_every_frame) {
     auto start_time = std::chrono::steady_clock::now();
 
     std::vector<uint8_t> indexed_spots(message.spots.size());
@@ -441,7 +442,8 @@ bool AnalyzeIndexing(DataMessage &message,
     // why XDS's INTEGRATE and dials.integrate predict on every image of the sweep. A frame whose spots
     // largely MISS the lattice is a different matter and is still refused.
     const bool frame_indexes = lattice_fits && nspots_indexed >= viable_cell_min_spots;
-    const bool integrate_frame = experiment.IsRotationIndexing() ? lattice_fits : frame_indexes;
+    const bool integrate_frame = experiment.IsRotationIndexing() ? (lattice_fits || integrate_every_frame)
+                                                                 : frame_indexes;
     if (integrate_frame) {
         auto uc = latt.GetUnitCell();
         if (ok(uc.a) && ok(uc.b) && ok(uc.c) && ok(uc.alpha) && ok(uc.beta) && ok(uc.gamma)) {
diff --git a/image_analysis/indexing/AnalyzeIndexing.h b/image_analysis/indexing/AnalyzeIndexing.h
index e20b05f6d..345df657f 100644
--- a/image_analysis/indexing/AnalyzeIndexing.h
+++ b/image_analysis/indexing/AnalyzeIndexing.h
@@ -46,6 +46,9 @@ constexpr float SPOT_BUDGET_SIGNIFICANCE_Z = 3.29f;   // 2(1 - Phi(z)) = 0.001
 // same rate all the way down, and the case a bare argmax gets wrong.
 int64_t SpotBudgetFromEvidence(const std::vector<int64_t> &indexed, const std::vector<int64_t> &counted);
 
+// integrate_every_frame: on rotation, integrate the frame from the sweep's lattice even where fewer than
+// LATTICE_MIN_INDEXED_FRACTION of its spots lie on it - for a sweep whose lattice was accepted on the pooled
+// spots although its frames, one at a time, cannot clear that floor (see Rugnux).
 // spots_on_lattice, when given, receives how many of this frame's non-ice spots lie on latt - the
 // numerator of the frame gate below, reported whatever the gate then decides. The rotation first
 // pass's acceptance test pools that count over its validation frames, so it needs it from the sparse
@@ -54,6 +57,7 @@ bool AnalyzeIndexing(DataMessage &message,
                      const DiffractionExperiment &experiment,
                      const CrystalLattice &latt,
                      const std::vector<CrystalLattice> &extra_lattices = {},
-                     int64_t *spots_on_lattice = nullptr);
+                     int64_t *spots_on_lattice = nullptr,
+                     bool integrate_every_frame = false);
 
 
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 4d97df765..4e6d247b0 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -3589,12 +3589,50 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                         // around the value the run started with rather than around a fit that has just
                         // been tested and found no better - and so a run that fails for some other
                         // reason fails at the geometry it was given.
+                        //
+                        // Unless the frame counts are both at the floor and the POOLED spots do decide:
+                        // a crystal whose spots are a minority of every frame indexes 0/60 at any centre,
+                        // and then only the pooled excess over chance - each lattice measured against its
+                        // own wrong-spindle null, so a larger cell is not credited for fitting more by
+                        // chance - says which centre sees it.
+                        PooledEvidence at_measured, at_header;
+                        if (alt.result.has_value())
+                            at_measured = pooled_evidence(*indexer, *alt.result);
                         restore_beam_center(header_x, header_y);
-                        logger.Info("Beam centre check: neither the file's centre ({}/{} frames) nor "
-                                    "the measured one {:.2f} px away ({}/{}) indexes this run - the "
-                                    "file's centre is kept and this is not a beam-centre failure",
-                                    best.score, static_cast<int>(validation.size()), moved, alt.score,
-                                    static_cast<int>(validation.size()));
+                        if (best.result.has_value())
+                            at_header = pooled_evidence(*indexer, *best.result);
+                        auto excess = [](const PooledEvidence &e) {
+                            return static_cast<double>(e.on_lattice - e.by_chance)
+                                   / static_cast<double>(std::max<int64_t>(1, e.spots));
+                        };
+                        auto rate_var = [](const PooledEvidence &e) {
+                            const double n = static_cast<double>(std::max<int64_t>(1, e.spots));
+                            const double p = static_cast<double>(e.on_lattice) / n;
+                            return p * (1.0 - p) / n;
+                        };
+                        const double margin = excess(at_measured) - excess(at_header);
+                        const double margin_sigma = std::sqrt(rate_var(at_measured) + rate_var(at_header));
+                        if (alt.result.has_value() && beats_chance(at_measured)
+                            && margin > SPOT_BUDGET_SIGNIFICANCE_Z * margin_sigma) {
+                            try_beam_center(measured_x, measured_y);
+                            logger.Warning("Beam centre from the background: neither centre indexes a "
+                                           "validation frame on its own, but the pooled spots put "
+                                           "{:.1f}% on the lattice at the measured ({:.2f},{:.2f}) against "
+                                           "{:.1f}% at the file's (chance {:.1f}% and {:.1f}%) - the run "
+                                           "adopts the measured centre",
+                                           100.0 * at_measured.on_lattice / std::max<int64_t>(1, at_measured.spots),
+                                           measured_x, measured_y,
+                                           100.0 * at_header.on_lattice / std::max<int64_t>(1, at_header.spots),
+                                           100.0 * at_measured.by_chance / std::max<int64_t>(1, at_measured.spots),
+                                           100.0 * at_header.by_chance / std::max<int64_t>(1, at_header.spots));
+                            best = alt;
+                        } else {
+                            logger.Info("Beam centre check: neither the file's centre ({}/{} frames) nor "
+                                        "the measured one {:.2f} px away ({}/{}) indexes this run - the "
+                                        "file's centre is kept and this is not a beam-centre failure",
+                                        best.score, static_cast<int>(validation.size()), moved, alt.score,
+                                        static_cast<int>(validation.size()));
+                        }
                     }
                 } else {
                     restore_beam_center(header_x, header_y);
@@ -4196,6 +4234,22 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 }
             }
             indexer->ForceRotationIndexerResult(*best.result);
+            // A lattice the pooled spots accept while hardly a validation frame clears the per-frame
+            // floor (LATTICE_MIN_INDEXED_FRACTION) on its own, because the sweep as a whole puts fewer of
+            // its spots on the lattice than that floor asks of each frame: the crystal is real but its
+            // spots are a minority of every frame - a weak crystal inside a powder of its own
+            // microcrystals and ice. The floor cannot tell its frames from anything else, so integrate
+            // every frame from the sweep's lattice, as XDS and DIALS do, and leave the frames to the
+            // scaling. A sweep that is sparse only in spots per frame (a small molecule) keeps the floor.
+            const bool sparse_lattice = best.score < static_cast<int>(validation.size()) / 6
+                                        && pooled < LATTICE_MIN_INDEXED_FRACTION;
+            indexer->IntegrateEveryFrame(sparse_lattice);
+            if (sparse_lattice)
+                logger.Warning("Sparse lattice: {}/{} validation frames clear the per-frame floor, but the "
+                               "pooled spots put {:.1f}% on the lattice against {:.1f}% by chance - every "
+                               "frame is integrated from the sweep's lattice",
+                               best.score, static_cast<int>(validation.size()), 100.0 * pooled,
+                               100.0 * pooled_chance);
             logger.Info("First-pass spot finding: {} frames in {} batches, {:.2f} s",
                         spot_cache.size(), prefetch_batches, prefetch_time_s);
             logger.Info("Two-pass rotation indexing found lattice (scheme '{}': {}/{} validation frames, "
@@ -4638,7 +4692,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
     }
 
     // Scaling and merging (full analysis only).
-    if (full && !cancelled_ && result.indexing_rate.has_value() && result.indexing_rate > 0
+    if (full && !cancelled_ && (result.indexing_rate.value_or(0.0f) > 0 || result.rotation_lattice_found)
         && (config_.run_scaling || !config_.reference_data.empty())) {
         // Scaling/merging is a long post-pass; report each sub-step as a phase so the GUI progress
         // bar reflects what is happening instead of freezing on one label.
-- 
2.54.0


From 091ef41f8de5d68199b525d44f53e3fe623d28bc Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:32:01 +0200
Subject: [PATCH 019/122] rugnux: the device merge before the correction
 surfaces sees the collapsed-scale drop

DropCollapsedFullScales zeroes the corr of fulls whose frame scale collapsed on
the host copy of the fulls; on the resident-fulls (GPU) path that zero reached
the device only with the corrected corr pushed after the surfaces. The merge
that measures CC1/2 before the correction surfaces runs in between, so on the
GPU it still merged the dropped frames' fulls while the host path excluded
them - the two builds measured different observations.

The corr is now pushed to the device right after the drop, and the later push
covers only the surfaces and the frame rejection.

This changes the input of the two-pass quality guard (cc_half_before_corrections)
on GPU runs where a full scale collapsed; the final merge is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../scale_merge/RotationScaleMerge.cpp        | 35 ++++++++++++-------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index bfde3cd48..d3597ca03 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -4841,9 +4841,8 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     }
     // The total scale each frame's fulls were amplified by - partial scale, incident flux and the fulls'
     // own G (corr = 1/G here) - taken BEFORE the correction surfaces fold per-observation terms into
-    // corr, and before a collapsed frame's fulls are zeroed: the resident fulls only get that zero with
-    // the corrected corr, so a merge on the device before then still sees them, and must weigh them by
-    // their own scale. Read by MergeAndStats for the CC1/2 weight.
+    // corr, and before a collapsed frame's fulls are zeroed (a zeroed corr says nothing about the
+    // frame's scale). Read by MergeAndStats for the CC1/2 weight.
     frame_scale_fulls.assign(n_frames, NAN);
     for (const auto &o : fulls)
         if (std::isfinite(o.corr) && o.corr > 0.0f && !std::isfinite(frame_scale_fulls[o.frame])) {
@@ -4852,6 +4851,22 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         }
     const bool rejected_full_scales =
             scale_fulls && DropCollapsedFullScales(combined_on_gpu && scaled_fulls_on_gpu);
+#ifdef JFJOCH_USE_CUDA
+    // The host fulls' corr is the truth from here on; a merge on the resident (GPU) fulls reads the
+    // device copy, so every change to it is pushed back before the next device merge.
+    auto upload_fulls_corr = [&]() {
+        std::vector<float> fcorr(fulls.size());
+        ParallelChunks(static_cast<int>(fulls.size()), ThreadsForWork(fulls.size(), nthreads),
+                       [&](int lo, int hi) {
+            for (int i = lo; i < hi; ++i) fcorr[i] = fulls[i].corr;
+        });
+        gpu_->SetFullsCorr(fcorr.data());
+    };
+    // Right away, not with the corrections below: the merge just before the surfaces must see the
+    // collapsed frames' fulls gone on the device exactly as the host merge does.
+    if (rejected_full_scales && combined_on_gpu && scaled_fulls_on_gpu)
+        upload_fulls_corr();
+#endif
 
     // --- 4b. Optional correction surfaces (decay = resolution x time; absorption = goniometer-frame
     //         diffracted-beam direction), each an alternating multiplicative fit of the fulls' corr against
@@ -4917,16 +4932,10 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         CountSweepDisposition();
     }
 #ifdef JFJOCH_USE_CUDA
-    // The corrections mutate the host fulls' corr; when the merge runs on the resident (GPU) fulls, push
-    // the corrected corr back to the device so the merge reads it.
-    if ((corrections || rejected_full_scales || rejected_frames) && combined_on_gpu && scaled_fulls_on_gpu) {
-        std::vector<float> fcorr(fulls.size());
-        ParallelChunks(static_cast<int>(fulls.size()), ThreadsForWork(fulls.size(), nthreads),
-                       [&](int lo, int hi) {
-            for (int i = lo; i < hi; ++i) fcorr[i] = fulls[i].corr;
-        });
-        gpu_->SetFullsCorr(fcorr.data());
-    }
+    // The corrections and the frame rejection mutate the host fulls' corr; push it to the device so the
+    // merge reads it. (The collapsed-scale drop was pushed where it happened.)
+    if ((corrections || rejected_frames) && combined_on_gpu && scaled_fulls_on_gpu)
+        upload_fulls_corr();
 #endif
 
     // --- 5. Error model + merge + statistics. ---
-- 
2.54.0


From d245ae9d305c7aab3104625bde0a61bb61292671 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:37:55 +0200
Subject: [PATCH 020/122] PostRefine: report the realised held-out residual,
 its noise and the starting cell

Each post-refinement now records, beside what it commits, what the integration
it was handed realises at the geometry it started from: the held-out residual
at nominal (the same value the log prints on the left of "held-out ... ->"),
its standard error over the held-out residual values, and the cell the pass's
own indexing refined. Nothing here changes a decision.

Two helpers read them: HeldOutResidualFell (a pass at a new geometry realises a
lower residual than another by more than the standard error of the difference)
and ReindexPushesCellBack (re-indexing at a committed geometry returns, on the
length the fit moved most, a cell on the side the fit moved away from). The
geometry walk in RunAllPasses uses both in the next commit.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 image_analysis/geom_refinement/PostRefine.cpp | 57 +++++++++++++++++--
 image_analysis/geom_refinement/PostRefine.h   | 23 ++++++++
 tests/CMakeLists.txt                          |  1 +
 tests/PostRefineTest.cpp                      | 53 +++++++++++++++++
 4 files changed, 129 insertions(+), 5 deletions(-)
 create mode 100644 tests/PostRefineTest.cpp

diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index 82a8d4027..65a6e905c 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -497,10 +497,12 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
             // Cost of a whole geometry over one subset, the two residual families kept apart so the log
             // can say which of them moved. Each is a mean per residual VALUE, and the number they are
             // summed over below is the same weighting the solver itself applies.
+            // se_out, where asked for: the standard error of the returned mean over the residual values
+            // it averages.
             auto joint_cost = [&](Subset s, const double bm[2], const double ds[1], const double rv[3],
                                   const double q0[3], const double q1[3], const double q2[3],
-                                  double &pos_out, double &exc_out) {
-                double cp = 0.0, ce = 0.0;
+                                  double &pos_out, double &exc_out, double *se_out = nullptr) {
+                double cp = 0.0, ce = 0.0, c4 = 0.0;
                 size_t np = 0, ne = 0;
                 for (size_t oi = 0; oi < n_obs; ++oi) {
                     const Partial *pp = obs[oi];
@@ -509,7 +511,10 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                                    angle_rad(pp->img), pp->h, pp->k, pp->l, sys, orientation);
                     double res[3] = {0, 0, 0};
                     r(bm, ds, det_rot, rv, q0, q1, q2, res);
-                    cp += res[0] * res[0] + res[1] * res[1] + res[2] * res[2];
+                    for (int j = 0; j < 3; ++j) {
+                        cp += res[j] * res[j];
+                        c4 += res[j] * res[j] * res[j] * res[j];
+                    }
                     np += 3;
                 }
                 for (const int32_t i : selected) {
@@ -520,11 +525,17 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                     double res = 0.0;
                     r(rv, q0, q1, q2, &res);
                     ce += res * res;
+                    c4 += res * res * res * res;
                     ++ne;
                 }
                 pos_out = np ? cp / np : 0.0;
                 exc_out = ne ? ce / ne : 0.0;
-                return (np + ne) ? (cp + ce) / static_cast<double>(np + ne) : 0.0;
+                const double n = static_cast<double>(np + ne);
+                const double mean = (np + ne) ? (cp + ce) / n : 0.0;
+                if (se_out)
+                    *se_out = (np + ne) > 1 ? std::sqrt(std::max(0.0, c4 / n - mean * mean) / (n - 1.0))
+                                            : std::numeric_limits<double>::quiet_NaN();
+                return mean;
             };
 
             // One problem, both residual families, every block seeded at the geometry it is handed -
@@ -596,7 +607,11 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
             bool commit = false;
             if (n_obs >= static_cast<size_t>(settings.min_events)) {
                 double pos_nom = 0.0, exc_nom = 0.0, pos_ref = 0.0, exc_ref = 0.0;
-                const double cv_nom = joint_cost(VAL, beam, dist, axv, p0, p1, p2, pos_nom, exc_nom);
+                double cv_nom_se = 0.0;
+                const double cv_nom = joint_cost(VAL, beam, dist, axv, p0, p1, p2, pos_nom, exc_nom,
+                                                 &cv_nom_se);
+                result.held_out_before = cv_nom;
+                result.held_out_before_se = cv_nom_se;
 
                 // How far a geometry has moved from nominal, in units of one step.
                 const auto beyond_a_step = [&](const double ds[1], const double q1c[3]) {
@@ -747,6 +762,11 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 double len_nom[3], ang_nom[3], len_fit[3], ang_fit[3];
                 EffectiveCellFromParams(sys, p1_0, p2_0, len_nom, ang_nom);
                 EffectiveCellFromParams(sys, q1_log, q2_log, len_fit, ang_fit);
+                result.cell_before = UnitCell{static_cast<float>(len_nom[0]), static_cast<float>(len_nom[1]),
+                                              static_cast<float>(len_nom[2]),
+                                              static_cast<float>(ang_nom[0] * 180.0 / PI),
+                                              static_cast<float>(ang_nom[1] * 180.0 / PI),
+                                              static_cast<float>(ang_nom[2] * 180.0 / PI)};
                 logger.Info("Post-refine GEOM (joint crystal + detector): dist {:.3f} -> {:.3f} mm, beam "
                             "({:.2f},{:.2f}) -> ({:.2f},{:.2f}), cell {:.3f} {:.3f} {:.3f} {:.2f} {:.2f} "
                             "{:.2f} -> {:.3f} {:.3f} {:.3f} {:.2f} {:.2f} {:.2f}, held-out positional "
@@ -1016,3 +1036,30 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
     }
 }
 
+
+bool HeldOutResidualFell(const PostRefineResult &before, const PostRefineResult &after) {
+    const double noise = std::hypot(before.held_out_before_se, after.held_out_before_se);
+    return std::isfinite(noise) && after.held_out_before < before.held_out_before - noise;
+}
+
+int ReindexPushesCellBack(const PostRefineResult &fit, const PostRefineResult &next) {
+    if (!fit.cell_refined)
+        return 0;
+    const double from[3] = {fit.cell_before.a, fit.cell_before.b, fit.cell_before.c};
+    const double to[3] = {fit.cell.a, fit.cell.b, fit.cell.c};
+    const double again[3] = {next.cell_before.a, next.cell_before.b, next.cell_before.c};
+    int axis = -1;
+    double largest = 0.0;
+    for (int j = 0; j < 3; ++j)
+        if (from[j] > 0.0 && std::fabs(to[j] - from[j]) / from[j] > largest) {
+            largest = std::fabs(to[j] - from[j]) / from[j];
+            axis = j;
+        }
+    if (axis < 0 || !(again[axis] > 0.0))
+        return 0;
+    const double move = to[axis] - from[axis];
+    const double back = again[axis] - to[axis];
+    if (!(move * back < 0.0))
+        return 0;
+    return move > 0.0 ? axis + 1 : -(axis + 1);
+}
diff --git a/image_analysis/geom_refinement/PostRefine.h b/image_analysis/geom_refinement/PostRefine.h
index e1f3b7101..b6f20833c 100644
--- a/image_analysis/geom_refinement/PostRefine.h
+++ b/image_analysis/geom_refinement/PostRefine.h
@@ -5,6 +5,7 @@
 
 #include <array>
 #include <cstdint>
+#include <limits>
 #include <memory>
 #include <optional>
 #include <string>
@@ -48,6 +49,17 @@ struct PostRefineResult {
     // from. Such a move is not refused for its size - it is RATIFIED by re-integrating and re-indexing
     // at it, which a second lattice does not survive and a wrong header does (see RunAllPasses).
     bool large_move = false;
+    // The held-out residual at the geometry the fit STARTED from - what the integration this fit was
+    // handed actually realises there, before the fit moves anything - and its standard error over the
+    // held-out values. Two passes at two geometries are compared on this, not on the fit's own
+    // prediction of where it is going (see the geometry walk in RunAllPasses). NaN where the fit had
+    // too few observations to measure it.
+    double held_out_before = std::numeric_limits<double>::quiet_NaN();
+    double held_out_before_se = std::numeric_limits<double>::quiet_NaN();
+    // The cell the fit started from: the one this pass's own indexing refined. Beside `cell` (what the
+    // fit committed), and against the next pass's cell_before, it says whether re-indexing at the
+    // committed geometry ratifies the committed cell.
+    UnitCell cell_before{};
     // Which test refused the fit and what it wanted, where it was refused; empty where it committed.
     // Nothing else says it - the geometry that comes out of a refusal is the nominal one whatever
     // refused it, so a silent refusal cannot be told from a fit that never wanted to move.
@@ -119,3 +131,14 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations obs,
                                             const CrystalLattice &reference_latt,
                                             const PostRefineSettings &settings,
                                             Logger &logger);
+
+// Whether the held-out residual `after` realises at its geometry is below the one `before` realises at
+// its own by more than the standard error of the difference - the cross-validation noise of the two
+// measurements. False where either was not measured.
+bool HeldOutResidualFell(const PostRefineResult &before, const PostRefineResult &after);
+
+// Whether re-indexing at the geometry `fit` committed pushed the committed cell back: on the cell length
+// the fit moved most, the cell `next` (the fit of the pass run at that geometry) started from lies on the
+// side the fit moved away from. Returns +-(axis + 1), signed as the fit's move, where it did; 0 where the
+// re-indexing followed the fit, or the fit committed nothing.
+int ReindexPushesCellBack(const PostRefineResult &fit, const PostRefineResult &next);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 45510abb0..1b9ef6040 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -54,6 +54,7 @@ ADD_EXECUTABLE(jfjoch_test
         ParallelForTest.cpp
         RugnuxTest.cpp
         ResultReportTest.cpp
+        PostRefineTest.cpp
         RugnuxLargeTest.cpp
         TestData.h
         MovingAverageTest.cpp
diff --git a/tests/PostRefineTest.cpp b/tests/PostRefineTest.cpp
new file mode 100644
index 000000000..eec9cb593
--- /dev/null
+++ b/tests/PostRefineTest.cpp
@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_all.hpp>
+
+#include "../image_analysis/geom_refinement/PostRefine.h"
+
+namespace {
+    PostRefineResult Measured(double residual, double se) {
+        PostRefineResult r;
+        r.held_out_before = residual;
+        r.held_out_before_se = se;
+        return r;
+    }
+
+    PostRefineResult Fit(UnitCell before, UnitCell after) {
+        PostRefineResult r;
+        r.cell_refined = true;
+        r.cell_before = before;
+        r.cell = after;
+        return r;
+    }
+
+    UnitCell Cell(float a, float b, float c) {
+        return UnitCell{.a = a, .b = b, .c = c, .alpha = 90.0f, .beta = 90.0f, .gamma = 90.0f};
+    }
+}
+
+TEST_CASE("PostRefine_HeldOutResidualFell", "[PostRefine]") {
+    // Down by more than the standard error of the difference, sqrt(3^2 + 4^2) = 5.
+    CHECK(HeldOutResidualFell(Measured(100.0, 3.0), Measured(94.0, 4.0)));
+    // Down, but within that noise.
+    CHECK_FALSE(HeldOutResidualFell(Measured(100.0, 3.0), Measured(96.0, 4.0)));
+    // Up.
+    CHECK_FALSE(HeldOutResidualFell(Measured(100.0, 3.0), Measured(110.0, 4.0)));
+    // Not measured on either side.
+    CHECK_FALSE(HeldOutResidualFell(PostRefineResult{}, Measured(10.0, 1.0)));
+    CHECK_FALSE(HeldOutResidualFell(Measured(100.0, 3.0), PostRefineResult{}));
+}
+
+TEST_CASE("PostRefine_ReindexPushesCellBack", "[PostRefine]") {
+    // The fit shortens b the most; re-indexing at its geometry returns a longer b: pushed back.
+    const auto fit = Fit(Cell(96.9f, 107.9f, 112.9f), Cell(96.8f, 106.6f, 112.9f));
+    CHECK(ReindexPushesCellBack(fit, Fit(Cell(96.7f, 107.6f, 112.6f), Cell(96.6f, 106.4f, 112.8f))) == -2);
+    // A walk that re-indexing follows (and overshoots a little) is not pushed back.
+    const auto walk = Fit(Cell(60.48f, 60.48f, 196.7f), Cell(60.05f, 60.05f, 195.2f));
+    CHECK(ReindexPushesCellBack(walk, Fit(Cell(60.00f, 60.00f, 195.1f), Cell(59.8f, 59.8f, 194.2f))) == 0);
+    // Nothing committed, or no cell measured by the next pass: no evidence either way.
+    PostRefineResult refused = fit;
+    refused.cell_refined = false;
+    CHECK(ReindexPushesCellBack(refused, Fit(Cell(96.7f, 107.6f, 112.6f), Cell(96.6f, 106.4f, 112.8f))) == 0);
+    CHECK(ReindexPushesCellBack(fit, PostRefineResult{}) == 0);
+}
-- 
2.54.0


From 4b0c33a47385c7ed1f00a95711b4754ea7b061e3 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:37:55 +0200
Subject: [PATCH 021/122] rugnux: the geometry walk continues only while
 re-integration realises a gain

The rotation geometry walk kept re-integrating while the post-refinement at
the adopted geometry still committed a move, up to four rounds. It never ended
on its own: every walking run hit the cap, and with the cap lifted to twelve
every one hit twelve. Each round's fit predicted a held-out gain the
re-integration at its geometry then did not realise - the realised residual
stayed flat from the first round, or passed a minimum and rose again while the
distance crept on along the distance/cell-scale degeneracy - so the cap decided
where on the drift the run stopped.

A round is now kept only when the held-out residual measured by the pass
re-integrated at its geometry falls below the best round's by more than the
standard error of the difference. The first round that does not ends the walk,
and the run goes back to the best round (one more pass, since the canonical
files were written by the last). The walk also stops when re-indexing pushes
the fitted cell back on the same length in the same direction on two rounds
running: the fit keeps asking for a cell nothing ratifies. The cap is 8; a
walk still paying at the cap keeps its last (= best) round, sets
geometry_not_converged, and the report flags GEOMETRY_NOT_CONVERGED. Either
way the kept round is judged against the header-geometry pass by
RefinedPassIsWorse, as before. PASS_DECISION lists distance and realised
residual per round and why the walk ended.

Runs whose post-refinement does not commit a move of more than one step do not
walk and are unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 docs/RUGNUX_REPORT.md      |   2 +-
 rugnux/ReportDocument.h    |   1 +
 rugnux/ResultReport.cpp    |   5 ++
 rugnux/Rugnux.cpp          | 133 +++++++++++++++++++++++++++++--------
 rugnux/Rugnux.h            |   3 +
 tests/ResultReportTest.cpp |  19 ++++++
 6 files changed, 133 insertions(+), 30 deletions(-)

diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index 264bf1cb9..325be8583 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -139,7 +139,7 @@ and a run that produced a textbook data set read identically for their first thr
   `SYMMETRY_AMBIGUITY`, `CENTERING_UNTESTED`, `UNUSABLE_MERGE`, `LOW_COMPLETENESS`, `SWEEP_GAPS`,
   `GONIO_SCALE`, `SPINDLE_CAP`, `ANISOTROPY`, `TWINNING`, `PSEUDO_TRANSLATION`,
   `LATTICE_TRANSLATION`, `MODEL_HAND`, `MODEL_NOT_VALIDATED`, `CANCELLED`, `RESOLUTION_FIT`,
-  `FLIGHT_PATH`. `NONE` when nothing fired. A code appears if and only if its
+  `FLIGHT_PATH`, `GEOMETRY_NOT_CONVERGED`. `NONE` when nothing fired. A code appears if and only if its
   warning fired, so the flags and the `WARNING:` lines are two renderings of one list — the closed
   type for machinery, the open sentence for a person.
 - **`WARNING_COUNT=`** and the **`WARNING:`** lines follow, in the same section. They are what they
diff --git a/rugnux/ReportDocument.h b/rugnux/ReportDocument.h
index 48b42c917..bc587c577 100644
--- a/rugnux/ReportDocument.h
+++ b/rugnux/ReportDocument.h
@@ -43,6 +43,7 @@ namespace PathologyCode {
     // in how exact it is. ANISOTROPY and RESOLUTION_FIT are already shared this way.
     constexpr const char *LATTICE_TRANSLATION = "LATTICE_TRANSLATION";   // a translation the cell does not declare
     constexpr const char *HARMONIC_CONTAMINATION = "HARMONIC_CONTAMINATION"; // the beam carries a higher harmonic
+    constexpr const char *GEOMETRY_NOT_CONVERGED = "GEOMETRY_NOT_CONVERGED"; // the geometry walk ran out of rounds
 }
 
 // A closed type plus an open description. The type is what machinery switches on; the text is what a
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index cbb2ae8ba..0a976d95d 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -385,6 +385,11 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
         if (result.pass_count > 1) {
             Add(s, KeyText("PASS", fmt::format("{} of {}", result.pass_number, result.pass_count)));
             Add(s, KeyText("PASS_DECISION", result.pass_decision, true));
+            if (result.geometry_not_converged)
+                Warn(doc, PathologyCode::GEOMETRY_NOT_CONVERGED,
+                     "the detector geometry post-refinement was still moving when the run stopped walking "
+                     "it: every round lowered the held-out residual, so the geometry this result was "
+                     "integrated at is the best one reached, not a settled one (see PASS_DECISION)");
         }
 
         Add(s, Blank());
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 4e6d247b0..a6da5bbb2 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1987,50 +1987,124 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
         // What starts the walk is a move of more than one step: that is the fit saying the geometry is
         // somewhere else entirely rather than a fraction of a percent away, and it leaves every run
         // whose fit settles beside its header at the two passes it always had. Once the run IS walking
-        // it keeps walking while the fit still commits, because the steps do not get smaller in
-        // proportion to what is left: measured on a header 3.9 % long, the first round took a third of
-        // the error and each of the next took a third of the rest. The walk is bounded rather than
-        // stopped at a size, because there is no size that separates the last step of a real walk from
-        // the first step of a runaway - and it does not run away: started BELOW the optimum the same fit
-        // turns back up, so it settles around the answer instead of past it.
-        constexpr int MAX_GEOMETRY_ROUNDS = 4;
-        std::optional<std::array<float, 5>> adopted_geometry;
-        int geometry_rounds = 0;
-        while (!cancelled_ && geometry_rounds < MAX_GEOMETRY_ROUNDS && prepass_detector_geometry_
-               && pass2.post_refine && pass2.post_refine->detector_refined
-               && (pass2.post_refine->large_move || geometry_rounds > 0)) {
-            adopted_geometry = *prepass_detector_geometry_;
-            const auto &g = *adopted_geometry;
-            logger.Info("Two-pass: the post-refinement at the adopted geometry still moves it "
-                        "(distance {:.3f} -> {:.3f} mm) - re-integrating and re-indexing at what it "
-                        "asks for (round {} of at most {})", pass2.post_refine->distance_before_mm,
-                        pass2.post_refine->distance_after_mm, geometry_rounds + 1,
-                        MAX_GEOMETRY_ROUNDS);
+        // it keeps walking because the steps do not get smaller in proportion to what is left: measured
+        // on a header 3.9 % long, the first round took a third of the error and each of the next took a
+        // third of the rest.
+        //
+        // But a round is kept only for what it REALISES, not for what the fit predicts: the held-out
+        // residual of the pass re-integrated and re-indexed at the new geometry has to fall below the
+        // best round's by more than the cross-validation noise of the two (HeldOutResidualFell). With
+        // the walk allowed twelve rounds, every round's fit predicted a gain the re-integration did not
+        // show - the realised residual stayed flat, or passed a minimum and rose again, while the
+        // distance crept on along the distance/cell-scale degeneracy - so "the fit still commits" never
+        // ended a walk, and the cap decided where on the drift the run stopped. A round that does not
+        // pay ends the walk and the run goes back to the best round it reached. So does a fit whose
+        // committed cell the re-indexing pushes back the same way twice running (ReindexPushesCellBack):
+        // the fit keeps asking for a cell the indexer at the fit's own geometry does not return, and
+        // nothing ratifies it. A walk still paying when the rounds run out keeps its best round - the
+        // last - and says it did not converge; the quality guard below judges it against the header
+        // pass as it judges every refined pass.
+        constexpr int MAX_GEOMETRY_ROUNDS = 8;
+        const auto current_geometry = [&] {
+            return std::array<float, 5>{experiment_.GetBeamX_pxl(), experiment_.GetBeamY_pxl(),
+                                        experiment_.GetDetectorDistance_mm(),
+                                        experiment_.GetPoniRot1_rad(), experiment_.GetPoniRot2_rad()};
+        };
+        const auto set_geometry = [&](const std::array<float, 5> &g) {
             experiment_.BeamX_pxl(g[0]).BeamY_pxl(g[1]).DetectorDistance_mm(g[2])
                        .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
+        };
+        int geometry_rounds = 0;      // passes run at a geometry the walk moved to
+        int walk_passes = 0;          // every pass the walk ran, the return to its best round included
+        int best_round = 0;
+        std::array<float, 5> best_geometry = current_geometry();
+        PostRefineResult best_fit;    // the fit measured in the best round's pass: its realised residual
+        int last_pushback = 0;
+        bool geometry_not_converged = false;
+        std::string walk_stop;        // why the walk ended, where anything but the fit settling ended it
+        std::string walk_rounds;      // distance / realised residual per round, for the pass decision
+        if (pass2.post_refine) {
+            best_fit = *pass2.post_refine;
+            walk_rounds = fmt::format("{:.3f} mm / {:.3e}", best_geometry[2], best_fit.held_out_before);
+        }
+        while (!cancelled_ && prepass_detector_geometry_
+               && pass2.post_refine && pass2.post_refine->detector_refined
+               && (pass2.post_refine->large_move || geometry_rounds > 0)) {
+            if (geometry_rounds == MAX_GEOMETRY_ROUNDS) {
+                geometry_not_converged = true;
+                walk_stop = fmt::format("the fit still moved the geometry after {} rounds, every one of "
+                                        "which lowered the realised residual", MAX_GEOMETRY_ROUNDS);
+                logger.Warning("Two-pass: {} - the walk did not converge; the run keeps its last round "
+                               "and the quality guard judges it against the header pass", walk_stop);
+                break;
+            }
+            const PostRefineResult fit = *pass2.post_refine;
+            const std::array<float, 5> g = *prepass_detector_geometry_;
+            logger.Info("Two-pass: the post-refinement at the adopted geometry still moves it "
+                        "(distance {:.3f} -> {:.3f} mm) - re-integrating and re-indexing at what it "
+                        "asks for (round {} of at most {})", fit.distance_before_mm,
+                        fit.distance_after_mm, geometry_rounds + 1, MAX_GEOMETRY_ROUNDS);
+            set_geometry(g);
             pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
             ++geometry_rounds;
+            ++walk_passes;
+            const double realised = pass2.post_refine ? pass2.post_refine->held_out_before : NAN;
+            walk_rounds += fmt::format(", {:.3f} mm / {:.3e}", g[2], realised);
+            if (!pass2.post_refine || !HeldOutResidualFell(best_fit, *pass2.post_refine)) {
+                walk_stop = fmt::format(
+                        "round {} did not lower the realised held-out residual by more than its noise "
+                        "({:.3e} against {:.3e}, standard errors {:.1e} and {:.1e})", geometry_rounds,
+                        realised, best_fit.held_out_before,
+                        pass2.post_refine ? pass2.post_refine->held_out_before_se : NAN,
+                        best_fit.held_out_before_se);
+                logger.Info("Two-pass: {}", walk_stop);
+                break;
+            }
+            best_round = geometry_rounds;
+            best_geometry = g;
+            best_fit = *pass2.post_refine;
+            const int pushback = ReindexPushesCellBack(fit, *pass2.post_refine);
+            if (pushback != 0 && pushback == last_pushback) {
+                walk_stop = fmt::format(
+                        "re-indexing pushed the cell length {} back against the fit for the second "
+                        "round running, so nothing ratifies the cell the fit asks for",
+                        "abc"[std::abs(pushback) - 1]);
+                logger.Info("Two-pass: {} - the walk stops at round {}", walk_stop, geometry_rounds);
+                break;
+            }
+            last_pushback = pushback;
         }
         postrefine_probe_ = false;
+        // The canonical files were written by the last round; where that is not the best one, the best
+        // one is run again to write them.
+        if (!cancelled_ && geometry_rounds > best_round) {
+            logger.Info("Two-pass: going back to round {} of the geometry walk (distance {:.3f} mm), the "
+                        "last one that lowered the realised residual", best_round, best_geometry[2]);
+            set_geometry(best_geometry);
+            pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
+            ++walk_passes;
+        }
 
         // The post-refinement is measured by pass 1 and consumed by pass 2, so carry it onto whichever
         // result is returned - it is a result of the run, not of the pass that happened to fit it. Where
         // the walk took rounds they are ONE geometry decision, so what the report names is where the
         // geometry started and where the run left it, not the first step of the way there.
-        if (geometry_rounds > 0 && pass1.post_refine && adopted_geometry) {
-            pass1.post_refine->beam_x_after_px = (*adopted_geometry)[0];
-            pass1.post_refine->beam_y_after_px = (*adopted_geometry)[1];
-            pass1.post_refine->distance_after_mm = (*adopted_geometry)[2];
+        if (best_round > 0 && pass1.post_refine) {
+            pass1.post_refine->beam_x_after_px = best_geometry[0];
+            pass1.post_refine->beam_y_after_px = best_geometry[1];
+            pass1.post_refine->distance_after_mm = best_geometry[2];
         }
         pass2.post_refine = pass1.post_refine;
-        pass2.pass_number = 2 + geometry_rounds;
-        pass2.pass_count = 2 + geometry_rounds;
+        pass2.pass_number = 2 + walk_passes;
+        pass2.pass_count = 2 + walk_passes;
         if (geometry_rounds > 0)
             pass2.pass_decision = fmt::format(
-                    "post-refined geometry adopted over {} rounds: the fit was still walking at each of "
-                    "them, and the detector distance ended at {:.3f} mm against the header's {:.3f}",
-                    geometry_rounds + 1, (*adopted_geometry)[2],
-                    pass1.post_refine ? pass1.post_refine->distance_before_mm : 0.0);
+                    "post-refined geometry walked {} round{} and kept round {}, detector distance {:.3f} mm "
+                    "against the header's {:.3f}: {}; distance / realised held-out residual by round: {}",
+                    geometry_rounds, geometry_rounds == 1 ? "" : "s", best_round, best_geometry[2],
+                    pass1.post_refine ? pass1.post_refine->distance_before_mm : 0.0,
+                    walk_stop.empty() ? "the fit at the kept geometry commits no further move" : walk_stop,
+                    walk_rounds);
 
         // r2 = r1 + 2 is also the inner edge of the background ring, so widening the signal disk pushes
         // that ring out into the neighbours; a reflection whose ring is left with five or fewer clean
@@ -2157,6 +2231,7 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass2.pass_decision = (prepass_detector_geometry_ || prepass_rotation_scale_)
                     ? "post-refined geometry adopted"
                     : "the post-refinement committed no geometry change, so this pass reproduces the first";
+        pass2.geometry_not_converged = geometry_not_converged;
         return pass2;
     }
     return RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index d56907983..91312251a 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -361,6 +361,9 @@ struct ProcessResult {
     int pass_number = 1;
     int pass_count = 1;
     std::string pass_decision;
+    // The rotation geometry walk used every round it was given and its fit still asked for a move: the
+    // geometry this result was integrated at is the best round the walk reached, not a settled one.
+    bool geometry_not_converged = false;
 
     // The radiation-damage report (rotation), the same text the log prints. Empty when not measured.
     std::string radiation_damage_text;
diff --git a/tests/ResultReportTest.cpp b/tests/ResultReportTest.cpp
index 594306c74..12d61a22b 100644
--- a/tests/ResultReportTest.cpp
+++ b/tests/ResultReportTest.cpp
@@ -793,3 +793,22 @@ TEST_CASE("ResultReport_TranslationalNCS", "[Diagnostics]") {
     CHECK(lat.find("\nPATHOLOGY_FLAGS= LATTICE_TRANSLATION\n") != std::string::npos);
     CHECK(lat.find("\nTNCS_SUBLATTICE=") == std::string::npos);
 }
+
+TEST_CASE("ResultReport_GeometryNotConverged", "[Diagnostics]") {
+    DiffractionExperiment x(DetJF(1));
+    ProcessResult result;
+    result.consensus_cell = UnitCell{.a = 79.0f, .b = 79.0f, .c = 38.0f,
+                                     .alpha = 90.0f, .beta = 90.0f, .gamma = 90.0f};
+    result.pass_number = 10;
+    result.pass_count = 10;
+    result.pass_decision = "post-refined geometry walked 8 rounds and kept round 8";
+
+    CHECK(RenderResultReport("p", "in.h5", x, result).find("GEOMETRY_NOT_CONVERGED") == std::string::npos);
+
+    result.geometry_not_converged = true;
+    const auto text = RenderResultReport("p", "in.h5", x, result);
+    const auto flags = text.find("\nPATHOLOGY_FLAGS= ");
+    REQUIRE(flags != std::string::npos);
+    CHECK(text.substr(flags, text.find('\n', flags + 1) - flags).find("GEOMETRY_NOT_CONVERGED")
+          != std::string::npos);
+}
-- 
2.54.0


From 162aaafef76362fd072033086fa3712e3c6999ba Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:25:42 +0200
Subject: [PATCH 022/122] tools/battery: -A where XDS kept Friedel mates apart

On the XDS-referenced arms rugnux merges Friedel mates separately whenever
XDS ran with FRIEDEL'S_LAW=FALSE, in forced and unforced mode alike, so the
merging statistics compare like with like.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/README.md  | 2 ++
 tools/battery/battery.py | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 6b31188fa..628c9d785 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -245,6 +245,8 @@ reproduces A was really changed by B.
    processing better than XDS's, reflection for reflection". `--unforced` leaves rugnux its own
    cut, which answers "what does a user get". A change can win one and lose the other, so at
    important moments run both. Never quote the forced run as what rugnux delivers.
+   Where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the manifest), rugnux gets
+   `-A` in both modes, so Friedel mates are merged separately on both sides.
 
 ### The XDS reference d_min
 
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index b369d949e..7fd9f48d3 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -167,6 +167,10 @@ def command(binary, e, opts):
             cmd += ["--scaling-high-resolution", f"{ref['dmin']:.3f}"]
         if ref.get("dmax"):
             cmd += ["--scaling-low-resolution", f"{ref['dmax']:.3f}"]
+    # XDS merged with FRIEDEL'S_LAW=FALSE: merge Friedel mates separately too, or the merging
+    # statistics are not comparable
+    if e.get("reference") == "xds" and ref.get("anomalous"):
+        cmd.append("-A")
     cmd += opts["extra_args"]
     cmd.append(e["input_path"])
     if opts["gpulock"]:
-- 
2.54.0


From 6c8a32124c9efb585947027c673f29cd450a0d11 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 13:02:41 +0200
Subject: [PATCH 023/122] rugnux --model: model structure factors with FFTW
 instead of pocketfft

Every map -> structure-factor transform on the model path - Fcalc from the
model density and Fmask from the bulk-solvent mask, in the fit, the rigid-body
evaluations (two per evaluation, ~120 evaluations per placement), the frame
probe and the stills model reference - went through gemmi's vendored pocketfft,
single-threaded. They now go through MapToFPhi (rugnux/ModelFFT.{h,cpp}): an
FFTW r2c (fftw3f, already fetched and linked) planned with the guru interface on
the same layout gemmi uses (u fastest, w halved), scaled by V/N, into the same
FPhiGrid, so gemmi's prepare_asu_data() extracts the reflections exactly as
before. gemmi's vendored code is not modified. The F -> map transforms of the
output maps are left on gemmi.

Plans are FFTW_ESTIMATE only (MEASURE times candidates and could choose
differently between runs), made under a mutex - FFTW's planner is not
thread-safe, and the null replicates and the parallel Jacobian call this
concurrently - cached per grid size for the life of the process, and executed
with fftwf_execute_dft_r2c on fftwf_malloc buffers (new-array execution needs
the planning arrays' alignment, which a std::vector does not promise).

NOT bit-identical with pocketfft: the two libraries order their arithmetic
differently, so structure factors move in the last float bits and everything
downstream (scale fit, rigid body, R-factors, maps) can move in the last
printed digit. Verify by tolerance, separately from the parallelisation commits:
MODEL_* keys equal to printed precision and the same MODEL_FIT / hand /
indexing decisions on the audit set.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/CMakeLists.txt         |  4 +-
 rugnux/ModelFFT.cpp           | 73 +++++++++++++++++++++++++++++++++++
 rugnux/ModelFFT.h             | 18 +++++++++
 rugnux/ModelValidation.cpp    | 13 ++++---
 rugnux/RigidBodyRefine.cpp    |  6 +--
 tests/ModelValidationTest.cpp | 35 +++++++++++++++++
 6 files changed, 139 insertions(+), 10 deletions(-)
 create mode 100644 rugnux/ModelFFT.cpp
 create mode 100644 rugnux/ModelFFT.h

diff --git a/rugnux/CMakeLists.txt b/rugnux/CMakeLists.txt
index 3484e35e9..37d0b3e0d 100644
--- a/rugnux/CMakeLists.txt
+++ b/rugnux/CMakeLists.txt
@@ -8,6 +8,8 @@ ADD_LIBRARY(Rugnux STATIC
         Rugnux.h
         RugnuxCommandLine.cpp
         RugnuxCommandLine.h
+        ModelFFT.cpp
+        ModelFFT.h
         ModelScaling.cpp
         ModelScaling.h
         ModelValidation.cpp
@@ -27,7 +29,7 @@ ADD_LIBRARY(Rugnux STATIC
         WriteModel.h
 )
 
-TARGET_LINK_LIBRARIES(Rugnux JFJochReader JFJochImageAnalysis JFJochWriter gemmi)
+TARGET_LINK_LIBRARIES(Rugnux JFJochReader JFJochImageAnalysis JFJochWriter gemmi fftw3f)
 
 # rugnux is the single offline analysis CLI; --mode picks what it does: mx (the full pipeline, the
 # default), azint, scale (re-scale/merge stored reflections) or calibration (powder-ring geometry).
diff --git a/rugnux/ModelFFT.cpp b/rugnux/ModelFFT.cpp
new file mode 100644
index 000000000..73daab1fc
--- /dev/null
+++ b/rugnux/ModelFFT.cpp
@@ -0,0 +1,73 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "ModelFFT.h"
+
+#include <algorithm>
+#include <array>
+#include <complex>
+#include <map>
+#include <mutex>
+
+#include <fftw3.h>
+
+#include "gemmi/fail.hpp"
+
+namespace {
+
+// The r2c plan for an (nu, nv, nw) map stored u fastest, halving w - the layout gemmi's own transform
+// reads and writes. FFTW's planner is not thread-safe, so plans are made under a lock; executing one
+// on new arrays (fftwf_execute_dft_r2c) is, which is how every caller uses it.
+fftwf_plan PlanFor(int nu, int nv, int nw) {
+    static std::mutex m;
+    static std::map<std::array<int, 3>, fftwf_plan> plans;
+    std::lock_guard lock(m);
+    const std::array<int, 3> key{nu, nv, nw};
+    if (const auto it = plans.find(key); it != plans.end())
+        return it->second;
+    float *in = fftwf_alloc_real(static_cast<size_t>(nu) * nv * nw);
+    fftwf_complex *out = fftwf_alloc_complex(static_cast<size_t>(nu) * nv * (nw / 2 + 1));
+    // The last dimension is the one r2c halves; the strides put u fastest on both sides.
+    fftwf_iodim dims[3] = {{nu, 1, 1}, {nv, nu, nu}, {nw, nu * nv, nu * nv}};
+    fftwf_plan plan = (in != nullptr && out != nullptr)
+            ? fftwf_plan_guru_dft_r2c(3, dims, 0, nullptr, in, out, FFTW_ESTIMATE)
+            : nullptr;
+    fftwf_free(in);
+    fftwf_free(out);
+    if (plan == nullptr)
+        gemmi::fail("MapToFPhi(): no FFTW plan for the grid");
+    plans.emplace(key, plan);
+    return plan;
+}
+
+}  // namespace
+
+gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map) {
+    if (map.axis_order == gemmi::AxisOrder::ZYX)
+        gemmi::fail("MapToFPhi(): ZYX order is not supported");
+    gemmi::FPhiGrid<float> hkl;
+    hkl.unit_cell = map.unit_cell;
+    hkl.spacegroup = map.spacegroup;
+    hkl.axis_order = map.axis_order;
+    hkl.half_l = true;
+    hkl.set_size_without_checking(map.nu, map.nv, map.nw / 2 + 1);
+    const float norm = static_cast<float>(map.unit_cell.volume / map.point_count());
+
+    const fftwf_plan plan = PlanFor(map.nu, map.nv, map.nw);
+    // Buffers from fftwf_malloc: a plan may only be executed on arrays aligned as the ones it was made
+    // on were, which the vectors' own allocations do not promise.
+    float *in = fftwf_alloc_real(map.data.size());
+    fftwf_complex *out = fftwf_alloc_complex(hkl.data.size());
+    if (in == nullptr || out == nullptr) {
+        fftwf_free(in);
+        fftwf_free(out);
+        gemmi::fail("MapToFPhi(): cannot allocate the FFT buffers");
+    }
+    std::copy(map.data.begin(), map.data.end(), in);
+    fftwf_execute_dft_r2c(plan, in, out);
+    for (size_t i = 0; i < hkl.data.size(); ++i)
+        hkl.data[i] = std::complex<float>(out[i][0], out[i][1]) * norm;
+    fftwf_free(in);
+    fftwf_free(out);
+    return hkl;
+}
diff --git a/rugnux/ModelFFT.h b/rugnux/ModelFFT.h
new file mode 100644
index 000000000..b98778bd2
--- /dev/null
+++ b/rugnux/ModelFFT.h
@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include "gemmi/grid.hpp"
+#include "gemmi/recgrid.hpp"
+
+// The structure factors of a real-space map on the model path (Fcalc from the model density, Fmask
+// from the bulk-solvent mask): what gemmi::transform_map_to_f_phi(map, true) returns - the forward
+// transform scaled by V/N, kept for l >= 0 on an (nu, nv, nw/2+1) grid in the map's own XYZ order,
+// ready for prepare_asu_data() - computed with FFTW rather than gemmi's single-threaded pocketfft.
+// The same transform, not the same bits: the two libraries order their arithmetic differently.
+//
+// Plans are FFTW_ESTIMATE only - MEASURE would time candidate algorithms and could pick a different
+// one from run to run - and made once per grid size and kept, so the rigid body's hundred-odd
+// evaluations on one grid plan once. Safe to call from several threads at once.
+gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map);
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 4deecd583..d85b0430b 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -19,7 +19,7 @@
 #include <gemmi/gz.hpp>        // MaybeGzipped
 #include <gemmi/it92.hpp>      // IT92 x-ray form factors
 #include <gemmi/dencalc.hpp>   // DensityCalculator
-#include <gemmi/fourier.hpp>   // transform_map_to_f_phi, get_f_phi_on_grid, transform_f_phi_grid_to_map
+#include <gemmi/fourier.hpp>   // get_f_phi_on_grid, transform_f_phi_grid_to_map (the maps)
 #include <gemmi/solmask.hpp>   // SolventMasker
 #include <gemmi/scaling.hpp>   // Scaling (bulk solvent + anisotropic B)
 #include <gemmi/ccp4.hpp>      // Ccp4 map I/O
@@ -30,6 +30,7 @@
 #include "../common/Logger.h"
 #include "../common/ParallelFor.h"  // ParallelFor
 #include "../image_analysis/scale_merge/ReindexAmbiguity.h"   // ReindexReflections
+#include "ModelFFT.h"
 #include "RigidBodyRefine.h"
 #include "SigmaA.h"
 
@@ -283,7 +284,7 @@ double frame_probe_r(const gemmi::Structure &st, const gemmi::SpaceGroup *sg,
     dc.set_refmac_compatible_blur(st.models[0]);
     dc.put_model_density_on_grid(st.models[0]);
     gemmi::AsuData<std::complex<float>> fcalc =
-        gemmi::transform_map_to_f_phi(dc.grid, true)
+        MapToFPhi(dc.grid)
             .prepare_asu_data(probe_d_min, dc.blur, false, false, false);
 
     gemmi::GroupOps gops = sg->operations();
@@ -476,7 +477,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         dc.set_grid_cell_and_spacegroup(ms.st);
         dc.set_refmac_compatible_blur(ms.st.models[0]);
         dc.put_model_density_on_grid(ms.st.models[0]);
-        ms.fcalc = gemmi::transform_map_to_f_phi(dc.grid, true)
+        ms.fcalc = MapToFPhi(dc.grid)
                        .prepare_asu_data(dc.d_min, dc.blur, false, false, false);
 
         // Refmac radii give a slightly lower R than the Cctbx set on our test cases, at no cost.
@@ -486,7 +487,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         mask_grid.spacegroup = dc.grid.spacegroup;
         mask_grid.set_size_from_spacing(dc.requested_grid_spacing(), gemmi::GridSizeRounding::Up);
         masker.put_mask_on_grid(mask_grid, ms.st.models[0]);
-        ms.fmask = gemmi::transform_map_to_f_phi(mask_grid, true).prepare_asu_data(dc.d_min, 0);
+        ms.fmask = MapToFPhi(mask_grid).prepare_asu_data(dc.d_min, 0);
     };
     compute_model_factors(mdl);
 
@@ -1246,7 +1247,7 @@ std::vector<MergedReflection> ModelReferenceIntensities(const std::string &model
     dc.set_refmac_compatible_blur(st.models[0]);
     dc.put_model_density_on_grid(st.models[0]);
     gemmi::AsuData<std::complex<float>> fcalc =
-        gemmi::transform_map_to_f_phi(dc.grid, true).prepare_asu_data(dc.d_min, dc.blur, false, false, false);
+        MapToFPhi(dc.grid).prepare_asu_data(dc.d_min, dc.blur, false, false, false);
 
     // Flat bulk solvent at the standard constants. Nothing here is fitted - there are no observations
     // yet - but without it the few lowest-resolution reflections are the largest and the most wrong,
@@ -1260,7 +1261,7 @@ std::vector<MergedReflection> ModelReferenceIntensities(const std::string &model
     mask_grid.set_size_from_spacing(dc.requested_grid_spacing(), gemmi::GridSizeRounding::Up);
     masker.put_mask_on_grid(mask_grid, st.models[0]);
     gemmi::AsuData<std::complex<float>> fmask =
-        gemmi::transform_map_to_f_phi(mask_grid, true).prepare_asu_data(dc.d_min, 0);
+        MapToFPhi(mask_grid).prepare_asu_data(dc.d_min, 0);
 
     std::unordered_map<long, std::complex<float>> mask_by_hkl;
     mask_by_hkl.reserve(fmask.v.size());
diff --git a/rugnux/RigidBodyRefine.cpp b/rugnux/RigidBodyRefine.cpp
index e9a34551f..91d25843c 100644
--- a/rugnux/RigidBodyRefine.cpp
+++ b/rugnux/RigidBodyRefine.cpp
@@ -13,11 +13,11 @@
 #include <ceres/rotation.h>
 
 #include "gemmi/dencalc.hpp"   // DensityCalculator
-#include "gemmi/fourier.hpp"   // transform_map_to_f_phi
 #include "gemmi/it92.hpp"      // IT92 x-ray form factors
 #include "gemmi/scaling.hpp"   // Scaling (bulk solvent + anisotropic B)
 #include "gemmi/solmask.hpp"   // SolventMasker
 
+#include "ModelFFT.h"               // MapToFPhi
 #include "ModelScaling.h"           // FitModelScale
 #include "../common/JFJochMath.h"   // PI
 #include "../common/Logger.h"
@@ -104,7 +104,7 @@ public:
         dc.set_refmac_compatible_blur(model_);
         dc.put_model_density_on_grid(model_);
         gemmi::AsuData<std::complex<float>> fcalc =
-            gemmi::transform_map_to_f_phi(dc.grid, true).prepare_asu_data(dc.d_min, dc.blur, false, false, false);
+            MapToFPhi(dc.grid).prepare_asu_data(dc.d_min, dc.blur, false, false, false);
 
         gemmi::SolventMasker masker(gemmi::AtomicRadiiSet::Refmac);
         gemmi::Grid<float> mask_grid;
@@ -113,7 +113,7 @@ public:
         mask_grid.set_size_from_spacing(dc.requested_grid_spacing(), gemmi::GridSizeRounding::Up);
         masker.put_mask_on_grid(mask_grid, model_);
         gemmi::AsuData<std::complex<float>> fmask =
-            gemmi::transform_map_to_f_phi(mask_grid, true).prepare_asu_data(dc.d_min, 0);
+            MapToFPhi(mask_grid).prepare_asu_data(dc.d_min, 0);
         if (fmask.size() != fcalc.size())
             return false;
 
diff --git a/tests/ModelValidationTest.cpp b/tests/ModelValidationTest.cpp
index b7e4ec822..943a559cc 100644
--- a/tests/ModelValidationTest.cpp
+++ b/tests/ModelValidationTest.cpp
@@ -11,8 +11,10 @@
 #include <sstream>
 
 #include <gemmi/mmread_gz.hpp>
+#include <gemmi/fourier.hpp>
 
 #include "../common/Logger.h"
+#include "../rugnux/ModelFFT.h"
 #include "../rugnux/ModelValidation.h"
 #include "../rugnux/RigidBodyRefine.h"
 #include "../rugnux/SigmaA.h"
@@ -587,3 +589,36 @@ TEST_CASE("ModelValidation_CCModelFollowsTheSignalByShell", "[ModelValidation]")
         std::filesystem::remove(prefix + suffix);
     std::filesystem::remove(path);
 }
+
+// The model path's structure factors come from FFTW; they must be gemmi's own transform to float
+// precision, in the same layout, so prepare_asu_data() reads the same reflections from either.
+TEST_CASE("ModelValidation_MapToFPhiMatchesGemmi", "[ModelValidation]") {
+    gemmi::Grid<float> map;
+    map.unit_cell.set(40.0, 50.0, 60.0, 90.0, 95.0, 90.0);
+    map.spacegroup = gemmi::find_spacegroup_by_name("P 1");
+    map.set_size(20, 24, 30);
+    std::mt19937 rng(7);
+    std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
+    for (auto &x : map.data)
+        x = dist(rng);
+
+    gemmi::FPhiGrid<float> ref = gemmi::transform_map_to_f_phi(map, true);
+    gemmi::FPhiGrid<float> ours = MapToFPhi(map);
+    REQUIRE(ours.nu == ref.nu);
+    REQUIRE(ours.nv == ref.nv);
+    REQUIRE(ours.nw == ref.nw);
+    REQUIRE(ours.half_l == ref.half_l);
+    REQUIRE(ours.data.size() == ref.data.size());
+    double largest = 0, worst = 0;
+    for (size_t i = 0; i < ref.data.size(); i++) {
+        largest = std::max(largest, static_cast<double>(std::abs(ref.data[i])));
+        worst = std::max(worst, static_cast<double>(std::abs(ours.data[i] - ref.data[i])));
+    }
+    CHECK(worst <= 1e-5 * largest);
+
+    const auto a = ref.prepare_asu_data(4.0, 0, false, false, false);
+    const auto b = ours.prepare_asu_data(4.0, 0, false, false, false);
+    REQUIRE(a.v.size() == b.v.size());
+    for (size_t i = 0; i < a.v.size(); i++)
+        CHECK(a.v[i].hkl == b.v[i].hkl);
+}
-- 
2.54.0


From bb0648ae87941815d3c729a9bcf2da5f72dc96a8 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:42:27 +0200
Subject: [PATCH 024/122] tools/battery: run every variant of a set back to
 back

The battery is bound by reading images from disk, so instead of one battery run per setting each
set now runs in all its variants in a row while its images are still in the page cache:

  open arm        bare, then model  (rugnux --model <deposited coordinates>)
  XDS arms        bare, then xds    (XDS's resolution range forced, -A where XDS was anomalous)

bare (plain rugnux <input>) runs first on every arm, so its time always carries the set's disk
read whichever variants are selected; each row records first_read and the report's timing table
says which variant's times are cold. --variants runs a subset; --unforced is gone (--variants
bare). Rows, work dirs (work/<arm>/<set>/<variant>/), compare and the report are per variant;
compare pairs (arm, set, variant) on the variants both runs have on an arm, and a schema-1 run is
read as one variant. The model variant takes the coordinates and published R-free from
model_check's RCSB cache (site key pdb_cache) and records rugnux's R-free/R-work and the ratio;
the REFMAC check is now opt-in (--model-check) and its keys moved to refmac_*. results_schema 2.

model_sweep.py is retired: the model variant replaces it (its --spot/--scaling-low-resolution 50
were rugnux's defaults, so the command is the same).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md                       |   7 +
 docs/TESTS.md                   |   6 +-
 tools/battery/README.md         | 143 +++++++++++------
 tools/battery/battery.py        | 183 ++++++++++++++--------
 tools/battery/model_sweep.py    | 262 --------------------------------
 tools/battery/report.py         | 238 +++++++++++++++++++----------
 tools/battery/score.py          |   7 +-
 tools/battery/site.example.json |   1 +
 8 files changed, 397 insertions(+), 450 deletions(-)
 delete mode 100755 tools/battery/model_sweep.py

diff --git a/CLAUDE.md b/CLAUDE.md
index 407dfb80b..ef6f72df0 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -106,9 +106,16 @@ scripts.
 ```
 tools/battery/battery.py run --rugnux build/rugnux/rugnux --only 5reo,lyso_ref   # named sets
 tools/battery/battery.py run --rugnux build/rugnux/rugnux --tier smoke           # smoke tier
+tools/battery/battery.py run --rugnux build/rugnux/rugnux --variants bare        # one variant only
 tools/battery/battery.py compare RUN_A RUN_B [--rerun-changed]
 ```
 
+Each set runs in all its arm's **variants** back to back, so its images are read from disk once:
+`bare` (plain `rugnux <input>`, what a user gets) first everywhere, then `model` (`--model` with the
+deposited coordinates, R-free vs the published one) on the open arm, or `xds` (XDS's resolution
+range forced, `-A` where XDS was anomalous) on the XDS arms. Only the first variant's time includes
+the disk read; compare times within one variant. The REFMAC check is opt-in (`--model-check`).
+
 - **Never start a full battery run (no `--only`/`--tier`) without the owner's go-ahead.**
 - Judge a change against a **persisted baseline run** (the site config's `baseline`) with
   `compare`, never against numbers remembered from an earlier session.
diff --git a/docs/TESTS.md b/docs/TESTS.md
index e9372bc61..5c560c0c7 100644
--- a/docs/TESTS.md
+++ b/docs/TESTS.md
@@ -40,9 +40,9 @@ pipeline is exercised on, and the DOI to cite for each, are listed in
 * `tools/battery/battery.py` - the rotation battery, the one canonical way to judge a rotation
   change: public PDB depositions scored against the deposition, in-house standard crystals and
   no-crystal controls scored against XDS, and a local-only private arm. Its manifests, the run
-  and compare protocol and the report are described in `tools/battery/README.md`.
-* `tools/battery/model_sweep.py` - the battery's open arm run with `--model`: each merge validated
-  against the depositor's own model and compared with the published resolution and R-work/R-free.
+  and compare protocol and the report are described in `tools/battery/README.md`. Each set runs
+  in several variants back to back: plain, with the deposited model (`--model`, R-free against the
+  published one) on the open arm, and with XDS's settings on the XDS arms.
 * `rugnux_stills_ab.py` - the stills analogue of the battery: scores a change on a serial
   dataset by what it does to the merge. Takes its dataset list from outside the repository.
 * `rugnux_anomalous.py` - the anomalous-peak-height arbiter, below.
diff --git a/tools/battery/README.md b/tools/battery/README.md
index 628c9d785..bb4c5f12d 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -23,6 +23,45 @@ scored with `sgequiv`. On the XDS arms only the point group is scored, because X
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
+## Variants
+
+Every set is run more than once, with different settings, and each run is a **variant**. The
+variants of one set run straight after each other, before the next set starts. The battery is
+limited by reading images from disk, and this way only the first variant reads them; the others
+find them in the page cache.
+
+| arm (reference) | variants, in the order they run |
+|---|---|
+| open (deposition) | `bare`, then `model` |
+| inhouse, private (XDS) | `bare`, then `xds` |
+
+- **`bare`**: plain `rugnux <input>` and nothing else (no `-A`, no resolution range). This is
+  what a user gets. It is scored against the reference like the others, and its d_min ratio
+  against the reference is plotted.
+- **`model`** (open arm): `rugnux --model <deposited coordinates>`. The coordinates (`<entry>.cif.gz`)
+  and the published R-free come from the RCSB and are cached in the site's `pdb_cache` (default
+  `/data/battery/pdb_cache`), so the first run of a new entry needs network access. The entry is the
+  set id up to the first `_`, so `6h2p_native` uses `6h2p`. A set with no PDB entry (small
+  molecules) or whose coordinates cannot be downloaded gets a `not_run` row with cause `no_model`.
+  The row records the R-free and R-work that rugnux reports for the model, the published R-free
+  and their ratio, which the report plots. rugnux's R-free is that of a rigid-body placement against
+  its own merge, and the published one comes from full refinement against the depositor's own
+  data, so the ratio is not a like-for-like score; watch how it moves between runs.
+- **`xds`** (XDS arms): XDS's reference settings. XDS's resolution range is forced (see "The XDS
+  reference d_min" below), and where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true`
+  in the manifest) rugnux gets `-A`. Both programs then merge the same reflections the same way.
+
+The variants are defined in one place, `VARIANTS` in `battery.py`. `--variants` runs a subset,
+for example `--variants bare`, and they always run in the table's order. `--unforced` is gone:
+`--variants bare` gives rugnux its own resolution cut (and, unlike `--unforced`, no `-A`).
+
+**Order and timing.** `bare` goes first on every arm. So its time always includes reading the
+data from disk (unless the images were still cached from before the run), whichever variants a run
+selects, and it is the time a user sees. The time of a later variant is taken on cached images.
+Each row records whether it was its set's `first_read`, and the report's timing table says which
+variant carries the disk reads. Compare times of one variant between runs only, never across
+variants.
+
 The private arm is never mixed with the others. A private run gets its own run directory
 (suffix `_private`) and its own report (`report_PRIVATE.*`), and it cannot be the baseline of a
 public report or be written into the repository. Its names, paths and values never go into a
@@ -86,6 +125,7 @@ export `JFJOCH_BATTERY_SITE=/data/battery/site.json`.
  "gpulock": "/data/tmp/gpulock",
  "baseline": "/data/battery/runs/<a blessed full run>",
  "baseline_private": null,
+ "pdb_cache": "/data/battery/pdb_cache",
  "arms": {
   "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/home/data/open"},
   "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/home/data/inhouse"},
@@ -97,7 +137,8 @@ export `JFJOCH_BATTERY_SITE=/data/battery/site.json`.
 
 A relative `manifest` path is resolved against `tools/battery/`. `gpulock` is a command that
 `rugnux` is prefixed with under `--gpulock`. At PSI it is a wrapper script that queues for one of
-the shared GPU slots. Set it to `null` if you have no such wrapper.
+the shared GPU slots. Set it to `null` if you have no such wrapper. `pdb_cache` (optional) is where
+the deposited models and their metadata are cached for the `model` variant and the REFMAC check.
 
 ## Running
 
@@ -109,7 +150,7 @@ $B run --rugnux $R                                  # full battery: open + inhou
 $B run --rugnux $R --tier smoke                     # 22 sets covering readers, symmetry, known hard cases
 $B run --rugnux $R --only 5reo,lyso_ref             # named sets
 $B run --rugnux $R --arm private                    # the private arm, on its own
-$B run --rugnux $R --arm inhouse --unforced         # XDS arms without XDS's resolution forced
+$B run --rugnux $R --variants bare                  # only what a user gets (no model, no XDS settings)
 ```
 
 Useful options:
@@ -119,7 +160,8 @@ Useful options:
 - `--gpulock` queues every rugnux behind the site's GPU wrapper.
 - `--extra "<args>"` adds rugnux arguments to every set.
 - `--baseline RUN|none` sets the run the report is compared against.
-- `--model-check` / `--no-model-check` turns the open-arm R-free check on or off (see below).
+- `--variants bare,model,xds` runs a subset of the variants (default: all of them).
+- `--model-check` adds the REFMAC check to the open arm's `bare` rows (off by default, see below).
 
 A run prints one line per set and ends by writing its report. The **smoke** tier is marked in the
 manifests (`"tiers": {"smoke": "<why this set>"}`).
@@ -128,23 +170,23 @@ manifests (`"tiers": {"smoke": "<why this set>"}`).
 two full runs cannot overlap. Do not start one without the owner's go-ahead: it takes hours, and
 everything else on the machine competes with it.
 
-### The model check (open arm)
+### The REFMAC model check (open arm, opt-in)
 
-`tools/battery/model_check.py` scores each open-arm merge (`p.mtz`) against the deposited model,
+The `model` variant is the battery's R-free check. `--model-check` adds a second, independent one
+that needs CCP4: `tools/battery/model_check.py` scores each open-arm `bare` merge (`p.mtz`) against
+the deposited model,
 unmodified (ligands, waters and hydrogens kept): REFMAC's rigid-body mode, R-factors taken before
 any shift, the data reindexed into the model's setting and reduced to the deposited space group.
-Our own free set was mostly work reflections for the depositor, so `rfree` reads low. The fair
-comparison is `rfree_depflags` (our data on the depositor's free set) against `rfree_depdata` (the
-depositor's structure factors, same free set, same protocol); `rfree_ratio` is that ratio, and the
-report plots it. It is null when the entry deposited no structure factors with a free set.
-`rfree_deposited` is the value in the entry, often from twin or full refinement. The runner records
-`rfree`, `rwork`, `rfree_deposited`, `rfree_depflags`, `rfree_depdata`, `rfree_ratio`,
-`model_status` and `model_reason`. The check is on by default when the module exists. The PDB entry
-is the set id up to the first `_`, so `6h2p_native` is checked as `6h2p`. Small-molecule sets are skipped.
+Our own free set was mostly work reflections for the depositor, so `refmac_rfree` reads low. The
+fair comparison is `refmac_rfree_depflags` (our data on the depositor's free set) against
+`refmac_rfree_depdata` (the depositor's structure factors, same free set, same protocol);
+`refmac_rfree_ratio` is that ratio, and the report plots it. It is null when the entry deposited no
+structure factors with a free set. The runner records `refmac_rfree`, `refmac_rwork`,
+`refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status` and
+`refmac_reason`. Small-molecule sets are skipped.
 
-`model_sweep.py` is a different tool: it runs `rugnux --model` over the open arm (same inputs, same
-site config) and compares the R-free that rugnux itself reports with the published value. It needs
-network access to the RCSB and runs separately from `battery.py`.
+`model_sweep.py`, which ran `rugnux --model` over the open arm as a separate sweep, is retired. The
+`model` variant does the same inside the battery.
 
 ## A run directory
 
@@ -155,9 +197,9 @@ read-only when the run completes.
 |---|---|
 | `bin/rugnux` | the exact binary that ran (sha256 in the manifest) |
 | `manifest.json` | the label, arms, subset, options, binary version, build flags and source HEAD, runner git and dirty flag, host, pid, start and end, `complete` / `aborted`, `gpu_shared`, and every set with its resolved input, reference and tags |
-| `results.json` | one row per set (the schema is below) |
+| `results.json` | one row per set and variant (the schema is below) |
 | `report.md`, `report.html` | the report (`report_PRIVATE.*` for a private run) |
-| `work/<arm>/<set>/` | `run.log`, `p_report.txt`, `p.mtz`, `p.cif`, ... and `model_check/` |
+| `work/<arm>/<set>/<variant>/` | `run.log`, `p_report.txt`, `p.mtz`, `p.cif`, ... and `model_check/` |
 
 **Run states** (`battery.py list`): `complete`; `running` (its runner process is alive);
 `aborted` (interrupted by Ctrl-C or SIGTERM, or marked with `battery.py abort RUN --reason ...`);
@@ -165,16 +207,24 @@ read-only when the run completes.
 covers an arbitrary part of its sets. `compare` and `report` refuse it unless given
 `--allow-incomplete`, and the report then says so at the top.
 
-### results.json (schema 1)
+### results.json (schema 2)
 
-This is a flat list with one object per set, and every arm uses the same keys. Missing values are
-`null`. `manifest.json` records the schema version as `results_schema`.
+This is a flat list with one object per set and variant, and every arm uses the same keys. Missing
+values are `null`. `manifest.json` records the schema version as `results_schema`, and the variants
+each arm ran as `variants`.
+
+Schema 2 added `variant` and `first_read`. It also changed the meaning of `rfree`, `rwork` and
+`rfree_ratio`: they are now rugnux's own `--model` values (model variant), and the REFMAC check's
+moved to `refmac_*`. A schema-1 run is still read, and compared, as if each set had one variant:
+`bare` on the open arm; on the XDS arms `xds`, or `bare` if it was run `--unforced` (which still
+passed `-A`).
 
 | key | meaning |
 |---|---|
-| `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
-| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` |
+| `set`, `arm`, `variant`, `tags`, `input`, `cmd` | the set's id, arm, variant (`bare`, `model`, `xds`), population tags, input file, and the exact command that ran |
+| `first_read` | true for the first variant of its set that ran: the one that read the images from disk |
+| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing, or no model for the `model` variant) |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` / `no_model` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours / the reference's |
 | `sg_relation` | open arm: how the two groups relate (`sgequiv`) |
@@ -183,7 +233,8 @@ This is a flat list with one object per set, and every arm uses the same keys. M
 | `d_min_ref_rule`, `d_min_xds` | XDS arms: how `d_min_ref` was derived (below), and the range XDS merged |
 | `r_meas`, `cc_half`, `isa`, `completeness`, `multiplicity`, `i_over_sigma`, `indexing_rate`, `images` | from rugnux's `_report.txt` |
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref` | XDS's overall values, over XDS's own range |
-| `rfree`, `rwork`, `rfree_deposited`, `rfree_depflags`, `rfree_depdata`, `rfree_ratio`, `model_status`, `model_reason` | the model check (open arm) |
+| `rfree`, `rwork`, `model_fit`, `rfree_deposited`, `rfree_ratio` | `model` variant: R-free, R-work and MODEL_FIT as rugnux reports them for the deposited model, the published R-free, and rfree / rfree_deposited |
+| `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm, `bare` rows) |
 | `wall_s`, `rugnux_wall_s`, `elapsed_s`, `exit_code`, `gpu_others`, `rugnux_verdict` | timing (`wall_s` is rugnux's own WALL_TIME, not the time spent waiting for the GPU queue), the exit code, other GPU processes seen before the set, and rugnux's own verdict line |
 
 ## The report
@@ -191,16 +242,19 @@ This is a flat list with one object per set, and every arm uses the same keys. M
 Every run writes the same report as Markdown and as a self-contained HTML page (inline CSS and
 SVG, no external files):
 
-- a header with the binary, build flags, host, subset, resolution mode and whether timing counts;
-- a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain,
-  ISa, R_meas, time) with a verdict bar chart;
-- a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
-  the main metrics;
-- plots per set: d_min(rugnux) / d_min(reference) for each arm whose resolution is not forced, and
-  R_free / deposited R_free for the open arm (HTML only; hovering a point shows the set);
-- the **failures**, and, if there is a baseline, the **delta against it**: pass rates on the
-  common sets and every set that moved beyond noise;
-- **one row per set** with all the numbers.
+- a header with the binary, build flags, host, subset, variants and whether timing counts;
+- a **timing** table per variant, saying which variant's times include reading the data;
+- **a section per variant**, each with:
+  - a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain,
+    ISa, R_meas, time) with a verdict bar chart;
+  - a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
+    the main metrics;
+  - plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
+    for each arm (not for `xds`, whose resolution is forced), and, for `model`, R_free / published
+    R_free;
+  - the **failures**, and **one row per set** with all the numbers;
+- if there is a baseline, the **delta against it**: pass rates per arm and variant on the common
+  rows, and every row that moved beyond noise.
 
 Re-render a report, for example against another baseline (run directories are read-only, so the
 output goes elsewhere and is named after the run):
@@ -221,8 +275,9 @@ $B compare RUN_A RUN_B [--all]                      # per-set table of what move
 $B compare RUN_A RUN_B --rerun-changed              # rerun the changed sets with A's binary
 ```
 
-`compare` pairs sets by arm and id, following the manifests' `aliases` across renames, and lists
-every set whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell,
+`compare` pairs rows by arm, set id and variant, following the manifests' `aliases` across
+renames. Only the variants both runs ran on an arm are compared, so a `--variants bare` run against a full
+one compares `bare`. It lists every row whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell,
 R-free or time moved by more than the noise thresholds in `report.py` (`NOISE`). Those thresholds
 are a first guess. `--rerun-changed` measures the noise directly: it reruns the changed sets with
 A's saved binary and options. A set that moves again under the same binary is noise. A set that
@@ -240,13 +295,11 @@ reproduces A was really changed by B.
    fix. For one fix, run the sets it touches with `--only`, plus the smoke tier.
 4. **Timing.** `--gpulock`, or another process seen on the GPU, marks the run "timing NOT a
    reference". Only a run with the machine to itself can be used to judge speed.
-5. **Resolution on the XDS arms.** By default XDS's resolution range is forced on rugnux, so both
-   programs merge the same reflections and the statistics are like for like. This answers "is our
-   processing better than XDS's, reflection for reflection". `--unforced` leaves rugnux its own
-   cut, which answers "what does a user get". A change can win one and lose the other, so at
-   important moments run both. Never quote the forced run as what rugnux delivers.
-   Where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the manifest), rugnux gets
-   `-A` in both modes, so Friedel mates are merged separately on both sides.
+5. **Resolution on the XDS arms.** The `xds` variant forces XDS's resolution range (and `-A`
+   where XDS kept Friedel mates apart), so both programs merge the same reflections and the
+   statistics are like for like. This answers "is our processing better than XDS's, reflection for
+   reflection". The `bare` variant answers "what does a user get". A change can win one and lose
+   the other, and every run has both. Never quote the `xds` variant as what rugnux delivers.
 
 ### The XDS reference d_min
 
@@ -262,7 +315,7 @@ is significant, and that decides which case applies (`inputs.reference_dmin`):
   point where XDS's CC1/2 falls through 0.30 (the target of rugnux's own cutoff), interpolated in
   1/d² between shell centres.
 
-The derived value is both the score reference and the forced range. The manifest keeps XDS's own
+The derived value is both the score reference and the range the `xds` variant forces. The manifest keeps XDS's own
 limit as `dmin_xds` and the rule used as `dmin_rule`. XDS's pooled R_meas, CC1/2 and completeness
 still cover its whole range.
 
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 7fd9f48d3..4d31afa80 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -12,7 +12,8 @@ Arms and where their truth comes from:
 
 Usage (README.md in this directory is the full guide):
   battery.py run --rugnux BIN [--label L] [--arm open,inhouse|private] [--only a,b | --tier smoke]
-                 [--build-dir DIR] [--gpulock] [--threads N] [--unforced] [--baseline RUN|none]
+                 [--variants bare,model,xds] [--build-dir DIR] [--gpulock] [--threads N]
+                 [--model-check] [--baseline RUN|none]
   battery.py list                                 runs under the runs root, with their state
   battery.py compare RUN_A RUN_B [--all] [--rerun-changed]
   battery.py report RUN --out DIR [--baseline RUN] re-render a run's report into DIR/<run>.{md,html}
@@ -24,9 +25,13 @@ Usage (README.md in this directory is the full guide):
 The site config (data roots, runs root, lock, gpulock, private manifest, baselines) is --site, else
 $JFJOCH_BATTERY_SITE, else site.json beside this script (not committed; site.example.json is).
 
+Every set runs in each of its arm's VARIANTS (bare + model on the open arm, bare + xds on the XDS
+arms), one straight after the other, so only the first reads the images from disk.
+
 A run writes <runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_<label>/ holding a copy of the binary,
-manifest.json (what was run, on what, with which references), results.json (one row per set),
-report.md + report.html and work/<arm>/<set>/ (log, report, cif). It is made read-only when done.
+manifest.json (what was run, on what, with which references), results.json (one row per set and
+variant), report.md + report.html and work/<arm>/<set>/<variant>/ (log, report, cif). It is made
+read-only when done.
 A full-arm run (no --only / --tier) takes the site lock and refuses to start if another holds it.
 A run that did not finish is never compared or reported on unless asked (--allow-incomplete).
 """
@@ -52,13 +57,24 @@ import inputs  # noqa: E402
 import report  # noqa: E402
 import score   # noqa: E402
 
-try:
-    import model_check   # optional: R-free of the deposited model against our merge (open arm)
-except ImportError:
-    model_check = None
+import model_check  # noqa: E402  the deposited model (model variant); REFMAC check (--model-check)
 
 PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
 
+# The variants every set of an arm runs in, by the arm's reference, in the order they run. All the
+# variants of one set run back to back, so only the first reads the images from disk and the later
+# ones find them in the page cache. `bare` goes first: it is in every arm, so its time is taken
+# under the same condition (the set's first read) whichever variants a run selects, and it is the
+# number a user sees.
+VARIANTS = {"deposition": ["bare", "model"], "xds": ["bare", "xds"]}
+VARIANT_DOC = {
+    "bare": "plain `rugnux <input>`, nothing else: what a user gets",
+    "model": "`rugnux --model <deposited coordinates>`: R-free of the deposited model against our merge, "
+             "as rugnux reports it",
+    "xds": "XDS's reference settings: its resolution range forced, and -A where XDS kept Friedel mates "
+           "apart, so both programs merge the same reflections the same way",
+}
+
 LOCAL_SITE = os.path.join(HERE, "site.json")
 
 
@@ -155,22 +171,23 @@ def gpu_others():
 
 # ------------------------------------------------------------------ running
 
-def command(binary, e, opts):
+def command(binary, e, variant, opts, model=None):
     cmd = [binary, "-o", "p", "--no-export-unmerged"]
     if opts["threads"]:
         cmd += ["-N", str(opts["threads"])]
     ref = e.get("ref") or {}
-    # On an XDS-referenced arm the only thing fixed is XDS's resolution range, so the two programs
-    # merge the same reflections. --unforced leaves rugnux its own cut.
-    if opts["xds_range"] and e.get("reference") == "xds":
+    if variant == "xds":
+        # XDS's resolution range, so the two programs merge the same reflections
         if ref.get("dmin"):
             cmd += ["--scaling-high-resolution", f"{ref['dmin']:.3f}"]
         if ref.get("dmax"):
             cmd += ["--scaling-low-resolution", f"{ref['dmax']:.3f}"]
-    # XDS merged with FRIEDEL'S_LAW=FALSE: merge Friedel mates separately too, or the merging
-    # statistics are not comparable
-    if e.get("reference") == "xds" and ref.get("anomalous"):
-        cmd.append("-A")
+        # XDS merged with FRIEDEL'S_LAW=FALSE: merge Friedel mates separately too, or the merging
+        # statistics are not comparable
+        if ref.get("anomalous"):
+            cmd.append("-A")
+    if variant == "model":
+        cmd += ["--model", model]
     cmd += opts["extra_args"]
     cmd.append(e["input_path"])
     if opts["gpulock"]:
@@ -190,16 +207,37 @@ def failure_note(log):
     return lines[-1].split("] ")[-1][:300] if lines else ""
 
 
-def run_one(run_dir, binary, e, opts):
-    wd = os.path.join(run_dir, "work", e["arm"], e["id"])
+def deposited_model(e, opts):
+    """(deposition record from model_check's RCSB cache, None) for the entry a set belongs to, or
+    (None, why not). A set id may carry a suffix (6h2p_native); the entry is the part before it."""
+    pdb = e["id"].split("_")[0].lower()
+    if not PDB_ID.match(pdb):
+        return None, "no model: not a PDB entry (small molecule or unpublished set)"
+    meta = model_check.deposition(pdb, opts["pdb_cache"])
+    if meta is None:
+        return None, f"no model: coordinates of {pdb} could not be downloaded"
+    return meta, None
+
+
+def run_one(run_dir, binary, e, variant, first_read, opts):
+    wd = os.path.join(run_dir, "work", e["arm"], e["id"], variant)
     os.makedirs(wd)
-    row = {"set": e["id"], "arm": e["arm"], "tags": e.get("tags", []), "input": e["input_path"],
-           "gpu_others": gpu_others(), "rfree": None, "rwork": None, "rfree_deposited": None,
-           "rfree_depflags": None, "rfree_depdata": None, "rfree_ratio": None, "model_status": None, "model_reason": None}
+    row = {"set": e["id"], "arm": e["arm"], "variant": variant, "first_read": first_read,
+           "tags": e.get("tags", []), "input": e["input_path"], "gpu_others": gpu_others(),
+           "rfree_deposited": None, "rfree_ratio": None, "cmd": None, "exit_code": None,
+           "elapsed_s": None, "wall_s": None}
+    row.update({k: None for k in REFMAC_KEYS})
     if not os.path.exists(e["input_path"]):
-        row.update(score.judge(e, {}, "no input"), exit_code=None, elapsed_s=None, wall_s=None, cmd=None)
+        row.update(score.judge(e, {}, "no input"))
         return row
-    cmd = command(binary, e, opts)
+    meta = None
+    if variant == "model":
+        meta, why = deposited_model(e, opts)
+        if meta is None:
+            row.update(score.judge(e, {}, why))
+            return row
+        row["rfree_deposited"] = meta["rfree"]
+    cmd = command(binary, e, variant, opts, meta and meta["xyz"])
     row["cmd"] = " ".join(cmd)
     t0 = time.time()
     note = ""
@@ -217,34 +255,38 @@ def run_one(run_dir, binary, e, opts):
     # rugnux's own WALL_TIME where it wrote one: the runner's clock also counts the wait for a
     # GPU slot under --gpulock
     row["wall_s"] = row["rugnux_wall_s"] if row["rugnux_wall_s"] is not None else row["elapsed_s"]
-    if opts.get("model_check") and e["arm"] == "open":
+    if row["rfree"] and row["rfree_deposited"]:
+        row["rfree_ratio"] = round(row["rfree"] / row["rfree_deposited"], 4)
+    if opts["model_check"] and e["arm"] == "open" and variant == "bare":
         row.update(check_model(e, wd))
     return row
 
 
+# what the REFMAC model check (model_check.py, --model-check) adds to an open-arm bare row
+REFMAC_KEYS = ("refmac_rfree", "refmac_rwork", "refmac_rfree_depflags", "refmac_rfree_depdata",
+               "refmac_rfree_ratio", "refmac_status", "refmac_reason")
+
+
 def check_model(e, wd):
-    """R-free of the deposited model against this run's merge (model_check.py). A set id may
-    carry a suffix (6h2p_native); the PDB entry is the part before it."""
-    out = {"rfree": None, "rwork": None, "rfree_deposited": None, "rfree_depflags": None,
-           "rfree_depdata": None, "rfree_ratio": None}
+    """R-free of the deposited model against this run's merge, by REFMAC (model_check.py)."""
+    out = {k: None for k in REFMAC_KEYS}
     pdb = e["id"].split("_")[0]
     mtz = os.path.join(wd, "p.mtz")
     if not PDB_ID.match(pdb):
-        return dict(out, model_status="skipped", model_reason="not a PDB entry")
+        return dict(out, refmac_status="skipped", refmac_reason="not a PDB entry")
     if not os.path.exists(mtz):
-        return dict(out, model_status="skipped", model_reason="no merged MTZ")
+        return dict(out, refmac_status="skipped", refmac_reason="no merged MTZ")
     try:
         res = model_check.check(mtz, pdb, os.path.join(wd, "model_check"))
     except Exception as ex:          # a failing check must not lose the set's processing result
-        return dict(out, model_status="error", model_reason=f"{type(ex).__name__}: {ex}"[:300])
-    out.update({k: res.get(k) for k in ("rfree", "rwork", "rfree_deposited", "rfree_depflags",
-                                        "rfree_depdata")},
-               model_status=res.get("status"), model_reason=res.get("reason"))
+        return dict(out, refmac_status="error", refmac_reason=f"{type(ex).__name__}: {ex}"[:300])
+    out.update({"refmac_" + k: res.get(k) for k in ("rfree", "rwork", "rfree_depflags", "rfree_depdata")},
+               refmac_status=res.get("status"), refmac_reason=res.get("reason"))
     # The fair ratio: our merge and the depositor's structure factors, both scored on the
     # depositor's free set by the same protocol. Our own free set was mostly work reflections
     # for the depositor, so R_free on it reads low.
-    if out["rfree_depflags"] and out["rfree_depdata"]:
-        out["rfree_ratio"] = round(out["rfree_depflags"] / out["rfree_depdata"], 4)
+    if out["refmac_rfree_depflags"] and out["refmac_rfree_depdata"]:
+        out["refmac_rfree_ratio"] = round(out["refmac_rfree_depflags"] / out["refmac_rfree_depdata"], 4)
     return out
 
 
@@ -314,7 +356,10 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     for e in sets:
         e["reference"] = site["arms"][e["arm"]]["reference"]
         e.setdefault("input_path", os.path.join(site["arms"][e["arm"]]["data_root"], e["input"]))
+    variants = {arm: [v for v in VARIANTS[site["arms"][arm]["reference"]] if v in opts["variants"]]
+                for arm in arms}
     man = {"label": label, "arms": arms, "private": private, "subset": subset, "baseline": baseline,
+           "variants": variants, "variant_doc": {v: VARIANT_DOC[v] for v in opts["variants"]},
            "binary": info,
            "runner_git": git(HERE, "rev-parse", "--short", "HEAD") or "unknown",
            "runner_dirty": bool(git(HERE, "status", "--porcelain", "--", ".")),
@@ -325,20 +370,25 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     print(f"run directory {run_dir}", flush=True)
 
     results = []
+    todo = sum(len(variants[e["arm"]]) for e in sets)
     # a kill by SIGTERM is recorded like Ctrl-C: the run directory then says it was aborted
     signal.signal(signal.SIGTERM, interrupted)
     try:
-        for n, e in enumerate(sets, 1):
-            row = run_one(run_dir, binary, e, opts)
-            results.append(row)
-            if row.get("gpu_others"):
-                man["gpu_shared"] = True
-            write_json(os.path.join(run_dir, "results.json"), results)
-            print(f"[{n}/{len(sets)}] {e['arm']:8s} {e['id']:24s} {row['verdict']:8s} "
-                  f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
-                  f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
+        for e in sets:
+            # the variants of one set back to back: only the first rugnux reads the images from disk
+            first_read = True
+            for v in variants[e["arm"]]:
+                row = run_one(run_dir, binary, e, v, first_read, opts)
+                first_read = first_read and row["cmd"] is None
+                results.append(row)
+                if row.get("gpu_others"):
+                    man["gpu_shared"] = True
+                write_json(os.path.join(run_dir, "results.json"), results)
+                print(f"[{len(results)}/{todo}] {e['arm']:8s} {e['id']:24s} {v:6s} {row['verdict']:8s} "
+                      f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
+                      f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
     except KeyboardInterrupt:
-        mark_aborted(run_dir, f"interrupted after {len(results)} of {len(sets)} sets")
+        mark_aborted(run_dir, f"interrupted after {len(results)} of {todo} rows")
         sys.exit(f"aborted; {run_dir} is marked as such")
 
     man.update(end=datetime.datetime.now().isoformat(timespec="seconds"), complete=True)
@@ -380,11 +430,16 @@ def cmd_run(a, site):
     if not sets:
         sys.exit("nothing selected")
     subset = a.only or (f"tier {a.tier}" if a.tier else None)
-    if a.model_check and not model_check:
-        sys.exit("--model-check: tools/battery/model_check.py is not there")
-    use_model = a.model_check if a.model_check is not None else bool(model_check)
-    opts = {"threads": a.threads, "xds_range": not a.unforced, "timeout": a.timeout,
-            "model_check": use_model and "open" in arms,
+    known = [v for vs in VARIANTS.values() for v in vs]
+    want = [v.strip() for v in a.variants.split(",")] if a.variants else known
+    if set(want) - set(known):
+        sys.exit(f"unknown variant(s) {', '.join(sorted(set(want) - set(known)))}; "
+                 f"there are {', '.join(dict.fromkeys(known))}")
+    if not any(v in want for arm in arms for v in VARIANTS[site["arms"][arm]["reference"]]):
+        sys.exit(f"none of the variants {a.variants} runs on the {'/'.join(arms)} arm(s)")
+    opts = {"threads": a.threads, "variants": [v for v in dict.fromkeys(known) if v in want],
+            "timeout": a.timeout, "model_check": a.model_check and "open" in arms,
+            "pdb_cache": site.get("pdb_cache") or model_check.DEFAULT_CACHE,
             "gpulock": site["gpulock"] if a.gpulock else None, "extra_args": a.extra.split(),
             "runs_root": a.runs_root or site["runs_root"]}
     if a.gpulock and not site.get("gpulock"):
@@ -404,7 +459,7 @@ def cmd_list(a, site):
         n = len(json.load(open(os.path.join(run, "results.json")))) \
             if os.path.exists(os.path.join(run, "results.json")) else 0
         mark = " <- baseline" if run in (site.get("baseline"), site.get("baseline_private")) else ""
-        print(f"{d:48s} {state:10s} {n:3d}/{len(man['sets']):3d} sets  "
+        print(f"{d:48s} {state:10s} {n:3d}/{report.expected_rows(man):3d} rows  "
               f"{man.get('subset') or 'full arm':20.20s} {','.join(man['arms'])}{mark}")
 
 
@@ -426,7 +481,9 @@ def cmd_compare(a, site):
                      f"{os.path.basename(os.path.normpath(a.run_b))}")
     doc.p(f"A: rugnux {man_a['binary'].get('version')} ({man_a['binary']['sha256'][:12]}); "
           f"B: rugnux {man_b['binary'].get('version')} ({man_b['binary']['sha256'][:12]}). "
-          f"{len(rows)} sets, {sum(1 for r in rows if r[3])} changed beyond noise.")
+          f"{len(rows)} set/variant rows, {sum(1 for r in rows if r[3])} changed beyond noise. "
+          f"Variants compared: {report.pairs_text(report.common_variants(res_a, res_b))} "
+          "(the ones both runs have).")
     report.compare_table(doc, rows, only_changed=not a.all)
     print(doc.markdown())
     if not a.rerun_changed:
@@ -437,9 +494,11 @@ def cmd_compare(a, site):
     if not changed:
         print("nothing changed beyond noise; no rerun")
         return
-    sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in changed]
-    opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"])
+    sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in {k[:2] for k in changed}]
+    opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"],
+                variants=[v for v in VARIANT_DOC if v in {k[2] for k in changed}])
     opts["gpulock"] = opts["gpulock"] and site.get("gpulock")
+    opts.setdefault("pdb_cache", site.get("pdb_cache") or model_check.DEFAULT_CACHE)
     label = "rerunA-" + man_a["label"]
     rerun = run_sets(site, sets, man_a["arms"], os.path.join(a.run_a, "bin", "rugnux"), None, label,
                      opts, ",".join(e["id"] for e in sets))
@@ -451,10 +510,10 @@ def cmd_compare(a, site):
         if k not in changed:
             continue
         noise = [c for c in again.get(k, []) if c != "time"]
-        rows_out.append([k[1], k[0], ", ".join(c for c in ch if c != "time"),
+        rows_out.append([k[1], k[0], k[2], ", ".join(c for c in ch if c != "time"),
                          ", ".join(noise) or "-",
                          "NOISE - A itself moved" if noise else "REAL - A reproduces"])
-    doc.table(["set", "arm", "A -> B", "A -> A again", "reading"], rows_out)
+    doc.table(["set", "arm", "variant", "A -> B", "A -> A again", "reading"], rows_out)
     doc.p(f"rerun directory: {rerun}")
     print(doc.markdown())
 
@@ -572,12 +631,12 @@ def main():
     r.add_argument("--gpulock", action="store_true",
                    help="queue each rugnux behind the site's GPU lock (timing is then not a reference)")
     r.add_argument("--threads", type=int, default=0, help="-N for rugnux (default: its own choice)")
-    r.add_argument("--unforced", action="store_true",
-                   help="do not force XDS's resolution range on the XDS-referenced arms")
-    r.add_argument("--timeout", type=int, default=10800)
-    r.add_argument("--model-check", action=argparse.BooleanOptionalAction, default=None,
-                   help="open arm: R-free of the deposited model against each merge "
-                        "(default: on when model_check.py is present)")
+    r.add_argument("--variants", help="comma-separated subset of bare,model,xds (default: all of "
+                                      "each arm's variants; e.g. 'bare' for what a user gets)")
+    r.add_argument("--timeout", type=int, default=10800, help="per rugnux run, in s")
+    r.add_argument("--model-check", action="store_true",
+                   help="open arm: also score each bare merge against the deposited model with "
+                        "REFMAC (model_check.py; needs CCP4)")
     r.add_argument("--extra", default="", help="extra rugnux arguments, applied to every set")
     r.add_argument("--baseline", help="earlier run directory to report the delta against (default: "
                                       "the site's persisted baseline; 'none' for no delta)")
diff --git a/tools/battery/model_sweep.py b/tools/battery/model_sweep.py
deleted file mode 100755
index d7f96aae2..000000000
--- a/tools/battery/model_sweep.py
+++ /dev/null
@@ -1,262 +0,0 @@
-#!/usr/bin/env python3
-"""
-model_sweep.py -- process a set of crystals whose data are deposited in the PDB, validate
-each merge against the depositor's own model, and compare the result with what they published.
-
-It runs the open arm of the battery (the same inputs, from open.json and the site config), but
-separately from battery.py: --model places the deposited coordinates, which needs network access
-to the RCSB and adds R-free, maps and model placement to every run.
-
-For every dataset given it:
-  * looks the entry up in the RCSB data API and records the deposited high-resolution limit,
-    R-work and R-free;
-  * downloads the deposited coordinates (gzipped mmCIF -- rugnux recognises the format by
-    content, so no conversion);
-  * runs rugnux de novo with --model and NOTHING else: no space group, no cell, no resolution
-    limit. That is the point. The question is what a bare invocation gets to, so anything told
-    to the program is a thumb on the scale;
-  * reads R_FREE / R_WORK and the resolution range back out of the results report, which is a
-    stable interface, and not out of the console log, which is not;
-  * tabulates deposited against measured, and plots the two scatters that answer the question:
-    resolution, and R-free.
-
-R-free here is not a refinement result. rugnux places the deposited model rigid-body and reports
-the free residual of THAT placement against its own merge, so it is a validation number: how well
-the depositor's model explains data this pipeline produced from their images. It is compared with
-the depositor's published R-free, which came from full refinement against their own reduction --
-a harder target, and deliberately so.
-
-Datasets are the open-arm sets whose id is a four-character PDB entry ID (optionally with a
-suffix, as in 6h2p_native); small-molecule sets and anything without a deposited model are
-skipped with a reason.
-
-  tools/battery/model_sweep.py --rugnux build/rugnux/rugnux --work /tmp/modelrun [--only 5reo,9jzo]
-  tools/battery/model_sweep.py --work /tmp/modelrun --score-only    # re-score without re-running
-"""
-
-import argparse
-import json
-import os
-import re
-import subprocess
-import sys
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-import battery  # noqa: E402
-
-RCSB_ENTRY = "https://data.rcsb.org/rest/v1/core/entry/{}"
-RCSB_MODEL = "https://files.rcsb.org/download/{}.cif.gz"
-PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
-
-
-def curl(url, dest=None, timeout=180):
-    cmd = ["curl", "-sfL", "--max-time", str(timeout), url]
-    if dest:
-        cmd += ["-o", dest]
-    r = subprocess.run(cmd, capture_output=True)
-    return r.returncode == 0, r.stdout
-
-
-def deposited(pdb, models_dir):
-    """Published resolution and R-factors, plus the coordinate file, for one entry."""
-    rec = {"id": pdb}
-    ok, body = curl(RCSB_ENTRY.format(pdb))
-    if ok:
-        try:
-            d = json.loads(body)
-            # The refine category is a list; a multi-stage refinement has more than one block and
-            # the last is the one the depositor stopped at.
-            refine = d.get("refine") or []
-            r = refine[-1] if refine else {}
-            rec["dep_dmin"] = r.get("ls_d_res_high")
-            rec["dep_rfree"] = r.get("ls_R_factor_R_free")
-            rec["dep_rwork"] = r.get("ls_R_factor_R_work")
-            rec["method"] = (d.get("exptl") or [{}])[0].get("method")
-        except Exception as e:
-            rec["meta_error"] = str(e)
-    else:
-        rec["meta_error"] = "entry not found"
-    dest = os.path.join(models_dir, f"{pdb}.cif.gz")
-    if not os.path.exists(dest) or os.path.getsize(dest) == 0:
-        ok, _ = curl(RCSB_MODEL.format(pdb), dest)
-        if not ok and os.path.exists(dest):
-            os.remove(dest)
-    if os.path.exists(dest) and os.path.getsize(dest) > 0:
-        rec["model"] = dest
-    else:
-        rec["model_error"] = "no deposited coordinates"
-    return rec
-
-
-def parse_report(path):
-    rec = {}
-    with open(path, errors="replace") as fh:
-        for line in fh:
-            if "=" in line:
-                k, _, v = line.partition("=")
-                rec[k.strip()] = v.strip()
-    return rec
-
-
-def num(rec, key):
-    try:
-        return float(rec[key])
-    except (KeyError, TypeError, ValueError):
-        return None
-
-
-def run_one(rugnux, model, image, outdir, threads, gpulock):
-    os.makedirs(outdir, exist_ok=True)
-    cmd = [gpulock] if gpulock else []
-    # threads=0 -> no -N: rugnux picks its own thread count
-    cmd += [rugnux, "-o", "p"] + (["-N", str(threads)] if threads else []) + ["--no-export-unmerged",
-            "--spot-low-resolution", "50", "--scaling-low-resolution", "50",
-            "--model", model, image]
-    with open(os.path.join(outdir, "run.log"), "w") as log:
-        return subprocess.run(cmd, cwd=outdir, stdout=log, stderr=subprocess.STDOUT).returncode
-
-
-def collect(work, meta):
-    rows = []
-    for pdb in sorted(meta):
-        report = os.path.join(work, "runs", pdb, "p_report.txt")
-        if not os.path.exists(report):
-            continue
-        rep = parse_report(report)
-        rng = rep.get("INCLUDE_RESOLUTION_RANGE", "").split()
-        rows.append(dict(
-            id=pdb,
-            dep_dmin=meta[pdb].get("dep_dmin"),
-            dep_rfree=meta[pdb].get("dep_rfree"),
-            dep_rwork=meta[pdb].get("dep_rwork"),
-            our_dmin=float(rng[1]) if len(rng) == 2 else None,
-            our_rfree=num(rep, "R_FREE"),
-            our_rwork=num(rep, "R_WORK"),
-            model_fit=rep.get("MODEL_FIT"),
-            space_group=rep.get("SPACE_GROUP_NAME"),
-            cc_half=num(rep, "CC_HALF"),
-        ))
-    return rows
-
-
-def scatter(pts, xlabel, ylabel, title, path, floor_at_zero=False):
-    try:
-        import matplotlib
-        matplotlib.use("Agg")
-        import matplotlib.pyplot as plt
-    except ImportError:
-        print(f"  (matplotlib absent, skipping {os.path.basename(path)})")
-        return
-    if not pts:
-        return
-    xs, ys = [p[0] for p in pts], [p[1] for p in pts]
-    lo = 0.0 if floor_at_zero else min(min(xs), min(ys)) * 0.95
-    hi = max(max(xs), max(ys)) * 1.05
-    fig, ax = plt.subplots(figsize=(6, 6))
-    ax.plot([lo, hi], [lo, hi], color="0.6", lw=1, zorder=1)
-    ax.scatter(xs, ys, s=26, alpha=0.8, edgecolor="none", zorder=2)
-    ax.set_xlim(lo, hi)
-    ax.set_ylim(lo, hi)
-    ax.set_aspect("equal")
-    ax.set_xlabel(xlabel)
-    ax.set_ylabel(ylabel)
-    ax.set_title(title)
-    ax.grid(alpha=0.25, lw=0.5)
-    fig.tight_layout()
-    fig.savefig(path, dpi=140)
-    plt.close(fig)
-    print(f"  wrote {path}")
-
-
-def report(work, rows):
-    both = [r for r in rows if r["our_rfree"] is not None and r["dep_rfree"] is not None]
-    res = [r for r in rows if r["our_dmin"] is not None and r["dep_dmin"] is not None]
-    print(f"\n{len(rows)} processed; R-free on both sides for {len(both)}; resolution for {len(res)}\n")
-    if both:
-        n = len(both)
-        below = sum(1 for r in both if r["our_rfree"] <= r["dep_rfree"])
-        w02 = sum(1 for r in both if r["our_rfree"] <= r["dep_rfree"] + 0.02)
-        w05 = sum(1 for r in both if r["our_rfree"] <= r["dep_rfree"] + 0.05)
-        d = sorted(r["our_rfree"] - r["dep_rfree"] for r in both)
-        print(f"  R-free at or below deposited   {below:3d}/{n}  ({100 * below / n:.0f}%)")
-        print(f"  within +0.02                   {w02:3d}/{n}  ({100 * w02 / n:.0f}%)")
-        print(f"  within +0.05                   {w05:3d}/{n}  ({100 * w05 / n:.0f}%)")
-        print(f"  median delta R-free            {d[len(d) // 2]:+.4f}   ({d[0]:+.4f} .. {d[-1]:+.4f})")
-    if res:
-        deeper = sum(1 for r in res if r["our_dmin"] < r["dep_dmin"])
-        d = sorted(r["our_dmin"] - r["dep_dmin"] for r in res)
-        print(f"  d_min deeper than deposited    {deeper:3d}/{len(res)}  ({100 * deeper / len(res):.0f}%)")
-        print(f"  median delta d_min             {d[len(d) // 2]:+.3f} A  ({d[0]:+.3f} .. {d[-1]:+.3f})")
-    print()
-    scatter([(r["dep_dmin"], r["our_dmin"]) for r in res],
-            "deposited $d_{min}$ (A)", "rugnux $d_{min}$ (A)",
-            f"Resolution, n={len(res)} (below the line: rugnux cuts deeper)",
-            os.path.join(work, "dmin.png"))
-    scatter([(r["dep_rfree"], r["our_rfree"]) for r in both],
-            "deposited $R_{free}$", "rugnux $R_{free}$",
-            f"R-free against the deposited model, n={len(both)} (below the line: better)",
-            os.path.join(work, "rfree.png"), floor_at_zero=True)
-    no_rfree = [r for r in rows if r["our_rfree"] is None]
-    if no_rfree:
-        print(f"\nran but reported no R-free ({len(no_rfree)}):")
-        for r in no_rfree:
-            print(f"  {r['id']:<8}MODEL_FIT={r['model_fit']}")
-
-
-def main():
-    ap = argparse.ArgumentParser(
-        description="Process deposited datasets with --model and compare with the deposition.")
-    ap.add_argument("--work", required=True, help="working directory (models, runs, results)")
-    ap.add_argument("--rugnux", help="rugnux binary (required unless --score-only)")
-    ap.add_argument("--site", help="battery site config (default as for battery.py)")
-    ap.add_argument("--only", help="comma-separated open-arm set ids")
-    ap.add_argument("--datasets", help="JSON file mapping entry ID to image file, instead of the "
-                                       "open arm")
-    ap.add_argument("--threads", type=int, default=0)
-    ap.add_argument("--gpulock", action="store_true",
-                    help="queue each rugnux behind the site's GPU lock")
-    ap.add_argument("--score-only", action="store_true", help="re-score existing runs, run nothing")
-    args = ap.parse_args()
-
-    work = args.work
-    os.makedirs(os.path.join(work, "models"), exist_ok=True)
-    os.makedirs(os.path.join(work, "runs"), exist_ok=True)
-    meta_path = os.path.join(work, "deposited.json")
-    meta = json.load(open(meta_path)) if os.path.exists(meta_path) else {}
-
-    if not args.score_only:
-        if not args.rugnux:
-            ap.error("--rugnux is required unless --score-only")
-        site = battery.load_site(args.site)
-        gpulock = site.get("gpulock") if args.gpulock else None
-        if args.datasets:
-            inputs = json.load(open(args.datasets))
-        else:
-            root = site["arms"]["open"]["data_root"]
-            inputs = {e["id"].lower(): os.path.join(root, e["input"])
-                      for e in battery.select(site, ["open"], args.only, None) if PDB_ID.match(e["id"].split("_")[0])}
-
-        print(f"{len(inputs)} datasets with a PDB-shaped name and an image file")
-        for i, (pdb, image) in enumerate(sorted(inputs.items()), 1):
-            if pdb not in meta or "model" not in meta[pdb]:
-                # a set id may carry a suffix (6h2p_native): the entry is the part before it
-                meta[pdb] = deposited(pdb.split("_")[0], os.path.join(work, "models"))
-                json.dump(meta, open(meta_path, "w"), indent=1)
-            if "model" not in meta[pdb]:
-                print(f"[{i}/{len(inputs)}] {pdb}: {meta[pdb].get('model_error', 'no model')}")
-                continue
-            outdir = os.path.join(work, "runs", pdb)
-            if os.path.exists(os.path.join(outdir, "p_report.txt")):
-                continue                      # resumable: an interrupted sweep picks up here
-            print(f"[{i}/{len(inputs)}] {pdb}", flush=True)
-            rc = run_one(args.rugnux, meta[pdb]["model"], image, outdir, args.threads, gpulock)
-            if rc != 0:
-                print(f"         exited {rc}")
-
-    rows = collect(work, meta)
-    json.dump(rows, open(os.path.join(work, "results.json"), "w"), indent=1)
-    report(work, rows)
-
-
-if __name__ == "__main__":
-    main()
diff --git a/tools/battery/report.py b/tools/battery/report.py
index 0acad8427..dfbe7e323 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -46,9 +46,33 @@ def load_run(run_dir, allow_incomplete=False):
         sys.exit(f"{run_dir} is {state}, not a finished run; pass --allow-incomplete to use it anyway")
     path = os.path.join(run_dir, "results.json")
     res = json.load(open(path)) if os.path.exists(path) else []
+    if man.get("results_schema", 1) < 2:
+        schema1(man, res)
     return man, res
 
 
+def schema1(man, res):
+    """Read a run from before the variants (results schema 1) as one: it ran each set once, plain
+    on the open arm and with XDS's settings on the XDS arms - unless --unforced, which left the
+    range free but still passed -A, and is read as `bare`. Its R-factors came from the REFMAC check."""
+    for r in res:
+        r.setdefault("variant", "xds" if r["arm"] != "open" and man["options"].get("xds_range") else "bare")
+        r.setdefault("first_read", True)
+        if "model_status" in r:
+            for k in ("rfree", "rwork", "rfree_depflags", "rfree_depdata", "rfree_ratio"):
+                r["refmac_" + k] = r.pop(k, None)
+            r["refmac_status"], r["refmac_reason"] = r.pop("model_status"), r.pop("model_reason", None)
+            r["rfree_deposited"] = None
+    man.setdefault("variants", {arm: sorted({r["variant"] for r in res if r["arm"] == arm})
+                                for arm in man["arms"]})
+    man.setdefault("variant_doc", {})
+
+
+def expected_rows(man):
+    """Rows a finished run has: one per set and variant."""
+    return sum(len(man.get("variants", {}).get(e["arm"], [None])) for e in man["sets"])
+
+
 def check_baseline(baseline, private):
     """A baseline must have finished, and be as private as the run it is compared with: the delta
     table names its sets."""
@@ -60,7 +84,9 @@ def check_baseline(baseline, private):
 
 # Version of the results.json row schema (README.md, "results.json"). Bump it when a field changes
 # meaning or is removed; adding a field does not need it.
-RESULTS_SCHEMA = 1
+# 2: one row per set AND variant (`variant`, `first_read`); `rfree`/`rwork`/`rfree_ratio` are rugnux's
+#    own --model R-factors, the REFMAC check's moved to `refmac_*`.
+RESULTS_SCHEMA = 2
 
 # {arm: {old set id: current id}} from the manifests (battery.py sets it), so a run made before a
 # dataset was renamed still pairs with one made after
@@ -68,7 +94,25 @@ ALIASES = {}
 
 
 def key(r):
-    return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]))
+    return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]), r["variant"])
+
+
+# the order variants are listed in (battery.VARIANTS runs them in this order within an arm)
+VARIANT_ORDER = ("bare", "model", "xds")
+
+
+def variants_of(res):
+    return [v for v in VARIANT_ORDER if any(r["variant"] == v for r in res)]
+
+
+def common_variants(res_a, res_b):
+    """The (arm, variant) pairs both runs ran - what a comparison of the two covers."""
+    pairs = lambda res: {(r["arm"], r["variant"]) for r in res}
+    return sorted(pairs(res_a) & pairs(res_b), key=lambda p: (p[0], VARIANT_ORDER.index(p[1])))
+
+
+def pairs_text(pairs):
+    return ", ".join(f"{arm} {v}" for arm, v in pairs) or "none"
 
 
 def f(x, fmt="{:.2f}", dash="-"):
@@ -123,9 +167,12 @@ def changes(ra, rb):
 
 
 def compare_rows(res_a, res_b):
-    """[(key, ra, rb, changes)] over the sets both runs have, then those only one has."""
-    a = {key(r): r for r in res_a}
-    b = {key(r): r for r in res_b}
+    """[(key, ra, rb, changes)] over the (set, variant) rows both runs have, then those only one
+    has. Only the variants both runs ran on an arm are compared: a run of just `bare` against a
+    full one is a comparison of `bare`."""
+    common = common_variants(res_a, res_b)
+    a = {key(r): r for r in res_a if (r["arm"], r["variant"]) in common}
+    b = {key(r): r for r in res_b if (r["arm"], r["variant"]) in common}
     rows = [(k, a[k], b[k], changes(a[k], b[k])) for k in sorted(a) if k in b]
     rows += [(k, a[k], None, ["only in A"]) for k in sorted(a) if k not in b]
     rows += [(k, None, b[k], ["only in B"]) for k in sorted(b) if k not in a]
@@ -139,14 +186,14 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 
 def compare_table(doc, rows, only_changed=True):
-    head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
+    head = ["set", "arm", "variant", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
             "cell dev %", "R_free", "time s", "beyond noise"]
     out = []
-    for (arm, s), ra, rb, ch in rows:
+    for (arm, s, v), ra, rb, ch in rows:
         if only_changed and not ch:
             continue
         ra, rb = ra or {}, rb or {}
-        out.append([s, arm, arrow(ra.get("verdict"), rb.get("verdict")),
+        out.append([s, arm, v, arrow(ra.get("verdict"), rb.get("verdict")),
                     arrow(ra.get("sg"), rb.get("sg")),
                     arrow(ra.get("d_min"), rb.get("d_min"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("isa"), rb.get("isa"), lambda v: f"{v:.1f}"),
@@ -187,67 +234,118 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     state = run_state(man)
     if state != "complete":
         why = f" ({man['aborted']['reason']})" if man.get("aborted") else ""
-        doc.p(f"RUN {state.upper()}{why}: {len(res)} of {len(man['sets'])} sets have a result. "
-              "Not a reference and not comparable with a finished run.")
+        doc.p(f"RUN {state.upper()}{why}: {len(res)} of {expected_rows(man)} set/variant rows have a "
+              "result. Not a reference and not comparable with a finished run.")
+    variants = variants_of(res)
     doc.ul([
         f"rugnux {b.get('version', '?')}, sha256 {b['sha256'][:16]}, build flags: {b.get('flags') or 'unknown'}",
         f"runner {man['runner_git']}, host {man['host']}, {man['start']} -> {man.get('end') or 'NOT FINISHED'}",
         f"arms: {', '.join(man['arms'])}; {len(man['sets'])} sets"
         + (f" (subset: {man['subset']})" if man.get("subset") else " (full arm)"),
-        "resolution: XDS's range forced on the XDS-referenced arms" if man["options"]["xds_range"]
-        else "resolution: rugnux's own choice everywhere (unforced)",
+        "variants: " + "; ".join(f"{arm}: {', '.join(man['variants'][arm])}" for arm in man["arms"]
+                                 if man["variants"].get(arm)),
         "timing: NOT a reference - the GPU was shared" if man.get("gpu_shared")
         else "timing: GPU was not shared during the run",
         f"command options: {' '.join(man['options']['extra_args']) or '(none beyond output selection)'}",
-    ])
+    ] + [f"variant {v}: {man['variant_doc'][v]}" for v in variants if man["variant_doc"].get(v)])
 
-    forced = {e["arm"] for e in man["sets"]
-              if man["options"]["xds_range"] and e.get("reference") == "xds"}
-    order = {arm: i for i, arm in enumerate(man["arms"])}
+    doc.h(2, "Timing")
+    rows = []
+    for v in variants:
+        rs = [r for r in res if r["variant"] == v and r.get("wall_s") is not None]
+        rows.append([v, len(rs), f"{sum(bool(r.get('first_read')) for r in rs)}/{len(rs)}",
+                     f(median(r["wall_s"] for r in rs), "{:.0f}"),
+                     f(sum(r["wall_s"] for r in rs) / 60, "{:.1f}")])
+    doc.table(["variant", "rows run", "first read of the set", "median time s", "total time min"],
+              rows, num=range(1, 5))
+    doc.p("The variants of a set run back to back, in the order listed. The first one to run reads "
+          "the images from disk (unless they were still in the page cache from before the run); the "
+          "later ones find them in the page cache. So only the first variant's times include reading "
+          "the data - normally `bare`, which runs first on every arm - and times are comparable only "
+          "between runs of the same variant.")
 
-    def gain(rs, arm):
-        return "forced" if arm in forced else f(median(r.get("res_gain_pct") for r in rs), "{:+.1f}%")
+    derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
+    if derived:
+        doc.p("XDS merged past its own signal (CC1/2 of its finest shell not significant), so the "
+              "reference d_min is where XDS's CC1/2 falls through 0.30, and that is also the range "
+              "the xds variant forces on rugnux: "
+              + "; ".join(f"{s} (XDS range {f(r.get('d_min_xds'))} A, reference "
+                          f"{f(r.get('d_min_ref'))} A)" for s, r in sorted(derived.items()))
+              + ". XDS's pooled R_meas, CC1/2 and completeness are over its whole range.")
 
-    doc.h(2, "Summary")
+    for v in variants:
+        variant_section(doc, man, [r for r in res if r["variant"] == v], v)
+
+    if baseline:
+        bman, bres = load_run(baseline)
+        doc.h(2, f"Delta vs baseline {os.path.basename(os.path.normpath(baseline))}")
+        common = common_variants(bres, res)
+        doc.p(f"Baseline rugnux {bman['binary'].get('version', '?')}. Pass rates on the set/variant "
+              f"rows both runs have (variants compared: {pairs_text(common)}):")
+        both = {key(r) for r in res} & {key(r) for r in bres}
+        rows = []
+        for arm, v in common:
+            ra = [r for r in bres if key(r) in both and r["arm"] == arm and r["variant"] == v]
+            rb = [r for r in res if key(r) in both and r["arm"] == arm and r["variant"] == v]
+            rows.append([arm, v, len(rb), rate(ra), rate(rb)])
+        doc.table(["arm", "variant", "common sets", "baseline", "this run"], rows, num=(2,))
+        doc.p("Rows whose result moved beyond noise (thresholds in report.py NOISE; confirm with "
+              "`compare --rerun-changed` before believing a single-set change):")
+        compare_table(doc, compare_rows(bres, res))
+    return doc
+
+
+def variant_section(doc, man, res, v):
+    """Summary, populations, distributions, plots, failures and the per-set table of one variant."""
+    forced = v == "xds"               # XDS's resolution range imposed: d_min ratio 1 by construction
+    arms = [arm for arm in man["arms"] if any(r["arm"] == arm for r in res)]
+    order = {arm: i for i, arm in enumerate(arms)}
+
+    def gain(rs):
+        return "forced" if forced else f(median(r.get("res_gain_pct") for r in rs), "{:+.1f}%")
+
+    doc.h(2, f"Variant {v}")
+    if man["variant_doc"].get(v):
+        doc.p(man["variant_doc"][v][0].upper() + man["variant_doc"][v][1:] + ".")
     head = ["arm", "sets", "pass", "fail", "unscored", "not run", "pass rate",
             "median res. gain", "median ISa", "median R_meas", "median time s", "total time min"]
     rows = []
-    for arm in man["arms"]:
+    for arm in arms:
         rs = [r for r in res if r["arm"] == arm]
-        cnt = {v: sum(r["verdict"] == v for r in rs) for v in ("pass", "fail", "unscored", "not_run")}
+        cnt = {x: sum(r["verdict"] == x for r in rs) for x in ("pass", "fail", "unscored", "not_run")}
         xs = crystals(rs)
         rows.append([arm, len(rs), cnt["pass"], cnt["fail"], cnt["unscored"], cnt["not_run"], rate(rs),
-                     gain(xs, arm), f(median(r.get("isa") for r in xs), "{:.1f}"),
+                     gain(xs), f(median(r.get("isa") for r in xs), "{:.1f}"),
                      pct(median(r.get("r_meas") for r in xs)),
                      f(median(r.get("wall_s") for r in rs), "{:.0f}"),
                      f(sum(r.get("wall_s") or 0 for r in rs) / 60, "{:.1f}")])
     doc.table(head, rows, num=range(1, 12))
-    doc.svg(verdict_bars([(arm, {v: sum(r["verdict"] == v and r["arm"] == arm for r in res)
-                                 for v in ("pass", "fail", "unscored", "not_run")})
-                          for arm in man["arms"]]), "verdicts per arm")
+    doc.svg(verdict_bars([(arm, {x: sum(r["verdict"] == x and r["arm"] == arm for r in res)
+                                 for x in ("pass", "fail", "unscored", "not_run")})
+                          for arm in arms]), f"{v}: verdicts per arm")
     doc.p("Pass rate is over the scored sets (pass + fail). Resolution gain is (reference d_min - "
           "our d_min) / reference d_min: positive = finer than the deposition, or than XDS; 'forced' "
           "where XDS's resolution range was imposed, which makes it zero by construction. Medians "
           "leave out the no-crystal controls. R_meas and CC1/2 are pooled over each run's own "
           "resolution range, so they describe a run and do not rank two.")
 
-    doc.h(3, "By population")
+    doc.h(3, f"{v}: by population")
     rows = []
-    for arm in man["arms"]:
+    for arm in arms:
         rs = [r for r in res if r["arm"] == arm]
         for tag in sorted({t for r in rs for t in r.get("tags", [])}):
             sub = [r for r in rs if tag in r.get("tags", [])]
-            rows.append([arm, tag, len(sub), rate(sub), gain(sub, arm)])
+            rows.append([arm, tag, len(sub), rate(sub), gain(sub)])
     doc.table(["arm", "population", "sets", "pass rate", "median res. gain"], rows, num=(2, 4))
 
-    doc.h(3, "Distributions (sets that merged, controls left out)")
+    doc.h(3, f"{v}: distributions (sets that merged, controls left out)")
     rows = []
-    for arm in man["arms"]:
+    for arm in arms:
         rs = crystals(r for r in res if r["arm"] == arm)
         for name, lab, fm in (("isa", "ISa", "{:.1f}"), ("r_meas", "R_meas", None),
                               ("cc_half", "CC1/2", "{:.3f}"), ("res_gain_pct", "res. gain %", "{:+.1f}"),
-                              ("wall_s", "time s", "{:.0f}")):
-            if name == "res_gain_pct" and arm in forced:
+                              ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
+            if name == "res_gain_pct" and forced:
                 continue
             q = quartiles(r.get(name) for r in rs)
             if q:
@@ -255,37 +353,36 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                 rows.append([arm, lab, sum(r.get(name) is not None for r in rs)] + cells)
     doc.table(["arm", "metric", "n", "min", "q1", "median", "q3", "max"], rows, num=range(2, 8))
 
-    doc.h(3, "Per set, against the reference")
-    for arm in man["arms"]:
-        if arm in forced:
+    doc.h(3, f"{v}: per set, against the reference")
+    for arm in arms:
+        if forced:
             doc.p(f"{arm}: d_min forced to the reference's, so its ratio is 1 by construction.")
             continue
         pts = [(r["set"], r["d_min"] / r["d_min_ref"], r["verdict"],
                 f"d_min {r['d_min']:.2f} vs {r['d_min_ref']:.2f} A, {r['verdict']}")
                for r in res if r["arm"] == arm and r.get("d_min") and r.get("d_min_ref")]
         if pts:
-            doc.svg(ratio_dots(pts, f"{arm}: d_min ratio"),
-                    f"{arm}: d_min(rugnux) / d_min(reference), one point per set, sorted; below 1 = "
+            doc.svg(ratio_dots(pts, f"{arm} {v}: d_min ratio"),
+                    f"{arm}, {v}: d_min(rugnux) / d_min(reference), one point per set, sorted; below 1 = "
                     "finer than the reference")
     pts = [(r["set"], r["rfree_ratio"], r["verdict"],
-            f"R_free {r['rfree_depflags']:.3f} vs {r['rfree_depdata']:.3f} on the deposited data")
+            f"R_free {r['rfree']:.3f} vs deposited {r['rfree_deposited']:.3f}")
            for r in res if r.get("rfree_ratio")]
     if pts:
-        doc.svg(ratio_dots(pts, "R_free ratio"),
-                "open: R_free of the deposited model against our merge / against the deposited structure "
-                "factors, both on the depositor's free set with the same protocol, one point per set, "
-                "sorted; below 1 = our data fit the model better")
+        doc.svg(ratio_dots(pts, f"{v}: R_free ratio"),
+                "R_free of the deposited model against our merge, as rugnux reports it with --model / "
+                "the R_free the depositor published (from full refinement against their own data), one "
+                "point per set, sorted; below 1 = lower than published")
+    pts = [(r["set"], r["refmac_rfree_ratio"], r["verdict"],
+            f"R_free {r['refmac_rfree_depflags']:.3f} vs {r['refmac_rfree_depdata']:.3f} on the deposited data")
+           for r in res if r.get("refmac_rfree_ratio")]
+    if pts:
+        doc.svg(ratio_dots(pts, f"{v}: REFMAC R_free ratio"),
+                "REFMAC check (--model-check): R_free of the deposited model against our merge / against "
+                "the deposited structure factors, both on the depositor's free set with the same protocol, "
+                "one point per set, sorted; below 1 = our data fit the model better")
 
-    derived = [r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"]
-    if derived:
-        doc.p("XDS merged past its own signal (CC1/2 of its finest shell not significant), so the "
-              "reference d_min is where XDS's CC1/2 falls through 0.30 (rule "
-              f"{derived[0]['d_min_ref_rule']}), and that is also the range forced on rugnux: "
-              + "; ".join(f"{r['set']} (XDS range {f(r.get('d_min_xds'))} A, reference "
-                          f"{f(r.get('d_min_ref'))} A)" for r in derived)
-              + ". XDS's pooled R_meas, CC1/2 and completeness are over its whole range.")
-
-    doc.h(2, "Failures")
+    doc.h(3, f"{v}: failures")
     fails = [r for r in res if r["verdict"] == "fail"]
     doc.table(["set", "arm", "cause", "reason"],
               [[r["set"], r["arm"], r["cause"], r["reason"]] for r in fails])
@@ -293,26 +390,14 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     if other:
         doc.p("Not scored: " + "; ".join(f"{r['set']} ({r['reason']})" for r in other))
 
-    if baseline:
-        bman, bres = load_run(baseline)
-        doc.h(2, f"Delta vs baseline {os.path.basename(os.path.normpath(baseline))}")
-        doc.p(f"Baseline rugnux {bman['binary'].get('version', '?')}. Pass rates on the sets both "
-              "runs have:")
-        both = {key(r) for r in res} & {key(r) for r in bres}
-        rows = []
-        for arm in man["arms"]:
-            ra = [r for r in bres if key(r) in both and r["arm"] == arm]
-            rb = [r for r in res if key(r) in both and r["arm"] == arm]
-            rows.append([arm, len(rb), rate(ra), rate(rb)])
-        doc.table(["arm", "common sets", "baseline", "this run"], rows, num=(1,))
-        doc.p("Sets whose result moved beyond noise (thresholds in report.py NOISE; confirm with "
-              "`compare --rerun-changed` before believing a single-set change):")
-        compare_table(doc, compare_rows(bres, res))
-
-    doc.h(2, "Per set")
+    doc.h(3, f"{v}: per set")
+    model = [("R_free", "rfree"), ("R_work", "rwork"), ("dep R_free", "rfree_deposited"),
+             ("R_free ratio", "rfree_ratio")] if any(r.get("rfree") for r in res) else []
+    model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
+              ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
     head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
-            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx", "R_free", "dep R_free",
-            "time s", "note"]
+            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
+           [h for h, _ in model] + ["time s", "note"]
     rows = []
     for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
         rows.append([r["set"], r["arm"], r["verdict"], r.get("sg") or "-", r.get("sg_ref") or "-",
@@ -320,10 +405,9 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                      f(r.get("d_min")), f(r.get("d_min_ref")), f(r.get("res_gain_pct"), "{:+.1f}%"),
                      f(r.get("completeness"), "{:.1f}"), f(r.get("multiplicity"), "{:.1f}"),
                      pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
-                     f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0),
-                     f(r.get("rfree"), "{:.3f}"), f(r.get("rfree_deposited"), "{:.3f}"),
-                     f(r.get("wall_s"), "{:.0f}"), r.get("reason") or ""])
-    doc.table(head, rows, num=range(5, 20),
+                     f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0)]
+                    + [f(r.get(k), "{:.3f}") for _, k in model]
+                    + [f(r.get("wall_s"), "{:.0f}"), r.get("reason") or ""])
+    doc.table(head, rows, num=range(5, len(head) - 1),
               row_class=lambda row: "fail" if row[2] == "fail" else "",
-              cell_class=lambda i, v: {"pass": "pass", "fail": "fail"}.get(v) if i == 2 else None)
-    return doc
+              cell_class=lambda i, x: {"pass": "pass", "fail": "fail"}.get(x) if i == 2 else None)
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 14f471034..d9466eedb 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -78,7 +78,7 @@ def sg_name(sgno):
 
 def judge(entry, rep, run_note):
     """Score one set. entry is its manifest row (with 'ref'), rep its parsed report, run_note
-    what the runner saw ('', 'timeout', 'exit N: message', 'no input')."""
+    what the runner saw ('', 'timeout', 'exit N: message', 'no input', 'no model: why')."""
     ref = dict(entry.get("ref") or {})
     if entry.get("ref_override"):          # a reference measured by hand, replacing the file's
         ref.update(entry["ref_override"])
@@ -96,6 +96,9 @@ def judge(entry, rep, run_note):
         "rugnux_wall_s": fnum(rep.get("WALL_TIME")), "rugnux_verdict": rep.get("VERDICT_TEXT"),
         "r_meas_ref": ref.get("r_meas"), "cc_half_ref": ref.get("cc_half"), "isa_ref": ref.get("isa"),
         "completeness_ref": ref.get("completeness"), "sg_relation": None,
+        # rugnux's own R-factors of the deposited model, when it was given one (--model)
+        "rfree": fnum(rep.get("R_FREE")), "rwork": fnum(rep.get("R_WORK")),
+        "model_fit": rep.get("MODEL_FIT"),
     }
     if rep.get("SPACE_GROUP_NUMBER"):
         r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
@@ -125,6 +128,8 @@ def judge(entry, rep, run_note):
     if not have_lattice:
         if run_note == "no input":
             return verdict("not_run", "no_input", "input file not found")
+        if run_note.startswith("no model"):
+            return verdict("not_run", "no_model", run_note)
         if run_note == "timeout":
             return verdict("fail", "timeout", "timed out")
         if re.search(r"Error reading input|Cannot open", run_note):
diff --git a/tools/battery/site.example.json b/tools/battery/site.example.json
index 7f75edb43..13e24c8ff 100644
--- a/tools/battery/site.example.json
+++ b/tools/battery/site.example.json
@@ -5,6 +5,7 @@
  "gpulock": null,
  "baseline": null,
  "baseline_private": null,
+ "pdb_cache": "/path/to/battery/pdb_cache",
  "arms": {
   "open":    {"manifest": "open.json",    "reference": "deposition", "data_root": "/path/to/battery/open"},
   "inhouse": {"manifest": "inhouse.json", "reference": "xds",        "data_root": "/path/to/battery/inhouse"}
-- 
2.54.0


From 1790abf478f75489d8d5eb1d418193ade46ede08 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 12:56:13 +0200
Subject: [PATCH 025/122] rugnux --model: fit the bulk-solvent grid points in
 parallel

FitModelScale fits ~113 (k_sol, b_sol) grid points, each a full
Levenberg-Marquardt over every working reflection, and it is the largest single
cost of --model (every fit_model call: the first fit, the twin-law probe, the
fit after the rigid body, each null replicate). It ran on one thread.

Each point starts from fit_isotropic_b_approximately(), which sets k_overall
and b_star from the data and the point's solvent pair alone, so no point
depends on the one before it. The points of each pass (coarse, then the
refinement around the coarse winner) now run in contiguous chunks, each on its
own copy of the Scaling, and the winner is read off afterwards in grid order
with the serial rule (lowest finite R, first on a tie). Each point's arithmetic
is unchanged, so the result is the serial loop's bit for bit. Where
fit_isotropic_b_approximately() has five or fewer reflections to fit on it
returns without setting anything and points would chain, so there the grid is
still walked serially on the caller's Scaling.

Inside a null replicate (a pool worker) the chunks run inline, as before.

To check: MODEL_* keys and md5 of the maps/.mtz/_model.cif identical with and
without this commit on the audit set; model-phase time on a fit-dominated set.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelScaling.cpp    | 72 +++++++++++++++++++++++++++++---------
 rugnux/ModelScaling.h      |  6 +++-
 rugnux/ModelValidation.cpp |  2 +-
 tests/ModelScalingTest.cpp | 23 ++++++++++++
 4 files changed, 84 insertions(+), 19 deletions(-)

diff --git a/rugnux/ModelScaling.cpp b/rugnux/ModelScaling.cpp
index 9a35b929d..e0c64e626 100644
--- a/rugnux/ModelScaling.cpp
+++ b/rugnux/ModelScaling.cpp
@@ -5,6 +5,9 @@
 
 #include <algorithm>
 #include <cmath>
+#include <vector>
+
+#include "../common/ParallelFor.h"
 
 namespace {
 
@@ -34,7 +37,15 @@ double RFactor(const gemmi::Scaling<float> &scaling) {
 // pair is held fixed at each grid point and only the overall scale and the symmetry-constrained
 // anisotropic B are refined, which is the well-conditioned half of the problem and is left to
 // gemmi's solver rather than reimplemented.
-ModelScaleReport FitModelScale(gemmi::Scaling<float> &scaling, ModelScaleBox box) {
+//
+// Every grid point is its own fit: fit_isotropic_b_approximately() sets k_overall and b_star from the
+// data and the point's solvent pair alone, so a point does not depend on the one fitted before it, and
+// the points run in parallel, each chunk on its own copy of `scaling`. The winner is then read off in
+// grid order with the serial rule (lowest finite R, the first on a tie), so the answer is the serial
+// loop's bit for bit. The one exception is fit_isotropic_b_approximately() finding five or fewer
+// reflections to fit on - it then returns without setting anything and a point WOULD start from where
+// the previous one ended - so there the grid is walked in order, on `scaling` itself, as it always was.
+ModelScaleReport FitModelScale(gemmi::Scaling<float> &scaling, ModelScaleBox box, size_t nthreads) {
     ModelScaleReport report;
     report.n_points = static_cast<int>(scaling.points.size());
     if (scaling.points.size() < 20)
@@ -44,36 +55,63 @@ ModelScaleReport FitModelScale(gemmi::Scaling<float> &scaling, ModelScaleBox box
     scaling.fix_k_sol = true;      // the grid owns the solvent pair; the solver never sees it
     scaling.fix_b_sol = true;
 
+    // The reflections fit_isotropic_b_approximately() fits on (its own filter).
+    int n_isotropic = 0;
+    for (const auto &p : scaling.points)
+        if (!(p.fobs < 1 || p.fobs < p.sigma))
+            ++n_isotropic;
+    const bool independent = n_isotropic > 5;
+
     double best_r = -1, best_k_sol = 0.35, best_b_sol = 46.0, best_k_overall = 1.0;
     gemmi::SMat33<double> best_b_star{0, 0, 0, 0, 0, 0};
 
-    auto try_point = [&](double k_sol, double b_sol) {
-        scaling.k_sol = k_sol;
-        scaling.b_sol = b_sol;
-        scaling.fit_isotropic_b_approximately();   // a fresh starting point for this solvent pair
-        scaling.fit_parameters();                  // k_overall + anisotropic B only
-        ++report.n_grid;
-        const double r = RFactor(scaling);
-        // A diverged fit gives r = NaN; latched as best_r it wins every later r < best_r.
-        if (std::isfinite(r) && (best_r < 0 || r < best_r)) {
-            best_r = r;
-            best_k_sol = k_sol;
-            best_b_sol = b_sol;
-            best_k_overall = scaling.k_overall;
-            best_b_star = scaling.b_star;
+    struct PointFit { double k_sol, b_sol, r = NAN, k_overall = 1.0; gemmi::SMat33<double> b_star{0, 0, 0, 0, 0, 0}; };
+    auto fit_point = [](gemmi::Scaling<float> &s, PointFit &pf) {
+        s.k_sol = pf.k_sol;
+        s.b_sol = pf.b_sol;
+        s.fit_isotropic_b_approximately();   // a fresh starting point for this solvent pair
+        s.fit_parameters();                  // k_overall + anisotropic B only
+        pf.r = RFactor(s);
+        pf.k_overall = s.k_overall;
+        pf.b_star = s.b_star;
+    };
+    auto try_points = [&](std::vector<PointFit> &pts) {
+        if (independent)
+            ParallelChunks(static_cast<int>(pts.size()), nthreads, [&](int lo, int hi) {
+                gemmi::Scaling<float> local = scaling;
+                for (int i = lo; i < hi; ++i)
+                    fit_point(local, pts[i]);
+            });
+        else
+            for (auto &pf : pts)
+                fit_point(scaling, pf);
+        for (const auto &pf : pts) {
+            ++report.n_grid;
+            // A diverged fit gives r = NaN; latched as best_r it wins every later r < best_r.
+            if (std::isfinite(pf.r) && (best_r < 0 || pf.r < best_r)) {
+                best_r = pf.r;
+                best_k_sol = pf.k_sol;
+                best_b_sol = pf.b_sol;
+                best_k_overall = pf.k_overall;
+                best_b_star = pf.b_star;
+            }
         }
     };
 
     // Coarse pass over the whole box, then one refinement pass around the winner.
+    std::vector<PointFit> coarse;
     for (double ks = box.k_lo; ks <= box.k_hi + 1e-9; ks += 0.05)
         for (double bs = box.b_lo; bs <= box.b_hi + 1e-9; bs += 10.0)
-            try_point(ks, bs);
+            coarse.push_back(PointFit{ks, bs});
+    try_points(coarse);
     const double k0 = best_k_sol, b0 = best_b_sol;
     const double k_hi2 = std::min(box.k_hi, k0 + 0.05);
     const double b_hi2 = std::min(box.b_hi, b0 + 10.0);
+    std::vector<PointFit> fine;
     for (double ks = std::max(box.k_lo, k0 - 0.05); ks <= k_hi2 + 1e-9; ks += 0.025)
         for (double bs = std::max(box.b_lo, b0 - 10.0); bs <= b_hi2 + 1e-9; bs += 5.0)
-            try_point(ks, bs);
+            fine.push_back(PointFit{ks, bs});
+    try_points(fine);
 
     scaling.k_sol = best_k_sol;
     scaling.b_sol = best_b_sol;
diff --git a/rugnux/ModelScaling.h b/rugnux/ModelScaling.h
index 0600097d1..9217d6cfc 100644
--- a/rugnux/ModelScaling.h
+++ b/rugnux/ModelScaling.h
@@ -3,6 +3,8 @@
 
 #pragma once
 
+#include <cstddef>
+
 #include "gemmi/scaling.hpp"
 
 // Fit the overall scale, the anisotropic B and the flat bulk solvent of a model to observed
@@ -31,4 +33,6 @@ struct ModelScaleReport {
     double r_work_fit = 1.0;  // R on the fitted reflections, at the chosen solution
 };
 
-ModelScaleReport FitModelScale(gemmi::Scaling<float> &scaling, ModelScaleBox box = {});
+// nthreads: the grid points are fitted in parallel on up to this many threads; the answer does not
+// depend on it.
+ModelScaleReport FitModelScale(gemmi::Scaling<float> &scaling, ModelScaleBox box = {}, size_t nthreads = 1);
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index d85b0430b..b3120e309 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -545,7 +545,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         gemmi::Scaling<float> scaling(ucell, sg);
         scaling.use_solvent = true;
         scaling.prepare_points(out.fmodel, fobs_work, &ms.fmask);
-        FitModelScale(scaling);
+        FitModelScale(scaling, {}, nthreads);
         scaling.scale_data(out.fmodel, &ms.fmask);   // out.fmodel now holds the scaled, solvent-corrected Fmodel
         out.k_sol = scaling.k_sol;
         out.b_sol = scaling.b_sol;
diff --git a/tests/ModelScalingTest.cpp b/tests/ModelScalingTest.cpp
index 155ece16a..28aa20bbc 100644
--- a/tests/ModelScalingTest.cpp
+++ b/tests/ModelScalingTest.cpp
@@ -141,3 +141,26 @@ TEST_CASE("ModelScaling adds nothing when there is no solvent to model") {
     CHECK(scaling.b_sol >= 10.0);
     CHECK(scaling.b_sol <= 80.0);
 }
+
+// The grid points are fitted in parallel; the answer must be the serial one, bit for bit.
+TEST_CASE("ModelScaling is the same on any number of threads") {
+    const gemmi::UnitCell cell = Cell();
+    const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name("P 21 21 21");
+    REQUIRE(sg != nullptr);
+    gemmi::Scaling<float> serial(cell, sg);
+    serial.use_solvent = true;
+    MakePoints(serial, cell, /*k_overall=*/0.5, /*b_iso=*/20.0,
+               /*k_sol=*/0.35, /*b_sol=*/45.0, /*d_min=*/2.0, /*d_max=*/50.0);
+    gemmi::Scaling<float> parallel = serial;
+
+    const ModelScaleReport r1 = FitModelScale(serial, {}, 1);
+    const ModelScaleReport r8 = FitModelScale(parallel, {}, 8);
+    CHECK(r1.n_grid == r8.n_grid);
+    CHECK(r1.r_work_fit == r8.r_work_fit);
+    CHECK(serial.k_sol == parallel.k_sol);
+    CHECK(serial.b_sol == parallel.b_sol);
+    CHECK(serial.k_overall == parallel.k_overall);
+    CHECK(serial.b_star.u11 == parallel.b_star.u11);
+    CHECK(serial.b_star.u22 == parallel.b_star.u22);
+    CHECK(serial.b_star.u33 == parallel.b_star.u33);
+}
-- 
2.54.0


From 8fe6ed1806ad82a54947fac2bcaf8fff9900b753 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 09:47:36 +0200
Subject: [PATCH 026/122] tools/battery: a working XDS reference for the
 half-shadowed lysozyme set

XDS was rerun with the pin shadow masked and the frames where the crystal
leaves the beam excluded; the reference is now P43212 to 1.65 A instead of a
failed P1 run.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/inhouse.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index a10b82c65..7ee9959b1 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -6,7 +6,7 @@
  {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
  {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
  {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 1, "cell": [37.267, 79.125, 81.145, 87.995, 90.636, 90.239], "anomalous": true, "isa": 1.87, "completeness": 43.2, "r_meas": 3.17, "cc_half": 0.179, "multiplicity": 1.44, "dmin": 2.602, "dmin_rule": "cc_half_0.30", "dmin_xds": 0.8, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
  {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
  {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
  {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
-- 
2.54.0


From 542a1a987db1f46ae8956c25c22a04480cd5ed1d Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 12:57:04 +0200
Subject: [PATCH 027/122] rugnux --model: drop two fits nothing needed

A rejected rigid-body placement put the atoms back and then recomputed the full
Fcalc and solvent mask at the restored positions. Nothing reads them: the real
model's ModelState is only fitted again after its own compute_model_factors
(the re-placement on the merged indexing, the null-failure fallback), and a
null replicate's state is discarded. The atoms are still put back; the
structure factors are left as they are.

Where the lattice has twin laws, the indexing probe fits the identity labelling
first, and place_and_fit then made the identical fit again - same
ModelState (nothing moves the model between the two), same reflections. The
probe now hands that Fit over, for the real model when the identity wins and
always for a null replicate (placed against the merged indexing). fit_model is
deterministic, so the reused Fit is the one the second call produced.

Bit-identical by construction: no value that is read changes. To check: MODEL_*
keys and md5 of maps/.mtz/_model.cif identical with and without this commit on
the audit set, including sets with twin laws and a null.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelValidation.cpp | 42 +++++++++++++++++++++++++++++---------
 1 file changed, 32 insertions(+), 10 deletions(-)

diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index b3120e309..06b3e4790 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -9,6 +9,7 @@
 #include <complex>
 #include <array>
 #include <numeric>
+#include <optional>
 #include <random>
 #include <string>
 #include <utility>
@@ -580,14 +581,24 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
     // The real model and every null replicate below go through this same lambda, so the two are
     // comparable - a null that was not placed would be the null of a weaker procedure than the one it
     // is there to judge. It leaves the model where it ends up, and the caller puts it back.
+    //
+    // `fitted`: fit_model(ms, obs_in) where the caller already has it - the indexing probe fits the
+    // identity labelling first, on the same structure factors and the same reflections - so the same
+    // fit is not made twice in a row.
+    //
+    // A rejected placement puts the atoms back but not ms.fcalc/ms.fmask, which are left at the
+    // rejected placement: nothing reads them afterwards - every later fit_model on this state is
+    // preceded by its own compute_model_factors - and recomputing them was a full Fcalc and mask
+    // for nothing.
     struct Placement {
         Fit fit;
         bool rb_applied = false;
         double rb_angle_deg = 0, rb_shift_A = 0, r_free_before_rb = 0;
     };
-    auto place_and_fit = [&](ModelState &ms, const std::vector<MergedReflection> &obs_in) -> Placement {
+    auto place_and_fit = [&](ModelState &ms, const std::vector<MergedReflection> &obs_in,
+                             std::optional<Fit> fitted) -> Placement {
         Placement out;
-        out.fit = fit_model(ms, obs_in);
+        out.fit = fitted ? std::move(*fitted) : fit_model(ms, obs_in);
 
         // --- rigid-body placement of the model in the data cell ---
         // Re-fractionalizing the model above puts it in the right box but not in the right place: a
@@ -620,7 +631,6 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                 out.fit = std::move(moved);
             } else {
                 SetModelPositions(ms.st.models[0], before);
-                compute_model_factors(ms);
             }
         }
         return out;
@@ -647,10 +657,12 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
     struct IndexingProbe {
         gemmi::Op op = gemmi::Op::identity();   // the lowest-R-free relabelling
         double margin = 0;                      // by how much in R-free it leads the runner-up
+        std::optional<Fit> identity_fit;        // fit_model(ms, obs), for place_and_fit to reuse
     };
     auto probe_indexing = [&](ModelState &ms) {
         IndexingProbe out;
-        std::vector<double> r_free{fit_model(ms, obs).r_free};   // identity first, then the twin laws
+        out.identity_fit = fit_model(ms, obs);
+        std::vector<double> r_free{out.identity_fit->r_free};   // identity first, then the twin laws
         double best_r_free = r_free.front();
         for (const auto &op : reindex_ops) {
             const double cand = fit_model(ms, ReindexReflections(obs, op)).r_free;
@@ -679,7 +691,13 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
             obs_model = &reindexed;
         }
     }
-    Placement real = place_and_fit(mdl, *obs_model);
+    // The probe's identity fit is this fit exactly when the identity won: same structure factors
+    // (nothing has moved the model since), same reflections.
+    std::optional<Fit> identity_fit;
+    if (obs_model == &obs)
+        identity_fit = std::move(indexing.identity_fit);
+    indexing.identity_fit.reset();
+    Placement real = place_and_fit(mdl, *obs_model, std::move(identity_fit));
 
     // --- is there anything for the model to decide? ---
     // There are only two: the space-group label, where the model asserts the other enantiomorph, and
@@ -737,9 +755,13 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
             SetModelPositions(rep.st.models[0], as_read);
             reorient_about_centroid(rep.st.models[0], null_rotation[i]);
             compute_model_factors(rep);
-            if (!reindex_ops.empty())
-                null_margin[i] = probe_indexing(rep).margin;
-            null_r_work[i] = place_and_fit(rep, obs).fit.r_work;
+            std::optional<Fit> identity_fit;
+            if (!reindex_ops.empty()) {
+                IndexingProbe probe = probe_indexing(rep);
+                null_margin[i] = probe.margin;
+                identity_fit = std::move(probe.identity_fit);   // replicates are placed against obs
+            }
+            null_r_work[i] = place_and_fit(rep, obs, std::move(identity_fit)).fit.r_work;
         });
         const auto [null_mean, null_sd] = mean_sd(null_r_work);
         result.fit_tested = true;
@@ -794,7 +816,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                 // are now the ones the merge produced, so the fit is remade on them.
                 SetModelPositions(st.models[0], as_read);
                 compute_model_factors(mdl);
-                real = place_and_fit(mdl, obs);
+                real = place_and_fit(mdl, obs, std::nullopt);
                 record_fit(real);
             }
         }
@@ -824,7 +846,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         result.r_work_sigma = 0.0;
         SetModelPositions(st.models[0], as_read);
         compute_model_factors(mdl);
-        real = place_and_fit(mdl, obs);
+        real = place_and_fit(mdl, obs, std::nullopt);
     }
 
     Fit &best = real.fit;
-- 
2.54.0


From 163bf851124898ad0f033488e1c30660214c0b70 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:02:08 +0200
Subject: [PATCH 028/122] tools/battery: the sparse myoglobin set gets a real
 XDS reference

The crystal does have a single P2 lattice, holding ~6% of each frame's spots
on top of ice and protein powder; XDS indexes it with the ice rings excluded.
The reference is now that P2 run to 2.0 A instead of a failed P1 run, and the
set is renamed from aggregate to sparse.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/inhouse.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index 7ee9959b1..29dbac2f1 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -1,4 +1,4 @@
-{"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_x10sa_90deg_1", "E08_lyso_2_007": "lyso_x10sa_90deg_2", "lyso_2": "lyso_x06da_atten_wedge", "lyso_6_5keV": "lyso_x06da_5keV", "lysoC_14_f46f0a": "lyso_x06da_ice", "Thau_9": "thau_x10sa_0p1deg", "thau_BL1A_1p9A": "thau_bl1a_6p5keV", "thau_BL1A_2p7A": "thau_bl1a_4p6keV", "thau_BL1A_3p3A": "thau_bl1a_3p8keV", "Ins_H_2_fa9841": "insu_H_x06da_twin", "Ins_H_3_d05684": "insu_H_x06da_notwin", "Ins_I_16": "insu_I_x06da_weak", "Ins_I_2_1a530d": "insu_I_x06da_low_isa", "Ins_I_3_5e90e3": "insu_I_x06da_ref", "Ins_I_6_13keV": "insu_I_x06da_13keV", "Ins_I_6_5keV": "insu_I_x06da_5keV", "Ins_I_6_6keV": "insu_I_x06da_6keV", "Ins_I_7_5keV": "insu_I_x06da_5keV_2", "cytC_10": "cytc_x10sa", "cytC_2_0770b5": "cytc_x06da_1", "cytC_3_874285": "cytc_x06da_2", "MyoB_13": "myob_x10sa", "MyoB_9_446b70": "myob_x06da", "MyoB2-1": "myob_x06da_powder_1", "MyoB2-2": "myob_x06da_powder_2", "MyoB2-4": "myob_x06da_split", "MyoB2-5": "myob_x06da_aggregate", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1", "lyso_90deg_1": "lyso_x10sa_90deg_1", "lyso_90deg_2": "lyso_x10sa_90deg_2", "lyso_atten_wedge": "lyso_x06da_atten_wedge", "lyso_5keV": "lyso_x06da_5keV", "lyso_ice": "lyso_x06da_ice", "lyso_ref": "lyso_x06da_ref", "lyso_strong": "lyso_x10sa_strong", "lyso_half_image": "lyso_x06da_half_image", "thau_16keV": "thau_x10sa_16keV", "thau_0p1deg": "thau_x10sa_0p1deg", "thau_1p9A": "thau_bl1a_6p5keV", "thau_2p7A": "thau_bl1a_4p6keV", "thau_3p3A": "thau_bl1a_3p8keV", "thau_injection": "thau_x10sa_injection", "thau_pink": "thau_micromax_pink", "insu_H_twin": "insu_H_x06da_twin", "insu_H_notwin": "insu_H_x06da_notwin", "insu_I_weak": "insu_I_x06da_weak", "insu_I_low_isa": "insu_I_x06da_low_isa", "insu_I_ref": "insu_I_x06da_ref", "insu_I_13keV": "insu_I_x06da_13keV", "insu_I_5keV": "insu_I_x06da_5keV", "insu_I_6keV": "insu_I_x06da_6keV", "insu_I_5keV_2": "insu_I_x06da_5keV_2", "cytc_eiger": "cytc_x10sa", "cytc_pilatus_1": "cytc_x06da_1", "cytc_pilatus_2": "cytc_x06da_2", "myob_eiger": "myob_x10sa", "myob_pilatus": "myob_x06da", "myob_powder_1": "myob_x06da_powder_1", "myob_powder_2": "myob_x06da_powder_2", "myob_split": "myob_x06da_split", "myob_aggregate": "myob_x06da_aggregate"}, "sets": [
+{"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_x10sa_90deg_1", "E08_lyso_2_007": "lyso_x10sa_90deg_2", "lyso_2": "lyso_x06da_atten_wedge", "lyso_6_5keV": "lyso_x06da_5keV", "lysoC_14_f46f0a": "lyso_x06da_ice", "Thau_9": "thau_x10sa_0p1deg", "thau_BL1A_1p9A": "thau_bl1a_6p5keV", "thau_BL1A_2p7A": "thau_bl1a_4p6keV", "thau_BL1A_3p3A": "thau_bl1a_3p8keV", "Ins_H_2_fa9841": "insu_H_x06da_twin", "Ins_H_3_d05684": "insu_H_x06da_notwin", "Ins_I_16": "insu_I_x06da_weak", "Ins_I_2_1a530d": "insu_I_x06da_low_isa", "Ins_I_3_5e90e3": "insu_I_x06da_ref", "Ins_I_6_13keV": "insu_I_x06da_13keV", "Ins_I_6_5keV": "insu_I_x06da_5keV", "Ins_I_6_6keV": "insu_I_x06da_6keV", "Ins_I_7_5keV": "insu_I_x06da_5keV_2", "cytC_10": "cytc_x10sa", "cytC_2_0770b5": "cytc_x06da_1", "cytC_3_874285": "cytc_x06da_2", "MyoB_13": "myob_x10sa", "MyoB_9_446b70": "myob_x06da", "MyoB2-1": "myob_x06da_powder_1", "MyoB2-2": "myob_x06da_powder_2", "MyoB2-4": "myob_x06da_split", "MyoB2-5": "myob_x06da_sparse", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1", "lyso_90deg_1": "lyso_x10sa_90deg_1", "lyso_90deg_2": "lyso_x10sa_90deg_2", "lyso_atten_wedge": "lyso_x06da_atten_wedge", "lyso_5keV": "lyso_x06da_5keV", "lyso_ice": "lyso_x06da_ice", "lyso_ref": "lyso_x06da_ref", "lyso_strong": "lyso_x10sa_strong", "lyso_half_image": "lyso_x06da_half_image", "thau_16keV": "thau_x10sa_16keV", "thau_0p1deg": "thau_x10sa_0p1deg", "thau_1p9A": "thau_bl1a_6p5keV", "thau_2p7A": "thau_bl1a_4p6keV", "thau_3p3A": "thau_bl1a_3p8keV", "thau_injection": "thau_x10sa_injection", "thau_pink": "thau_micromax_pink", "insu_H_twin": "insu_H_x06da_twin", "insu_H_notwin": "insu_H_x06da_notwin", "insu_I_weak": "insu_I_x06da_weak", "insu_I_low_isa": "insu_I_x06da_low_isa", "insu_I_ref": "insu_I_x06da_ref", "insu_I_13keV": "insu_I_x06da_13keV", "insu_I_5keV": "insu_I_x06da_5keV", "insu_I_6keV": "insu_I_x06da_6keV", "insu_I_5keV_2": "insu_I_x06da_5keV_2", "cytc_eiger": "cytc_x10sa", "cytc_pilatus_1": "cytc_x06da_1", "cytc_pilatus_2": "cytc_x06da_2", "myob_eiger": "myob_x10sa", "myob_pilatus": "myob_x06da", "myob_powder_1": "myob_x06da_powder_1", "myob_powder_2": "myob_x06da_powder_2", "myob_split": "myob_x06da_split", "myob_aggregate": "myob_x06da_sparse", "myob_x06da_aggregate": "myob_x06da_sparse"}, "sets": [
  {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
  {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
  {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
@@ -31,7 +31,7 @@
  {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
  {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
  {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_x06da_aggregate", "input": "MyoB2-5/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 1, "cell": [43.226, 67.346, 121.692, 100.15, 89.855, 96.62], "anomalous": false, "isa": 1.24, "completeness": 11.8, "r_meas": 1.527, "cc_half": 0.125, "multiplicity": 1.41, "dmin": 1.11, "dmin_rule": "xds_range", "dmin_xds": 1.11, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_sparse", "input": "myob_x06da_sparse/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 3, "cell": [35.388, 28.752, 64.083, 90.0, 106.352, 90.0], "anomalous": false, "isa": 5.46, "completeness": 73.7, "r_meas": 0.326, "cc_half": 0.972, "multiplicity": 5.21, "dmin": 2.0, "dmin_rule": "xds_range", "dmin_xds": 2.0, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
  {"id": "nothing_2", "input": "nothing_2/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
  {"id": "nothing_1", "input": "nothing_1/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
 ]}
-- 
2.54.0


From 13de0e7a87c61dc9b98d27e05f605b4748557aba Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 12:58:03 +0200
Subject: [PATCH 029/122] rugnux --model: evaluate the rigid-body Jacobian's
 columns in parallel

The rigid-body target is an Fcalc + solvent mask + scale re-fit per
evaluation, and its forward-difference Jacobian made six of them one after the
other after the central one - 7 of the ~8 evaluations per LM iteration.

The six shifted evaluations now run in parallel, column j on its own Evaluator
over its own copy of the model (an evaluation moves every atom, so two cannot
share one), set to the same zone and given the central evaluation's bulk-solvent
pair - the pair the serial loop's shifted evaluations used, since the zone's
solvent is fitted on the zone's first evaluation and every Evaluate starts with
the central one. Each column's arithmetic is the serial one and the Jacobian is
assembled in column order, so the refinement is bit-identical; the evaluation
count is kept as the serial loop kept it (up to and including a failing column).
The per-zone solvent fit (FitModelScale) gets the thread count as well.

Inside a null replicate (a pool worker) the columns run inline, as before.

To check: RIGID_BODY_* and MODEL_* keys and md5 of maps/.mtz/_model.cif identical
with and without this commit on the audit set; rigid-body seconds on a large
model.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelValidation.cpp    |  2 +-
 rugnux/RigidBodyRefine.cpp    | 63 ++++++++++++++++++++++++++++-------
 rugnux/RigidBodyRefine.h      |  4 ++-
 tests/ModelValidationTest.cpp | 40 ++++++++++++++++++++++
 4 files changed, 95 insertions(+), 14 deletions(-)

diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 06b3e4790..4d09805ab 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -610,7 +610,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         // exactly where it was read.
         const std::vector<gemmi::Position> before = ModelPositions(ms.st.models[0]);
         const RigidBodyRefineResult rb =
-            RefineRigidBody(ms.st.models[0], ucell, *sg, out.fit.fobs_work, d_min, logger);
+            RefineRigidBody(ms.st.models[0], ucell, *sg, out.fit.fobs_work, d_min, logger, nthreads);
         if (!rb.converged) {
             // RefineRigidBody leaves the model wherever the solver left it, usable answer or not, so
             // the restore cannot be conditional on the same flag the re-fit is.
diff --git a/rugnux/RigidBodyRefine.cpp b/rugnux/RigidBodyRefine.cpp
index 91d25843c..8b36f44d5 100644
--- a/rugnux/RigidBodyRefine.cpp
+++ b/rugnux/RigidBodyRefine.cpp
@@ -4,6 +4,7 @@
 #include "RigidBodyRefine.h"
 
 #include <algorithm>
+#include <array>
 #include <chrono>
 #include <cmath>
 #include <complex>
@@ -21,6 +22,7 @@
 #include "ModelScaling.h"           // FitModelScale
 #include "../common/JFJochMath.h"   // PI
 #include "../common/Logger.h"
+#include "../common/ParallelFor.h"
 
 namespace {
 
@@ -72,8 +74,8 @@ struct Placement {
 class Evaluator {
 public:
     Evaluator(gemmi::Model &model, const gemmi::UnitCell &cell, const gemmi::SpaceGroup &sg,
-              const std::vector<gemmi::Position> &base, const Placement &placement)
-        : model_(model), cell_(cell), sg_(sg), base_(base), placement_(placement) {}
+              const std::vector<gemmi::Position> &base, const Placement &placement, size_t nthreads)
+        : model_(model), cell_(cell), sg_(sg), base_(base), placement_(placement), nthreads_(nthreads) {}
 
     // The zone's observations, and the scale the residuals are expressed in.
     void SetZone(const gemmi::AsuData<gemmi::ValueSigma<float>> &fobs, double d_min) {
@@ -86,6 +88,14 @@ public:
         solvent_fitted_ = false;
     }
 
+    // Hold the zone's bulk solvent at a pair another evaluator already fitted, as if this one had
+    // fitted it itself (the Jacobian's column evaluators take the central evaluation's).
+    void UseSolvent(double k, double b) {
+        k_sol = k;
+        b_sol = b;
+        solvent_fitted_ = true;
+    }
+
     size_t NumObservations() const { return fobs_.v.size(); }
     double JacobianStep() const { return JACOBIAN_STEP_FRACTION * d_min_; }
     int evaluations = 0;
@@ -135,7 +145,7 @@ public:
         if (scaling.points.empty())
             return false;
         if (!solvent_fitted_) {
-            FitModelScale(scaling);
+            FitModelScale(scaling, {}, nthreads_);
             k_sol = scaling.k_sol;
             b_sol = scaling.b_sol;
             solvent_fitted_ = true;
@@ -179,6 +189,7 @@ private:
     double d_min_ = 0;
     double f_mean_ = 1;
     bool solvent_fitted_ = false;
+    size_t nthreads_ = 1;
 };
 
 // Ceres' own numeric differentiation steps by |x| * relative_step_size, which is zero at the start of
@@ -186,9 +197,17 @@ private:
 // forward differences at a step chosen in the parameters' units. Analytic dF/dp would need
 // derivatives GEMMI's structure-factor path does not have, and at six parameters it is not worth it:
 // a Jacobian costs seven evaluations, and the evaluations at 6-3.5 A are cheap.
+//
+// The six shifted evaluations are independent of each other, so they run in parallel, column j on
+// `columns[j]`: an evaluator over its own copy of the model (an evaluation moves every atom to the
+// placement it is asked about, so two cannot share one), set to the same zone and handed the solvent
+// pair the central evaluation fitted - which is the pair the serial loop's shifted evaluations used,
+// since the zone's solvent is fitted by the first evaluation of the zone and every Evaluate starts
+// with the central one. Each column's arithmetic is the serial one, so the Jacobian is too.
 class RigidBodyCost : public ceres::CostFunction {
 public:
-    explicit RigidBodyCost(Evaluator &ev) : ev_(ev) {
+    RigidBodyCost(Evaluator &ev, std::vector<Evaluator> &columns, size_t nthreads)
+        : ev_(ev), columns_(columns), nthreads_(nthreads) {
         set_num_residuals(static_cast<int>(ev.NumObservations()));
         mutable_parameter_block_sizes()->push_back(6);
     }
@@ -198,16 +217,24 @@ public:
         if (!ev_.Residuals(parameters[0], residuals))
             return false;
         if (jacobians != nullptr && jacobians[0] != nullptr) {
-            std::vector<double> shifted(n);
-            for (int j = 0; j < 6; j++) {
+            const double step = ev_.JacobianStep();
+            std::vector<std::vector<double>> shifted(6, std::vector<double>(n));
+            std::array<bool, 6> ok{};
+            ParallelFor(6, nthreads_, [&](int j) {
                 double q[6];
                 std::copy(parameters[0], parameters[0] + 6, q);
-                const double step = ev_.JacobianStep();
                 q[j] += step;
-                if (!ev_.Residuals(q, shifted.data()))
+                columns_[j].UseSolvent(ev_.k_sol, ev_.b_sol);
+                ok[j] = columns_[j].Residuals(q, shifted[j].data());
+            });
+            // Counted as the serial loop counted them: it stopped at the first column that failed.
+            for (int j = 0; j < 6; j++) {
+                ++ev_.evaluations;
+                ev_.unmatched = columns_[j].unmatched;
+                if (!ok[j])
                     return false;
                 for (int i = 0; i < n; i++)
-                    jacobians[0][i * 6 + j] = (shifted[i] - residuals[i]) / step;
+                    jacobians[0][i * 6 + j] = (shifted[j][i] - residuals[i]) / step;
             }
         }
         return true;
@@ -215,6 +242,8 @@ public:
 
 private:
     Evaluator &ev_;
+    std::vector<Evaluator> &columns_;
+    size_t nthreads_;
 };
 
 // The directions in which this space group's origin is free. Translating the whole cell content along
@@ -274,7 +303,8 @@ RigidBodyRefineResult RefineRigidBody(gemmi::Model &model,
                                       const gemmi::SpaceGroup &sg,
                                       const gemmi::AsuData<gemmi::ValueSigma<float>> &fobs,
                                       double d_min,
-                                      Logger &logger) {
+                                      Logger &logger,
+                                      size_t nthreads) {
     const auto t0 = std::chrono::steady_clock::now();
     RigidBodyRefineResult result;
 
@@ -301,7 +331,14 @@ RigidBodyRefineResult RefineRigidBody(gemmi::Model &model,
         ladder.push_back(d_min);
 
     const gemmi::Mat33 gauge = GaugeProjector(sg, cell);
-    Evaluator ev(model, cell, sg, base, placement);
+    Evaluator ev(model, cell, sg, base, placement, nthreads);
+    // The Jacobian's six column evaluators, each over its own copy of the model (see RigidBodyCost).
+    // The copies only ever hold probe placements; `model` is left at the answer below.
+    std::vector<gemmi::Model> column_models(6, model);
+    std::vector<Evaluator> columns;
+    columns.reserve(6);
+    for (int j = 0; j < 6; j++)
+        columns.emplace_back(column_models[j], cell, sg, base, placement, 1);
     double q[6] = {0, 0, 0, 0, 0, 0};
     bool any_zone_solved = false;
     for (double zone : ladder) {
@@ -315,9 +352,11 @@ RigidBodyRefineResult RefineRigidBody(gemmi::Model &model,
             continue;
         result.zones.push_back(zone);   // the ladder WALKED, which a thin zone drops out of
         ev.SetZone(zone_obs, zone);
+        for (Evaluator &c : columns)
+            c.SetZone(zone_obs, zone);
 
         ceres::Problem problem;
-        problem.AddResidualBlock(new RigidBodyCost(ev), nullptr, q);
+        problem.AddResidualBlock(new RigidBodyCost(ev, columns, nthreads), nullptr, q);
         ceres::Solver::Options options;
         options.linear_solver_type = ceres::DENSE_QR;
         options.max_num_iterations = 15;
diff --git a/rugnux/RigidBodyRefine.h b/rugnux/RigidBodyRefine.h
index 2f57fdc5d..a17f3489b 100644
--- a/rugnux/RigidBodyRefine.h
+++ b/rugnux/RigidBodyRefine.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <vector>
 
 #include "gemmi/asudata.hpp"
@@ -41,4 +42,5 @@ RigidBodyRefineResult RefineRigidBody(gemmi::Model &model,
                                       const gemmi::SpaceGroup &sg,
                                       const gemmi::AsuData<gemmi::ValueSigma<float>> &fobs,
                                       double d_min,
-                                      Logger &logger);
+                                      Logger &logger,
+                                      size_t nthreads = 1);
diff --git a/tests/ModelValidationTest.cpp b/tests/ModelValidationTest.cpp
index 943a559cc..3fcb7bee8 100644
--- a/tests/ModelValidationTest.cpp
+++ b/tests/ModelValidationTest.cpp
@@ -622,3 +622,43 @@ TEST_CASE("ModelValidation_MapToFPhiMatchesGemmi", "[ModelValidation]") {
     for (size_t i = 0; i < a.v.size(); i++)
         CHECK(a.v[i].hkl == b.v[i].hkl);
 }
+
+// The Jacobian's six columns are evaluated in parallel; the placement must be the serial one, bit for
+// bit.
+TEST_CASE("ModelValidation_RigidBodySameOnAnyNumberOfThreads", "[ModelValidation]") {
+    Logger logger("ModelValidation_RigidBodySameOnAnyNumberOfThreads");
+
+    const auto path = WriteTemp("rigid_body_threads_test.pdb", ClusterPdb().c_str());
+    gemmi::Structure st = gemmi::read_structure_gz(path, gemmi::CoorFormat::Detect);
+    const gemmi::SpaceGroup *sg = st.find_spacegroup();
+    REQUIRE(sg != nullptr);
+    st.setup_cell_images();
+
+    const auto ref = ModelReferenceIntensities(path, {}, {}, 3.0, logger);
+    REQUIRE_FALSE(ref.empty());
+    gemmi::AsuData<gemmi::ValueSigma<float>> fobs;
+    fobs.unit_cell_ = st.cell;
+    fobs.spacegroup_ = sg;
+    for (const auto &r : ref)
+        fobs.v.push_back({{{r.h, r.k, r.l}}, {std::sqrt(r.I), 1.0f}});
+    fobs.ensure_sorted();
+
+    std::vector<gemmi::Position> displaced;
+    for (const gemmi::Position &p : ModelPositions(st.models[0]))
+        displaced.emplace_back(p.x + 0.40, p.y - 0.30, p.z + 0.20);
+
+    gemmi::Model serial = st.models[0], parallel = st.models[0];
+    SetModelPositions(serial, displaced);
+    SetModelPositions(parallel, displaced);
+    const RigidBodyRefineResult r1 = RefineRigidBody(serial, st.cell, *sg, fobs, 3.0, logger, 1);
+    const RigidBodyRefineResult r6 = RefineRigidBody(parallel, st.cell, *sg, fobs, 3.0, logger, 6);
+    CHECK(r1.evaluations == r6.evaluations);
+    CHECK(r1.angle_deg == r6.angle_deg);
+    CHECK(r1.shift_A == r6.shift_A);
+    const auto p1 = ModelPositions(serial), p6 = ModelPositions(parallel);
+    REQUIRE(p1.size() == p6.size());
+    for (size_t i = 0; i < p1.size(); i++)
+        CHECK((p1[i].x == p6[i].x && p1[i].y == p6[i].y && p1[i].z == p6[i].z));
+
+    std::filesystem::remove(path);
+}
-- 
2.54.0


From 060a89cd7d04361b49eab5bf9d6c9a28e5fe2ee4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:39:39 +0200
Subject: [PATCH 030/122] CUDA: allocation streams are handed back, not leaked;
 a handled pool failure leaves no error

A long-running broker began cancelling every data collection with

    Device decoding failed (CUDA (GPU) error (out of memory)), falling back to host decompression
    CUDA (GPU) error (out of memory)

while nvidia-smi showed the cards less than a fifth full. Two defects, both in CUDAMemHelpers.h and
both from the pooled allocator (cudaMallocAsync) that came with rc.162.

The leak. cuda_allocation_stream() kept one stream per (thread, device) in a thread_local map of raw
cudaStream_t and never destroyed them. That was written against rugnux, where the worker threads live
as long as the process. The broker starts fresh std::async threads for every data collection - 16 or
64 of them - so every collection left that many streams behind. Measured: 0.56 MB of device memory
per leaked stream, linear to 4928 streams, never returned, with nothing on the host side growing.

The RAII wrapper (CudaStream) was there but not used at this site, and using it as-is - a stream
destroyed when its thread exits - would not have been safe: ShadowFinder builds its GPU accumulator
on a throw-away std::async thread and frees it from another thread long after, and that free is
ordered on the allocating thread's stream. So the streams are still never destroyed, but a thread
now only borrows one: CudaStream objects live in a process-wide per-device idle list, a thread takes
one on first use and hands it back when it exits. Their number is bounded by the threads that were
ever alive at once instead of by the threads ever started. The list itself is deliberately leaked, so
that nothing calls into CUDA during static destruction.

Replaying the broker's pattern against the real header, 60 collections of 64 threads:
    before   3840 streams, 260 -> 2424 MB of device memory
    after      64 streams, 260 ->  358 MB

The stale error. Every helper here throws a named message, yet the log carried the raw CUDA string,
so the failure came through a cuda_err() and not from an allocation. CudaDevicePtr falls back to
cudaMalloc when cudaMallocAsync fails, silently - but the failed call stays behind as the thread's
last error, and the cudaGetLastError() that follows the next kernel launch reports it. The buffers
were all allocated; the frame was lost anyway, once on the device-decode route (caught, hence the
warning) and once more on the host fallback (fatal). The pooled attempt failing, and a stream that
cannot be created, are both handled by falling back, so both now clear the error they leave.

What finite resource the production cards ran out of at under 4 GB used was not established - no
cap on the number of streams was found up to 4928 on the card this was measured on. The leak is the
only thing on this path that grows with uptime.

tests/CUDAMemHelpersTest.cpp: later threads end up on the same stream, concurrent threads on
different ones, a buffer is freed cleanly after its allocating thread has exited (and another has
borrowed its stream), and a pool that cannot serve a request leaves no error behind - the last by
capping a memory pool at 4 MB so that the pooled attempt fails and the fallback succeeds.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 docs/CHANGELOG.md                        |   4 +
 image_analysis/indexing/CUDAMemHelpers.h |  94 ++++++++++++++++-----
 tests/CMakeLists.txt                     |   1 +
 tests/CUDAMemHelpersTest.cpp             | 103 +++++++++++++++++++++++
 4 files changed, 182 insertions(+), 20 deletions(-)
 create mode 100644 tests/CUDAMemHelpersTest.cpp

diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 0e9d21248..7a7d86dc4 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -1,6 +1,10 @@
 # Changelog
 ## 1.0.0
 
+### 1.0.0-rc.172
+
+* Fixed `jfjoch_broker` cancelling every data collection with a CUDA "out of memory" error after long operation: GPU memory no longer leaks with each collection.
+
 ### 1.0.0-rc.171
 
 * Rugnux: basic support for CCD images (marCCD, SMV) and for gzipped miniCBF.
diff --git a/image_analysis/indexing/CUDAMemHelpers.h b/image_analysis/indexing/CUDAMemHelpers.h
index 40c6f0833..adbd98a20 100644
--- a/image_analysis/indexing/CUDAMemHelpers.h
+++ b/image_analysis/indexing/CUDAMemHelpers.h
@@ -6,6 +6,7 @@
 #include <cuda_runtime.h>
 #include <cufft.h>
 #include <map>
+#include <mutex>
 #include <stdexcept>
 #include <vector>
 #include "../common/JFJochException.h"
@@ -126,8 +127,8 @@ public:
 // the image loop, so do not hold everything.
 constexpr uint64_t CUDA_MEM_POOL_RELEASE_THRESHOLD = 1ull << 30;
 
-// The stream device allocations are ordered on: one per (thread, device), created on first use and
-// never destroyed.
+// The stream device allocations are ordered on: one per (thread, device), borrowed on first use and
+// handed back when the thread exits. The streams themselves are never destroyed.
 //
 // cudaMalloc and cudaFree are on CUDA's implicit-synchronization list - each one synchronises the
 // device across every stream - so one analysis engine per worker thread, each making a few dozen of
@@ -137,24 +138,70 @@ constexpr uint64_t CUDA_MEM_POOL_RELEASE_THRESHOLD = 1ull << 30;
 // The stream is deliberately not owned by the engine: cudaFreeAsync must be ordered on a stream that
 // is still alive, and an engine's own stream can be destroyed before the buffers it allocated. It is
 // keyed by device because a thread pinned to one GPU must not order work on another's stream.
+//
+// Nor is it owned by the thread, for the same reason: a buffer can outlive the thread that allocated
+// it - the shadow finder builds its accumulator on a throw-away thread and frees it from another,
+// long after - so the thread only borrows the stream. But it does hand it back. The broker starts
+// fresh worker threads for every data collection, and a stream holds about half a megabyte of device
+// memory, so a stream per thread ever started is a leak that a long-running broker does not survive.
+// Handed back, the streams number as many as the threads that were ever alive at once.
+namespace jfjoch_cuda_allocation_streams {
+    struct Idle {
+        std::mutex m;
+        std::map<int, std::vector<CudaStream>> streams;   // by device
+    };
+
+    // Never destroyed: a thread can still be handing a stream back while the process exits, and
+    // destroying streams during static destruction would call into a runtime that may be gone.
+    inline Idle &idle() {
+        static Idle *i = new Idle;
+        return *i;
+    }
+
+    struct Borrowed {
+        std::map<int, CudaStream> streams;   // by device
+        ~Borrowed() {
+            std::lock_guard lock(idle().m);
+            for (auto &[device, stream] : streams)
+                idle().streams[device].push_back(std::move(stream));
+        }
+    };
+}
+
 inline cudaStream_t cuda_allocation_stream() {
     int device = 0;
     if (cudaGetDevice(&device) != cudaSuccess)
         return nullptr;
-    thread_local std::map<int, cudaStream_t> streams;
-    const auto it = streams.find(device);
-    if (it != streams.end())
+    thread_local jfjoch_cuda_allocation_streams::Borrowed borrowed;
+    const auto it = borrowed.streams.find(device);
+    if (it != borrowed.streams.end())
         return it->second;
-    cudaStream_t stream = nullptr;
-    if (cudaStreamCreateWithFlags(&stream, cudaStreamNonBlocking) != cudaSuccess)
+
+    auto &idle = jfjoch_cuda_allocation_streams::idle();
+    {
+        std::lock_guard lock(idle.m);
+        auto &streams = idle.streams[device];
+        if (!streams.empty()) {
+            CudaStream stream = std::move(streams.back());
+            streams.pop_back();
+            return borrowed.streams.emplace(device, std::move(stream)).first->second;
+        }
+    }
+
+    try {
+        CudaStream stream;
+        cudaMemPool_t pool = nullptr;
+        if (cudaDeviceGetDefaultMemPool(&pool, device) == cudaSuccess) {
+            uint64_t threshold = CUDA_MEM_POOL_RELEASE_THRESHOLD;
+            cudaMemPoolSetAttribute(pool, cudaMemPoolAttrReleaseThreshold, &threshold);
+        }
+        return borrowed.streams.emplace(device, std::move(stream)).first->second;
+    } catch (const JFJochException &) {
+        // No stream: the caller allocates synchronously instead, so this is handled - see
+        // CudaDevicePtr for why it must then not stay behind as the thread's last error.
+        cudaGetLastError();
         return nullptr;
-    cudaMemPool_t pool = nullptr;
-    if (cudaDeviceGetDefaultMemPool(&pool, device) == cudaSuccess) {
-        uint64_t threshold = CUDA_MEM_POOL_RELEASE_THRESHOLD;
-        cudaMemPoolSetAttribute(pool, cudaMemPoolAttrReleaseThreshold, &threshold);
     }
-    streams.emplace(device, stream);
-    return stream;
 }
 
 // Which allocator a device buffer uses. Pooled is what every per-worker buffer wants. Synchronous is
@@ -183,14 +230,21 @@ public:
     explicit CudaDevicePtr(size_t count, CudaAlloc alloc = CudaAlloc::Pooled) {
         if (alloc == CudaAlloc::Pooled)
             stream_ = cuda_allocation_stream();
-        if (stream_ && cudaMallocAsync(&ptr_, count * sizeof(T), stream_) == cudaSuccess) {
-            // The allocation is ordered on this stream, so anything that wants to use the memory from
-            // another stream has to be ordered after it. Waiting for it once here is that ordering,
-            // and it leaves the pointer as freely usable as cudaMalloc's would have been.
-            cudaStreamSynchronize(stream_);
-            return;
+        if (stream_) {
+            if (cudaMallocAsync(&ptr_, count * sizeof(T), stream_) == cudaSuccess) {
+                // The allocation is ordered on this stream, so anything that wants to use the memory
+                // from another stream has to be ordered after it. Waiting for it once here is that
+                // ordering, and it leaves the pointer as freely usable as cudaMalloc's would have been.
+                cudaStreamSynchronize(stream_);
+                return;
+            }
+            // The pool failing is handled - by the synchronous allocation below - so it must not stay
+            // behind as the thread's last error. Every kernel launch is followed by cudaGetLastError(),
+            // which would report it there: an "out of memory" thrown over an image whose buffers were
+            // all allocated and whose kernel launched.
+            cudaGetLastError();
+            stream_ = nullptr;
         }
-        stream_ = nullptr;
         if (cudaMalloc(&ptr_, count * sizeof(T)) != cudaSuccess)
             throw JFJochException(JFJochExceptionCategory::GPUCUDAError,
                                   "Failed to allocate device memory");
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 6d748a52b..45510abb0 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -76,6 +76,7 @@ ADD_EXECUTABLE(jfjoch_test
         ImagePreprocessorGPUFusedTest.cpp
         AdaptiveSpotFinderGPUTest.cpp
         SpotExtractorGPUParityTest.cpp
+        CUDAMemHelpersTest.cpp
         CalcBraggPredictionTest.cpp
         SpotUtilsTest.cpp
         LatticeSearchTest.cpp
diff --git a/tests/CUDAMemHelpersTest.cpp b/tests/CUDAMemHelpersTest.cpp
new file mode 100644
index 000000000..e9e00fc7c
--- /dev/null
+++ b/tests/CUDAMemHelpersTest.cpp
@@ -0,0 +1,103 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_all.hpp>
+#include "../common/CUDAWrapper.h"
+
+#ifdef JFJOCH_USE_CUDA
+
+#include <future>
+#include <latch>
+#include <set>
+#include <thread>
+
+#include "../image_analysis/indexing/CUDAMemHelpers.h"
+
+// The broker starts fresh worker threads for every data collection. A stream per thread ever started
+// is a device-memory leak that ends a long-running broker, so threads that follow one another have to
+// end up on the same stream.
+TEST_CASE("CudaAllocationStream_ReusedByLaterThreads", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    std::set<cudaStream_t> seen;
+    for (int i = 0; i < 100; i++)
+        std::thread([&seen] {
+            CudaDevicePtr<uint8_t> buffer(1 << 16);
+            seen.insert(cuda_allocation_stream());
+        }).join();
+
+    CHECK(seen.size() == 1);
+    CHECK(*seen.begin() != nullptr);
+}
+
+TEST_CASE("CudaAllocationStream_DistinctForConcurrentThreads", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    // Neither thread may exit - and hand its stream back - before the other has taken its own.
+    std::latch both_have_one(2);
+    auto take = [&both_have_one] {
+        const cudaStream_t stream = cuda_allocation_stream();
+        both_have_one.count_down();
+        both_have_one.wait();
+        return stream;
+    };
+    auto a = std::async(std::launch::async, take);
+    auto b = std::async(std::launch::async, take);
+    const cudaStream_t stream_a = a.get();
+    const cudaStream_t stream_b = b.get();
+
+    CHECK(stream_a != nullptr);
+    CHECK(stream_b != nullptr);
+    CHECK(stream_a != stream_b);
+}
+
+// The shadow finder builds its GPU accumulator on a throw-away thread and frees it from another one
+// long after. The free is ordered on the allocating thread's stream, so that stream has to outlive
+// the thread - including while a later thread has borrowed it.
+TEST_CASE("CudaDevicePtr_FreedAfterAllocatingThreadExited", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    auto buffer = std::async(std::launch::async, [] {
+        return std::make_unique<CudaDevicePtr<uint8_t>>(1 << 20);
+    }).get();
+    std::thread([] { CudaDevicePtr<uint8_t> other(1 << 16); }).join();
+
+    REQUIRE(cudaMemset(buffer->get(), 0, 1 << 20) == cudaSuccess);
+    buffer.reset();
+    CHECK(cudaDeviceSynchronize() == cudaSuccess);
+    CHECK(cudaGetLastError() == cudaSuccess);
+}
+
+// A pool that cannot serve the request is not an error: the buffer comes from cudaMalloc instead. It
+// must then not stay behind as the thread's last error, or the cudaGetLastError() after the next
+// kernel launch throws "out of memory" over work that went fine.
+TEST_CASE("CudaDevicePtr_HandledPoolFailureLeavesNoError", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    int device = 0;
+    REQUIRE(cudaGetDevice(&device) == cudaSuccess);
+
+    cudaMemPoolProps props{};
+    props.allocType = cudaMemAllocationTypePinned;
+    props.location.type = cudaMemLocationTypeDevice;
+    props.location.id = device;
+    props.maxSize = 4 << 20;
+
+    cudaMemPool_t previous = nullptr, capped = nullptr;
+    REQUIRE(cudaDeviceGetMemPool(&previous, device) == cudaSuccess);
+    REQUIRE(cudaMemPoolCreate(&capped, &props) == cudaSuccess);
+    REQUIRE(cudaDeviceSetMemPool(device, capped) == cudaSuccess);
+    {
+        CudaDevicePtr<uint8_t> buffer(64 << 20);
+        CHECK(buffer.get() != nullptr);
+        CHECK(cudaGetLastError() == cudaSuccess);
+    }
+    REQUIRE(cudaDeviceSetMemPool(device, previous) == cudaSuccess);
+    cudaMemPoolDestroy(capped);
+}
+
+#endif
-- 
2.54.0


From 7dea9eaf9c88d034218302e6aa89eccf7e8816d9 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 16:04:23 +0200
Subject: [PATCH 031/122] One process-wide lock for FFTW planning

FFTW's planner (every fftwf_plan_* and fftwf_destroy_plan) shares global state
and is not thread-safe; executing a plan is. FFTIndexerCPU and BeamCenterFFTCPU
each guarded their planning with a lock of their own, TranslationalNCS and the
viewer's spectrum with none, and ModelFFT with a third - which does not stop
two of them planning at once. common/FFTWPlannerLock.h holds the one mutex they
all now take. No numerical change.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 common/FFTWPlannerLock.h                      | 14 +++++++++++++
 .../geom_refinement/BeamCenterFFTCPU.cpp      | 16 ++++++---------
 image_analysis/indexing/FFTIndexerCPU.cpp     |  6 +++---
 .../scale_merge/TranslationalNCS.cpp          | 15 +++++++++++---
 rugnux/ModelFFT.cpp                           | 10 ++++++----
 viewer/charts/JFJochDatasetInfoChartView.cpp  | 20 +++++++++++++------
 6 files changed, 55 insertions(+), 26 deletions(-)
 create mode 100644 common/FFTWPlannerLock.h

diff --git a/common/FFTWPlannerLock.h b/common/FFTWPlannerLock.h
new file mode 100644
index 000000000..a432b7971
--- /dev/null
+++ b/common/FFTWPlannerLock.h
@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <mutex>
+
+// FFTW's planner - every fftwf_plan_* and fftwf_destroy_plan call - shares global state and is not
+// thread-safe; executing a plan is. So every piece of code that makes or destroys a plan takes this
+// one lock, not a lock of its own: two private locks do not stop two planners running at once.
+inline std::mutex &FFTWPlannerMutex() {
+    static std::mutex m;
+    return m;
+}
diff --git a/image_analysis/geom_refinement/BeamCenterFFTCPU.cpp b/image_analysis/geom_refinement/BeamCenterFFTCPU.cpp
index 6c59f77d6..a9be3f21f 100644
--- a/image_analysis/geom_refinement/BeamCenterFFTCPU.cpp
+++ b/image_analysis/geom_refinement/BeamCenterFFTCPU.cpp
@@ -11,13 +11,9 @@
 
 #include <fftw3.h>
 
-namespace {
+#include "../../common/FFTWPlannerLock.h"
 
-// FFTW planning is not thread-safe (execution is); same idiom as FFTIndexerCPU.
-std::mutex &FftwPlanMutex() {
-    static std::mutex m;
-    return m;
-}
+namespace {
 
 // One real-to-complex 2D FFT workspace of fixed padded size, reused for every forward transform.
 class Rfft2 {
@@ -32,7 +28,7 @@ public:
     Rfft2(int64_t ny_, int64_t nx_) : ny(ny_), nx(nx_), nxc(nx_ / 2 + 1) {
         real.resize(static_cast<size_t>(ny * nx));
         spectrum.resize(static_cast<size_t>(ny * nxc));
-        std::unique_lock lock(FftwPlanMutex());
+        std::unique_lock lock(FFTWPlannerMutex());
         fwd = fftwf_plan_dft_r2c_2d(static_cast<int>(ny), static_cast<int>(nx), real.data(),
                                     reinterpret_cast<fftwf_complex *>(spectrum.data()),
                                     FFTW_ESTIMATE);
@@ -45,7 +41,7 @@ public:
     Rfft2(const Rfft2 &) = delete;
     Rfft2 &operator=(const Rfft2 &) = delete;
     ~Rfft2() {
-        std::unique_lock lock(FftwPlanMutex());
+        std::unique_lock lock(FFTWPlannerMutex());
         if (fwd)
             fftwf_destroy_plan(fwd);
         if (bwd)
@@ -136,7 +132,7 @@ BeamCenterConvSurfaces1D BeamCenterFFTCPU::LineSurfaces(const std::vector<float>
 
     fftwf_plan fwd, bwd;
     {
-        std::unique_lock lock(FftwPlanMutex());
+        std::unique_lock lock(FFTWPlannerMutex());
         fwd = fftwf_plan_dft_r2c_1d(static_cast<int>(nfft), in.data(),
                                     reinterpret_cast<fftwf_complex *>(A.data()), FFTW_ESTIMATE);
         bwd = fftwf_plan_dft_c2r_1d(static_cast<int>(nfft),
@@ -190,7 +186,7 @@ BeamCenterConvSurfaces1D BeamCenterFFTCPU::LineSurfaces(const std::vector<float>
     out.Q = inverse(accQ);
     out.D = inverse(accD);
     {
-        std::unique_lock lock(FftwPlanMutex());
+        std::unique_lock lock(FFTWPlannerMutex());
         fftwf_destroy_plan(fwd);
         fftwf_destroy_plan(bwd);
     }
diff --git a/image_analysis/indexing/FFTIndexerCPU.cpp b/image_analysis/indexing/FFTIndexerCPU.cpp
index 8061b62f5..218c95cef 100644
--- a/image_analysis/indexing/FFTIndexerCPU.cpp
+++ b/image_analysis/indexing/FFTIndexerCPU.cpp
@@ -10,7 +10,7 @@
 #include <mutex>
 #include <vector>
 
-static std::mutex fftw_plan_mutex;
+#include "../../common/FFTWPlannerLock.h"
 
 static inline double dot_abs(const Coord& a, const Coord& b) {
     return std::fabs(a.x * b.x + a.y * b.y + a.z * b.z);
@@ -35,7 +35,7 @@ FFTIndexerCPU::FFTIndexerCPU(const IndexingSettings& settings)
     int n[1] = { H };
 
     {
-        std::unique_lock ul(fftw_plan_mutex);
+        std::unique_lock ul(FFTWPlannerMutex());
         plan = fftwf_plan_many_dft_r2c(
                 1, n, nDirections,
                 h_input_fft.data(), nullptr, 1, H,
@@ -49,7 +49,7 @@ FFTIndexerCPU::FFTIndexerCPU(const IndexingSettings& settings)
 
 
 FFTIndexerCPU::~FFTIndexerCPU() {
-    std::unique_lock ul(fftw_plan_mutex);
+    std::unique_lock ul(FFTWPlannerMutex());
     fftwf_destroy_plan(plan);
 }
 
diff --git a/image_analysis/scale_merge/TranslationalNCS.cpp b/image_analysis/scale_merge/TranslationalNCS.cpp
index 5fa3b1a96..7b5a91e07 100644
--- a/image_analysis/scale_merge/TranslationalNCS.cpp
+++ b/image_analysis/scale_merge/TranslationalNCS.cpp
@@ -15,6 +15,8 @@
 
 #include <fftw3.h>
 
+#include "../../common/FFTWPlannerLock.h"
+
 namespace {
     // The Patterson is measured in a band, not over the whole dataset: below ~20 A the bulk solvent
     // and the beam stop dominate, above ~5 A the map answers a question about atoms rather than about
@@ -231,8 +233,12 @@ TranslationalNCSResult AnalyzeTranslationalNCS(const std::vector<MergedReflectio
         result.refusal = "could not allocate the Patterson grid";
         return result;
     }
-    fftwf_plan plan = fftwf_plan_dft_c2r_3d(nx, ny, nz, reinterpret_cast<fftwf_complex *>(coeff), map,
-                                            FFTW_ESTIMATE);
+    fftwf_plan plan;
+    {
+        std::lock_guard lock(FFTWPlannerMutex());
+        plan = fftwf_plan_dft_c2r_3d(nx, ny, nz, reinterpret_cast<fftwf_complex *>(coeff), map,
+                                     FFTW_ESTIMATE);
+    }
 
     // The near-origin exclusion, as a set of grid points rather than a per-point distance test: only
     // the points inside a 15 A ball around each origin-equivalent point can be excluded, and there
@@ -368,7 +374,10 @@ TranslationalNCSResult AnalyzeTranslationalNCS(const std::vector<MergedReflectio
         }
     }
 
-    fftwf_destroy_plan(plan);
+    {
+        std::lock_guard lock(FFTWPlannerMutex());
+        fftwf_destroy_plan(plan);
+    }
     fftwf_free(coeff);
     fftwf_free(map);
     result.measurable = true;
diff --git a/rugnux/ModelFFT.cpp b/rugnux/ModelFFT.cpp
index 73daab1fc..304ec673a 100644
--- a/rugnux/ModelFFT.cpp
+++ b/rugnux/ModelFFT.cpp
@@ -13,15 +13,17 @@
 
 #include "gemmi/fail.hpp"
 
+#include "../common/FFTWPlannerLock.h"
+
 namespace {
 
 // The r2c plan for an (nu, nv, nw) map stored u fastest, halving w - the layout gemmi's own transform
-// reads and writes. FFTW's planner is not thread-safe, so plans are made under a lock; executing one
-// on new arrays (fftwf_execute_dft_r2c) is, which is how every caller uses it.
+// reads and writes. FFTW's planner is not thread-safe, so plans are made under the process-wide planner
+// lock (which also guards this cache); executing one on new arrays (fftwf_execute_dft_r2c) is, which is
+// how every caller uses it.
 fftwf_plan PlanFor(int nu, int nv, int nw) {
-    static std::mutex m;
     static std::map<std::array<int, 3>, fftwf_plan> plans;
-    std::lock_guard lock(m);
+    std::lock_guard lock(FFTWPlannerMutex());
     const std::array<int, 3> key{nu, nv, nw};
     if (const auto it = plans.find(key); it != plans.end())
         return it->second;
diff --git a/viewer/charts/JFJochDatasetInfoChartView.cpp b/viewer/charts/JFJochDatasetInfoChartView.cpp
index 068699d7d..abdfe4305 100644
--- a/viewer/charts/JFJochDatasetInfoChartView.cpp
+++ b/viewer/charts/JFJochDatasetInfoChartView.cpp
@@ -11,6 +11,7 @@
 #include <cmath>
 
 #include "JFJochDatasetInfoChartView.h"
+#include "../../common/FFTWPlannerLock.h"
 
 namespace {
     // Qt Charts draws its curves 2 px wide, which is hard to follow across a desk. Take the weight
@@ -965,18 +966,25 @@ void JFJochDatasetInfoChartView::buildFFTChart() {
 
     std::vector<fftwf_complex> out(static_cast<size_t>(nComplex));
 
-    fftwf_plan plan = fftwf_plan_dft_r2c_1d(
-            n,
-            in.data(),
-            out.data(),
-            FFTW_ESTIMATE);
+    fftwf_plan plan;
+    {
+        std::lock_guard lock(FFTWPlannerMutex());
+        plan = fftwf_plan_dft_r2c_1d(
+                n,
+                in.data(),
+                out.data(),
+                FFTW_ESTIMATE);
+    }
 
     if (!plan) {
         return;
     }
 
     fftwf_execute(plan);
-    fftwf_destroy_plan(plan);
+    {
+        std::lock_guard lock(FFTWPlannerMutex());
+        fftwf_destroy_plan(plan);
+    }
 
     // Compute amplitude spectrum and frequencies (0 .. Nyquist)
     m_fftMagnitudes.resize(static_cast<size_t>(nComplex));
-- 
2.54.0


From 53715d010de045f9f75c959a0b2124996268988a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:47:53 +0200
Subject: [PATCH 032/122] rugnux: overall SigAno and CCanom over the written
 range only

The per-shell SigAno and CCanom of the rotation merge were accumulated on the
report grid, but the overall pair of numbers - the SIGANO / CC_ANOM keys and
the mmCIF's pdbx_absDiff_over_sigma_anomalous - were summed over every Bijvoet
pair the fulls hold, including the ones past the automatic resolution cut that
the written reflections do not contain. On a run the cut trims, the overall
line therefore described more data than the shells above it add up to. Both
overall numbers now count only the pairs that land in a shell, as the rest of
the table does; a run with a manual limit, whose ingest already ends at the
limit, is unchanged.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 .../scale_merge/RotationScaleMerge.cpp          | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 13690baa6..8d4f2da49 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -4294,23 +4294,24 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             if (swp > 0.0) { ex.Ip = static_cast<float>(swIp / swp); ex.sIp = static_cast<float>(1.0 / std::sqrt(swp)); }
             if (swm > 0.0) { ex.Im = static_cast<float>(swIm / swm); ex.sIm = static_cast<float>(1.0 / std::sqrt(swm)); }
             if (std::isfinite(ex.Ip) || std::isfinite(ex.Im)) anom_export[fkey] = ex;
-            if (swp > 0.0 && swm > 0.0 && a.d > 0.0f) {
+            // A pair outside the grid is outside the table, its overall line included: the fulls
+            // hold every pair that was ingested, and the ones past the written range are not the
+            // data these numbers describe.
+            const auto shell = shells.GetShell(a.d);
+            if (!shell || *shell < 0 || *shell >= n_shells) continue;
+            if (swp > 0.0 && swm > 0.0) {
                 const double abs_di = std::fabs(swIp / swp - swIm / swm);
                 const double sig_di = std::sqrt(1.0 / swp + 1.0 / swm);
-                const auto shell = shells.GetShell(a.d);
-                if (shell && *shell >= 0 && *shell < n_shells) { sig_num[*shell] += abs_di; sig_den[*shell] += sig_di; }
+                sig_num[*shell] += abs_di; sig_den[*shell] += sig_di;
                 sig_num_all += abs_di; sig_den_all += sig_di; ++sig_n;
             }
             // CCanom: the anomalous difference measured twice, once per half, correlated over the
             // pairs where all four cells were filled - which needs both mates measured at least
             // twice, so it asks more of the data than SigAno does.
-            if (a.sw[0][0] > 0.0 && a.sw[0][1] > 0.0 && a.sw[1][0] > 0.0 && a.sw[1][1] > 0.0
-                && a.d > 0.0f) {
+            if (a.sw[0][0] > 0.0 && a.sw[0][1] > 0.0 && a.sw[1][0] > 0.0 && a.sw[1][1] > 0.0) {
                 const double d_first  = a.swI[0][0] / a.sw[0][0] - a.swI[1][0] / a.sw[1][0];
                 const double d_second = a.swI[0][1] / a.sw[0][1] - a.swI[1][1] / a.sw[1][1];
-                const auto shell = shells.GetShell(a.d);
-                if (shell && *shell >= 0 && *shell < n_shells)
-                    cc_anom_shell[*shell].Add(d_first, d_second);
+                cc_anom_shell[*shell].Add(d_first, d_second);
                 cc_anom_overall.Add(d_first, d_second);
                 ++cc_anom_n;
             }
-- 
2.54.0


From 440e19343c81dc65b60f904277fab6b9fcc71749 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 16:08:23 +0200
Subject: [PATCH 033/122] rugnux --model: MapToFPhi returns the conjugate, as
 gemmi's transform does

gemmi::transform_map_to_f_phi conjugates the forward FFT at the end (a
structure factor is the sum over exp(+2 pi i h.x), a forward FFT the sum over
exp(-2 pi i h.x)); MapToFPhi did not, so every model-path Fcalc and Fmask came
out with its phase negated. Amplitudes, and so the R-factors and the scale,
were unaffected; the phases of the maps and everything read off them (map
coefficients, density at atom centres) were not. Caught by
ModelValidation_MapToFPhiMatchesGemmi, which now passes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelFFT.cpp | 4 +++-
 rugnux/ModelFFT.h   | 4 ++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/rugnux/ModelFFT.cpp b/rugnux/ModelFFT.cpp
index 304ec673a..03ce9c69c 100644
--- a/rugnux/ModelFFT.cpp
+++ b/rugnux/ModelFFT.cpp
@@ -67,8 +67,10 @@ gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map) {
     }
     std::copy(map.data.begin(), map.data.end(), in);
     fftwf_execute_dft_r2c(plan, in, out);
+    // Conjugated, as gemmi does: FFTW's forward transform carries exp(-2 pi i h.x), and a structure
+    // factor is the sum over exp(+2 pi i h.x).
     for (size_t i = 0; i < hkl.data.size(); ++i)
-        hkl.data[i] = std::complex<float>(out[i][0], out[i][1]) * norm;
+        hkl.data[i] = std::complex<float>(out[i][0] * norm, -out[i][1] * norm);
     fftwf_free(in);
     fftwf_free(out);
     return hkl;
diff --git a/rugnux/ModelFFT.h b/rugnux/ModelFFT.h
index b98778bd2..fd807d1de 100644
--- a/rugnux/ModelFFT.h
+++ b/rugnux/ModelFFT.h
@@ -7,8 +7,8 @@
 #include "gemmi/recgrid.hpp"
 
 // The structure factors of a real-space map on the model path (Fcalc from the model density, Fmask
-// from the bulk-solvent mask): what gemmi::transform_map_to_f_phi(map, true) returns - the forward
-// transform scaled by V/N, kept for l >= 0 on an (nu, nv, nw/2+1) grid in the map's own XYZ order,
+// from the bulk-solvent mask): what gemmi::transform_map_to_f_phi(map, true) returns - the
+// conjugated forward transform (F = sum rho exp(+2 pi i h.x)) scaled by V/N, kept for l >= 0 on an (nu, nv, nw/2+1) grid in the map's own XYZ order,
 // ready for prepare_asu_data() - computed with FFTW rather than gemmi's single-threaded pocketfft.
 // The same transform, not the same bits: the two libraries order their arithmetic differently.
 //
-- 
2.54.0


From 7547df77de5ab3b1cb9c318716a4aa6d95c3c524 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 10:56:26 +0200
Subject: [PATCH 034/122] rugnux: --report-resolution, a second statistics
 table at a reference range

Comparing a run with another program's table has meant running rugnux AT that
program's resolution range (--scaling-high-resolution), which is a different
run: the range moves the cut, the space-group decision and everything after
them, so the comparison buys itself a different answer. --report-resolution
<dmin>[,<dmax>] instead leaves the run alone and adds a second table to
section 3 of the report - the REFRES_* keys and a shell table - binned from the
same merged reflections over the range given, with the completeness
denominator enumerated over that range and the shells in equal steps of 1/d^2
so they read row for row against a CORRECT.LP at the same range. Report-only:
the merged files and every decision are byte-identical with and without it.

The table holds only what the run kept. Where the reference range is finer
than the run's own limit, the shells past it are printed as not merged (with
their possible count) rather than as zeros, REFRES_SHELLS_PAST_LIMIT counts
them so a consumer can tell "not merged" from a measured zero, REFRES_
COMPLETENESS counts their reflections as missing, and the other overall numbers
are over the shells the run reached; nothing is read from the observations the
run judged to carry no signal. REFRES_ISA is the error model refitted on the
reflections of the table alone, in XDS's convention (rotation only; the stills
model is fitted over the whole range already).

On the rotation path the statistics block of MergeAndStats becomes a lambda
over a shell grid, called once for the run's own grid and once for the
reference one; the reference call floors every observation-level count at the
cut by group d, the rule the erase applied. The stills MergeStats takes a
declared range, whose bounds are the grid's whether or not any reflection
reaches them. Both --mode mx and --mode scale report it, the viewer's command
line echoes it, and the docs describe the keys.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 common/ScalingSettings.cpp                    |  12 +
 common/ScalingSettings.h                      |  13 +
 docs/RUGNUX_ADVANCED.md                       |   1 +
 docs/RUGNUX_REPORT.md                         |  31 +
 image_analysis/scale_merge/Merge.cpp          |  40 +-
 image_analysis/scale_merge/Merge.h            |  10 +-
 .../scale_merge/RotationScaleMerge.cpp        | 555 ++++++++++--------
 .../scale_merge/RotationScaleMerge.h          |   9 +
 rugnux/ResultReport.cpp                       |  88 +++
 rugnux/Rugnux.cpp                             |  13 +-
 rugnux/Rugnux.h                               |   9 +
 rugnux/RugnuxCommandLine.cpp                  |   5 +
 rugnux/rugnux_cli.cpp                         |  46 ++
 tests/MergeScaleTest.cpp                      |  41 ++
 tests/ResultReportTest.cpp                    |  55 ++
 15 files changed, 661 insertions(+), 267 deletions(-)

diff --git a/common/ScalingSettings.cpp b/common/ScalingSettings.cpp
index 773ed9fa6..2016afba5 100644
--- a/common/ScalingSettings.cpp
+++ b/common/ScalingSettings.cpp
@@ -303,3 +303,15 @@ ScalingSettings &ScalingSettings::ReportShellCount(int input) {
 int ScalingSettings::GetReportShellCount() const {
     return report_shell_count;
 }
+
+ScalingSettings& ScalingSettings::ReportResolutionRange_A(std::optional<ReportResolutionRange> input) {
+    if (input && !(input->d_min > 0.0 && input->d_max > input->d_min))
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Report resolution range must be positive and d_max coarser than d_min");
+    report_resolution_range = input;
+    return *this;
+}
+
+std::optional<ReportResolutionRange> ScalingSettings::GetReportResolutionRange_A() const {
+    return report_resolution_range;
+}
diff --git a/common/ScalingSettings.h b/common/ScalingSettings.h
index ac25888c9..1d2e5a9bb 100644
--- a/common/ScalingSettings.h
+++ b/common/ScalingSettings.h
@@ -11,6 +11,12 @@
 // CCHalfLogistic = fit the CC1/2 fall-off and cut one shell past cc_target (DIALS-style, generous).
 enum class ResolutionCutoffMethod { Off, CCHalfLogistic };
 
+// A resolution range in A, d_max coarse and d_min fine; d_max may be infinite (no low-resolution bound).
+struct ReportResolutionRange {
+    double d_min = 0.0;
+    double d_max = 0.0;
+};
+
 class ScalingSettings {
     bool refine_wedge = false;
 
@@ -109,6 +115,11 @@ class ScalingSettings {
     double resolution_cc_target = 0.30;   // CC1/2 value defining the fall-off limit before the +1 shell
     int report_shell_count = 9;           // resolution shells in the reported statistics table (XDS's count,
                                           // over the same equal-1/d^2 bins, so the two tables read row for row)
+    // A second statistics table over this REFERENCE range (--report-resolution), binned from the same
+    // scaled and merged observations as the run's own table and reported beside it, so a run can be
+    // read against another program's numbers at that program's range. Report-only: the cut, the
+    // scaling, the error model and every decision are the run's own whether or not it is set.
+    std::optional<ReportResolutionRange> report_resolution_range;
 
 public:
     ScalingSettings& RefineRotationWedge(bool input);
@@ -139,6 +150,7 @@ public:
     ScalingSettings& ResolutionCutoff(ResolutionCutoffMethod input);
     ScalingSettings& ResolutionCCTarget(double input);
     ScalingSettings& ReportShellCount(int input);
+    ScalingSettings& ReportResolutionRange_A(std::optional<ReportResolutionRange> input);
 
     [[nodiscard]] bool GetRefineWedge() const;
 
@@ -177,4 +189,5 @@ public:
     [[nodiscard]] ResolutionCutoffMethod GetResolutionCutoff() const;
     [[nodiscard]] double GetResolutionCCTarget() const;
     [[nodiscard]] int GetReportShellCount() const;
+    [[nodiscard]] std::optional<ReportResolutionRange> GetReportResolutionRange_A() const;
 };
diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 6a8a885ed..7984cfd5e 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -323,6 +323,7 @@ Scaling and merging:
 | `--resolution-cutoff <txt>` | Automatic high-resolution cutoff for the written reflections and reported shells: `cc-logistic` \| `off` (default: `cc-logistic`; ignored when `--scaling-high-resolution` is set) |
 | `--resolution-cc-target <num>` | CC1/2 target defining the `cc-logistic` fall-off (default: 0.30) |
 | `--resolution-shells <num>` | Number of resolution shells in the reported statistics table (default: 9). The bins are equal steps in 1/d² between the lowest- and highest-resolution reflection merged, which is XDS's rule, and 9 is XDS's count — so at the same resolution limits the two tables have the same shells and can be read row for row |
+| `--report-resolution <dmin>[,<dmax>]` | Also report the merging statistics over this resolution range, Å (either order; `dmax` defaults to the run's own low-resolution limit), as a second table beside the run's own — the `REFRES_*` keys of the [results report](RUGNUX_REPORT.md#the-reference-range-table) — binned from the same merged reflections, so a run can be read against another program's table at that program's range. Report-only: the cut, the scaling, the error model and every decision stay the run's own, and shells finer than the run's own limit are reported as not merged rather than filled from data the run did not keep |
 | `--min-partiality <num>` | Minimum partiality to accept a reflection (default: 0.02) |
 | `--ice-min-score <num>` | Ice-presence gate: the measured per-run ice score (1 = no ice) a dataset must reach before **any** ice handling is applied — the flagging and the exclusion from scaling (default: 1.5; 0 = no gate). The fixed hexagonal bands cover 16–26 % of the unique reflections whether or not the crystal has ice, so handling ice on a clean crystal only costs completeness |
 | `--ice-min-spot-ratio <num>` | The second ice-presence channel: found **spots** on the hexagonal rings over the same q width of ice-free flanks beside them (1 = spots spread evenly). Ice in large crystallites diffracts as discrete spots and leaves the radial profile flat, so `--ice-min-score` alone is blind to it (default: 2.0; 0 disables this channel) |
diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index b7ed36671..264bf1cb9 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -148,6 +148,37 @@ and a run that produced a textbook data set read identically for their first thr
 Then the numbered sections: **1. DATA SET AND GEOMETRY**, **2. CRYSTAL**,
 **3. MERGED DATA**, **4. DIAGNOSTICS**, and **5. MODEL VALIDATION** only with `--model`.
 
+## The reference-range table
+
+`--report-resolution <dmin>[,<dmax>]` adds a second block of merging statistics to section 3, the
+`REFRES_*` keys and a second shell table, over the resolution range it is given rather than the range
+the run chose. It exists for comparison: another program's table is at that program's range, and
+running rugnux *at* that range (`--scaling-high-resolution`) is not the same run — the cut moves, and
+with it the symmetry decision and everything downstream of it. The reference table is instead the
+same merged reflections binned again, so nothing is processed differently whether or not it is
+asked for; the merged files and every decision are byte-for-byte the run's own.
+
+- **`REFRES_RANGE=`** is the requested range (`dmax dmin`, as `INCLUDE_RESOLUTION_RANGE`; `INF` when
+  the run has no low-resolution limit and none was given). **`REFRES_MEASURED_RANGE=`** is the
+  coarsest and finest merged reflection that actually landed in it.
+- **`REFRES_COMPLETENESS=`**, **`REFRES_MULTIPLICITY=`**, **`REFRES_I_OVER_SIGMA=`**,
+  **`REFRES_R_MEAS=`**, **`REFRES_CC_HALF=`**, **`REFRES_SIGANO=`**, **`REFRES_CC_ANOM=`**,
+  **`REFRES_UNIQUE_REFLECTIONS=`** and **`REFRES_TOTAL_OBSERVATIONS=`** are the overall numbers over
+  that range, under the same absent-when-unmeasured rule as their section-3 namesakes.
+  **`REFRES_ISA=`** is the error model refitted on the reflections of this table alone, in XDS's
+  convention, so it reads against an `ISa` produced at that range; the table itself is merged under
+  the run's own model.
+- **The table holds only what the run kept.** Where the reference range is finer than the run's own
+  limit, the shells past that limit are empty by the run's decision — it judged them to carry no
+  signal and did not merge them — and are printed as `past the run's own limit of X A: not merged
+  (N possible)` rather than as zeros; the shell the limit falls inside is marked. **`REFRES_SHELLS_PAST_LIMIT=`**
+  counts those shells (0 when the range lies within the run's own), so a consumer can tell *not
+  merged* from a measured zero. `REFRES_COMPLETENESS` counts their reflections as missing; every
+  other overall number is over the shells the run reached.
+
+The shells are equal steps in 1/d² between the two bounds, as XDS's are, so at XDS's
+`INCLUDE_RESOLUTION_RANGE` the two tables read row for row.
+
 ## The developer report
 
 `--developer` renders the same report in full. The default report carries what a person deciding
diff --git a/image_analysis/scale_merge/Merge.cpp b/image_analysis/scale_merge/Merge.cpp
index 2aeebdb20..ce7b87f2e 100644
--- a/image_analysis/scale_merge/Merge.cpp
+++ b/image_analysis/scale_merge/Merge.cpp
@@ -512,13 +512,19 @@ void CalcPossibleReflections(const gemmi::SpaceGroup &sg,
 MergeStatistics MergeOnTheFly::MergeStats(const std::vector<MergedReflection> &merged,
                            const std::vector<IntegrationOutcome > &integration_outcome,
                            const std::vector<MergedReflection> &reference,
-                           std::optional<double> d_min_override) {
+                           std::optional<double> d_min_override,
+                           std::optional<ReportResolutionRange> declared_range) {
 
     const int n_shells = scaling_settings.GetReportShellCount();
 
     auto d_min_limit_A = d_min_override.has_value()
         ? d_min_override : scaling_settings.GetHighResolutionLimit_A();
-    const auto d_max_limit_A = scaling_settings.GetLowResolutionLimit_A();
+    auto d_max_limit_A = scaling_settings.GetLowResolutionLimit_A();
+    if (declared_range) {
+        d_min_limit_A = declared_range->d_min;
+        d_max_limit_A = std::isfinite(declared_range->d_max)
+            ? std::optional<double>(declared_range->d_max) : std::nullopt;
+    }
 
     std::unordered_map<uint64_t, float> reference_intensities;
     if (!reference.empty()) {
@@ -547,7 +553,8 @@ MergeStatistics MergeOnTheFly::MergeStats(const std::vector<MergedReflection> &m
         d_max = std::max(d_max, m.d);
     }
 
-    if (!(d_min < d_max && d_min > 0.0f))
+    // A declared range is a grid whether or not anything landed in it.
+    if (!(d_min < d_max && d_min > 0.0f) && !declared_range)
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
             "MergeStats: Error in resolution calculation");
 
@@ -560,7 +567,8 @@ MergeStatistics MergeOnTheFly::MergeStats(const std::vector<MergedReflection> &m
     // infinite d_max is how that is spelled. The high end stays the finest d reached anywhere -
     // that is the resolution the run reports, and the full sphere down to it already shows
     // anisotropic loss.
-    const float d_min_pad = d_min * 0.999f;   // GetShell rejects d <= d_min; the finest reflection needs the room
+    const float d_min_pad = declared_range ? static_cast<float>(declared_range->d_min)
+                                           : d_min * 0.999f;   // GetShell rejects d <= d_min; the finest reflection needs the room
     const float d_max_declared = d_max_limit_A ? static_cast<float>(*d_max_limit_A)
                                                : std::numeric_limits<float>::infinity();
     // The innermost shell is labelled by the bound it reaches, except when that bound is infinite
@@ -696,7 +704,7 @@ MergeStatistics MergeOnTheFly::MergeStats(const std::vector<MergedReflection> &m
     }
 
     auto &overall = out.overall;
-    overall.d_min = d_min;
+    overall.d_min = d_min < d_max ? d_min : 0.0f;   // 0: nothing landed in a declared range
     overall.d_max = d_max;
 
     int all_possible = 0;
@@ -792,14 +800,21 @@ std::ostream &operator<<(std::ostream &output, const MergeStatisticsShell &in) {
     return output;
 }
 
+std::string ShellTableHeader() {
+    return fmt::format("  {:>8s} {:>8s} {:>8s} {:>8s} {:>8s} {:>7s} {:>8s} {:>8s} {:>8s} {:>8s} {:>8s} {:>8s}",
+        "d_min", "N_obs", "N_uniq", "N_possib", "Compl", "Mult", "<I/sig>", "R_meas", "CC1/2", "CCref",
+        "CCanom", "SigAno");
+}
+
+std::string ShellTableRule() {
+    return fmt::format("  {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->7s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s}",
+        "", "", "", "", "", "", "", "", "", "", "", "");
+}
+
 std::ostream &operator<<(std::ostream &output, const MergeStatistics &in) {
     output << std::endl;
-    output << fmt::format("  {:>8s} {:>8s} {:>8s} {:>8s} {:>8s} {:>7s} {:>8s} {:>8s} {:>8s} {:>8s} {:>8s} {:>8s}",
-        "d_min", "N_obs", "N_uniq", "N_possib", "Compl", "Mult", "<I/sig>", "R_meas", "CC1/2", "CCref",
-        "CCanom", "SigAno")
-    << std::endl;
-    output << fmt::format("  {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->7s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s}",
-        "", "", "", "", "", "", "", "", "", "", "", "") << std::endl;
+    output << ShellTableHeader() << std::endl;
+    output << ShellTableRule() << std::endl;
     for (const auto &sh: in.shells) {
         if (sh.unique_reflections == 0)
             continue;
@@ -807,8 +822,7 @@ std::ostream &operator<<(std::ostream &output, const MergeStatistics &in) {
         output << sh;
         output << std::endl;
     }
-    output << fmt::format("  {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->7s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s} {:->8s}",
-        "", "", "", "", "", "", "", "", "", "", "", "") << std::endl;
+    output << ShellTableRule() << std::endl;
 
     output << fmt::format("  {:>8s} ", "Overall");
     output << in.overall;
diff --git a/image_analysis/scale_merge/Merge.h b/image_analysis/scale_merge/Merge.h
index 32144fad0..025dfe7cb 100644
--- a/image_analysis/scale_merge/Merge.h
+++ b/image_analysis/scale_merge/Merge.h
@@ -165,6 +165,10 @@ struct MergeStatistics {
 
 std::ostream &operator<<(std::ostream &output, const MergeStatisticsShell &in);
 std::ostream &operator<<(std::ostream &output, const MergeStatistics &in);
+// The header and the rule of the table operator<< prints, for a table with the same columns rendered
+// elsewhere (the report's reference-range table).
+std::string ShellTableHeader();
+std::string ShellTableRule();
 
 struct MergeAccum {
     int32_t h = 0;
@@ -283,10 +287,14 @@ public:
     // d_min_override, when set, is the effective high-resolution limit for the shell table (used for
     // the automatic resolution cutoff computed by the caller); otherwise the manual
     // ScalingSettings high-resolution limit stands. The number of shells is ScalingSettings::ReportShellCount.
+    // declared_range: bin over exactly this range instead - its bounds are the shell grid's and the
+    // completeness denominator's whether or not any reflection reaches them, and the limits above
+    // are ignored. The reference-range table of --report-resolution.
     MergeStatistics MergeStats(const std::vector<MergedReflection> &merged,
                                const std::vector<IntegrationOutcome> &reflections,
                                const std::vector<MergedReflection> &reference = {},
-                               std::optional<double> d_min_override = std::nullopt);
+                               std::optional<double> d_min_override = std::nullopt,
+                               std::optional<ReportResolutionRange> declared_range = std::nullopt);
 
     std::vector<MergedReflection> ExportReflections();
 };
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 8d4f2da49..b95fac06b 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -250,6 +250,7 @@ RotationScaleMerge::RotationScaleMerge(const DiffractionExperiment &experiment,
     resolution_cutoff_method = s.GetResolutionCutoff();
     resolution_cc_target = s.GetResolutionCCTarget();
     report_shell_count = s.GetReportShellCount();
+    report_range = s.GetReportResolutionRange_A();
     if (const auto forced = s.GetForcedMosaicity(); forced.has_value())
         mosaicity_deg = *forced;
     else
@@ -4080,8 +4081,274 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
 
     if (reject_count > 0)
         logger.Info("Merge outlier rejection: dropped {} observations", reject_count);
-    // ---- Statistics (report_shell_count shells): completeness, multiplicity, <I/sigma>, R_meas, CC1/2. ----
+    // ---- Statistics (report_shell_count shells): completeness, multiplicity, <I/sigma>, R_meas, CC1/2,
+    //      SigAno and CCanom, over a shell grid. A lambda because the same merged reflections are
+    //      binned a second time, over the reference range, when --report-resolution asked for that
+    //      table (see the end of this function). The grid runs from grid_d_min (exclusive) to
+    //      grid_d_max, and the completeness denominator is enumerated over exactly that. The fulls
+    //      hold every group that was ingested, cut or not, so a grid reaching past the cut needs
+    //      d_floor - the cut, as the erase above applied it, by group d - to keep the observations
+    //      of the groups the run did not keep out of every count; the run's own grid ends at the
+    //      finest kept reflection and needs none. ----
     const int n_shells = report_shell_count;
+    struct AnomExport { float Ip = NAN, sIp = NAN, Im = NAN, sIm = NAN; };
+    std::unordered_map<uint64_t, AnomExport> anom_export;   // filled by the run's own table only
+    auto statistics_over = [&](const std::vector<MergedReflection> &merged, float grid_d_min,
+                               float grid_d_max, float d_max_label, float d_floor,
+                               bool own_table) -> MergeStatistics {
+        ResolutionShells shells(grid_d_min, grid_d_max, n_shells);
+        const auto shell_mean_1_d2 = shells.GetShellMeanOneOverResSq();
+        const auto shell_min_res = shells.GetShellMinRes();
+
+        struct ShellAcc {
+            int unique = 0, total_obs = 0, possible = 0;
+            double sum_i_over_sigma = 0.0; int n_i_over_sigma = 0;
+            CorrelationCoefficient cc_half;
+        };
+        std::vector<ShellAcc> sa(n_shells);
+        std::vector<int> possible(n_shells, 0);
+        // Completeness is a reported quantity: it is read off the merge a pass writes out, never off the
+        // ones the space-group search runs on the way there. Those are also the expensive ones to count -
+        // the search merges in P1, where the list of possible reflections is the whole hemisphere rather
+        // than an asymmetric unit of it - so enumerating it there is the largest single piece of work in
+        // the merge that nothing goes on to read.
+        if (reference_cell && !for_search)
+            PossiblePerShell(x.GetSpaceGroupOrP1(), *reference_cell, grid_d_min, grid_d_max,
+                             shells, merge_friedel, possible, nthreads);
+        for (int s = 0; s < n_shells; ++s) sa[s].possible = possible[s];
+
+        CorrelationCoefficient cc_half_overall;
+        for (const auto &m : merged) {
+            const auto shell = shells.GetShell(m.d);
+            if (!shell || *shell < 0 || *shell >= n_shells) continue;
+            if (std::isfinite(m.I) && std::isfinite(m.sigma) && m.sigma > 0.0) {
+                auto &s = sa[*shell];
+                s.unique++;
+                s.sum_i_over_sigma += m.I / m.sigma; s.n_i_over_sigma++;
+                if (std::isfinite(m.I_half[0]) && std::isfinite(m.I_half[1])) {
+                    s.cc_half.Add(m.I_half[0], m.I_half[1]);
+                    cc_half_overall.Add(m.I_half[0], m.I_half[1]);
+                }
+            }
+        }
+
+        std::vector<double> rmeas_num(n_shells, 0.0), rmeas_den(n_shells, 0.0);
+        double rmeas_num_all = 0.0, rmeas_den_all = 0.0;
+        // R_meas and the observation counts behind the reported multiplicity. Report-only, and the last
+        // full pass over the observations there is - so, like the correction surfaces, it is not made on a
+        // merge whose numbers nobody reads.
+        if (full_stats) {
+            // R_meas: re-walk the fulls (Mask = cell only; no ice / error-model), accumulate
+            // |I_i - <I>| per reflection.
+            struct RmeasObs { double sum_abs_dev = 0, sum_I = 0; int n = 0, shell = -1; };
+            std::vector<RmeasObs> rmeas(n_groups);
+            bool did_gpu_rmeas = false;
+#ifdef JFJOCH_USE_CUDA
+            if (use_gpu_merge) {
+                // Per-group R_meas + usable count on the GPU; the shell is assigned per group (its fulls share d).
+                std::vector<double> rabsdev(n_groups), rsumI(n_groups);
+                std::vector<int32_t> rn(n_groups), rnusable(n_groups);
+                gpu_->MergeRmeas(merged_I.data(), rabsdev.data(), rsumI.data(), rn.data(), rnusable.data());
+                for (int g = 0; g < n_groups; ++g) {
+                    if (rnusable[g] == 0 || acc[g].d < d_floor) continue;
+                    const auto shell = shells.GetShell(acc[g].d);
+                    if (!shell || *shell < 0 || *shell >= n_shells) continue;
+                    // Count the MERGED population, not the R_meas one. The R_meas re-walk deliberately
+                    // ignores the ice flag on a search pass, so its count includes observations that never
+                    // entered `unique` - which inflates the reported multiplicity of whatever shell they
+                    // land in. acc[g].nh is what actually went into this group's mean, and it is zero for a
+                    // group the merge dropped entirely. (acc[g].d is NaN for such a group, so GetShell above
+                    // already declines it; this is the same statement made where it counts.)
+                    sa[*shell].total_obs += static_cast<int>(acc[g].nh[0] + acc[g].nh[1]);
+                    if (std::isfinite(merged_I[g]) && rn[g] > 0) {
+                        auto &r = rmeas[g];
+                        r.sum_abs_dev = rabsdev[g]; r.sum_I = rsumI[g]; r.n = rn[g]; r.shell = *shell;
+                    }
+                }
+                did_gpu_rmeas = true;
+            }
+#endif
+            if (!did_gpu_rmeas)
+                for (const auto &o : fulls) {
+                    if (o.group < 0 || acc[o.group].d < d_floor) continue;
+                    if (rejected_obs[&o - fulls.data()]) continue;   // outlier-rejected in the merge -> also out of R_meas
+                    if (!frame_cell_ok[o.frame]) continue;
+                    if (!(o.corr > 0.0f) || !std::isfinite(o.corr)) continue;
+                    if (o.partiality < min_partiality) continue;
+                    const float I_corr = o.I * o.corr, sigma_corr = o.sigma * o.corr;
+                    if (!std::isfinite(I_corr) || !std::isfinite(sigma_corr) || sigma_corr <= 0.0f) continue;
+                    const auto shell = shells.GetShell(o.d);
+                    if (!shell || *shell < 0 || *shell >= n_shells) continue;
+                    // Only what the merge kept counts towards multiplicity - see the GPU branch above. The
+                    // R_meas accumulation below keeps its own, wider filter.
+                    if (usable_merge(o))
+                        sa[*shell].total_obs++;
+                    if (std::isfinite(merged_I[o.group])) {
+                        auto &r = rmeas[o.group];
+                        r.sum_abs_dev += std::fabs(static_cast<double>(I_corr) - merged_I[o.group]);
+                        r.sum_I += I_corr; r.n++; r.shell = *shell;
+                    }
+                }
+            for (const auto &r : rmeas) {
+                if (r.n < 2 || r.shell < 0 || r.shell >= n_shells) continue;
+                const double factor = std::sqrt(static_cast<double>(r.n) / (r.n - 1));
+                rmeas_num[r.shell] += factor * r.sum_abs_dev; rmeas_den[r.shell] += r.sum_I;
+                rmeas_num_all += factor * r.sum_abs_dev; rmeas_den_all += r.sum_I;
+            }
+        }
+
+        // ---- Anomalous split (always, even when the merge is Friedel-averaged): for each acentric
+        // reflection, the inverse-variance I(+)/I(-) from the SAME scaled fulls (so it never touches the
+        // Friedel-merged IMEAN, scaling or error model above). Lets I(+)/I(-) and F(+)/F(-) be written by
+        // default without scaling anomalously; a reflection with only one mate, or a centric, is left
+        // without the split. Skipped for the P1 search pass, which has no use for it, and for a merge that
+        // is not written. ----
+        // SigAno = <|I(+)-I(-)|>/<sigma(I(+)-I(-))> accumulated on the standard report shells (num=sum|dI|,
+        // den=sum sigma(dI)); mmCIF pdbx_absDiff_over_sigma_anomalous. NaN'd below when there is no split.
+        std::vector<double> sig_num(n_shells, 0.0), sig_den(n_shells, 0.0);
+        double sig_num_all = 0.0, sig_den_all = 0.0;
+        size_t sig_n = 0;
+        // CCanom on the same shells, and over the whole range as one correlation (not a mean of shells).
+        std::vector<CorrelationCoefficient> cc_anom_shell(n_shells);
+        CorrelationCoefficient cc_anom_overall;
+        size_t cc_anom_n = 0;
+        if (!for_search && full_stats) {
+            const HKLKeyGenerator anom_keygen(/*merge_friedel=*/false, x.GetSpaceGroupOrP1());
+            const gemmi::GroupOps gops = x.GetSpaceGroupOrP1().operations();
+            // [hand][half]: hand 0 = I(+), 1 = I(-). The half sets are what CCanom needs - the anomalous
+            // difference formed twice, once from each half of the observations - and their sums add back
+            // to the whole-mate I(+)/I(-) that SigAno and the export read, so there is one accumulation.
+            struct AnomAcc {
+                double swI[2][2] = {}; double sw[2][2] = {}; int32_t nh[2][2] = {};
+                int32_t h = 0, k = 0, l = 0; float d = NAN;
+            };
+            // The Friedel-merged key an observation lands on, and which hand it is, are properties of its
+            // ASU GROUP, not of the observation - group_h/k/l is that group's SIGNED representative, so the
+            // same reduction applied to it returns both. Reduce once per group (a few hundred thousand)
+            // instead of once per observation (millions), and index a dense accumulator from there, which
+            // is the rule ComputeAsuGroups states for itself. The hand only follows the group when the
+            // merge distinguishes the hands; a Friedel-merged run holds both in one group and must ask.
+            std::vector<int32_t> pair_of_group(n_groups, -1);
+            std::vector<uint8_t> hand_of_group(merge_friedel ? 0 : n_groups, 0);
+            std::vector<HKLKey> pair_hkl;
+            {
+                std::unordered_map<uint64_t, int32_t> pair_id;
+                pair_id.reserve(static_cast<size_t>(n_groups) + 1);
+                for (int g = 0; g < n_groups; ++g) {
+                    const HKLKey gk = anom_keygen(group_h[g], group_k[g], group_l[g]);
+                    if (!merge_friedel) hand_of_group[g] = gk.plus ? 0 : 1;
+                    const uint64_t key = HKLKey{gk.h, gk.k, gk.l, true}.pack();
+                    const auto [it, fresh] = pair_id.emplace(key, static_cast<int32_t>(pair_hkl.size()));
+                    if (fresh) pair_hkl.push_back(HKLKey{gk.h, gk.k, gk.l, true});
+                    pair_of_group[g] = it->second;
+                }
+            }
+            std::vector<AnomAcc> anom(pair_hkl.size());
+            // The half-sets CCanom needs are balanced within the MATE, not merely within the reflection:
+            // it correlates one half's I(+)-I(-) against the other's, so each hand separately needs both
+            // of its halves filled, and a mate left entirely in one half loses the whole pair rather than
+            // half of it. So the cell here is (pair, hand), where the merge above used the reflection.
+            std::vector<int32_t> anom_cell(fulls.size(), -1);
+            for (size_t i = 0; i < fulls.size(); ++i) {
+                const Obs &o = fulls[i];
+                if (!usable_merge(o) || rejected_obs[i]) continue;   // as the merge saw it
+                if (acc[o.group].d < d_floor) continue;
+                const int hand = merge_friedel ? (anom_keygen(o.h, o.k, o.l).plus ? 0 : 1)
+                                               : hand_of_group[o.group];
+                anom_cell[i] = pair_of_group[o.group] * 2 + hand;
+            }
+            std::vector<uint8_t> anom_half;
+            AssignHalvesByRank(obs_key, anom_cell, static_cast<int>(pair_hkl.size()) * 2, anom_half, nthreads);
+            for (size_t i = 0; i < fulls.size(); ++i) {
+                const int cell = anom_cell[i];
+                if (cell < 0) continue;
+                const Obs &o = fulls[i];
+                const float I_corr = o.I * o.corr;
+                const float sigma_corr = corrected_sigma(o, I_corr, o.sigma * o.corr);
+                if (!(sigma_corr > 0.0f) || !std::isfinite(sigma_corr)) continue;
+                const double w = 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
+                AnomAcc &a = anom[cell >> 1];
+                a.d = o.d;
+                a.swI[cell & 1][anom_half[i]] += w * static_cast<double>(I_corr);
+                a.sw[cell & 1][anom_half[i]] += w;
+                a.nh[cell & 1][anom_half[i]]++;
+            }
+            for (size_t p = 0; p < anom.size(); ++p) {
+                AnomAcc a = anom[p];
+                a.h = pair_hkl[p].h; a.k = pair_hkl[p].k; a.l = pair_hkl[p].l;
+                const uint64_t fkey = pair_hkl[p].pack();
+                // Centrics have I(+)=I(-) by symmetry; leave them without an anomalous split.
+                if (gops.is_reflection_centric(gemmi::Op::Miller{a.h, a.k, a.l})) continue;
+                // Whole-mate sums: the two halves put back together. I(+)/I(-) and SigAno are read off
+                // these, so splitting the accumulation above changed neither.
+                const double swp = a.sw[0][0] + a.sw[0][1], swm = a.sw[1][0] + a.sw[1][1];
+                const double swIp = a.swI[0][0] + a.swI[0][1], swIm = a.swI[1][0] + a.swI[1][1];
+                AnomExport ex;
+                if (swp > 0.0) { ex.Ip = static_cast<float>(swIp / swp); ex.sIp = static_cast<float>(1.0 / std::sqrt(swp)); }
+                if (swm > 0.0) { ex.Im = static_cast<float>(swIm / swm); ex.sIm = static_cast<float>(1.0 / std::sqrt(swm)); }
+                if (own_table && (std::isfinite(ex.Ip) || std::isfinite(ex.Im))) anom_export[fkey] = ex;
+                // A pair outside the grid is outside the table, its overall line included: the fulls
+                // hold every pair that was ingested, and the ones past the written range are not
+                // the data these numbers describe.
+                const auto shell = shells.GetShell(a.d);
+                if (!shell || *shell < 0 || *shell >= n_shells) continue;
+                if (swp > 0.0 && swm > 0.0) {
+                    const double abs_di = std::fabs(swIp / swp - swIm / swm);
+                    const double sig_di = std::sqrt(1.0 / swp + 1.0 / swm);
+                    sig_num[*shell] += abs_di; sig_den[*shell] += sig_di;
+                    sig_num_all += abs_di; sig_den_all += sig_di; ++sig_n;
+                }
+                // CCanom: the anomalous difference measured twice, once per half, correlated over the
+                // pairs where all four cells were filled - which needs both mates measured at least
+                // twice, so it asks more of the data than SigAno does.
+                if (a.sw[0][0] > 0.0 && a.sw[0][1] > 0.0 && a.sw[1][0] > 0.0 && a.sw[1][1] > 0.0) {
+                    const double d_first  = a.swI[0][0] / a.sw[0][0] - a.swI[1][0] / a.sw[1][0];
+                    const double d_second = a.swI[0][1] / a.sw[0][1] - a.swI[1][1] / a.sw[1][1];
+                    cc_anom_shell[*shell].Add(d_first, d_second);
+                    cc_anom_overall.Add(d_first, d_second);
+                    ++cc_anom_n;
+                }
+            }
+        }
+
+        MergeStatistics out;
+        out.shells.resize(n_shells);
+        for (int s = 0; s < n_shells; ++s) {
+            auto &ss = out.shells[s];
+            ss.mean_one_over_d2 = shell_mean_1_d2[s];
+            ss.d_min = shell_min_res[s];
+            ss.d_max = s == 0 ? d_max_label : shell_min_res[s - 1];
+            ss.total_observations = sa[s].total_obs;
+            ss.unique_reflections = sa[s].unique;
+            ss.possible_unique_reflections = sa[s].possible;
+            ss.mean_i_over_sigma = sa[s].n_i_over_sigma > 0 ? sa[s].sum_i_over_sigma / sa[s].n_i_over_sigma : 0.0;
+            ss.cc_half = sa[s].cc_half.GetCC();
+            ss.cc_ref = NAN;
+            ss.r_meas = rmeas_den[s] > 0.0 ? rmeas_num[s] / rmeas_den[s] : NAN;
+            ss.abs_diff_over_sigma_anomalous = sig_den[s] > 0.0 ? sig_num[s] / sig_den[s] : NAN;
+            ss.cc_anom = cc_anom_shell[s].GetCC();
+        }
+        auto &overall = out.overall;
+        double sum_ios = 0.0; int n_ios = 0;
+        for (int s = 0; s < n_shells; ++s) {
+            overall.total_observations += sa[s].total_obs;
+            overall.unique_reflections += sa[s].unique;
+            overall.possible_unique_reflections += sa[s].possible;
+            sum_ios += sa[s].sum_i_over_sigma; n_ios += sa[s].n_i_over_sigma;
+        }
+        overall.mean_i_over_sigma = n_ios > 0 ? sum_ios / n_ios : 0.0;
+        overall.cc_half = cc_half_overall.GetCC();
+        overall.cc_ref = NAN;
+        overall.r_meas = rmeas_den_all > 0.0 ? rmeas_num_all / rmeas_den_all : NAN;
+        overall.abs_diff_over_sigma_anomalous = sig_den_all > 0.0 ? sig_num_all / sig_den_all : NAN;
+        overall.cc_anom = cc_anom_overall.GetCC();
+        if (own_table && std::isfinite(overall.abs_diff_over_sigma_anomalous))
+            logger.Info("Anomalous signal SigAno = {:.2f} ({} acentric pairs), CCanom = {:.3f} ({} pairs "
+                        "split in both hands)",
+                        overall.abs_diff_over_sigma_anomalous, sig_n, overall.cc_anom, cc_anom_n);
+        return out;
+    };
+
     float sd_min = std::numeric_limits<float>::max(), sd_max = 0.0f;
     for (const auto &m : result.merged) {
         if (!std::isfinite(m.d) || m.d <= 0.0f) continue;
@@ -4102,258 +4369,9 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     // The innermost shell is labelled by the bound it reaches, except when that bound is infinite
     // and the coarsest reflection measured is the only finite thing to say.
     const float d_max_label = std::isfinite(d_max_declared) ? d_max_declared : sd_max;
-    ResolutionShells shells(d_min_pad, d_max_declared, n_shells);
-    const auto shell_mean_1_d2 = shells.GetShellMeanOneOverResSq();
-    const auto shell_min_res = shells.GetShellMinRes();
-
-    struct ShellAcc {
-        int unique = 0, total_obs = 0, possible = 0;
-        double sum_i_over_sigma = 0.0; int n_i_over_sigma = 0;
-        CorrelationCoefficient cc_half;
-    };
-    std::vector<ShellAcc> sa(n_shells);
-    std::vector<int> possible(n_shells, 0);
-    // Completeness is a reported quantity: it is read off the merge a pass writes out, never off the
-    // ones the space-group search runs on the way there. Those are also the expensive ones to count -
-    // the search merges in P1, where the list of possible reflections is the whole hemisphere rather
-    // than an asymmetric unit of it - so enumerating it there is the largest single piece of work in
-    // the merge that nothing goes on to read.
-    if (reference_cell && !for_search)
-        PossiblePerShell(x.GetSpaceGroupOrP1(), *reference_cell, d_min_pad, d_max_declared,
-                         shells, merge_friedel, possible, nthreads);
-    for (int s = 0; s < n_shells; ++s) sa[s].possible = possible[s];
-
-    CorrelationCoefficient cc_half_overall;
-    for (const auto &m : result.merged) {
-        const auto shell = shells.GetShell(m.d);
-        if (!shell || *shell < 0 || *shell >= n_shells) continue;
-        if (std::isfinite(m.I) && std::isfinite(m.sigma) && m.sigma > 0.0) {
-            auto &s = sa[*shell];
-            s.unique++;
-            s.sum_i_over_sigma += m.I / m.sigma; s.n_i_over_sigma++;
-            if (std::isfinite(m.I_half[0]) && std::isfinite(m.I_half[1])) {
-                s.cc_half.Add(m.I_half[0], m.I_half[1]);
-                cc_half_overall.Add(m.I_half[0], m.I_half[1]);
-            }
-        }
-    }
-
-    std::vector<double> rmeas_num(n_shells, 0.0), rmeas_den(n_shells, 0.0);
-    double rmeas_num_all = 0.0, rmeas_den_all = 0.0;
-    // R_meas and the observation counts behind the reported multiplicity. Report-only, and the last
-    // full pass over the observations there is - so, like the correction surfaces, it is not made on a
-    // merge whose numbers nobody reads.
-    if (full_stats) {
-        // R_meas: re-walk the fulls (Mask = cell only; no ice / error-model), accumulate
-        // |I_i - <I>| per reflection.
-        struct RmeasObs { double sum_abs_dev = 0, sum_I = 0; int n = 0, shell = -1; };
-        std::vector<RmeasObs> rmeas(n_groups);
-        bool did_gpu_rmeas = false;
-#ifdef JFJOCH_USE_CUDA
-        if (use_gpu_merge) {
-            // Per-group R_meas + usable count on the GPU; the shell is assigned per group (its fulls share d).
-            std::vector<double> rabsdev(n_groups), rsumI(n_groups);
-            std::vector<int32_t> rn(n_groups), rnusable(n_groups);
-            gpu_->MergeRmeas(merged_I.data(), rabsdev.data(), rsumI.data(), rn.data(), rnusable.data());
-            for (int g = 0; g < n_groups; ++g) {
-                if (rnusable[g] == 0) continue;
-                const auto shell = shells.GetShell(acc[g].d);
-                if (!shell || *shell < 0 || *shell >= n_shells) continue;
-                // Count the MERGED population, not the R_meas one. The R_meas re-walk deliberately
-                // ignores the ice flag on a search pass, so its count includes observations that never
-                // entered `unique` - which inflates the reported multiplicity of whatever shell they
-                // land in. acc[g].nh is what actually went into this group's mean, and it is zero for a
-                // group the merge dropped entirely. (acc[g].d is NaN for such a group, so GetShell above
-                // already declines it; this is the same statement made where it counts.)
-                sa[*shell].total_obs += static_cast<int>(acc[g].nh[0] + acc[g].nh[1]);
-                if (std::isfinite(merged_I[g]) && rn[g] > 0) {
-                    auto &r = rmeas[g];
-                    r.sum_abs_dev = rabsdev[g]; r.sum_I = rsumI[g]; r.n = rn[g]; r.shell = *shell;
-                }
-            }
-            did_gpu_rmeas = true;
-        }
-#endif
-        if (!did_gpu_rmeas)
-            for (const auto &o : fulls) {
-                if (o.group < 0) continue;
-                if (rejected_obs[&o - fulls.data()]) continue;   // outlier-rejected in the merge -> also out of R_meas
-                if (!frame_cell_ok[o.frame]) continue;
-                if (!(o.corr > 0.0f) || !std::isfinite(o.corr)) continue;
-                if (o.partiality < min_partiality) continue;
-                const float I_corr = o.I * o.corr, sigma_corr = o.sigma * o.corr;
-                if (!std::isfinite(I_corr) || !std::isfinite(sigma_corr) || sigma_corr <= 0.0f) continue;
-                const auto shell = shells.GetShell(o.d);
-                if (!shell || *shell < 0 || *shell >= n_shells) continue;
-                // Only what the merge kept counts towards multiplicity - see the GPU branch above. The
-                // R_meas accumulation below keeps its own, wider filter.
-                if (usable_merge(o))
-                    sa[*shell].total_obs++;
-                if (std::isfinite(merged_I[o.group])) {
-                    auto &r = rmeas[o.group];
-                    r.sum_abs_dev += std::fabs(static_cast<double>(I_corr) - merged_I[o.group]);
-                    r.sum_I += I_corr; r.n++; r.shell = *shell;
-                }
-            }
-        for (const auto &r : rmeas) {
-            if (r.n < 2 || r.shell < 0 || r.shell >= n_shells) continue;
-            const double factor = std::sqrt(static_cast<double>(r.n) / (r.n - 1));
-            rmeas_num[r.shell] += factor * r.sum_abs_dev; rmeas_den[r.shell] += r.sum_I;
-            rmeas_num_all += factor * r.sum_abs_dev; rmeas_den_all += r.sum_I;
-        }
-    }
-
-    // ---- Anomalous split (always, even when the merge is Friedel-averaged): for each acentric
-    // reflection, the inverse-variance I(+)/I(-) from the SAME scaled fulls (so it never touches the
-    // Friedel-merged IMEAN, scaling or error model above). Lets I(+)/I(-) and F(+)/F(-) be written by
-    // default without scaling anomalously; a reflection with only one mate, or a centric, is left
-    // without the split. Skipped for the P1 search pass, which has no use for it, and for a merge that
-    // is not written. ----
-    struct AnomExport { float Ip = NAN, sIp = NAN, Im = NAN, sIm = NAN; };
-    std::unordered_map<uint64_t, AnomExport> anom_export;
-    // SigAno = <|I(+)-I(-)|>/<sigma(I(+)-I(-))> accumulated on the standard report shells (num=sum|dI|,
-    // den=sum sigma(dI)); mmCIF pdbx_absDiff_over_sigma_anomalous. NaN'd below when there is no split.
-    std::vector<double> sig_num(n_shells, 0.0), sig_den(n_shells, 0.0);
-    double sig_num_all = 0.0, sig_den_all = 0.0;
-    size_t sig_n = 0;
-    // CCanom on the same shells, and over the whole range as one correlation (not a mean of shells).
-    std::vector<CorrelationCoefficient> cc_anom_shell(n_shells);
-    CorrelationCoefficient cc_anom_overall;
-    size_t cc_anom_n = 0;
-    if (!for_search && full_stats) {
-        const HKLKeyGenerator anom_keygen(/*merge_friedel=*/false, x.GetSpaceGroupOrP1());
-        const gemmi::GroupOps gops = x.GetSpaceGroupOrP1().operations();
-        // [hand][half]: hand 0 = I(+), 1 = I(-). The half sets are what CCanom needs - the anomalous
-        // difference formed twice, once from each half of the observations - and their sums add back
-        // to the whole-mate I(+)/I(-) that SigAno and the export read, so there is one accumulation.
-        struct AnomAcc {
-            double swI[2][2] = {}; double sw[2][2] = {}; int32_t nh[2][2] = {};
-            int32_t h = 0, k = 0, l = 0; float d = NAN;
-        };
-        // The Friedel-merged key an observation lands on, and which hand it is, are properties of its
-        // ASU GROUP, not of the observation - group_h/k/l is that group's SIGNED representative, so the
-        // same reduction applied to it returns both. Reduce once per group (a few hundred thousand)
-        // instead of once per observation (millions), and index a dense accumulator from there, which
-        // is the rule ComputeAsuGroups states for itself. The hand only follows the group when the
-        // merge distinguishes the hands; a Friedel-merged run holds both in one group and must ask.
-        std::vector<int32_t> pair_of_group(n_groups, -1);
-        std::vector<uint8_t> hand_of_group(merge_friedel ? 0 : n_groups, 0);
-        std::vector<HKLKey> pair_hkl;
-        {
-            std::unordered_map<uint64_t, int32_t> pair_id;
-            pair_id.reserve(static_cast<size_t>(n_groups) + 1);
-            for (int g = 0; g < n_groups; ++g) {
-                const HKLKey gk = anom_keygen(group_h[g], group_k[g], group_l[g]);
-                if (!merge_friedel) hand_of_group[g] = gk.plus ? 0 : 1;
-                const uint64_t key = HKLKey{gk.h, gk.k, gk.l, true}.pack();
-                const auto [it, fresh] = pair_id.emplace(key, static_cast<int32_t>(pair_hkl.size()));
-                if (fresh) pair_hkl.push_back(HKLKey{gk.h, gk.k, gk.l, true});
-                pair_of_group[g] = it->second;
-            }
-        }
-        std::vector<AnomAcc> anom(pair_hkl.size());
-        // The half-sets CCanom needs are balanced within the MATE, not merely within the reflection:
-        // it correlates one half's I(+)-I(-) against the other's, so each hand separately needs both
-        // of its halves filled, and a mate left entirely in one half loses the whole pair rather than
-        // half of it. So the cell here is (pair, hand), where the merge above used the reflection.
-        std::vector<int32_t> anom_cell(fulls.size(), -1);
-        for (size_t i = 0; i < fulls.size(); ++i) {
-            const Obs &o = fulls[i];
-            if (!usable_merge(o) || rejected_obs[i]) continue;   // as the merge saw it
-            const int hand = merge_friedel ? (anom_keygen(o.h, o.k, o.l).plus ? 0 : 1)
-                                           : hand_of_group[o.group];
-            anom_cell[i] = pair_of_group[o.group] * 2 + hand;
-        }
-        std::vector<uint8_t> anom_half;
-        AssignHalvesByRank(obs_key, anom_cell, static_cast<int>(pair_hkl.size()) * 2, anom_half, nthreads);
-        for (size_t i = 0; i < fulls.size(); ++i) {
-            const int cell = anom_cell[i];
-            if (cell < 0) continue;
-            const Obs &o = fulls[i];
-            const float I_corr = o.I * o.corr;
-            const float sigma_corr = corrected_sigma(o, I_corr, o.sigma * o.corr);
-            if (!(sigma_corr > 0.0f) || !std::isfinite(sigma_corr)) continue;
-            const double w = 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
-            AnomAcc &a = anom[cell >> 1];
-            a.d = o.d;
-            a.swI[cell & 1][anom_half[i]] += w * static_cast<double>(I_corr);
-            a.sw[cell & 1][anom_half[i]] += w;
-            a.nh[cell & 1][anom_half[i]]++;
-        }
-        for (size_t p = 0; p < anom.size(); ++p) {
-            AnomAcc a = anom[p];
-            a.h = pair_hkl[p].h; a.k = pair_hkl[p].k; a.l = pair_hkl[p].l;
-            const uint64_t fkey = pair_hkl[p].pack();
-            // Centrics have I(+)=I(-) by symmetry; leave them without an anomalous split.
-            if (gops.is_reflection_centric(gemmi::Op::Miller{a.h, a.k, a.l})) continue;
-            // Whole-mate sums: the two halves put back together. I(+)/I(-) and SigAno are read off
-            // these, so splitting the accumulation above changed neither.
-            const double swp = a.sw[0][0] + a.sw[0][1], swm = a.sw[1][0] + a.sw[1][1];
-            const double swIp = a.swI[0][0] + a.swI[0][1], swIm = a.swI[1][0] + a.swI[1][1];
-            AnomExport ex;
-            if (swp > 0.0) { ex.Ip = static_cast<float>(swIp / swp); ex.sIp = static_cast<float>(1.0 / std::sqrt(swp)); }
-            if (swm > 0.0) { ex.Im = static_cast<float>(swIm / swm); ex.sIm = static_cast<float>(1.0 / std::sqrt(swm)); }
-            if (std::isfinite(ex.Ip) || std::isfinite(ex.Im)) anom_export[fkey] = ex;
-            // A pair outside the grid is outside the table, its overall line included: the fulls
-            // hold every pair that was ingested, and the ones past the written range are not the
-            // data these numbers describe.
-            const auto shell = shells.GetShell(a.d);
-            if (!shell || *shell < 0 || *shell >= n_shells) continue;
-            if (swp > 0.0 && swm > 0.0) {
-                const double abs_di = std::fabs(swIp / swp - swIm / swm);
-                const double sig_di = std::sqrt(1.0 / swp + 1.0 / swm);
-                sig_num[*shell] += abs_di; sig_den[*shell] += sig_di;
-                sig_num_all += abs_di; sig_den_all += sig_di; ++sig_n;
-            }
-            // CCanom: the anomalous difference measured twice, once per half, correlated over the
-            // pairs where all four cells were filled - which needs both mates measured at least
-            // twice, so it asks more of the data than SigAno does.
-            if (a.sw[0][0] > 0.0 && a.sw[0][1] > 0.0 && a.sw[1][0] > 0.0 && a.sw[1][1] > 0.0) {
-                const double d_first  = a.swI[0][0] / a.sw[0][0] - a.swI[1][0] / a.sw[1][0];
-                const double d_second = a.swI[0][1] / a.sw[0][1] - a.swI[1][1] / a.sw[1][1];
-                cc_anom_shell[*shell].Add(d_first, d_second);
-                cc_anom_overall.Add(d_first, d_second);
-                ++cc_anom_n;
-            }
-        }
-    }
-
+    result.statistics = statistics_over(result.merged, d_min_pad, d_max_declared, d_max_label, 0.0f, true);
     MergeStatistics &out = result.statistics;
-    out.shells.resize(n_shells);
-    for (int s = 0; s < n_shells; ++s) {
-        auto &ss = out.shells[s];
-        ss.mean_one_over_d2 = shell_mean_1_d2[s];
-        ss.d_min = shell_min_res[s];
-        ss.d_max = s == 0 ? d_max_label : shell_min_res[s - 1];
-        ss.total_observations = sa[s].total_obs;
-        ss.unique_reflections = sa[s].unique;
-        ss.possible_unique_reflections = sa[s].possible;
-        ss.mean_i_over_sigma = sa[s].n_i_over_sigma > 0 ? sa[s].sum_i_over_sigma / sa[s].n_i_over_sigma : 0.0;
-        ss.cc_half = sa[s].cc_half.GetCC();
-        ss.cc_ref = NAN;
-        ss.r_meas = rmeas_den[s] > 0.0 ? rmeas_num[s] / rmeas_den[s] : NAN;
-        ss.abs_diff_over_sigma_anomalous = sig_den[s] > 0.0 ? sig_num[s] / sig_den[s] : NAN;
-        ss.cc_anom = cc_anom_shell[s].GetCC();
-    }
-    auto &overall = out.overall;
-    overall.d_min = sd_min; overall.d_max = sd_max;
-    double sum_ios = 0.0; int n_ios = 0;
-    for (int s = 0; s < n_shells; ++s) {
-        overall.total_observations += sa[s].total_obs;
-        overall.unique_reflections += sa[s].unique;
-        overall.possible_unique_reflections += sa[s].possible;
-        sum_ios += sa[s].sum_i_over_sigma; n_ios += sa[s].n_i_over_sigma;
-    }
-    overall.mean_i_over_sigma = n_ios > 0 ? sum_ios / n_ios : 0.0;
-    overall.cc_half = cc_half_overall.GetCC();
-    overall.cc_ref = NAN;
-    overall.r_meas = rmeas_den_all > 0.0 ? rmeas_num_all / rmeas_den_all : NAN;
-    overall.abs_diff_over_sigma_anomalous = sig_den_all > 0.0 ? sig_num_all / sig_den_all : NAN;
-    overall.cc_anom = cc_anom_overall.GetCC();
-    if (std::isfinite(overall.abs_diff_over_sigma_anomalous))
-        logger.Info("Anomalous signal SigAno = {:.2f} ({} acentric pairs), CCanom = {:.3f} ({} pairs "
-                    "split in both hands)",
-                    overall.abs_diff_over_sigma_anomalous, sig_n, overall.cc_anom, cc_anom_n);
+    out.overall.d_min = sd_min; out.overall.d_max = sd_max;
 
     // Radiation-damage monitor (measured before any correction by MeasureRadiationDamageB): carry the
     // first->last relative-B change and the per-batch curve into the reported statistics / mmCIF.
@@ -4363,6 +4381,39 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     out.radiation_damage_batch_deg = rad_damage_batch_deg;
     out.sweep_quality = sweep_quality;
 
+    // The reference-range table (--report-resolution): the reflections the run KEPT, binned over the
+    // reference range instead of the run's own. Nothing past the run's own cut is merged into it -
+    // the run decided those reflections are not signal, and a table that read them anyway would
+    // describe data the run's output does not contain - so where the reference range is finer than
+    // the cut its outer shells are empty and the overall numbers are over what was kept. The ISa is
+    // the error model refitted on the samples of exactly that table, in XDS's convention, so it can
+    // be read against a program that was run at that range; report-only, and fitted last because
+    // nothing after it reads the model.
+    if (report_range && full_stats && !for_search) {
+        const float d_lo = static_cast<float>(report_range->d_min);
+        const float d_hi = static_cast<float>(report_range->d_max);
+        float in_min = std::numeric_limits<float>::max(), in_max = 0.0f;
+        for (const auto &m : result.merged) {
+            if (!std::isfinite(m.d) || m.d <= d_lo || m.d > d_hi) continue;
+            in_min = std::min(in_min, m.d); in_max = std::max(in_max, m.d);
+        }
+        MergeStatistics ref = statistics_over(result.merged, d_lo, d_hi, std::isfinite(d_hi) ? d_hi : in_max,
+                                              static_cast<float>(effective_d_min.value_or(0.0)), false);
+        ref.overall.d_min = in_min < in_max ? in_min : 0.0f;
+        ref.overall.d_max = in_max;
+        result.reference_statistics = std::move(ref);
+
+        std::vector<Sample> pool;
+        pool.reserve(samples.size());
+        for (const auto &s : samples)
+            if (s.d > d_lo && s.d <= d_hi && !(effective_d_min && s.d < *effective_d_min))
+                pool.push_back(s);
+        error_model_active = false;   // a pool too small to fit leaves no model, not the run's own
+        fit_error_model(pool);
+        if (error_model_active)
+            result.reference_isa = ToXdsErrorModel(error_model_a, error_model_b).isa;
+    }
+
     // Attach the per-reflection anomalous split so the writer can emit I(+)/I(-) by default (each merged
     // reflection maps to its Friedel-ASU key; in an anomalous merge both mates map to the same key).
     if (!anom_export.empty()) {
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index f7cdccf40..24a1fed00 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -62,6 +62,14 @@ public:
         // Where the automatic CC1/2 fit says the data reach, without the deliberate one-shell
         // extension the reflections are written to. Empty when no automatic cut ran.
         std::optional<double> resolution_fit_A;
+        // The merged reflections the run kept, binned over the reference range of
+        // ScalingSettings::ReportResolutionRange_A (--report-resolution) instead of the run's own,
+        // and the error model refitted on the observations of that table alone, for its ISa. Nothing
+        // past the run's own cut is in it: those shells are empty, and the overall numbers are over
+        // what the run kept. Absent when no range was given, on a search merge, and on a merge whose
+        // numbers are not written.
+        std::optional<MergeStatistics> reference_statistics;
+        double reference_isa = 0.0;
     };
 
     // experiment: read live (its space group is changed by the caller between Run() calls).
@@ -205,6 +213,7 @@ private:
     ResolutionCutoffMethod resolution_cutoff_method = ResolutionCutoffMethod::Off;
     double resolution_cc_target = 0.30;
     int report_shell_count = 9;
+    std::optional<ReportResolutionRange> report_range;   // the second, reference-range table
 
     // Flat buffers, allocated once by Ingest() and reused across Run() calls. Exactly one of the
     // two observation arrays is built: the narrow resident record when the device pipeline is
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index af0fddec6..f3d6b25e4 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -181,6 +181,29 @@ namespace {
         return out;
     }
 
+    // The reference-range table of --report-resolution, with the columns of the run's own. A shell
+    // finer than the run's own limit holds nothing BY THE RUN'S DECISION, and says so in words rather
+    // than as a row of zeros, so a reader cannot take it for a measured total failure.
+    std::string ReferenceShellTable(const MergeStatistics &rs, double own_d_min) {
+        std::ostringstream o;
+        o << "\n" << ShellTableHeader() << "\n" << ShellTableRule() << "\n";
+        for (const auto &sh : rs.shells) {
+            if (sh.unique_reflections == 0) {
+                if (sh.d_max <= own_d_min)
+                    o << fmt::format("  {:8.2f}  past the run's own limit of {:.2f} A: not merged ({} possible)\n",
+                                     sh.d_min, own_d_min, sh.possible_unique_reflections);
+                continue;
+            }
+            o << fmt::format("  {:8.2f} ", sh.d_min) << sh;
+            if (sh.d_min < own_d_min)
+                o << fmt::format("  <- the run's own limit, {:.2f} A, is inside this shell", own_d_min);
+            o << "\n";
+        }
+        o << ShellTableRule() << "\n";
+        o << fmt::format("  {:>8s} ", "Overall") << rs.overall << "\n";
+        return o.str();
+    }
+
     // The finest shell whose CC1/2 still reaches the cut's own target. A fitted resolution finer than
     // this was read off a curve that never behaved like a fall-off, and asserting it states a
     // resolution the shell table on the same page refutes.
@@ -705,6 +728,71 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                 Add(s, Prose(shells.str()));
             }
 
+            // The reference-range table (--report-resolution): the same kept reflections binned over
+            // a range given from outside, so the run can be read against another program's table at
+            // that program's range without having been RUN at it - which moves the cut, the symmetry
+            // decision and everything after them. Nothing past the run's own limit is in it: those
+            // shells are empty by the run's decision, REFRES_COMPLETENESS counts their reflections as
+            // missing, and REFRES_SHELLS_PAST_LIMIT says how many there are, so a consumer can tell
+            // "not merged" from a measured zero.
+            if (result.reference_merge_statistics) {
+                const auto &rs = *result.reference_merge_statistics;
+                const auto &ro = rs.overall;
+                const auto range = experiment.GetScalingSettings().GetReportResolutionRange_A();
+                const double d_max_req = range ? range->d_max : rs.shells.front().d_max;
+                const double d_min_req = range ? range->d_min : rs.shells.back().d_min;
+                int past = 0;
+                for (const auto &sh : rs.shells)
+                    if (sh.d_max <= o.d_min)
+                        ++past;
+                Add(s, Blank());
+                Add(s, KeyText("REFRES_RANGE", fmt::format(
+                        "{} {:.3f}", std::isfinite(d_max_req) ? fmt::format("{:.3f}", d_max_req) : "INF",
+                        d_min_req)));
+                if (ro.d_min > 0.0f)
+                    Add(s, KeyText("REFRES_MEASURED_RANGE", fmt::format("{:.3f} {:.3f}", ro.d_max, ro.d_min)));
+                Add(s, KeyInt("REFRES_SHELLS_PAST_LIMIT", past));
+                Add(s, KeyInt("REFRES_UNIQUE_REFLECTIONS", ro.unique_reflections));
+                Add(s, KeyInt("REFRES_TOTAL_OBSERVATIONS", ro.total_observations));
+                if (ro.possible_unique_reflections > 0)
+                    Add(s, KeyReal("REFRES_COMPLETENESS",
+                                   100.0 * ro.unique_reflections / ro.possible_unique_reflections, "{:.1f}"));
+                if (ro.unique_reflections > 0) {
+                    Add(s, KeyReal("REFRES_MULTIPLICITY",
+                                   static_cast<double>(ro.total_observations) / ro.unique_reflections, "{:.2f}"));
+                    Add(s, KeyReal("REFRES_I_OVER_SIGMA", ro.mean_i_over_sigma, "{:.2f}"));
+                }
+                if (std::isfinite(ro.r_meas))
+                    Add(s, KeyReal("REFRES_R_MEAS", ro.r_meas, "{:.4f}"));
+                if (std::isfinite(ro.cc_half))
+                    Add(s, KeyReal("REFRES_CC_HALF", ro.cc_half, "{:.4f}"));
+                if (std::isfinite(ro.abs_diff_over_sigma_anomalous))
+                    Add(s, KeyReal("REFRES_SIGANO", ro.abs_diff_over_sigma_anomalous, "{:.3f}"));
+                if (std::isfinite(ro.cc_anom))
+                    Add(s, KeyReal("REFRES_CC_ANOM", ro.cc_anom, "{:.4f}"));
+                if (result.reference_isa > 0.0)
+                    Add(s, KeyReal("REFRES_ISA", result.reference_isa, "{:.2f}"));
+                Add(s, Blank());
+                Add(s, Prose(fmt::format(
+                        " REFRES_* is the same merged data binned over REFRES_RANGE, the reference range given\n"
+                        " with --report-resolution, so it can be read against another program's table at that\n"
+                        " program's range; nothing was processed differently for it. It holds only what the run\n"
+                        " kept: {}{}",
+                        past > 0
+                            ? fmt::format("the run's own limit is {:.2f} A (INCLUDE_RESOLUTION_RANGE), the {} shell{}\n"
+                                          " finer than it hold{} nothing because the run judged them to carry no signal and did\n"
+                                          " not merge them, REFRES_COMPLETENESS counts their reflections as missing, and every\n"
+                                          " other REFRES_ number is over the shells the run reached.",
+                                          o.d_min, past, past == 1 ? "" : "s", past == 1 ? "s" : "")
+                            : std::string("the range lies within the run's own, so this is a subset of the table\n"
+                                          " above."),
+                        result.reference_isa > 0.0
+                            ? "\n REFRES_ISA is the error model refitted on the reflections of this table alone, in\n"
+                              " XDS's convention."
+                            : "")));
+                Add(s, Prose(ReferenceShellTable(rs, o.d_min)));
+            }
+
             // A merge with no signal in it. Neither of these is caught anywhere else: CC1/2 near zero
             // beside a healthy I/sigma is the signature of observations of DIFFERENT reflections being
             // averaged together (mixed indexing hands, a wrong point group), and a rejection count
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index bf5518985..011d69512 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -4705,6 +4705,9 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // quality guard in Run() compares the passes on. Equal to the reported CC1/2 wherever no
             // surface was fitted, which is every merge on the stills path.
             double cc_half_before_corrections = NAN;
+            // The reference-range table and its ISa (--report-resolution); see ProcessResult.
+            std::optional<MergeStatistics> reference_statistics;
+            double reference_isa = 0.0;
         };
         // The reference path computes each image's G once (per-image scaling against the
         // reference); the scaling loop below is skipped, so G is stable across the two passes.
@@ -4917,7 +4920,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 result.error_model_a = r.error_model_a;
                 result.error_model_b = r.error_model_b;
                 return ScaleMergeResult{std::move(r.merged), std::move(r.statistics),
-                                        r.cc_half_before_corrections};
+                                        r.cc_half_before_corrections,
+                                        std::move(r.reference_statistics), r.reference_isa};
             }
             // Stills (rotation goes through RotationScaleMerge above): self-scale each image against the
             // running merge with ScaleOnTheFly (fixed partiality), then merge directly. This runs even
@@ -4993,6 +4997,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
 
             phase("Computing statistics");
             out.statistics = merge_engine.MergeStats(out.merged, merge_input, config_.reference_data, effective_d_min);
+            // The same kept reflections binned over the reference range (--report-resolution); the
+            // stills error model is fitted over the whole range already, so no ISa of its own.
+            if (const auto range = cut_ss.GetReportResolutionRange_A(); range && !for_search)
+                out.reference_statistics = merge_engine.MergeStats(out.merged, merge_input, config_.reference_data,
+                                                                   std::nullopt, range);
             {   // stills: no asymptote tier, and its ISa already IS the whole-range 1/b
                 const auto em = ToXdsErrorModel(merge_engine.ErrorModelA(), merge_engine.ErrorModelB());
                 result.error_model_isa = em.isa;
@@ -6412,6 +6421,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         result.merge_statistics_text = stats_text.str();
         result.has_merge_statistics = true;
         result.merge_statistics = sm.statistics;
+        result.reference_merge_statistics = sm.reference_statistics;
+        result.reference_isa = sm.reference_isa;
         result.cc_half_before_corrections = sm.cc_half_before_corrections;
 
         // Per-image form of the sweep-quality ranges, for the _process.h5: one code per image, 0 where
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 8365b84e1..e992ffa3b 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -243,6 +243,15 @@ struct ProcessResult {
     double error_model_b = 0.0;
     bool has_reference = false;
 
+    // The reflections the run kept, binned over the reference range of --report-resolution
+    // (ScalingSettings::ReportResolutionRange_A) instead of the run's own range: a second table, not
+    // a second processing, so a run can be read against another program's numbers at that program's
+    // range. Shells finer than the run's own limit are empty. reference_isa is the error model
+    // refitted on that table's reflections alone (rotation; 0 where not measured). Absent when no
+    // range was given.
+    std::optional<MergeStatistics> reference_merge_statistics;
+    double reference_isa = 0.0;
+
     // The overall CC1/2 as it stood before the scaling correction surfaces were folded in (NaN when no
     // merge ran). The rotation two-pass quality guard judges the refined pass on this rather than on the
     // reported CC1/2: the geometry pre-pass fits no surfaces, so only the uncorrected number is the same
diff --git a/rugnux/RugnuxCommandLine.cpp b/rugnux/RugnuxCommandLine.cpp
index 2f83c90a1..3896fbd6c 100644
--- a/rugnux/RugnuxCommandLine.cpp
+++ b/rugnux/RugnuxCommandLine.cpp
@@ -4,6 +4,7 @@
 #include "RugnuxCommandLine.h"
 #include "../common/DiffractionExperiment.h"
 
+#include <cmath>
 #include <sstream>
 #include <vector>
 
@@ -221,6 +222,10 @@ std::string RugnuxCommandLine(const ProcessConfig &config,
             const auto d_max_default = ScalingSettings().GetLowResolutionLimit_A();
             if (d_max != d_max_default)
                 args.push_back("--scaling-low-resolution=" + num(d_max.value_or(0.0)));
+            // An infinite d_max is the default of a run with no low limit, so d_min alone restates it.
+            if (const auto r = sc.GetReportResolutionRange_A())
+                args.push_back("--report-resolution=" + num(r->d_min)
+                               + (std::isfinite(r->d_max) ? "," + num(r->d_max) : ""));
         } else {
             args.emplace_back("--no-merge");
         }
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index 20ee52170..ecd6e07cc 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -164,6 +164,7 @@ void print_usage() {
     std::cout << "   --resolution-cutoff <txt>       Automatic high-resolution cutoff for the written reflections + reported shells: cc-logistic|off (default: cc-logistic; ignored when --scaling-high-resolution is set)" << std::endl;
     std::cout << "   --resolution-cc-target <num>    CC1/2 target defining the cc-logistic fall-off (default: 0.30)" << std::endl;
     std::cout << "   --resolution-shells <num>       Number of resolution shells in the reported statistics table (default: 9, as XDS)" << std::endl;
+    std::cout << "   --report-resolution <dmin>[,<dmax>] Also report the merging statistics over this resolution range (A, either order; dmax defaults to the run's own low-resolution limit) as a second table beside the run's own - the REFRES_* keys of the report - binned from the same merged reflections, so a run can be read against another program's table at that program's range. Report-only: the cut, the scaling, the error model and every decision stay the run's own, and shells finer than the run's own limit are empty rather than filled from data the run did not keep" << std::endl;
     std::cout << "   --ice-min-score <num>           Ice-presence gate: measured ice score (1 = no ice) a run must reach before ANY ice handling is applied - the flagging and the exclusion from scaling (default: 1.5). The eleven hexagonal bands cover 16-26% of the unique reflections whether or not the crystal has ice, so handling ice on a clean crystal is a pure loss. 0 = no gate (always handle ice)" << std::endl;
     std::cout << "   --ice-min-spot-ratio <num>      Second ice-presence channel: found spots on the hexagonal rings over the same q width of ice-free flanks beside them (1 = spots spread evenly). Ice in large crystallites diffracts as discrete spots and leaves the radial profile flat, so --ice-min-score alone is blind to it. Default 2.0; 0 disables this channel" << std::endl;
     std::cout << "   --min-partiality <num>          Minimum partiality to accept reflection (default: 0.02)" << std::endl;
@@ -239,6 +240,7 @@ enum {
     OPT_RESOLUTION_CUTOFF,
     OPT_RESOLUTION_CC_TARGET,
     OPT_RESOLUTION_SHELLS,
+    OPT_REPORT_RESOLUTION,
     OPT_SINGLE_PASS_ROTATION,
     OPT_FORCE_ROTATION_LATTICE,
     OPT_MIN_INDEXED_SPOTS,
@@ -407,6 +409,7 @@ static option long_options[] = {
     {"resolution-cutoff", required_argument, nullptr, OPT_RESOLUTION_CUTOFF},
     {"resolution-cc-target", required_argument, nullptr, OPT_RESOLUTION_CC_TARGET},
     {"resolution-shells", required_argument, nullptr, OPT_RESOLUTION_SHELLS},
+    {"report-resolution", required_argument, nullptr, OPT_REPORT_RESOLUTION},
     {"bandwidth", required_argument, nullptr, OPT_BANDWIDTH},
     {"integration-radius", required_argument, nullptr, OPT_INTEGRATION_RADIUS},
     {"adaptive-integration-radius", optional_argument, nullptr, OPT_ADAPTIVE_INTEGRATION_RADIUS},
@@ -494,6 +497,30 @@ float parse_float_arg(const char *arg, const char *option_name, Logger &logger)
     return parse_number_arg<float>(arg, option_name, logger);
 }
 
+// --report-resolution <d_min>[,<d_max>], in A and in either order; d_max defaults to the run's own
+// low-resolution limit. Report-only - see ScalingSettings::ReportResolutionRange_A.
+ReportResolutionRange ParseReportResolution(const std::string &arg, const ScalingSettings &scaling,
+                                            Logger &logger) {
+    std::vector<double> v;
+    std::stringstream ss(arg);
+    std::string tok;
+    while (std::getline(ss, tok, ',')) {
+        trim_in_place(tok);
+        if (!tok.empty())
+            v.push_back(parse_number_arg<double>(tok.c_str(), "--report-resolution", logger, 0.1, 100000.0));
+    }
+    if (v.empty() || v.size() > 2 || (v.size() == 2 && v[0] == v[1])) {
+        logger.Error("--report-resolution expects d_min or d_min,d_max in A: '{}'", arg);
+        print_usage();
+        exit(EXIT_FAILURE);
+    }
+    ReportResolutionRange r;
+    r.d_min = v.size() == 2 ? std::min(v[0], v[1]) : v[0];
+    r.d_max = v.size() == 2 ? std::max(v[0], v[1])
+              : scaling.GetLowResolutionLimit_A().value_or(std::numeric_limits<double>::infinity());
+    return r;
+}
+
 bool parse_on_off(const char *arg, bool &out) {
     std::string s = arg ? arg : "";
     std::transform(s.begin(), s.end(), s.begin(),
@@ -764,6 +791,7 @@ static int RunRugnux(int argc, char **argv) {
     std::optional<ResolutionCutoffMethod> resolution_cutoff_method;   // --resolution-cutoff cc-logistic|off
     std::optional<double> resolution_cc_target;                      // --resolution-cc-target
     std::optional<int> report_shell_count;                           // --resolution-shells
+    std::optional<std::string> report_resolution_arg;                // --report-resolution
     std::optional<std::string> integration_radius_arg;
     // --adaptive-integration-radius: unset means the per-workflow default below (on for rotation).
     std::optional<bool> adaptive_integration_radius_arg;
@@ -1255,6 +1283,9 @@ static int RunRugnux(int argc, char **argv) {
         case OPT_RESOLUTION_CC_TARGET:
             resolution_cc_target = parse_double_arg(optarg, "--resolution-cc-target", logger);
             break;
+        case OPT_REPORT_RESOLUTION:
+            report_resolution_arg = optarg;
+            break;
         case OPT_RESOLUTION_SHELLS:
             report_shell_count = atoi(optarg);
             if (report_shell_count.value() < 1) {
@@ -1543,6 +1574,9 @@ static int RunRugnux(int argc, char **argv) {
         if (resolution_cutoff_method) scaling_settings.ResolutionCutoff(*resolution_cutoff_method);
         if (resolution_cc_target) scaling_settings.ResolutionCCTarget(*resolution_cc_target);
         if (report_shell_count) scaling_settings.ReportShellCount(*report_shell_count);
+        if (report_resolution_arg)
+            scaling_settings.ReportResolutionRange_A(
+                ParseReportResolution(*report_resolution_arg, scaling_settings, logger));
         scaling_settings.MergeFriedel(!anomalous_mode);
         scaling_settings.MinPartiality(min_partiality);
         scaling_settings.MinCapturedFraction(
@@ -1696,6 +1730,8 @@ static int RunRugnux(int argc, char **argv) {
         std::optional<double> resolution_fit_A;   // CC1/2 crossing, without the one-shell extension
         double error_model_a = 0.0;
         double error_model_b = 0.0;
+        std::optional<MergeStatistics> reference_statistics;   // --report-resolution
+        double reference_isa = 0.0;
 
         // Rotation (rot3d): the dedicated RotationScaleMerge does the whole self-scale -> 3D combine ->
         // merge, including the default-on decay + absorption correction surfaces. It does not support
@@ -1722,6 +1758,8 @@ static int RunRugnux(int argc, char **argv) {
             error_model_a = r.error_model_a;
             error_model_b = r.error_model_b;
             resolution_fit_A = r.resolution_fit_A;
+            reference_statistics = std::move(r.reference_statistics);
+            reference_isa = r.reference_isa;
         } else {
             // Scaling self-references: the reference MTZ (if any) fixes the cell/space group, reports
             // CCref and provides the R-free test set, but is NOT a scale anchor - scaling each image
@@ -1768,6 +1806,9 @@ static int RunRugnux(int argc, char **argv) {
 
             merged_statistics = merge_engine.MergeStats(merged_reflections, reflections, reference_data,
                                                         effective_d_min);
+            if (const auto range = cut_ss.GetReportResolutionRange_A())
+                reference_statistics = merge_engine.MergeStats(merged_reflections, reflections, reference_data,
+                                                               std::nullopt, range);
             {   // stills: no asymptote tier, and its ISa already IS the whole-range 1/b
                 const auto em = ToXdsErrorModel(merge_engine.ErrorModelA(), merge_engine.ErrorModelB());
                 error_model_isa = em.isa;
@@ -1952,6 +1993,8 @@ static int RunRugnux(int argc, char **argv) {
         scale_result.error_model_a = error_model_a;
         scale_result.error_model_b = error_model_b;
         scale_result.resolution_fit_A = resolution_fit_A;
+        scale_result.reference_merge_statistics = reference_statistics;
+        scale_result.reference_isa = reference_isa;
         scale_result.has_reference = !reference_data.empty();
         scale_result.twinning = twinning;
         scale_result.model_validation = model_validation;
@@ -2439,6 +2482,9 @@ static int RunRugnux(int argc, char **argv) {
     if (resolution_cutoff_method) scaling_settings.ResolutionCutoff(*resolution_cutoff_method);
     if (resolution_cc_target) scaling_settings.ResolutionCCTarget(*resolution_cc_target);
     if (report_shell_count) scaling_settings.ReportShellCount(*report_shell_count);
+    if (report_resolution_arg)
+        scaling_settings.ReportResolutionRange_A(
+            ParseReportResolution(*report_resolution_arg, scaling_settings, logger));
     scaling_settings.MergeFriedel(!anomalous_mode);
     scaling_settings.MinPartiality(min_partiality);
     // Drop edge-of-sweep truncated fulls (rocking curve captured < this fraction) from the rot3d combine.
diff --git a/tests/MergeScaleTest.cpp b/tests/MergeScaleTest.cpp
index 5ca2294cb..31dd7676a 100644
--- a/tests/MergeScaleTest.cpp
+++ b/tests/MergeScaleTest.cpp
@@ -259,6 +259,47 @@ TEST_CASE("MergeStats_NoReferenceCellLeavesCompletenessUnmeasured") {
     }
 }
 
+// The reference-range table (--report-resolution) is binned over the range it is GIVEN, whether or
+// not the data reach it: its last shell ends at the declared d_min, and past the run's own limit
+// nothing is read from anywhere - the reflections the run did not keep count as missing.
+TEST_CASE("MergeStats_ReferenceRangeIsBinnedOverTheDeclaredRange") {
+    const auto &sg = TestSpaceGroup();
+    const auto merged = MeasuredBetween(sg, TEST_CELL, 2.0, 20.0, true);   // what the run kept
+    DiffractionExperiment x;
+    x.SetSpaceGroup(sg);
+    MergeOnTheFly merge(x);
+    merge.ReferenceCell(TEST_CELL);
+    const auto own = merge.MergeStats(merged, {});
+
+    // A range coarser than the run's own: a complete subset, on a grid ending at the declared bound.
+    const auto within = merge.MergeStats(merged, {}, {}, std::nullopt, ReportResolutionRange{3.0, 50.0});
+    CHECK(within.shells.back().d_min == Catch::Approx(3.0));
+    CHECK(within.shells.front().d_max == Catch::Approx(50.0));
+    int coarser_than_3 = 0;
+    for (const auto &m: merged)
+        if (m.d > 3.0f) ++coarser_than_3;
+    CHECK(within.overall.unique_reflections == coarser_than_3);
+    CHECK(within.overall.unique_reflections < own.overall.unique_reflections);
+    CHECK(Completeness(within.overall) > 99.0);
+
+    // A range finer than the run kept: the grid still ends at 1.5 A, the outer shell is empty and its
+    // possible reflections are in the denominator, and the measured range says where the data stop.
+    const auto beyond = merge.MergeStats(merged, {}, {}, std::nullopt, ReportResolutionRange{1.5, 50.0});
+    CHECK(beyond.shells.back().d_min == Catch::Approx(1.5));
+    CHECK(beyond.overall.unique_reflections == own.overall.unique_reflections);
+    CHECK(beyond.overall.possible_unique_reflections > own.overall.possible_unique_reflections);
+    CHECK(Completeness(beyond.overall) < Completeness(own.overall));
+    CHECK(beyond.shells.back().unique_reflections == 0);
+    CHECK(beyond.shells.back().possible_unique_reflections > 0);
+    CHECK(beyond.overall.d_min == Catch::Approx(own.overall.d_min));
+
+    // A range the data never reach at all is still a grid, not an error.
+    const auto empty = merge.MergeStats(merged, {}, {}, std::nullopt, ReportResolutionRange{1.0, 1.5});
+    CHECK(empty.overall.unique_reflections == 0);
+    CHECK(empty.overall.possible_unique_reflections > 0);
+    CHECK(empty.overall.d_min == 0.0f);
+}
+
 // ---------------------------------------------------------------- the automatic resolution cutoff
 namespace {
     // Half-set pairs spread uniformly in s = 1/d^2 over [s_from, s_to), either correlated with each
diff --git a/tests/ResultReportTest.cpp b/tests/ResultReportTest.cpp
index 9dcec514a..5bafc0525 100644
--- a/tests/ResultReportTest.cpp
+++ b/tests/ResultReportTest.cpp
@@ -157,6 +157,61 @@ TEST_CASE("ResultReport_Render", "[Diagnostics]") {
           != std::string::npos);
 }
 
+// The reference-range table: REFRES_* keys beside the run's own, the shells past the run's own limit
+// reported as not merged rather than as zeros, and no REFRES_ key at all when no range was given.
+TEST_CASE("ResultReport_ReferenceRangeTable", "[Diagnostics]") {
+    DiffractionExperiment x(DetJF(1));
+    ProcessResult result;
+    result.consensus_cell = UnitCell{.a = 79.0f, .b = 79.0f, .c = 38.0f,
+                                     .alpha = 90.0f, .beta = 90.0f, .gamma = 90.0f};
+    result.space_group = *gemmi::find_spacegroup_by_number(96);
+    result.has_merge_statistics = true;
+    auto &own = result.merge_statistics.overall;
+    own.d_max = 45.0f; own.d_min = 1.6f;   // the run's own limit
+    own.unique_reflections = 1000; own.possible_unique_reflections = 1000; own.total_observations = 5000;
+    own.mean_i_over_sigma = 10.0; own.r_meas = 0.1; own.cc_half = 0.99;
+
+    CHECK(RenderResultReport("prefix", "in.h5", x, result).find("REFRES_") == std::string::npos);
+
+    ScalingSettings s = x.GetScalingSettings();
+    s.ReportResolutionRange_A(ReportResolutionRange{1.2, 50.0});
+    x.ImportScalingSettings(s);
+    MergeStatistics rs;
+    auto shell = [](float d_max, float d_min, int unique, int possible, int obs) {
+        MergeStatisticsShell sh;
+        sh.d_max = d_max; sh.d_min = d_min;
+        sh.unique_reflections = unique; sh.possible_unique_reflections = possible; sh.total_observations = obs;
+        sh.mean_i_over_sigma = unique > 0 ? 8.0 : 0.0;
+        sh.cc_half = unique > 0 ? 0.9 : NAN;
+        sh.r_meas = unique > 0 ? 0.2 : NAN;
+        return sh;
+    };
+    rs.shells = {shell(50.0f, 2.0f, 600, 600, 3000),   // within the run's own range
+                 shell(2.0f, 1.5f, 300, 500, 1200),    // the run's limit of 1.6 A falls inside
+                 shell(1.5f, 1.2f, 0, 700, 0)};        // past it: not merged
+    rs.overall = shell(45.0f, 1.6f, 900, 1800, 4200);
+    result.reference_merge_statistics = rs;
+    result.reference_isa = 12.5;
+
+    const auto text = RenderResultReport("prefix", "in.h5", x, result);
+    CHECK(text.find("\nREFRES_RANGE= 50.000 1.200\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_MEASURED_RANGE= 45.000 1.600\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_SHELLS_PAST_LIMIT= 1\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_UNIQUE_REFLECTIONS= 900\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_COMPLETENESS= 50.0\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_MULTIPLICITY= 4.67\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_R_MEAS= 0.2000\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_CC_HALF= 0.9000\n") != std::string::npos);
+    CHECK(text.find("\nREFRES_ISA= 12.50\n") != std::string::npos);
+    // The run's own keys are untouched by the second table.
+    CHECK(text.find("\nCOMPLETENESS= 100.0\n") != std::string::npos);
+    CHECK(text.find("\nINCLUDE_RESOLUTION_RANGE= 45.000 1.600\n") != std::string::npos);
+    // The shell past the limit is words, not zeros; the shell holding the limit is marked.
+    CHECK(text.find("1.20  past the run's own limit of 1.60 A: not merged (700 possible)") != std::string::npos);
+    CHECK(text.find("<- the run's own limit, 1.60 A, is inside this shell") != std::string::npos);
+    CHECK(text.find("the 1 shell\n") != std::string::npos);
+}
+
 TEST_CASE("ResultReport_RenderEmpty", "[Diagnostics]") {
     // A clean run and a run that never looked must be distinguishable: both have a count of 0, and
     // only the STATUS key separates them. This is the property a consumer relies on.
-- 
2.54.0


From 65e7b658e5e173543bab74b6caf8e99f5b8883da Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 17:56:16 +0200
Subject: [PATCH 035/122] rugnux: with Friedel mates merged separately, a thin
 hand takes its outlier median from the pair

The rot3d merge tests each observation against the weighted median of its
reflection, and only from three observations up: at two the median is one of
them. With -A each hand of a Friedel pair is its own reflection, so a P1
anomalous merge sits at about two observations a hand and almost nothing is
tested - on one P1 sweep the merge rejected 0 observations with -A against
tens of thousands without it. A single observation a hundred times its
partner's intensity (300 sigma apart, a 3.9 A reflection) then survived into
the merge, carried 94% of the weighted variance of its CC1/2 bin, took that
bin from 0.80 to 0.18, and the automatic cut with it: 3.46 A and UNUSABLE,
where the same data without -A cut at 1.40 A.

A hand with fewer than three observations now takes the weighted median of
both hands together, where the pair has three. I(+) and I(-) differ by the
anomalous signal, a few percent of I and far inside the six-sigma test, so
the mate supplies the observations the hand is missing. A hand with three of
its own keeps its own median exactly as before, and a Friedel-merged run is
unchanged. The medians are formed on the host, so the device merge reads the
same ones.

Measured with -A: the P1 sweep 3.46 A / UNUSABLE -> 1.49 A (1.63 A XDS
reference; 1.40 A without -A, unchanged), 0 -> 3,699 rejections. Two lysozyme
and one insulin set: same cut, space group, CC1/2 and ISa. On one of the
lysozyme sets 16 more observations are rejected, every shell's CCanom is
unchanged, and the overall CCanom goes 0.31 -> -0.02: the whole-range figure
was being carried by a handful of wild pairs, while the shells ranged -18% to
+12% and XDS's overall anomalous correlation is 1%.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 65 +++++++++++++++----
 1 file changed, 53 insertions(+), 12 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index d3597ca03..c3c0112cc 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3769,27 +3769,65 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             // threshold is not the problem - 12 sigma rejects 1.35% of observations and gives the
             // same answer as 6 sigma - the rule is, and it only has a defined median from three.
             // Groups below the cut keep a NaN median and the test below skips them.
-            std::vector<int32_t> start(n_groups + 1, 0);
-            for (int g = 0; g < n_groups; ++g)
-                start[g + 1] = start[g] + (cnt[g] >= 3 ? cnt[g] : 0);
+            //
+            // With the Friedel mates merged separately (-A) a hand below three borrows its MATE's
+            // observations: I(+) and I(-) differ by the anomalous signal, a few percent of I and far
+            // inside a six-sigma test, so together they are a median the hand alone does not have. Without
+            // it a P1 anomalous merge sits at about two observations a hand and nothing is tested: one
+            // observation a hundred times its partner's intensity (300 sigma apart) then survived into
+            // the merge and took a whole CC1/2 bin, and the cut with it, from 0.80 to 0.18. A hand with
+            // three of its own keeps its own median, as before. Median set g is group g's own; median
+            // set n_groups + p is Friedel pair p's, filled only where a hand of p needs it.
+            std::vector<int32_t> pair_of_group;
+            std::vector<uint8_t> pair_needed;
+            if (!merge_friedel) {
+                const HKLKeyGenerator anom_keygen(/*merge_friedel=*/false, x.GetSpaceGroupOrP1());
+                std::unordered_map<uint64_t, int32_t> pair_id;
+                pair_id.reserve(static_cast<size_t>(n_groups) + 1);
+                pair_of_group.resize(n_groups);
+                for (int g = 0; g < n_groups; ++g) {
+                    const HKLKey gk = anom_keygen(group_h[g], group_k[g], group_l[g]);
+                    const uint64_t key = HKLKey{gk.h, gk.k, gk.l, true}.pack();
+                    pair_of_group[g] = pair_id.emplace(key, static_cast<int32_t>(pair_id.size())).first->second;
+                }
+                std::vector<int32_t> pair_cnt(pair_id.size(), 0);
+                for (int g = 0; g < n_groups; ++g) pair_cnt[pair_of_group[g]] += cnt[g];
+                pair_needed.assign(pair_id.size(), 0);
+                for (int g = 0; g < n_groups; ++g)
+                    if (cnt[g] > 0 && cnt[g] < 3 && pair_cnt[pair_of_group[g]] >= 3)
+                        pair_needed[pair_of_group[g]] = 1;
+            }
+            const int n_sets = n_groups + static_cast<int>(pair_needed.size());
+            std::vector<int32_t> set_cnt(n_sets, 0);
+            for (int g = 0; g < n_groups; ++g) {
+                if (cnt[g] >= 3) set_cnt[g] = cnt[g];
+                if (!pair_needed.empty() && pair_needed[pair_of_group[g]])
+                    set_cnt[n_groups + pair_of_group[g]] += cnt[g];
+            }
+            std::vector<int32_t> start(n_sets + 1, 0);
+            for (int t = 0; t < n_sets; ++t)
+                start[t + 1] = start[t] + set_cnt[t];
             // Inverse-variance WEIGHTED median: a frame the crystal barely diffracted on is scaled up by
             // 1/G together with its sigma, so a plain median lets two such observations outvote one
             // well-measured one - and the test below then rejects the well-measured one against its
             // own small sigma.
-            std::vector<std::pair<float, float>> iv(start[n_groups]);   // (I*corr, 1/(sigma*corr)^2)
+            std::vector<std::pair<float, float>> iv(start[n_sets]);   // (I*corr, 1/(sigma*corr)^2)
             {
                 std::vector<int32_t> fill(start.begin(), start.end() - 1);
                 for (int i = 0; i < n_full; ++i) {
                     const int g = mf.group[i];
-                    if (g >= 0 && cnt[g] >= 3) {
-                        const float sc = mf.sigma[i] * mf.corr[i];
-                        iv[fill[g]++] = {mf.I[i] * mf.corr[i], sc > 0.0f ? 1.0f / (sc * sc) : 0.0f};
-                    }
+                    if (g < 0) continue;
+                    const float sc = mf.sigma[i] * mf.corr[i];
+                    const std::pair<float, float> v{mf.I[i] * mf.corr[i], sc > 0.0f ? 1.0f / (sc * sc) : 0.0f};
+                    if (cnt[g] >= 3) iv[fill[g]++] = v;
+                    if (!pair_needed.empty() && pair_needed[pair_of_group[g]])
+                        iv[fill[n_groups + pair_of_group[g]]++] = v;
                 }
             }
-            ParallelChunks(n_groups, ThreadsForWork(iv.size(), nthreads), [&](int glo, int ghi) {
-                for (int g = glo; g < ghi; ++g) {
-                    const int lo = start[g], hi = start[g + 1];
+            std::vector<float> set_median(n_sets, NAN);
+            ParallelChunks(n_sets, ThreadsForWork(iv.size(), nthreads), [&](int tlo, int thi) {
+                for (int t = tlo; t < thi; ++t) {
+                    const int lo = start[t], hi = start[t + 1];
                     if (lo == hi) continue;
                     std::sort(iv.begin() + lo, iv.begin() + hi);
                     double total = 0.0;
@@ -3800,9 +3838,12 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                         run += iv[j].second;
                         if (run >= 0.5 * total) break;
                     }
-                    reject_median[g] = iv[j].first;
+                    set_median[t] = iv[j].first;
                 }
             });
+            for (int g = 0; g < n_groups; ++g)
+                reject_median[g] = cnt[g] >= 3 ? set_median[g]
+                                 : !pair_needed.empty() ? set_median[n_groups + pair_of_group[g]] : NAN;
         }
         fit_error_model(samples);
     }
-- 
2.54.0


From 6a265917866cfebc250e5b1c925c7ed9bed16d51 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:18:00 +0200
Subject: [PATCH 036/122] rugnux: the indexing-ambiguity warning is withdrawn
 only where the model settled it

The INDEXING_AMBIGUITY warning was suppressed whenever --model was given on
rotation data, decided before the model was read. A model that then decided
nothing - not tested, rejected, or a probe winner that did not beat its own null
- still silenced it, so WARNING_COUNT, PATHOLOGY_FLAGS and possibly VERDICT
differed from a run without the model although the written reflections were
identical.

The warning is now issued exactly as without a model, and withdrawn (from the
warnings and from the statistics text) after model validation only where the
indexing probe decided the indexing: the model fits and the winner's R-free
margin beats the random-placement null (ModelValidationResult::indexing_decided,
set where the decision is taken). A reference MTZ, or the model reference on
serial stills with -C and -S, suppresses it up front as before.

Verified bare vs --model on three open-arm sets: merged MTZ data identical in
all three; warnings identical where the model decided nothing (identity probe
without null; no twin law); withdrawn where the probe decided (+33 sigma).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 rugnux/ModelValidation.cpp |  2 ++
 rugnux/ModelValidation.h   |  3 +++
 rugnux/Rugnux.cpp          | 35 +++++++++++++++++++++--------------
 3 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index cc136e487..4deecd583 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -777,6 +777,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
             // A random model also picks a winner, and on these data it picks one by a comparable lead
             // (measured), so the raw margin says nothing on its own.
             const bool decided = result.model_fits && result.indexing_margin_sigma >= MODEL_FIT_SIGMA;
+            result.indexing_decided = decided;
             if (decided)
                 result.indexing_op = indexing.op;
             logger.Info("Model validation: probed {} indexing solution(s) against the model; the winner "
@@ -817,6 +818,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         result.fit_tested = false;
         result.model_fits = false;
         result.indexing_probed = false;
+        result.indexing_decided = false;
         result.indexing_op = gemmi::Op::identity();
         result.r_work_sigma = 0.0;
         SetModelPositions(st.models[0], as_read);
diff --git a/rugnux/ModelValidation.h b/rugnux/ModelValidation.h
index 21b87b706..7fc6831a8 100644
--- a/rugnux/ModelValidation.h
+++ b/rugnux/ModelValidation.h
@@ -126,6 +126,9 @@ struct ModelValidationResult {
     // same margin comes out at for a model in a random orientation. A winner that leads by no more
     // than chance has decided nothing, and the data keep the indexing they were merged in.
     bool indexing_probed = false;
+    // The probe's winner beat its own null on a model that fits: the indexing ambiguity is settled by
+    // the model, whether that kept the data's indexing or moved it to indexing_op.
+    bool indexing_decided = false;
     double indexing_margin = 0.0;
     double indexing_margin_null_mean = 0.0;
     double indexing_margin_null_sd = 0.0;
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 011d69512..baa964214 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -5227,6 +5227,9 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         }
 
         std::ostringstream stats_text;
+        // The indexing-ambiguity paragraph as it went into stats_text, so that a model which then
+        // settles the ambiguity can withdraw it; empty where there was none.
+        std::string ambiguity_warning_text;
         // True when the point group below was chosen BY THE SEARCH (rather than given by the user) and is
         // above triclinic - i.e. a promotion was made, which is what makes a later "the Laue class is
         // holohedral so there is no twin law" conclusion circular.
@@ -6352,13 +6355,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     std::replace(t.begin(), t.end(), 'z', 'l');
                     laws += (laws.empty() ? "" : " ; ") + t;
                 }
-                // A model resolves it too: on rotation data at the validation step below, by R-free;
-                // on serial stills only through the per-image reference computed from it at integration
-                // time, which needs the cell and the space group up front - so a model on its own does
-                // not always suffice there, and `ambiguity_reference` says whether it did.
-                const bool will_be_resolved = ambiguity_reference
-                    || (!config_.model_path.empty() && experiment_.IsRotationIndexing());
-                if (!will_be_resolved) {
+                // A model can resolve it too, but whether it does is only known once the model has
+                // been fitted (validation step below), so the warning stands here exactly as in a run
+                // without a model, and is withdrawn there if the model's indexing probe decided it.
+                // On serial stills with -C and -S the model is already in `ambiguity_reference`.
+                if (!ambiguity_reference) {
                     const std::string msg = fmt::format(
                         "Indexing ambiguity: this cell / space group admits alternative indexing "
                         "(reindex operator(s): {}). {} are indexed in one hand at random, and rugnux can only "
@@ -6367,14 +6368,9 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                         laws, experiment_.IsRotationIndexing() ? "Lattices" : "Serial-stills crystals",
                         experiment_.IsRotationIndexing() ? "--model" : "--model, which needs -C and -S here");
                     logger.Warning("{}", msg);
-                    stats_text << "  !! " << msg << "\n\n";
+                    ambiguity_warning_text = "  !! " + msg + "\n\n";
+                    stats_text << ambiguity_warning_text;
                     result.warnings.push_back({PathologyCode::INDEXING_AMBIGUITY, msg});
-                } else if (config_.reference_data.empty()) {
-                    // Said before the model has been read, so it says what will be tried, not what
-                    // came of it - a model that turns out to be unreadable is reported where it is
-                    // read, and claiming success here would contradict it.
-                    logger.Info("Indexing ambiguity present (reindex operator(s): {}); the supplied "
-                                "model will be used to resolve it.", laws);
                 } else {
                     logger.Info("Indexing ambiguity present (reindex operator(s): {}); resolved "
                                 "against the supplied reference.", laws);
@@ -6609,6 +6605,17 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             if (!validation.failure_reason.empty())
                 result.warnings.push_back({PathologyCode::MODEL_NOT_VALIDATED,
                                           "Model validation did not run: " + validation.failure_reason});
+            // The ambiguity warning above was issued before the model was read; take it back only
+            // where the model actually settled the indexing.
+            if (validation.indexing_decided && !ambiguity_warning_text.empty()) {
+                std::erase_if(result.warnings, [](const ReportWarning &w) {
+                    return w.code == PathologyCode::INDEXING_AMBIGUITY;
+                });
+                const auto pos = result.merge_statistics_text.find(ambiguity_warning_text);
+                if (pos != std::string::npos)
+                    result.merge_statistics_text.erase(pos, ambiguity_warning_text.size());
+                logger.Info("Indexing ambiguity resolved against the model; warning withdrawn");
+            }
             if (data_sg.has_value()) {
                 const gemmi::SpaceGroup *adopted =
                     AdoptModelFrame(validation, sm.merged, *data_sg,
-- 
2.54.0


From 90e84718fe0a9c5fc099fa60701c6f03c705072b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 17:21:46 +0200
Subject: [PATCH 037/122] tools/battery: a set with a known-wrong reference can
 be left unscored

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md | 2 ++
 tools/battery/score.py  | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 982e7d7e5..65d6c2005 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -341,6 +341,8 @@ whole range; the manifest keeps the rule used as `dmin_rule`.
   control), then run `battery.py refs --arm inhouse --write` to fill in `ref` from the
   `CORRECT.LP` beside the input. Without `--write`, `refs` only shows what would change.
   A reference measured by hand goes in `ref_override`, which `refs` leaves alone.
+  A set whose reference is known to be wrong gets `"unscored": "<why>"`: it still runs, but
+  scores `unscored` instead of pass or fail.
 - **Renamed data directories**: `battery.py remap --arm inhouse MAP.json --write`, where
   `MAP.json` is `{"old": "new"}` (renames the set and its directory) or
   `{"old id": {"id": "...", "input": "..."}}`. Each old id is recorded under `aliases` in the
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 81cae0ff1..331722d7d 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -159,6 +159,8 @@ def judge(entry, rep, run_note):
         return verdict("fail", "crash", run_note or "no lattice in the report")
     if not ref.get("sgno") or not ref.get("cell"):
         return verdict("unscored", "no_reference", "no reference to score against")
+    if entry.get("unscored"):              # a reference known to be wrong: run, but do not score
+        return verdict("unscored", "reference_problem", entry["unscored"])
 
     vr, edge = lattice_match(r["cell"], space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
                              ref["cell"], space_group(ref.get("sg"), ref["sgno"]))
-- 
2.54.0


From 0ef6b3f00bdedfcde1c19bcbbd8fb0df70b4cfc4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:18:00 +0200
Subject: [PATCH 038/122] rugnux: the run's own N_obs and R_meas stop at the
 same cut as N_uniq

The own statistics table's grid bottoms 0.1% below the finest kept reflection,
and the observation-level counts (N_obs, R_meas, the Bijvoet split behind SigAno
and CCanom) re-walk the fulls, which still hold every ingested group. Groups in
that band just below the auto cut were erased from the merge, so they were not
in N_uniq, but their observations still counted in N_obs and R_meas of the
finest shell. The own table now floors those counts at the cut by group d, the
rule the erase applies - the same floor the reference-range table already used
(now passed as a double, so the comparison is exactly the erase's).

Report-only: on an auto-cut cubic in-house set the written MTZ, HKL, P1 MTZ, unmerged
MTZ and image table are byte-identical; TOTAL_OBSERVATIONS 378754 -> 377933,
MULTIPLICITY 40.31 -> 40.22 (now equal to the reference-range table's), finest
shell N_obs 60873 -> 60052, R_meas 1136.9% -> 1129.2%, CCanom -0.6% -> -0.3%;
overall R_MEAS, CC1/2, SigAno unchanged at printed precision; the mmCIF's
pdbx_number_measured_all / pdbx_redundancy / last shell row follow. A
detector-limited lysozyme run (no auto cut) is byte-identical throughout.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 image_analysis/scale_merge/RotationScaleMerge.cpp | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index b95fac06b..39db29683 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -4088,13 +4088,15 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     //      grid_d_max, and the completeness denominator is enumerated over exactly that. The fulls
     //      hold every group that was ingested, cut or not, so a grid reaching past the cut needs
     //      d_floor - the cut, as the erase above applied it, by group d - to keep the observations
-    //      of the groups the run did not keep out of every count; the run's own grid ends at the
-    //      finest kept reflection and needs none. ----
+    //      of the groups the run did not keep out of every count. The run's own grid needs it too:
+    //      it bottoms 0.1% below the finest kept reflection, and the groups in that band were erased
+    //      from the merge, so without the floor they would count in N_obs and R_meas but not in
+    //      N_uniq. ----
     const int n_shells = report_shell_count;
     struct AnomExport { float Ip = NAN, sIp = NAN, Im = NAN, sIm = NAN; };
     std::unordered_map<uint64_t, AnomExport> anom_export;   // filled by the run's own table only
     auto statistics_over = [&](const std::vector<MergedReflection> &merged, float grid_d_min,
-                               float grid_d_max, float d_max_label, float d_floor,
+                               float grid_d_max, float d_max_label, double d_floor,
                                bool own_table) -> MergeStatistics {
         ResolutionShells shells(grid_d_min, grid_d_max, n_shells);
         const auto shell_mean_1_d2 = shells.GetShellMeanOneOverResSq();
@@ -4369,7 +4371,8 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     // The innermost shell is labelled by the bound it reaches, except when that bound is infinite
     // and the coarsest reflection measured is the only finite thing to say.
     const float d_max_label = std::isfinite(d_max_declared) ? d_max_declared : sd_max;
-    result.statistics = statistics_over(result.merged, d_min_pad, d_max_declared, d_max_label, 0.0f, true);
+    result.statistics = statistics_over(result.merged, d_min_pad, d_max_declared, d_max_label,
+                                        effective_d_min.value_or(0.0), true);
     MergeStatistics &out = result.statistics;
     out.overall.d_min = sd_min; out.overall.d_max = sd_max;
 
@@ -4398,7 +4401,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             in_min = std::min(in_min, m.d); in_max = std::max(in_max, m.d);
         }
         MergeStatistics ref = statistics_over(result.merged, d_lo, d_hi, std::isfinite(d_hi) ? d_hi : in_max,
-                                              static_cast<float>(effective_d_min.value_or(0.0)), false);
+                                              effective_d_min.value_or(0.0), false);
         ref.overall.d_min = in_min < in_max ? in_min : 0.0f;
         ref.overall.d_max = in_max;
         result.reference_statistics = std::move(ref);
-- 
2.54.0


From 8eaa4b9df7940e8541d3615ec8148470396c69b7 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 17:48:45 +0200
Subject: [PATCH 039/122] Bragg integration: size each image's reflection list
 to what is kept

Finalize reserved npredicted reflections and kept only the ones whose fit succeeded. On a dense
long-axis pattern more than half the predicted reflections lose their background ring, so each
retained per-image vector carried more dead capacity than data for the rest of the pass. Count the
kept ones first and reserve exactly that. No result changes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../bragg_integration/BraggIntegrationEngine.cpp          | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/image_analysis/bragg_integration/BraggIntegrationEngine.cpp b/image_analysis/bragg_integration/BraggIntegrationEngine.cpp
index f44132c1e..ced5d0caf 100644
--- a/image_analysis/bragg_integration/BraggIntegrationEngine.cpp
+++ b/image_analysis/bragg_integration/BraggIntegrationEngine.cpp
@@ -215,8 +215,14 @@ std::vector<Reflection> BraggIntegrationEngine::Finalize(const std::vector<Refle
                                                          size_t npredicted,
                                                          const std::vector<BraggFitResult> &results,
                                                          int64_t image_number) const {
+    // Sized to what is kept, not to what was predicted: this vector is the one every image holds to the
+    // end of the pass, and a background ring lost to the neighbours drops a reflection here - on a
+    // dense pattern more than half of them, which a reserve of npredicted would carry as dead capacity.
+    size_t n_ok = 0;
+    for (size_t i = 0; i < npredicted; ++i)
+        n_ok += results[i].ok ? 1 : 0;
     std::vector<Reflection> out;
-    out.reserve(npredicted);
+    out.reserve(n_ok);
     for (size_t i = 0; i < npredicted; ++i) {
         const auto &fr = results[i];
         if (!fr.ok)
-- 
2.54.0


From 665338d3d15895e66f684777edb5495e4225e63b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:18:00 +0200
Subject: [PATCH 040/122] tools/battery: one rugnux run per set

--model and --report-resolution are both processing-inert (merged reflections
bit-identical with and without them), so the bare/model and bare/xds variant
pairs collapse into one command per arm:

  open:          rugnux -o p --no-export-unmerged --model <deposited coords> <input>
                 (no --model where there is no deposited model)
  inhouse/private: rugnux -o p --no-export-unmerged [-A] --report-resolution
                 <reference d_min>,<XDS d_max> <input>

Every row is rugnux's own result (own cut vs the reference, as `bare` was), and
on the XDS arms also carries the REFRES_* table, scored against CORRECT.LP's
completeness, multiplicity, R_meas, CC1/2 and ISa, with ISa and R_meas ratio
plots and a like-for-like table; REFRES_SHELLS_PAST_LIMIT > 0 marks the row as
coverage (rugnux's cut coarser than the reference). Nothing is forced on the
processing any more. On the open arm the space group is scored on the data's
own determination (SOHNCKE_SPACE_GROUP where SPACE_GROUP_ENANTIOMORPH is
ASSUMED_FROM_MODEL), the model's label kept as sg_label; R_FREE/R_WORK/CC_MODEL
/MODEL_FIT are trend fields (placement-only, own free set); REFMAC stays opt-in.

results.json schema 3: one row per set, no variant/first_read; older runs are
read through their bare rows (open-arm model R-factors folded in), so compare
and report keep working against them. Every time is now a first read.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CLAUDE.md                |  14 +-
 tools/battery/README.md  | 176 +++++++++++++------------
 tools/battery/battery.py | 134 ++++++++-----------
 tools/battery/report.py  | 275 +++++++++++++++++++++------------------
 tools/battery/score.py   |  32 ++++-
 5 files changed, 332 insertions(+), 299 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index ef6f72df0..73f61737a 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -106,15 +106,17 @@ scripts.
 ```
 tools/battery/battery.py run --rugnux build/rugnux/rugnux --only 5reo,lyso_ref   # named sets
 tools/battery/battery.py run --rugnux build/rugnux/rugnux --tier smoke           # smoke tier
-tools/battery/battery.py run --rugnux build/rugnux/rugnux --variants bare        # one variant only
 tools/battery/battery.py compare RUN_A RUN_B [--rerun-changed]
 ```
 
-Each set runs in all its arm's **variants** back to back, so its images are read from disk once:
-`bare` (plain `rugnux <input>`, what a user gets) first everywhere, then `model` (`--model` with the
-deposited coordinates, R-free vs the published one) on the open arm, or `xds` (XDS's resolution
-range forced, `-A` where XDS was anomalous) on the XDS arms. Only the first variant's time includes
-the disk read; compare times within one variant. The REFMAC check is opt-in (`--model-check`).
+Each set runs **once**, with one command per arm: `rugnux --model <deposited coordinates>` on the
+open arm (without `--model` where there is none), and `rugnux [-A] --report-resolution <ref d_min>,<XDS
+d_max>` on the XDS arms (`-A` where XDS was anomalous). Neither option changes the processing, so
+the row carries both rugnux's own result (own cut vs the reference: what a user gets) and the
+like-for-like numbers (the REFRES_* table vs XDS; where rugnux's cut is coarser than XDS's, its
+completeness there is coverage, not quality). Open-arm space groups are scored on the data's own
+determination, not on a model-adopted hand; rugnux's `--model` R-free is a placement-only trend
+number. The REFMAC check is opt-in (`--model-check`).
 
 - **Never start a full battery run (no `--only`/`--tier`) without the owner's go-ahead.**
 - Judge a change against a **persisted baseline run** (the site config's `baseline`) with
diff --git a/tools/battery/README.md b/tools/battery/README.md
index bb4c5f12d..f8dddceee 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -23,44 +23,44 @@ scored with `sgequiv`. On the XDS arms only the point group is scored, because X
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
-## Variants
+## One command per arm
 
-Every set is run more than once, with different settings, and each run is a **variant**. The
-variants of one set run straight after each other, before the next set starts. The battery is
-limited by reading images from disk, and this way only the first variant reads them; the others
-find them in the page cache.
+Every set runs **once**, with one command per arm:
 
-| arm (reference) | variants, in the order they run |
+| arm (reference) | command |
 |---|---|
-| open (deposition) | `bare`, then `model` |
-| inhouse, private (XDS) | `bare`, then `xds` |
+| open (deposition) | `rugnux -o p --no-export-unmerged --model <deposited coordinates> <input>`; sets without a deposited model (small molecules, unpublished sets, or coordinates that cannot be downloaded) run the same command without `--model` |
+| inhouse, private (XDS) | `rugnux -o p --no-export-unmerged [-A] --report-resolution <reference d_min>,<XDS d_max> <input>` |
 
-- **`bare`**: plain `rugnux <input>` and nothing else (no `-A`, no resolution range). This is
-  what a user gets. It is scored against the reference like the others, and its d_min ratio
-  against the reference is plotted.
-- **`model`** (open arm): `rugnux --model <deposited coordinates>`. The coordinates (`<entry>.cif.gz`)
-  and the published R-free come from the RCSB and are cached in the site's `pdb_cache` (default
-  `/data/battery/pdb_cache`), so the first run of a new entry needs network access. The entry is the
-  set id up to the first `_`, so `6h2p_native` uses `6h2p`. A set with no PDB entry (small
-  molecules) or whose coordinates cannot be downloaded gets a `not_run` row with cause `no_model`.
-  The row records the R-free and R-work that rugnux reports for the model, the published R-free
-  and their ratio, which the report plots. rugnux's R-free is that of a rigid-body placement against
-  its own merge, and the published one comes from full refinement against the depositor's own
-  data, so the ratio is not a like-for-like score; watch how it moves between runs.
-- **`xds`** (XDS arms): XDS's reference settings. XDS's resolution range is forced (see "The XDS
-  reference d_min" below), and where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true`
-  in the manifest) rugnux gets `-A`. Both programs then merge the same reflections the same way.
+Neither `--model` nor `--report-resolution` changes the processing: the merged reflections, the
+resolution cut and every decision are the same with and without them (verified bit for bit). So
+the one run is both what a user gets and, through the extra report sections, the comparison with
+the reference:
 
-The variants are defined in one place, `VARIANTS` in `battery.py`. `--variants` runs a subset,
-for example `--variants bare`, and they always run in the table's order. `--unforced` is gone:
-`--variants bare` gives rugnux its own resolution cut (and, unlike `--unforced`, no `-A`).
+- **Own result** (every arm): rugnux's own cut and statistics, scored against the reference and
+  plotted as d_min(rugnux) / d_min(reference). This is what a user gets.
+- **`--model`** (open arm): the deposited coordinates (`<entry>.cif.gz`) and the published R-free
+  come from the RCSB and are cached in the site's `pdb_cache` (default `/data/battery/pdb_cache`),
+  so the first run of a new entry needs network access. The entry is the set id up to the first
+  `_`, so `6h2p_native` uses `6h2p`. The row records MODEL_FIT, R_FREE, R_WORK and CC_MODEL as
+  **trend fields**: rugnux's R-free is a rigid-body placement scored on rugnux's own free set, not
+  a refinement against the depositor's, so the ratio to the published R-free is not a like-for-like
+  score; watch how it moves between runs. The comparable number is the REFMAC check (below).
+  A model that fits may put its enantiomorph on the space-group label; the scorer reads the
+  data's own determination instead (`SOHNCKE_SPACE_GROUP` where `SPACE_GROUP_ENANTIOMORPH` is
+  `ASSUMED_FROM_MODEL`) and keeps the label in `sg_label`.
+- **`--report-resolution`** (XDS arms): a second statistics table from the same merge, binned over
+  XDS's range (the reference d_min, see "The XDS reference d_min" below, and XDS's d_max as given,
+  999 included), and `-A` where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the
+  manifest), so the two tables count the same way. Its REFRES_* numbers are scored against XDS's
+  CORRECT.LP totals: completeness, multiplicity, R_meas, CC1/2 and ISa (I/sigma is shown; the
+  manifest holds no XDS value for it). Where rugnux's own cut is coarser than the reference
+  (`REFRES_SHELLS_PAST_LIMIT` > 0), the shells past it are not merged, so the completeness is read
+  as **coverage** of the reference range, not as a quality regression, and the other numbers are
+  over the shells rugnux reached.
 
-**Order and timing.** `bare` goes first on every arm. So its time always includes reading the
-data from disk (unless the images were still cached from before the run), whichever variants a run
-selects, and it is the time a user sees. The time of a later variant is taken on cached images.
-Each row records whether it was its set's `first_read`, and the report's timing table says which
-variant carries the disk reads. Compare times of one variant between runs only, never across
-variants.
+**Timing.** Each set runs once, so every time includes reading the images from disk (unless they
+were still in the page cache from before the run).
 
 The private arm is never mixed with the others. A private run gets its own run directory
 (suffix `_private`) and its own report (`report_PRIVATE.*`), and it cannot be the baseline of a
@@ -138,7 +138,7 @@ export `JFJOCH_BATTERY_SITE=/data/battery/site.json`.
 A relative `manifest` path is resolved against `tools/battery/`. `gpulock` is a command that
 `rugnux` is prefixed with under `--gpulock`. At PSI it is a wrapper script that queues for one of
 the shared GPU slots. Set it to `null` if you have no such wrapper. `pdb_cache` (optional) is where
-the deposited models and their metadata are cached for the `model` variant and the REFMAC check.
+the deposited models and their metadata are cached for `--model` and the REFMAC check.
 
 ## Running
 
@@ -150,7 +150,6 @@ $B run --rugnux $R                                  # full battery: open + inhou
 $B run --rugnux $R --tier smoke                     # 22 sets covering readers, symmetry, known hard cases
 $B run --rugnux $R --only 5reo,lyso_ref             # named sets
 $B run --rugnux $R --arm private                    # the private arm, on its own
-$B run --rugnux $R --variants bare                  # only what a user gets (no model, no XDS settings)
 ```
 
 Useful options:
@@ -160,8 +159,7 @@ Useful options:
 - `--gpulock` queues every rugnux behind the site's GPU wrapper.
 - `--extra "<args>"` adds rugnux arguments to every set.
 - `--baseline RUN|none` sets the run the report is compared against.
-- `--variants bare,model,xds` runs a subset of the variants (default: all of them).
-- `--model-check` adds the REFMAC check to the open arm's `bare` rows (off by default, see below).
+- `--model-check` adds the REFMAC check to the open arm's rows (off by default, see below).
 
 A run prints one line per set and ends by writing its report. The **smoke** tier is marked in the
 manifests (`"tiers": {"smoke": "<why this set>"}`).
@@ -172,9 +170,9 @@ everything else on the machine competes with it.
 
 ### The REFMAC model check (open arm, opt-in)
 
-The `model` variant is the battery's R-free check. `--model-check` adds a second, independent one
-that needs CCP4: `tools/battery/model_check.py` scores each open-arm `bare` merge (`p.mtz`) against
-the deposited model,
+rugnux's own `--model` R-free is a trend number. `--model-check` adds an independent one, comparable
+with the deposition, that needs CCP4: `tools/battery/model_check.py` scores each open-arm merge
+(`p.mtz`) against the deposited model,
 unmodified (ligands, waters and hydrogens kept): REFMAC's rigid-body mode, R-factors taken before
 any shift, the data reindexed into the model's setting and reduced to the deposited space group.
 Our own free set was mostly work reflections for the depositor, so `refmac_rfree` reads low. The
@@ -186,7 +184,7 @@ structure factors with a free set. The runner records `refmac_rfree`, `refmac_rw
 `refmac_reason`. Small-molecule sets are skipped.
 
 `model_sweep.py`, which ran `rugnux --model` over the open arm as a separate sweep, is retired. The
-`model` variant does the same inside the battery.
+open arm's command does the same inside the battery.
 
 ## A run directory
 
@@ -197,9 +195,9 @@ read-only when the run completes.
 |---|---|
 | `bin/rugnux` | the exact binary that ran (sha256 in the manifest) |
 | `manifest.json` | the label, arms, subset, options, binary version, build flags and source HEAD, runner git and dirty flag, host, pid, start and end, `complete` / `aborted`, `gpu_shared`, and every set with its resolved input, reference and tags |
-| `results.json` | one row per set and variant (the schema is below) |
+| `results.json` | one row per set (the schema is below) |
 | `report.md`, `report.html` | the report (`report_PRIVATE.*` for a private run) |
-| `work/<arm>/<set>/<variant>/` | `run.log`, `p_report.txt`, `p.mtz`, `p.cif`, ... and `model_check/` |
+| `work/<arm>/<set>/` | `run.log`, `p_report.txt`, `p.mtz`, `p.cif`, ... and `model_check/` |
 
 **Run states** (`battery.py list`): `complete`; `running` (its runner process is alive);
 `aborted` (interrupted by Ctrl-C or SIGTERM, or marked with `battery.py abort RUN --reason ...`);
@@ -207,34 +205,44 @@ read-only when the run completes.
 covers an arbitrary part of its sets. `compare` and `report` refuse it unless given
 `--allow-incomplete`, and the report then says so at the top.
 
-### results.json (schema 2)
+### results.json (schema 3)
 
-This is a flat list with one object per set and variant, and every arm uses the same keys. Missing
-values are `null`. `manifest.json` records the schema version as `results_schema`, and the variants
-each arm ran as `variants`.
+This is a flat list with one object per set, and every arm uses the same keys. Missing values are
+`null`. `manifest.json` records the schema version as `results_schema`, and each arm's command as
+`command_doc`.
 
-Schema 2 added `variant` and `first_read`. It also changed the meaning of `rfree`, `rwork` and
-`rfree_ratio`: they are now rugnux's own `--model` values (model variant), and the REFMAC check's
-moved to `refmac_*`. A schema-1 run is still read, and compared, as if each set had one variant:
-`bare` on the open arm; on the XDS arms `xds`, or `bare` if it was run `--unforced` (which still
-passed `-A`).
+Schema 3 is one row per set again: `variant` and `first_read` are gone, and `refres_*`,
+`isa_ratio`, `r_meas_ratio`, `multiplicity_ref`, `cc_model`, `sg_label`, `model` and `model_note`
+are new. `sgno`/`sg` are now the data's own space group where `--model` relabelled the hand.
+Older runs are still read and compared: a schema-2 run as its `bare` rows, with the open arm's
+`model` rows' R-factors folded in. On the open arm that is the same processing as today's
+command; on the XDS arms today's command adds `-A` where XDS was anomalous, which changes how the
+merging statistics count (unique reflections, multiplicity, I/sigma, ISa), so expect those to
+move there against an old run; its `xds` rows, which
+forced XDS's range on the processing, have no counterpart and are left out. A schema-1 run is read
+as schema 2 with one variant first (`bare` on the open arm; on the XDS arms `xds`, or `bare` if it
+was run `--unforced`), so its forced XDS-arm rows are left out the same way.
+`compare --rerun-changed` needs A to be a schema-3 run.
 
 | key | meaning |
 |---|---|
-| `set`, `arm`, `variant`, `tags`, `input`, `cmd` | the set's id, arm, variant (`bare`, `model`, `xds`), population tags, input file, and the exact command that ran |
-| `first_read` | true for the first variant of its set that ran: the one that read the images from disk |
-| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing, or no model for the `model` variant) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` / `no_model` |
+| `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
+| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` |
 | `reason` | one line for a human |
-| `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours / the reference's |
+| `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
+| `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
 | `sg_relation` | open arm: how the two groups relate (`sgequiv`) |
 | `cell`, `cell_ref`, `cell_dev_pct`, `volume_ratio` | cells, the largest edge deviation in % (over axis orders), and the primitive volume ratio |
 | `d_min`, `d_min_ref`, `res_gain_pct` | our high-resolution limit, the reference's, and (ref - ours) / ref in % |
 | `d_min_ref_rule`, `d_min_xds` | XDS arms: how `d_min_ref` was derived (below), and the range XDS merged |
-| `r_meas`, `cc_half`, `isa`, `completeness`, `multiplicity`, `i_over_sigma`, `indexing_rate`, `images` | from rugnux's `_report.txt` |
-| `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref` | XDS's overall values, over XDS's own range |
-| `rfree`, `rwork`, `model_fit`, `rfree_deposited`, `rfree_ratio` | `model` variant: R-free, R-work and MODEL_FIT as rugnux reports them for the deposited model, the published R-free, and rfree / rfree_deposited |
-| `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm, `bare` rows) |
+| `r_meas`, `cc_half`, `isa`, `completeness`, `multiplicity`, `i_over_sigma`, `indexing_rate`, `images` | from rugnux's `_report.txt`, over its own range |
+| `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref`, `multiplicity_ref` | XDS's overall values, over XDS's own range |
+| `refres_range`, `refres_shells_past_limit`, `refres_unique_reflections`, `refres_completeness`, `refres_multiplicity`, `refres_i_over_sigma`, `refres_r_meas`, `refres_cc_half`, `refres_isa` | XDS arms: the REFRES_* keys, the same merge over the reference range |
+| `isa_ratio`, `r_meas_ratio` | refres_isa / isa_ref and refres_r_meas / r_meas_ref |
+| `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
+| `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
+| `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm) |
 | `wall_s`, `rugnux_wall_s`, `elapsed_s`, `exit_code`, `gpu_others`, `rugnux_verdict` | timing (`wall_s` is rugnux's own WALL_TIME, not the time spent waiting for the GPU queue), the exit code, other GPU processes seen before the set, and rugnux's own verdict line |
 
 ## The report
@@ -242,19 +250,19 @@ passed `-A`).
 Every run writes the same report as Markdown and as a self-contained HTML page (inline CSS and
 SVG, no external files):
 
-- a header with the binary, build flags, host, subset, variants and whether timing counts;
-- a **timing** table per variant, saying which variant's times include reading the data;
-- **a section per variant**, each with:
-  - a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain,
-    ISa, R_meas, time) with a verdict bar chart;
-  - a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
-    the main metrics;
-  - plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
-    for each arm (not for `xds`, whose resolution is forced), and, for `model`, R_free / published
-    R_free;
-  - the **failures**, and **one row per set** with all the numbers;
-- if there is a baseline, the **delta against it**: pass rates per arm and variant on the common
-  rows, and every row that moved beyond noise.
+- a header with the binary, build flags, host, subset, each arm's command and whether timing counts;
+- a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain, ISa,
+  R_meas, time) with a verdict bar chart, all from rugnux's own run;
+- a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
+  the main metrics;
+- plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
+  for each arm; on the XDS arms the reference-range ISa and R_meas over XDS's; on the open arm
+  R_free / published R_free;
+- on the XDS arms the **like-for-like table**: the reference-range numbers beside XDS's, with the
+  rows where rugnux's cut is coarser marked as coverage;
+- the **failures**, and **one row per set** with all the numbers;
+- if there is a baseline, the **delta against it**: pass rates per arm on the common sets, and
+  every set that moved beyond noise.
 
 Re-render a report, for example against another baseline (run directories are read-only, so the
 output goes elsewhere and is named after the run):
@@ -275,10 +283,11 @@ $B compare RUN_A RUN_B [--all]                      # per-set table of what move
 $B compare RUN_A RUN_B --rerun-changed              # rerun the changed sets with A's binary
 ```
 
-`compare` pairs rows by arm, set id and variant, following the manifests' `aliases` across
-renames. Only the variants both runs ran on an arm are compared, so a `--variants bare` run against a full
-one compares `bare`. It lists every row whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell,
-R-free or time moved by more than the noise thresholds in `report.py` (`NOISE`). Those thresholds
+`compare` pairs rows by arm and set id, following the manifests' `aliases` across renames. A run
+from before schema 3 is compared through its `bare` rows (see the schema above). It lists every
+row whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell, R-free,
+reference-range R_meas or ISa (where both runs have them), or time moved by more than the noise
+thresholds in `report.py` (`NOISE`). Those thresholds
 are a first guess. `--rerun-changed` measures the noise directly: it reruns the changed sets with
 A's saved binary and options. A set that moves again under the same binary is noise. A set that
 reproduces A was really changed by B.
@@ -295,11 +304,12 @@ reproduces A was really changed by B.
    fix. For one fix, run the sets it touches with `--only`, plus the smoke tier.
 4. **Timing.** `--gpulock`, or another process seen on the GPU, marks the run "timing NOT a
    reference". Only a run with the machine to itself can be used to judge speed.
-5. **Resolution on the XDS arms.** The `xds` variant forces XDS's resolution range (and `-A`
-   where XDS kept Friedel mates apart), so both programs merge the same reflections and the
-   statistics are like for like. This answers "is our processing better than XDS's, reflection for
-   reflection". The `bare` variant answers "what does a user get". A change can win one and lose
-   the other, and every run has both. Never quote the `xds` variant as what rugnux delivers.
+5. **Resolution on the XDS arms.** Nothing forces XDS's range on the processing any more: rugnux
+   keeps its own cut, and the reference-range table re-bins the same merge over XDS's range.
+   The own numbers answer "what does a user get"; the reference-range numbers answer "is our
+   merge better than XDS's over the same range". Where rugnux's cut is coarser than XDS's, the
+   second question is only answered over the shells rugnux reached, and the missing shells are
+   coverage.
 
 ### The XDS reference d_min
 
@@ -315,7 +325,7 @@ is significant, and that decides which case applies (`inputs.reference_dmin`):
   point where XDS's CC1/2 falls through 0.30 (the target of rugnux's own cutoff), interpolated in
   1/d² between shell centres.
 
-The derived value is both the score reference and the range the `xds` variant forces. The manifest keeps XDS's own
+The derived value is both the score reference and the d_min of the reference-range table. The manifest keeps XDS's own
 limit as `dmin_xds` and the rule used as `dmin_rule`. XDS's pooled R_meas, CC1/2 and completeness
 still cover its whole range.
 
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 4d31afa80..5fae02de1 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -12,7 +12,7 @@ Arms and where their truth comes from:
 
 Usage (README.md in this directory is the full guide):
   battery.py run --rugnux BIN [--label L] [--arm open,inhouse|private] [--only a,b | --tier smoke]
-                 [--variants bare,model,xds] [--build-dir DIR] [--gpulock] [--threads N]
+                 [--build-dir DIR] [--gpulock] [--threads N]
                  [--model-check] [--baseline RUN|none]
   battery.py list                                 runs under the runs root, with their state
   battery.py compare RUN_A RUN_B [--all] [--rerun-changed]
@@ -25,13 +25,14 @@ Usage (README.md in this directory is the full guide):
 The site config (data roots, runs root, lock, gpulock, private manifest, baselines) is --site, else
 $JFJOCH_BATTERY_SITE, else site.json beside this script (not committed; site.example.json is).
 
-Every set runs in each of its arm's VARIANTS (bare + model on the open arm, bare + xds on the XDS
-arms), one straight after the other, so only the first reads the images from disk.
+Every set runs once, with one command per arm (COMMAND_DOC): the open arm with the deposited model
+(--model), the XDS arms with -A where XDS was anomalous and XDS's range as a report-only second
+table (--report-resolution). Neither option changes the processing, so the one run is both what a
+user gets and the like-for-like comparison.
 
 A run writes <runs_root>/<YYYYMMDD-HHMM>_<rugnux git>_<label>/ holding a copy of the binary,
-manifest.json (what was run, on what, with which references), results.json (one row per set and
-variant), report.md + report.html and work/<arm>/<set>/<variant>/ (log, report, cif). It is made
-read-only when done.
+manifest.json (what was run, on what, with which references), results.json (one row per set),
+report.md + report.html and work/<arm>/<set>/ (log, report, cif). It is made read-only when done.
 A full-arm run (no --only / --tier) takes the site lock and refuses to start if another holds it.
 A run that did not finish is never compared or reported on unless asked (--allow-incomplete).
 """
@@ -57,22 +58,18 @@ import inputs  # noqa: E402
 import report  # noqa: E402
 import score   # noqa: E402
 
-import model_check  # noqa: E402  the deposited model (model variant); REFMAC check (--model-check)
+import model_check  # noqa: E402  the deposited model (--model); REFMAC check (--model-check)
 
 PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
 
-# The variants every set of an arm runs in, by the arm's reference, in the order they run. All the
-# variants of one set run back to back, so only the first reads the images from disk and the later
-# ones find them in the page cache. `bare` goes first: it is in every arm, so its time is taken
-# under the same condition (the set's first read) whichever variants a run selects, and it is the
-# number a user sees.
-VARIANTS = {"deposition": ["bare", "model"], "xds": ["bare", "xds"]}
-VARIANT_DOC = {
-    "bare": "plain `rugnux <input>`, nothing else: what a user gets",
-    "model": "`rugnux --model <deposited coordinates>`: R-free of the deposited model against our merge, "
-             "as rugnux reports it",
-    "xds": "XDS's reference settings: its resolution range forced, and -A where XDS kept Friedel mates "
-           "apart, so both programs merge the same reflections the same way",
+# The one command each set runs, by its arm's reference. --model and --report-resolution only add
+# to the report (the merge is the same with and without them), so this one run is what a user
+# gets and carries the like-for-like numbers too.
+COMMAND_DOC = {
+    "deposition": "`rugnux --model <deposited coordinates> <input>` (without --model where there is no "
+                  "deposited model: small molecules, unpublished sets)",
+    "xds": "`rugnux [-A] --report-resolution <reference d_min>,<XDS d_max> <input>`: -A where XDS kept "
+           "Friedel mates apart; the second statistics table at XDS's range is report-only",
 }
 
 LOCAL_SITE = os.path.join(HERE, "site.json")
@@ -171,22 +168,21 @@ def gpu_others():
 
 # ------------------------------------------------------------------ running
 
-def command(binary, e, variant, opts, model=None):
+def command(binary, e, opts, model=None):
     cmd = [binary, "-o", "p", "--no-export-unmerged"]
     if opts["threads"]:
         cmd += ["-N", str(opts["threads"])]
     ref = e.get("ref") or {}
-    if variant == "xds":
-        # XDS's resolution range, so the two programs merge the same reflections
-        if ref.get("dmin"):
-            cmd += ["--scaling-high-resolution", f"{ref['dmin']:.3f}"]
-        if ref.get("dmax"):
-            cmd += ["--scaling-low-resolution", f"{ref['dmax']:.3f}"]
+    if e["reference"] == "xds":
         # XDS merged with FRIEDEL'S_LAW=FALSE: merge Friedel mates separately too, or the merging
         # statistics are not comparable
         if ref.get("anomalous"):
             cmd.append("-A")
-    if variant == "model":
+        # a second statistics table over XDS's range, from the same merge (report only)
+        if ref.get("dmin"):
+            cmd += ["--report-resolution",
+                    f"{ref['dmin']:.3f}" + (f",{ref['dmax']:.3f}" if ref.get("dmax") else "")]
+    if model:
         cmd += ["--model", model]
     cmd += opts["extra_args"]
     cmd.append(e["input_path"])
@@ -219,25 +215,23 @@ def deposited_model(e, opts):
     return meta, None
 
 
-def run_one(run_dir, binary, e, variant, first_read, opts):
-    wd = os.path.join(run_dir, "work", e["arm"], e["id"], variant)
+def run_one(run_dir, binary, e, opts):
+    wd = os.path.join(run_dir, "work", e["arm"], e["id"])
     os.makedirs(wd)
-    row = {"set": e["id"], "arm": e["arm"], "variant": variant, "first_read": first_read,
-           "tags": e.get("tags", []), "input": e["input_path"], "gpu_others": gpu_others(),
-           "rfree_deposited": None, "rfree_ratio": None, "cmd": None, "exit_code": None,
-           "elapsed_s": None, "wall_s": None}
+    row = {"set": e["id"], "arm": e["arm"], "tags": e.get("tags", []), "input": e["input_path"],
+           "gpu_others": gpu_others(), "model": None, "model_note": None, "rfree_deposited": None,
+           "rfree_ratio": None, "cmd": None, "exit_code": None, "elapsed_s": None, "wall_s": None}
     row.update({k: None for k in REFMAC_KEYS})
     if not os.path.exists(e["input_path"]):
         row.update(score.judge(e, {}, "no input"))
         return row
     meta = None
-    if variant == "model":
-        meta, why = deposited_model(e, opts)
-        if meta is None:
-            row.update(score.judge(e, {}, why))
-            return row
-        row["rfree_deposited"] = meta["rfree"]
-    cmd = command(binary, e, variant, opts, meta and meta["xyz"])
+    if e["reference"] == "deposition":
+        # no deposited model (small molecule, unpublished): the same command without --model
+        meta, row["model_note"] = deposited_model(e, opts)
+        if meta:
+            row["model"], row["rfree_deposited"] = meta["xyz"], meta["rfree"]
+    cmd = command(binary, e, opts, row["model"])
     row["cmd"] = " ".join(cmd)
     t0 = time.time()
     note = ""
@@ -257,12 +251,12 @@ def run_one(run_dir, binary, e, variant, first_read, opts):
     row["wall_s"] = row["rugnux_wall_s"] if row["rugnux_wall_s"] is not None else row["elapsed_s"]
     if row["rfree"] and row["rfree_deposited"]:
         row["rfree_ratio"] = round(row["rfree"] / row["rfree_deposited"], 4)
-    if opts["model_check"] and e["arm"] == "open" and variant == "bare":
+    if opts["model_check"] and e["arm"] == "open":
         row.update(check_model(e, wd))
     return row
 
 
-# what the REFMAC model check (model_check.py, --model-check) adds to an open-arm bare row
+# what the REFMAC model check (model_check.py, --model-check) adds to an open-arm row
 REFMAC_KEYS = ("refmac_rfree", "refmac_rwork", "refmac_rfree_depflags", "refmac_rfree_depdata",
                "refmac_rfree_ratio", "refmac_status", "refmac_reason")
 
@@ -356,10 +350,8 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     for e in sets:
         e["reference"] = site["arms"][e["arm"]]["reference"]
         e.setdefault("input_path", os.path.join(site["arms"][e["arm"]]["data_root"], e["input"]))
-    variants = {arm: [v for v in VARIANTS[site["arms"][arm]["reference"]] if v in opts["variants"]]
-                for arm in arms}
     man = {"label": label, "arms": arms, "private": private, "subset": subset, "baseline": baseline,
-           "variants": variants, "variant_doc": {v: VARIANT_DOC[v] for v in opts["variants"]},
+           "command_doc": {arm: COMMAND_DOC[site["arms"][arm]["reference"]] for arm in arms},
            "binary": info,
            "runner_git": git(HERE, "rev-parse", "--short", "HEAD") or "unknown",
            "runner_dirty": bool(git(HERE, "status", "--porcelain", "--", ".")),
@@ -370,25 +362,20 @@ def run_sets(site, sets, arms, binary_src, build_dir, label, opts, subset, basel
     print(f"run directory {run_dir}", flush=True)
 
     results = []
-    todo = sum(len(variants[e["arm"]]) for e in sets)
     # a kill by SIGTERM is recorded like Ctrl-C: the run directory then says it was aborted
     signal.signal(signal.SIGTERM, interrupted)
     try:
         for e in sets:
-            # the variants of one set back to back: only the first rugnux reads the images from disk
-            first_read = True
-            for v in variants[e["arm"]]:
-                row = run_one(run_dir, binary, e, v, first_read, opts)
-                first_read = first_read and row["cmd"] is None
-                results.append(row)
-                if row.get("gpu_others"):
-                    man["gpu_shared"] = True
-                write_json(os.path.join(run_dir, "results.json"), results)
-                print(f"[{len(results)}/{todo}] {e['arm']:8s} {e['id']:24s} {v:6s} {row['verdict']:8s} "
-                      f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
-                      f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
+            row = run_one(run_dir, binary, e, opts)
+            results.append(row)
+            if row.get("gpu_others"):
+                man["gpu_shared"] = True
+            write_json(os.path.join(run_dir, "results.json"), results)
+            print(f"[{len(results)}/{len(sets)}] {e['arm']:8s} {e['id']:24s} {row['verdict']:8s} "
+                  f"{row.get('sg') or '-':12s} d={report.f(row.get('d_min'))} "
+                  f"t={report.f(row.get('wall_s'), '{:.0f}')}s  {row.get('reason') or ''}", flush=True)
     except KeyboardInterrupt:
-        mark_aborted(run_dir, f"interrupted after {len(results)} of {todo} rows")
+        mark_aborted(run_dir, f"interrupted after {len(results)} of {len(sets)} sets")
         sys.exit(f"aborted; {run_dir} is marked as such")
 
     man.update(end=datetime.datetime.now().isoformat(timespec="seconds"), complete=True)
@@ -430,15 +417,7 @@ def cmd_run(a, site):
     if not sets:
         sys.exit("nothing selected")
     subset = a.only or (f"tier {a.tier}" if a.tier else None)
-    known = [v for vs in VARIANTS.values() for v in vs]
-    want = [v.strip() for v in a.variants.split(",")] if a.variants else known
-    if set(want) - set(known):
-        sys.exit(f"unknown variant(s) {', '.join(sorted(set(want) - set(known)))}; "
-                 f"there are {', '.join(dict.fromkeys(known))}")
-    if not any(v in want for arm in arms for v in VARIANTS[site["arms"][arm]["reference"]]):
-        sys.exit(f"none of the variants {a.variants} runs on the {'/'.join(arms)} arm(s)")
-    opts = {"threads": a.threads, "variants": [v for v in dict.fromkeys(known) if v in want],
-            "timeout": a.timeout, "model_check": a.model_check and "open" in arms,
+    opts = {"threads": a.threads, "timeout": a.timeout, "model_check": a.model_check and "open" in arms,
             "pdb_cache": site.get("pdb_cache") or model_check.DEFAULT_CACHE,
             "gpulock": site["gpulock"] if a.gpulock else None, "extra_args": a.extra.split(),
             "runs_root": a.runs_root or site["runs_root"]}
@@ -481,9 +460,7 @@ def cmd_compare(a, site):
                      f"{os.path.basename(os.path.normpath(a.run_b))}")
     doc.p(f"A: rugnux {man_a['binary'].get('version')} ({man_a['binary']['sha256'][:12]}); "
           f"B: rugnux {man_b['binary'].get('version')} ({man_b['binary']['sha256'][:12]}). "
-          f"{len(rows)} set/variant rows, {sum(1 for r in rows if r[3])} changed beyond noise. "
-          f"Variants compared: {report.pairs_text(report.common_variants(res_a, res_b))} "
-          "(the ones both runs have).")
+          f"{len(rows)} sets, {sum(1 for r in rows if r[3])} changed beyond noise.")
     report.compare_table(doc, rows, only_changed=not a.all)
     print(doc.markdown())
     if not a.rerun_changed:
@@ -494,9 +471,10 @@ def cmd_compare(a, site):
     if not changed:
         print("nothing changed beyond noise; no rerun")
         return
-    sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in {k[:2] for k in changed}]
-    opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"],
-                variants=[v for v in VARIANT_DOC if v in {k[2] for k in changed}])
+    if man_a.get("results_schema", 1) < report.RESULTS_SCHEMA:
+        sys.exit("--rerun-changed: A ran the older variant commands; rerun it with this runner instead")
+    sets = [e for e in man_a["sets"] if (e["arm"], e["id"]) in changed]
+    opts = dict(man_a["options"], runs_root=a.runs_root or site["runs_root"])
     opts["gpulock"] = opts["gpulock"] and site.get("gpulock")
     opts.setdefault("pdb_cache", site.get("pdb_cache") or model_check.DEFAULT_CACHE)
     label = "rerunA-" + man_a["label"]
@@ -510,10 +488,10 @@ def cmd_compare(a, site):
         if k not in changed:
             continue
         noise = [c for c in again.get(k, []) if c != "time"]
-        rows_out.append([k[1], k[0], k[2], ", ".join(c for c in ch if c != "time"),
+        rows_out.append([k[1], k[0], ", ".join(c for c in ch if c != "time"),
                          ", ".join(noise) or "-",
                          "NOISE - A itself moved" if noise else "REAL - A reproduces"])
-    doc.table(["set", "arm", "variant", "A -> B", "A -> A again", "reading"], rows_out)
+    doc.table(["set", "arm", "A -> B", "A -> A again", "reading"], rows_out)
     doc.p(f"rerun directory: {rerun}")
     print(doc.markdown())
 
@@ -631,11 +609,9 @@ def main():
     r.add_argument("--gpulock", action="store_true",
                    help="queue each rugnux behind the site's GPU lock (timing is then not a reference)")
     r.add_argument("--threads", type=int, default=0, help="-N for rugnux (default: its own choice)")
-    r.add_argument("--variants", help="comma-separated subset of bare,model,xds (default: all of "
-                                      "each arm's variants; e.g. 'bare' for what a user gets)")
     r.add_argument("--timeout", type=int, default=10800, help="per rugnux run, in s")
     r.add_argument("--model-check", action="store_true",
-                   help="open arm: also score each bare merge against the deposited model with "
+                   help="open arm: also score each merge against the deposited model with "
                         "REFMAC (model_check.py; needs CCP4)")
     r.add_argument("--extra", default="", help="extra rugnux arguments, applied to every set")
     r.add_argument("--baseline", help="earlier run directory to report the delta against (default: "
diff --git a/tools/battery/report.py b/tools/battery/report.py
index dfbe7e323..df86c2e13 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -17,6 +17,8 @@ NOISE = {
     "completeness": ("abs", 1.0),   # percentage points
     "cell_dev_pct": ("abs", 0.2),   # percentage points
     "rfree": ("abs", 0.005),
+    "refres_r_meas": ("rel", 0.05),
+    "refres_isa": ("rel", 0.05),
     "wall_s": ("rel", 0.25),        # and at least 10 s - see beyond_noise()
 }
 
@@ -46,8 +48,11 @@ def load_run(run_dir, allow_incomplete=False):
         sys.exit(f"{run_dir} is {state}, not a finished run; pass --allow-incomplete to use it anyway")
     path = os.path.join(run_dir, "results.json")
     res = json.load(open(path)) if os.path.exists(path) else []
-    if man.get("results_schema", 1) < 2:
+    schema = man.get("results_schema", 1)
+    if schema < 2:
         schema1(man, res)
+    if schema < 3:
+        res[:] = schema2(res)
     return man, res
 
 
@@ -57,19 +62,34 @@ def schema1(man, res):
     range free but still passed -A, and is read as `bare`. Its R-factors came from the REFMAC check."""
     for r in res:
         r.setdefault("variant", "xds" if r["arm"] != "open" and man["options"].get("xds_range") else "bare")
-        r.setdefault("first_read", True)
         if "model_status" in r:
             for k in ("rfree", "rwork", "rfree_depflags", "rfree_depdata", "rfree_ratio"):
                 r["refmac_" + k] = r.pop(k, None)
             r["refmac_status"], r["refmac_reason"] = r.pop("model_status"), r.pop("model_reason", None)
             r["rfree_deposited"] = None
-    man.setdefault("variants", {arm: sorted({r["variant"] for r in res if r["arm"] == arm})
-                                for arm in man["arms"]})
-    man.setdefault("variant_doc", {})
+
+
+def schema2(res):
+    """Read a run with variants (schema 2) as one run per set: its `bare` row, with the open arm's
+    `model` row's R-factors folded in. That is today's processing on the open arm; on the XDS arms
+    today's command adds -A where XDS was anomalous. The `xds` rows (XDS's range forced on the
+    processing) have no counterpart and are left out."""
+    model = {r["set"]: r for r in res if r["variant"] == "model"}
+    out = []
+    for r in res:
+        if r["variant"] != "bare":
+            continue
+        m = model.get(r["set"])
+        if m:
+            r.update({k: m.get(k) for k in ("rfree", "rwork", "model_fit", "rfree_deposited", "rfree_ratio")})
+        out.append(r)
+    return out
 
 
 def expected_rows(man):
-    """Rows a finished run has: one per set and variant."""
+    """Rows a finished run has: one per set (per set and variant before schema 3)."""
+    if man.get("results_schema", 1) >= 3:
+        return len(man["sets"])
     return sum(len(man.get("variants", {}).get(e["arm"], [None])) for e in man["sets"])
 
 
@@ -86,7 +106,9 @@ def check_baseline(baseline, private):
 # meaning or is removed; adding a field does not need it.
 # 2: one row per set AND variant (`variant`, `first_read`); `rfree`/`rwork`/`rfree_ratio` are rugnux's
 #    own --model R-factors, the REFMAC check's moved to `refmac_*`.
-RESULTS_SCHEMA = 2
+# 3: one row per set again (one command per arm, no `variant`/`first_read`); `refres_*` added;
+#    `sgno`/`sg` are the data's own group where --model relabelled the hand (`sg_label`).
+RESULTS_SCHEMA = 3
 
 # {arm: {old set id: current id}} from the manifests (battery.py sets it), so a run made before a
 # dataset was renamed still pairs with one made after
@@ -94,25 +116,7 @@ ALIASES = {}
 
 
 def key(r):
-    return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]), r["variant"])
-
-
-# the order variants are listed in (battery.VARIANTS runs them in this order within an arm)
-VARIANT_ORDER = ("bare", "model", "xds")
-
-
-def variants_of(res):
-    return [v for v in VARIANT_ORDER if any(r["variant"] == v for r in res)]
-
-
-def common_variants(res_a, res_b):
-    """The (arm, variant) pairs both runs ran - what a comparison of the two covers."""
-    pairs = lambda res: {(r["arm"], r["variant"]) for r in res}
-    return sorted(pairs(res_a) & pairs(res_b), key=lambda p: (p[0], VARIANT_ORDER.index(p[1])))
-
-
-def pairs_text(pairs):
-    return ", ".join(f"{arm} {v}" for arm, v in pairs) or "none"
+    return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]))
 
 
 def f(x, fmt="{:.2f}", dash="-"):
@@ -161,18 +165,19 @@ def changes(ra, rb):
     for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct", "rfree"):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
+    # the like-for-like table only where both runs have one (a pre-schema-3 run has none)
+    for name in ("refres_r_meas", "refres_isa"):
+        if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
+            out.append(name)
     if beyond_noise("wall_s", ra.get("wall_s"), rb.get("wall_s")):
         out.append("time")
     return out
 
 
 def compare_rows(res_a, res_b):
-    """[(key, ra, rb, changes)] over the (set, variant) rows both runs have, then those only one
-    has. Only the variants both runs ran on an arm are compared: a run of just `bare` against a
-    full one is a comparison of `bare`."""
-    common = common_variants(res_a, res_b)
-    a = {key(r): r for r in res_a if (r["arm"], r["variant"]) in common}
-    b = {key(r): r for r in res_b if (r["arm"], r["variant"]) in common}
+    """[(key, ra, rb, changes)] over the sets both runs have, then those only one has."""
+    a = {key(r): r for r in res_a}
+    b = {key(r): r for r in res_b}
     rows = [(k, a[k], b[k], changes(a[k], b[k])) for k in sorted(a) if k in b]
     rows += [(k, a[k], None, ["only in A"]) for k in sorted(a) if k not in b]
     rows += [(k, None, b[k], ["only in B"]) for k in sorted(b) if k not in a]
@@ -186,14 +191,14 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 
 def compare_table(doc, rows, only_changed=True):
-    head = ["set", "arm", "variant", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "R_free", "time s", "beyond noise"]
+    head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
+            "cell dev %", "R_free", "ref-range R_meas", "time s", "beyond noise"]
     out = []
-    for (arm, s, v), ra, rb, ch in rows:
+    for (arm, s), ra, rb, ch in rows:
         if only_changed and not ch:
             continue
         ra, rb = ra or {}, rb or {}
-        out.append([s, arm, v, arrow(ra.get("verdict"), rb.get("verdict")),
+        out.append([s, arm, arrow(ra.get("verdict"), rb.get("verdict")),
                     arrow(ra.get("sg"), rb.get("sg")),
                     arrow(ra.get("d_min"), rb.get("d_min"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("isa"), rb.get("isa"), lambda v: f"{v:.1f}"),
@@ -201,6 +206,7 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("cc_half"), rb.get("cc_half"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
+                    arrow(ra.get("refres_r_meas"), rb.get("refres_r_meas"), lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("wall_s"), rb.get("wall_s"), lambda v: f"{v:.0f}"),
                     ", ".join(ch)])
     doc.table(head, out, row_class=lambda r: "fail" if "verdict" in r[-1] else "")
@@ -234,79 +240,25 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     state = run_state(man)
     if state != "complete":
         why = f" ({man['aborted']['reason']})" if man.get("aborted") else ""
-        doc.p(f"RUN {state.upper()}{why}: {len(res)} of {expected_rows(man)} set/variant rows have a "
+        doc.p(f"RUN {state.upper()}{why}: {len(res)} of {expected_rows(man)} rows have a "
               "result. Not a reference and not comparable with a finished run.")
-    variants = variants_of(res)
+    if man.get("results_schema", 1) < 3:
+        doc.p("A run from before the one-command battery: shown by its `bare` rows (with the `model` "
+              "rows' R-factors on the open arm); its `xds` rows have no counterpart and are left out.")
     doc.ul([
         f"rugnux {b.get('version', '?')}, sha256 {b['sha256'][:16]}, build flags: {b.get('flags') or 'unknown'}",
         f"runner {man['runner_git']}, host {man['host']}, {man['start']} -> {man.get('end') or 'NOT FINISHED'}",
         f"arms: {', '.join(man['arms'])}; {len(man['sets'])} sets"
         + (f" (subset: {man['subset']})" if man.get("subset") else " (full arm)"),
-        "variants: " + "; ".join(f"{arm}: {', '.join(man['variants'][arm])}" for arm in man["arms"]
-                                 if man["variants"].get(arm)),
         "timing: NOT a reference - the GPU was shared" if man.get("gpu_shared")
         else "timing: GPU was not shared during the run",
         f"command options: {' '.join(man['options']['extra_args']) or '(none beyond output selection)'}",
-    ] + [f"variant {v}: {man['variant_doc'][v]}" for v in variants if man["variant_doc"].get(v)])
+    ] + [f"command, {arm} arm: {d}" for arm, d in man.get("command_doc", {}).items()])
 
-    doc.h(2, "Timing")
-    rows = []
-    for v in variants:
-        rs = [r for r in res if r["variant"] == v and r.get("wall_s") is not None]
-        rows.append([v, len(rs), f"{sum(bool(r.get('first_read')) for r in rs)}/{len(rs)}",
-                     f(median(r["wall_s"] for r in rs), "{:.0f}"),
-                     f(sum(r["wall_s"] for r in rs) / 60, "{:.1f}")])
-    doc.table(["variant", "rows run", "first read of the set", "median time s", "total time min"],
-              rows, num=range(1, 5))
-    doc.p("The variants of a set run back to back, in the order listed. The first one to run reads "
-          "the images from disk (unless they were still in the page cache from before the run); the "
-          "later ones find them in the page cache. So only the first variant's times include reading "
-          "the data - normally `bare`, which runs first on every arm - and times are comparable only "
-          "between runs of the same variant.")
-
-    derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
-    if derived:
-        doc.p("XDS merged past its own signal (CC1/2 of its finest shell not significant), so the "
-              "reference d_min is where XDS's CC1/2 falls through 0.30, and that is also the range "
-              "the xds variant forces on rugnux: "
-              + "; ".join(f"{s} (XDS range {f(r.get('d_min_xds'))} A, reference "
-                          f"{f(r.get('d_min_ref'))} A)" for s, r in sorted(derived.items()))
-              + ". XDS's pooled R_meas, CC1/2 and completeness are over its whole range.")
-
-    for v in variants:
-        variant_section(doc, man, [r for r in res if r["variant"] == v], v)
-
-    if baseline:
-        bman, bres = load_run(baseline)
-        doc.h(2, f"Delta vs baseline {os.path.basename(os.path.normpath(baseline))}")
-        common = common_variants(bres, res)
-        doc.p(f"Baseline rugnux {bman['binary'].get('version', '?')}. Pass rates on the set/variant "
-              f"rows both runs have (variants compared: {pairs_text(common)}):")
-        both = {key(r) for r in res} & {key(r) for r in bres}
-        rows = []
-        for arm, v in common:
-            ra = [r for r in bres if key(r) in both and r["arm"] == arm and r["variant"] == v]
-            rb = [r for r in res if key(r) in both and r["arm"] == arm and r["variant"] == v]
-            rows.append([arm, v, len(rb), rate(ra), rate(rb)])
-        doc.table(["arm", "variant", "common sets", "baseline", "this run"], rows, num=(2,))
-        doc.p("Rows whose result moved beyond noise (thresholds in report.py NOISE; confirm with "
-              "`compare --rerun-changed` before believing a single-set change):")
-        compare_table(doc, compare_rows(bres, res))
-    return doc
-
-
-def variant_section(doc, man, res, v):
-    """Summary, populations, distributions, plots, failures and the per-set table of one variant."""
-    forced = v == "xds"               # XDS's resolution range imposed: d_min ratio 1 by construction
     arms = [arm for arm in man["arms"] if any(r["arm"] == arm for r in res)]
     order = {arm: i for i, arm in enumerate(arms)}
 
-    def gain(rs):
-        return "forced" if forced else f(median(r.get("res_gain_pct") for r in rs), "{:+.1f}%")
-
-    doc.h(2, f"Variant {v}")
-    if man["variant_doc"].get(v):
-        doc.p(man["variant_doc"][v][0].upper() + man["variant_doc"][v][1:] + ".")
+    doc.h(2, "Summary")
     head = ["arm", "sets", "pass", "fail", "unscored", "not run", "pass rate",
             "median res. gain", "median ISa", "median R_meas", "median time s", "total time min"]
     rows = []
@@ -315,74 +267,118 @@ def variant_section(doc, man, res, v):
         cnt = {x: sum(r["verdict"] == x for r in rs) for x in ("pass", "fail", "unscored", "not_run")}
         xs = crystals(rs)
         rows.append([arm, len(rs), cnt["pass"], cnt["fail"], cnt["unscored"], cnt["not_run"], rate(rs),
-                     gain(xs), f(median(r.get("isa") for r in xs), "{:.1f}"),
+                     f(median(r.get("res_gain_pct") for r in xs), "{:+.1f}%"),
+                     f(median(r.get("isa") for r in xs), "{:.1f}"),
                      pct(median(r.get("r_meas") for r in xs)),
                      f(median(r.get("wall_s") for r in rs), "{:.0f}"),
                      f(sum(r.get("wall_s") or 0 for r in rs) / 60, "{:.1f}")])
     doc.table(head, rows, num=range(1, 12))
     doc.svg(verdict_bars([(arm, {x: sum(r["verdict"] == x and r["arm"] == arm for r in res)
                                  for x in ("pass", "fail", "unscored", "not_run")})
-                          for arm in arms]), f"{v}: verdicts per arm")
-    doc.p("Pass rate is over the scored sets (pass + fail). Resolution gain is (reference d_min - "
-          "our d_min) / reference d_min: positive = finer than the deposition, or than XDS; 'forced' "
-          "where XDS's resolution range was imposed, which makes it zero by construction. Medians "
-          "leave out the no-crystal controls. R_meas and CC1/2 are pooled over each run's own "
-          "resolution range, so they describe a run and do not rank two.")
+                          for arm in arms]), "verdicts per arm")
+    doc.p("Pass rate is over the scored sets (pass + fail). Every number in this table is rugnux's own "
+          "run at its own resolution cut: what a user gets. Resolution gain is (reference d_min - our "
+          "d_min) / reference d_min: positive = finer than the deposition, or than XDS. Medians leave "
+          "out the no-crystal controls. R_meas and CC1/2 are pooled over each run's own resolution "
+          "range, so they describe a run and do not rank two; the like-for-like comparison with XDS "
+          "is the reference-range table below. Each set runs once, so every time includes reading "
+          "its images from disk (unless they were still in the page cache from before the run).")
 
-    doc.h(3, f"{v}: by population")
+    doc.h(3, "By population")
     rows = []
     for arm in arms:
         rs = [r for r in res if r["arm"] == arm]
         for tag in sorted({t for r in rs for t in r.get("tags", [])}):
             sub = [r for r in rs if tag in r.get("tags", [])]
-            rows.append([arm, tag, len(sub), rate(sub), gain(sub)])
+            rows.append([arm, tag, len(sub), rate(sub), f(median(r.get("res_gain_pct") for r in sub), "{:+.1f}%")])
     doc.table(["arm", "population", "sets", "pass rate", "median res. gain"], rows, num=(2, 4))
 
-    doc.h(3, f"{v}: distributions (sets that merged, controls left out)")
+    doc.h(3, "Distributions (sets that merged, controls left out)")
     rows = []
     for arm in arms:
         rs = crystals(r for r in res if r["arm"] == arm)
         for name, lab, fm in (("isa", "ISa", "{:.1f}"), ("r_meas", "R_meas", None),
                               ("cc_half", "CC1/2", "{:.3f}"), ("res_gain_pct", "res. gain %", "{:+.1f}"),
+                              ("isa_ratio", "ref-range ISa / XDS", "{:.3f}"),
+                              ("r_meas_ratio", "ref-range R_meas / XDS", "{:.3f}"),
+                              ("rfree", "R_free (placement)", "{:.3f}"),
                               ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
-            if name == "res_gain_pct" and forced:
-                continue
             q = quartiles(r.get(name) for r in rs)
             if q:
                 cells = [pct(x) if fm is None else f(x, fm) for x in q]
                 rows.append([arm, lab, sum(r.get(name) is not None for r in rs)] + cells)
     doc.table(["arm", "metric", "n", "min", "q1", "median", "q3", "max"], rows, num=range(2, 8))
 
-    doc.h(3, f"{v}: per set, against the reference")
+    doc.h(3, "Per set, against the reference")
     for arm in arms:
-        if forced:
-            doc.p(f"{arm}: d_min forced to the reference's, so its ratio is 1 by construction.")
-            continue
         pts = [(r["set"], r["d_min"] / r["d_min_ref"], r["verdict"],
                 f"d_min {r['d_min']:.2f} vs {r['d_min_ref']:.2f} A, {r['verdict']}")
                for r in res if r["arm"] == arm and r.get("d_min") and r.get("d_min_ref")]
         if pts:
-            doc.svg(ratio_dots(pts, f"{arm} {v}: d_min ratio"),
-                    f"{arm}, {v}: d_min(rugnux) / d_min(reference), one point per set, sorted; below 1 = "
-                    "finer than the reference")
+            doc.svg(ratio_dots(pts, f"{arm}: d_min ratio"),
+                    f"{arm}: d_min(rugnux, own cut) / d_min(reference), one point per set, sorted; below 1 "
+                    "= finer than the reference")
+    for name, what, cap in (
+            ("isa_ratio", "ISa", "ISa of the reference-range table (the error model refitted on it) / "
+                                 "XDS's ISa; above 1 = rugnux's error model is the better one"),
+            ("r_meas_ratio", "R_meas", "R_meas over the reference range / XDS's R_meas; below 1 = "
+                                       "rugnux's merge is the more consistent one")):
+        for arm in arms:
+            pts = [(r["set"], r[name], r["verdict"], f"{what} ratio, {refres_note(r)}")
+                   for r in res if r["arm"] == arm and r.get(name)]
+            if pts:
+                doc.svg(ratio_dots(pts, f"{arm}: reference-range {what} ratio"),
+                        f"{arm}: {cap}. One point per set, sorted.")
     pts = [(r["set"], r["rfree_ratio"], r["verdict"],
             f"R_free {r['rfree']:.3f} vs deposited {r['rfree_deposited']:.3f}")
            for r in res if r.get("rfree_ratio")]
     if pts:
-        doc.svg(ratio_dots(pts, f"{v}: R_free ratio"),
-                "R_free of the deposited model against our merge, as rugnux reports it with --model / "
-                "the R_free the depositor published (from full refinement against their own data), one "
-                "point per set, sorted; below 1 = lower than published")
+        doc.svg(ratio_dots(pts, "R_free ratio"),
+                "R_free of the deposited model against our merge, as rugnux reports it with --model (a "
+                "rigid-body placement, scored on rugnux's own free set: a trend number, not a refinement) / "
+                "the R_free the depositor published, one point per set, sorted; below 1 = lower than published")
     pts = [(r["set"], r["refmac_rfree_ratio"], r["verdict"],
             f"R_free {r['refmac_rfree_depflags']:.3f} vs {r['refmac_rfree_depdata']:.3f} on the deposited data")
            for r in res if r.get("refmac_rfree_ratio")]
     if pts:
-        doc.svg(ratio_dots(pts, f"{v}: REFMAC R_free ratio"),
+        doc.svg(ratio_dots(pts, "REFMAC R_free ratio"),
                 "REFMAC check (--model-check): R_free of the deposited model against our merge / against "
                 "the deposited structure factors, both on the depositor's free set with the same protocol, "
                 "one point per set, sorted; below 1 = our data fit the model better")
 
-    doc.h(3, f"{v}: failures")
+    xds = [r for r in res if r.get("refres_range")]
+    if xds:
+        doc.h(3, "Like for like with XDS: the reference-range table")
+        doc.p("The same merge, binned a second time over XDS's range (--report-resolution; report-only, "
+              "nothing was processed differently for it), against XDS's CORRECT.LP totals. Where "
+              "rugnux's own cut is coarser than the reference ('coverage' in the last column), the "
+              "shells past it are not merged at all: the completeness there is coverage of XDS's "
+              "range, not a quality loss, and the other rugnux numbers are over the shells it reached. "
+              "XDS's totals are over its own merged range, which is the reference range except where "
+              "the reference d_min was derived (see below).")
+        rows = []
+        for r in sorted(xds, key=lambda r: (order.get(r["arm"], 9), r["set"])):
+            rows.append([r["set"], r["arm"], r["refres_range"], f(r.get("d_min")),
+                         f(r.get("refres_completeness"), "{:.1f}") + " / " + f(r.get("completeness_ref"), "{:.1f}"),
+                         f(r.get("refres_multiplicity"), "{:.1f}") + " / " + f(r.get("multiplicity_ref"), "{:.1f}"),
+                         f(r.get("refres_i_over_sigma"), "{:.1f}"),
+                         pct(r.get("refres_r_meas")) + " / " + pct(r.get("r_meas_ref")),
+                         f(r.get("refres_cc_half"), "{:.3f}") + " / " + f(r.get("cc_half_ref"), "{:.3f}"),
+                         f(r.get("refres_isa"), "{:.1f}") + " / " + f(r.get("isa_ref"), "{:.1f}"),
+                         refres_note(r)])
+        doc.table(["set", "arm", "range A", "own d_min", "compl % (rugnux / XDS)", "mult", "I/sigma",
+                   "R_meas", "CC1/2", "ISa", "reading"], rows, num=(3, 6))
+
+    derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
+    if derived:
+        doc.p("XDS merged past its own signal (CC1/2 of its finest shell not significant), so the "
+              "reference d_min is where XDS's CC1/2 falls through 0.30, and that is also the d_min of the "
+              "reference-range table: "
+              + "; ".join(f"{s} (XDS range {f(r.get('d_min_xds'))} A, reference "
+                          f"{f(r.get('d_min_ref'))} A)" for s, r in sorted(derived.items()))
+              + ". XDS's pooled R_meas, CC1/2 and completeness are over its whole range.")
+
+    doc.h(3, "Failures")
     fails = [r for r in res if r["verdict"] == "fail"]
     doc.table(["set", "arm", "cause", "reason"],
               [[r["set"], r["arm"], r["cause"], r["reason"]] for r in fails])
@@ -390,16 +386,20 @@ def variant_section(doc, man, res, v):
     if other:
         doc.p("Not scored: " + "; ".join(f"{r['set']} ({r['reason']})" for r in other))
 
-    doc.h(3, f"{v}: per set")
-    model = [("R_free", "rfree"), ("R_work", "rwork"), ("dep R_free", "rfree_deposited"),
+    doc.h(3, "Per set")
+    doc.p("Space group: on the open arm the data's own determination. Where --model put the model's "
+          "enantiomorph on the label, the label is in the note and the group scored is the search's.")
+    model = [("R_free", "rfree"), ("R_work", "rwork"), ("CC model", "cc_model"), ("dep R_free", "rfree_deposited"),
              ("R_free ratio", "rfree_ratio")] if any(r.get("rfree") for r in res) else []
     model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
               ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
     head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
             "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
-           [h for h, _ in model] + ["time s", "note"]
+           [h for h, _ in model] + (["model fit"] if model else []) + ["time s", "note"]
     rows = []
     for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
+        note = "; ".join(x for x in (r.get("reason"), r.get("sg_label") and f"labelled {r['sg_label']} from the model")
+                         if x)
         rows.append([r["set"], r["arm"], r["verdict"], r.get("sg") or "-", r.get("sg_ref") or "-",
                      f(r.get("cell_dev_pct")), f(r.get("volume_ratio"), "{:.3f}"),
                      f(r.get("d_min")), f(r.get("d_min_ref")), f(r.get("res_gain_pct"), "{:+.1f}%"),
@@ -407,7 +407,32 @@ def variant_section(doc, man, res, v):
                      pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
                      f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0)]
                     + [f(r.get(k), "{:.3f}") for _, k in model]
-                    + [f(r.get("wall_s"), "{:.0f}"), r.get("reason") or ""])
+                    + ([r.get("model_fit") or "-"] if model else [])
+                    + [f(r.get("wall_s"), "{:.0f}"), note])
     doc.table(head, rows, num=range(5, len(head) - 1),
               row_class=lambda row: "fail" if row[2] == "fail" else "",
               cell_class=lambda i, x: {"pass": "pass", "fail": "fail"}.get(x) if i == 2 else None)
+
+    if baseline:
+        bman, bres = load_run(baseline)
+        doc.h(2, f"Delta vs baseline {os.path.basename(os.path.normpath(baseline))}")
+        doc.p(f"Baseline rugnux {bman['binary'].get('version', '?')}. Pass rates on the sets both runs have:")
+        both = {key(r) for r in res} & {key(r) for r in bres}
+        rows = []
+        for arm in arms:
+            ra = [r for r in bres if key(r) in both and r["arm"] == arm]
+            rb = [r for r in res if key(r) in both and r["arm"] == arm]
+            rows.append([arm, len(rb), rate(ra), rate(rb)])
+        doc.table(["arm", "common sets", "baseline", "this run"], rows, num=(1,))
+        doc.p("Rows whose result moved beyond noise (thresholds in report.py NOISE; confirm with "
+              "`compare --rerun-changed` before believing a single-set change):")
+        compare_table(doc, compare_rows(bres, res))
+    return doc
+
+
+def refres_note(r):
+    """How to read a row of the reference-range table."""
+    if r.get("refres_shells_past_limit"):
+        return (f"coverage: own cut {f(r.get('d_min'))} A is coarser than the reference, "
+                f"{r['refres_shells_past_limit']:.0f} shell(s) not merged")
+    return "like for like"
diff --git a/tools/battery/score.py b/tools/battery/score.py
index d9466eedb..81cae0ff1 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -27,6 +27,12 @@ def read_report(path):
     return out
 
 
+# REFRES_* keys of the report read as numbers, stored lower-case under the same name
+REFRES_KEYS = ("refres_shells_past_limit", "refres_unique_reflections", "refres_completeness",
+               "refres_multiplicity", "refres_i_over_sigma", "refres_r_meas", "refres_cc_half",
+               "refres_isa")
+
+
 def fnum(s):
     try:
         return float(s.split()[0])
@@ -78,7 +84,7 @@ def sg_name(sgno):
 
 def judge(entry, rep, run_note):
     """Score one set. entry is its manifest row (with 'ref'), rep its parsed report, run_note
-    what the runner saw ('', 'timeout', 'exit N: message', 'no input', 'no model: why')."""
+    what the runner saw ('', 'timeout', 'exit N: message', 'no input')."""
     ref = dict(entry.get("ref") or {})
     if entry.get("ref_override"):          # a reference measured by hand, replacing the file's
         ref.update(entry["ref_override"])
@@ -95,14 +101,30 @@ def judge(entry, rep, run_note):
         "indexing_rate": fnum(rep.get("INDEXING_RATE")), "images": fnum(rep.get("IMAGES_PROCESSED")),
         "rugnux_wall_s": fnum(rep.get("WALL_TIME")), "rugnux_verdict": rep.get("VERDICT_TEXT"),
         "r_meas_ref": ref.get("r_meas"), "cc_half_ref": ref.get("cc_half"), "isa_ref": ref.get("isa"),
-        "completeness_ref": ref.get("completeness"), "sg_relation": None,
-        # rugnux's own R-factors of the deposited model, when it was given one (--model)
+        "completeness_ref": ref.get("completeness"), "multiplicity_ref": ref.get("multiplicity"),
+        "sg_relation": None,
+        # rugnux's own fit of the deposited model (--model, open arm): a rigid-body placement scored
+        # on rugnux's own free set, so a trend number, not the depositor's R-free
         "rfree": fnum(rep.get("R_FREE")), "rwork": fnum(rep.get("R_WORK")),
-        "model_fit": rep.get("MODEL_FIT"),
+        "model_fit": rep.get("MODEL_FIT"), "cc_model": fnum(rep.get("CC_MODEL_OVERALL")),
+        "sg_label": None,
     }
+    # the same merge binned over the reference's range (--report-resolution, XDS arms)
+    r.update({k: fnum(rep.get(k.upper())) for k in REFRES_KEYS})
+    r["refres_range"] = rep.get("REFRES_RANGE")
+    r["isa_ratio"] = round(r["refres_isa"] / r["isa_ref"], 4) if r["refres_isa"] and r["isa_ref"] else None
+    r["r_meas_ratio"] = (round(r["refres_r_meas"] / r["r_meas_ref"], 4)
+                         if r["refres_r_meas"] and r["r_meas_ref"] else None)
     if rep.get("SPACE_GROUP_NUMBER"):
         r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
         r["sg"] = rep.get("SPACE_GROUP_NAME") or sg_name(r["sgno"])
+        # With --model the reported group can be the model's enantiomorph, a label the data did not
+        # decide. The data's own answer is then the search's Sohncke group (same class up to hand).
+        if rep.get("SPACE_GROUP_ENANTIOMORPH") == "ASSUMED_FROM_MODEL" and rep.get("SOHNCKE_SPACE_GROUP"):
+            own = gemmi.find_spacegroup_by_name(rep["SOHNCKE_SPACE_GROUP"])
+            if own and own.number != r["sgno"] and sgequiv.indistinguishable(r["sgno"], own.number):
+                r["sg_label"] = r["sg"]
+                r["sgno"], r["sg"] = own.number, own.hm
         r["pg"] = point_group(r["sgno"])
     if rep.get("UNIT_CELL_CONSTANTS"):
         r["cell"] = [float(x) for x in rep["UNIT_CELL_CONSTANTS"].split()[:6]]
@@ -128,8 +150,6 @@ def judge(entry, rep, run_note):
     if not have_lattice:
         if run_note == "no input":
             return verdict("not_run", "no_input", "input file not found")
-        if run_note.startswith("no model"):
-            return verdict("not_run", "no_model", run_note)
         if run_note == "timeout":
             return verdict("fail", "timeout", "timed out")
         if re.search(r"Error reading input|Cannot open", run_note):
-- 
2.54.0


From 3e5e0109845374e6ff7152a77750a01d09ed8999 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 17:48:45 +0200
Subject: [PATCH 041/122] RotationScaleMerge: ingest without the index-order
 copy of the sort keys

Ingest wrote every observation's 24-byte SortKey into an index-order array and then scattered that
array into its h buckets - two key arrays alive together at the top of the ingest. Count the
buckets per chunk of frames straight from the source reflections and scatter from them instead:
a frame's reflections are consecutive in the key numbering, so the chunks are consecutive index
ranges and each bucket lands in the same index order as before. The key array is byte-identical.

BuildInRangeObservations also hands back the remap temporaries (old runs, per-run maps, new_idx)
before the observation array is built rather than at the end of the function.

Measured on a 3600-frame long-axis rotation set (95.7 M partials in the geometry pre-pass): the
pre-pass ingest high-water drops 15.45 -> 14.1 GB (sampled RSS, -N 6); merged MTZ/HKL/CIF, the P1
cross-check MTZ and the per-image table are byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 50 ++++++++++---------
 1 file changed, 27 insertions(+), 23 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index c3c0112cc..8b3e371aa 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -343,7 +343,6 @@ void RotationScaleMerge::Ingest() {
     // pure waste. Only the survivors are built, from the source reflections, once the runs are known.
     constexpr int INT_LO = std::numeric_limits<int>::min();
     constexpr int INT_HI = std::numeric_limits<int>::max();
-    std::vector<SortKey> unsorted(total);
     std::vector<int> h_lo(n_frames, INT_HI), h_hi(n_frames, INT_LO);
     ParallelFor(n_frames, nthreads, [&](int o) {
         if (reference_cell) {
@@ -353,13 +352,10 @@ void RotationScaleMerge::Ingest() {
         double bkg_sum = 0.0;
         int bkg_n = 0;
         int lmin = INT_HI, lmax = INT_LO;
-        int32_t at = src_start[o];
         for (const auto &r : partials_out[o].reflections) {
             if (std::isfinite(r.bkg) && r.bkg > 0.0f) { bkg_sum += r.bkg; ++bkg_n; }
-            unsorted[at] = SortKey{r.h, r.k, r.l, r.image_number, at, r.d};
             lmin = std::min(lmin, r.h);
             lmax = std::max(lmax, r.h);
-            ++at;
         }
         if (bkg_n > 0) mean_bkg[o] = bkg_sum / bkg_n;
         h_lo[o] = lmin; h_hi[o] = lmax;
@@ -395,30 +391,30 @@ void RotationScaleMerge::Ingest() {
         if (a.image_number != b.image_number) return a.image_number < b.image_number;
         return a.idx < b.idx;
     };
-    // Two key arrays for a moment: the sweep above wrote them in index order, and where a key belongs
-    // in the bucketed order is not known until the whole histogram is. Both together are less than half
-    // of what the observation array they replace used to occupy on its own.
+    // One key array, scattered into its h bucket straight from the source reflections. The buckets are
+    // counted per chunk of FRAMES first; a frame's reflections are consecutive in the key numbering, so
+    // the chunks are consecutive index ranges and the scatter lands each bucket in index order - the
+    // same array an index-order copy scattered afterwards gave, without that copy (24 bytes a partial,
+    // gigabytes on a long axis, at the top of the pass's memory).
     std::vector<SortKey> keys(total);
     {
         // Bucket by h first, then sort each bucket. h is the comparator's leading key, so the sorted
         // array is exactly the buckets laid end to end - and because the order is total (see above)
         // the permutation is the one a single std::sort produces, whichever algorithm gets there.
         // That is what makes this checkable: the output is byte-identical, not merely equivalent.
-        const int n = static_cast<int>(total);
-        const int nt = static_cast<int>(std::clamp<size_t>(nthreads, 1, std::max(1, n)));
-        const int chunk = (n + nt - 1) / nt;
+        const int nt = static_cast<int>(std::clamp<size_t>(nthreads, 1, std::max(1, n_frames)));
+        const int chunk = (n_frames + nt - 1) / nt;   // the split ParallelChunks makes below
         const int H = h_max - h_min + 1;
 
         std::vector<std::vector<int32_t>> hist(nt, std::vector<int32_t>(H, 0));
-        ParallelChunks(nt, nthreads, [&](int tlo, int thi) {
-            for (int t = tlo; t < thi; ++t) {
-                const int lo = t * chunk, hi = std::min(n, lo + chunk);
-                for (int i = lo; i < hi; ++i) hist[t][unsorted[i].h - h_min]++;
-            }
+        ParallelChunks(n_frames, nthreads, [&](int lo, int hi) {
+            std::vector<int32_t> &h_count = hist[lo / chunk];
+            for (int o = lo; o < hi; ++o)
+                for (const auto &r : partials_out[o].reflections) h_count[r.h - h_min]++;
         });
 
         // Where each chunk writes each bucket: buckets in order, and within a bucket the chunks in
-        // index order, so the scatter below is stable and lands in original order inside a bucket.
+        // frame order, so the scatter below is stable and lands in original order inside a bucket.
         std::vector<int32_t> bstart(H + 1, 0);
         int32_t acc = 0;
         for (int b = 0; b < H; ++b) {
@@ -431,15 +427,16 @@ void RotationScaleMerge::Ingest() {
         }
         bstart[H] = acc;
 
-        ParallelChunks(nt, nthreads, [&](int tlo, int thi) {
-            for (int t = tlo; t < thi; ++t) {
-                std::vector<int32_t> fill = hist[t];
-                const int lo = t * chunk, hi = std::min(n, lo + chunk);
-                for (int i = lo; i < hi; ++i) keys[fill[unsorted[i].h - h_min]++] = unsorted[i];
+        ParallelChunks(n_frames, nthreads, [&](int lo, int hi) {
+            std::vector<int32_t> fill = hist[lo / chunk];
+            for (int o = lo; o < hi; ++o) {
+                int32_t at = src_start[o];
+                for (const auto &r : partials_out[o].reflections) {
+                    keys[fill[r.h - h_min]++] = SortKey{r.h, r.k, r.l, r.image_number, at, r.d};
+                    ++at;
+                }
             }
         });
-        unsorted.clear();
-        unsorted.shrink_to_fit();
 
         // Largest bucket first: the tail of this is one bucket, so it should be the big one.
         std::vector<int> order(H);
@@ -687,6 +684,13 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
     rawrun_start.swap(ns); rawrun_count.swap(nc);
     rawrun_h.swap(nh); rawrun_k.swap(nk); rawrun_l.swap(nl); rawrun_d.swap(nd);
     std::vector<SortKey>().swap(keys);   // consumed (see the header)
+    // Everything above that only served the remap - the old runs now in ns..nd, the per-run maps and
+    // new_idx - is handed back before the observation array below is built, not at the end of the
+    // function: on a long axis it is a gigabyte beside the largest array of the ingest.
+    for (auto *v : {&ns, &nc, &nh, &nk, &nl, &dst_run, &dst_start, &new_idx})
+        std::vector<int32_t>().swap(*v);
+    std::vector<float>().swap(nd);
+    std::vector<uint8_t>().swap(keep_run);
 
     // The observations themselves, one frame per thread. finite_ok is the per-obs AcceptReflection
     // finiteness (immutable) - it lets ComputeAsuGroups stamp the ASU-group id per obs from a flat
-- 
2.54.0


From 764add208d7137d60be157e65a9dd3539166d837 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:22:49 +0200
Subject: [PATCH 042/122] tools/battery: the like-for-like table covers XDS's
 own range

--report-resolution now gets XDS's own d_min, the range its CORRECT.LP totals
cover, so the comparison is exact; shells past rugnux's cut print as not
merged. The derived reference d_min stays what rugnux's own cut is scored
against.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/README.md  | 12 ++++++------
 tools/battery/battery.py | 12 ++++++++----
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index f8dddceee..982e7d7e5 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -30,7 +30,7 @@ Every set runs **once**, with one command per arm:
 | arm (reference) | command |
 |---|---|
 | open (deposition) | `rugnux -o p --no-export-unmerged --model <deposited coordinates> <input>`; sets without a deposited model (small molecules, unpublished sets, or coordinates that cannot be downloaded) run the same command without `--model` |
-| inhouse, private (XDS) | `rugnux -o p --no-export-unmerged [-A] --report-resolution <reference d_min>,<XDS d_max> <input>` |
+| inhouse, private (XDS) | `rugnux -o p --no-export-unmerged [-A] --report-resolution <XDS d_min>,<XDS d_max> <input>` |
 
 Neither `--model` nor `--report-resolution` changes the processing: the merged reflections, the
 resolution cut and every decision are the same with and without them (verified bit for bit). So
@@ -50,8 +50,8 @@ the reference:
   data's own determination instead (`SOHNCKE_SPACE_GROUP` where `SPACE_GROUP_ENANTIOMORPH` is
   `ASSUMED_FROM_MODEL`) and keeps the label in `sg_label`.
 - **`--report-resolution`** (XDS arms): a second statistics table from the same merge, binned over
-  XDS's range (the reference d_min, see "The XDS reference d_min" below, and XDS's d_max as given,
-  999 included), and `-A` where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the
+  XDS's own range (`dmin_xds` and XDS's d_max as given, 999 included, so it covers exactly what
+  XDS's CORRECT.LP totals cover), and `-A` where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the
   manifest), so the two tables count the same way. Its REFRES_* numbers are scored against XDS's
   CORRECT.LP totals: completeness, multiplicity, R_meas, CC1/2 and ISa (I/sigma is shown; the
   manifest holds no XDS value for it). Where rugnux's own cut is coarser than the reference
@@ -325,9 +325,9 @@ is significant, and that decides which case applies (`inputs.reference_dmin`):
   point where XDS's CC1/2 falls through 0.30 (the target of rugnux's own cutoff), interpolated in
   1/d² between shell centres.
 
-The derived value is both the score reference and the d_min of the reference-range table. The manifest keeps XDS's own
-limit as `dmin_xds` and the rule used as `dmin_rule`. XDS's pooled R_meas, CC1/2 and completeness
-still cover its whole range.
+The derived value is the reference rugnux's own cut is scored against. The reference-range table
+uses XDS's own limit, `dmin_xds`, because XDS's pooled R_meas, CC1/2 and completeness cover its
+whole range; the manifest keeps the rule used as `dmin_rule`.
 
 ## Adding or changing datasets
 
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 5fae02de1..27ae2c150 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -68,7 +68,7 @@ PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
 COMMAND_DOC = {
     "deposition": "`rugnux --model <deposited coordinates> <input>` (without --model where there is no "
                   "deposited model: small molecules, unpublished sets)",
-    "xds": "`rugnux [-A] --report-resolution <reference d_min>,<XDS d_max> <input>`: -A where XDS kept "
+    "xds": "`rugnux [-A] --report-resolution <XDS d_min>,<XDS d_max> <input>`: -A where XDS kept "
            "Friedel mates apart; the second statistics table at XDS's range is report-only",
 }
 
@@ -178,10 +178,14 @@ def command(binary, e, opts, model=None):
         # statistics are not comparable
         if ref.get("anomalous"):
             cmd.append("-A")
-        # a second statistics table over XDS's range, from the same merge (report only)
-        if ref.get("dmin"):
+        # a second statistics table over XDS's own range, from the same merge (report only). XDS's
+        # own limit, not the derived reference d_min: the manifest's XDS totals are over XDS's range,
+        # so only that makes the table like for like. Shells past rugnux's own cut print as not
+        # merged.
+        dmin = ref.get("dmin_xds") or ref.get("dmin")
+        if dmin:
             cmd += ["--report-resolution",
-                    f"{ref['dmin']:.3f}" + (f",{ref['dmax']:.3f}" if ref.get("dmax") else "")]
+                    f"{dmin:.3f}" + (f",{ref['dmax']:.3f}" if ref.get("dmax") else "")]
     if model:
         cmd += ["--model", model]
     cmd += opts["extra_args"]
-- 
2.54.0


From 66db3353c7c567f0de6b943b2feb8b935d2efd9d Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:00:10 +0200
Subject: [PATCH 043/122] rugnux: measure the canonical pass's geometry probe
 before the scaling engine is built

The post-refinement probe on a canonical pass only measures, and it reads nothing the scaling
engine produces - the reflections' hkl, I, sigma and positions are final once the images are
integrated, and the engine writes back per-frame fields only. It ran after the first merge,
beside the engine's arrays, where its gathered observations and rocking events set the pass's
memory high-water mark. Run it before the engine is built instead; the pre-pass keeps its
original place (it consumes the smoothed mosaicity the merge writes back).

Measured on a 3600-frame long-axis rotation set: the canonical pass's high-water drops from
14.8 GB to under 12.8 GB (sampled RSS, -N 6); merged MTZ/HKL/CIF, P1 MTZ, per-image table and the
report are byte-identical, the probe's own result included.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 179 ++++++++++++++++++++++++----------------------
 1 file changed, 95 insertions(+), 84 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index a6da5bbb2..8e40c0399 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -5006,6 +5006,99 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         const auto &rot_ss = experiment_.GetScalingSettings();
         const bool is_rotation = experiment_.IsRotationIndexing();   // rotation indexing -> rotation scaling/merge
         std::optional<RotationScaleMerge> rsm;
+        std::optional<PostRefineObservations> prepass_postrefine_obs;
+        // The rotation geometry post-refinement (see its call sites below for what it is for).
+        const auto post_refine_geometry = [&] {
+            const auto &outcomes = indexer->GetIntegrationOutcome();
+            if (geometry_prepass) {
+                prepass_mosaicity_.assign(outcomes.size(), NAN);
+                for (size_t o = 0; o < outcomes.size(); ++o)
+                    if (outcomes[o].mosaicity_deg) prepass_mosaicity_[o] = *outcomes[o].mosaicity_deg;
+            }
+            if (result.consensus_cell.has_value()) {
+                if (const auto rot = indexer->FinalizeRotationIndexing(); rot && rot->axis) {
+                    if (geometry_prepass)
+                        prepass_result_ = *rot;   // full result (lattice+geom+axis), for the supercell fallback
+                    PostRefineSettings prs;
+                    prs.crystal_system = rot->search_result.system;
+                    prs.num_threads = static_cast<int>(config_.nthreads);
+                    prs.refine_geometry = true;
+                    // The centre the pre-scan measured, where the fit was precise enough to be used as
+                    // a centre at all (the same ceiling --estimate-beam-center adopts one on). It does
+                    // not move the geometry - it only tells the bound on step B's beam move where else
+                    // the centre is independently believed to be.
+                    if (measured_beam_center_
+                        && measured_beam_center_->sigma_pxl <= std::max(MAX_BEAM_CENTER_SIGMA_PXL,
+                                                                        BeamCenterNeed_pxl(experiment_)))
+                        prs.measured_beam_px = std::array<double, 2>{
+                            static_cast<double>(measured_beam_center_->beam_x_pxl),
+                            static_cast<double>(measured_beam_center_->beam_y_pxl)};
+                    // The first pass's own geometry, not the header's. The outcomes being post-refined
+                    // were integrated at it, and step B holds the tilt fixed while it fits the beam and
+                    // the distance - so handing it the header tilt fits a beam that has to absorb a tilt
+                    // error the images do not have, and the answer describes neither geometry.
+                    //
+                    // On the pre-pass the observations were gathered right after Ingest (see there) and
+                    // the scaling engine is finished - nothing after this point reads it on that pass
+                    // (the search and the reference re-merge run only on the canonical one) - so it is
+                    // freed BEFORE the fit: the engine holds about twice the partial payload again,
+                    // and with it gone the fit no longer sits on the pass's memory peak.
+                    if (prepass_postrefine_obs)
+                        rsm.reset();
+                    auto pr_obs = prepass_postrefine_obs
+                            ? std::move(*prepass_postrefine_obs)
+                            : GatherPostRefineObservations(indexer->GetIntegrationOutcome(),
+                                                           config_.nthreads,
+                                                           /*release_reflections=*/false, logger);
+                    prepass_postrefine_obs.reset();
+                    const auto pr = PostRefineRotationGeometry(std::move(pr_obs), *rot->axis,
+                                        rot->geom, rot->lattice, prs, logger);
+                    result.post_refine = pr;
+                    if (pr.ok && pr.detector_refined) {
+                        // Store, don't apply: this pass continues to write its own (header-geometry) output;
+                        // Run() applies the refined geometry before the second pass.
+                        prepass_detector_geometry_ = std::array<float, 5>{
+                            static_cast<float>(pr.beam_x_after_px),
+                            static_cast<float>(pr.beam_y_after_px),
+                            static_cast<float>(pr.distance_after_mm),
+                            rot->geom.GetPoniRot1_rad(),
+                            rot->geom.GetPoniRot2_rad()};
+                        logger.Info("Two-pass: post-refined detector geometry (distance {:.3f} mm, "
+                                    "beam {:.2f},{:.2f} px, tilt {:.4f},{:.4f} deg) - {}",
+                                    pr.distance_after_mm, pr.beam_x_after_px, pr.beam_y_after_px,
+                                    rot->geom.GetPoniRot1_rad() * 180.0 / PI,
+                                    rot->geom.GetPoniRot2_rad() * 180.0 / PI,
+                                    geometry_prepass ? "it will drive the second integration pass"
+                                                     : "what the fit still asks for at the geometry "
+                                                       "this pass ran at");
+                    } else {
+                        logger.Info("Two-pass: geometry post-refine committed no detector change{}",
+                                    geometry_prepass ? " - the second pass reproduces the first" : "");
+                    }
+                    // DECISION POINT for the goniometer rotation scale. It does not ride on pr.ok - the
+                    // scale is its own cross-validated fit and the crystals that have a stage fault are
+                    // exactly the ones whose cell and detector steps do NOT pass, because the angle error
+                    // is what their residual is made of. A calibration fault is rare (36 of 37 rotation
+                    // datasets sit at 1.0000) and applying a 1 % angle correction to a healthy dataset
+                    // would silently damage it, so the asymmetry is deliberate: committed only when the
+                    // fit is both cross-validated and outside the tolerance. A manual --rotation-scale is
+                    // already on the goniometer and is left alone.
+                    // Only the pre-pass fits the rotation scale. It is applied from the goniometer
+                    // the file came with, so a scale measured again on angles that have already been
+                    // corrected once is not a correction that can be applied on top of that one.
+                    if (pr.rotation_scale_suspect && !config_.rotation_scale.has_value() && geometry_prepass)
+                        prepass_rotation_scale_ = static_cast<float>(pr.rotation_scale);
+                }
+            }
+        };
+        // On a CANONICAL pass the post-refinement only measures (see below), and it reads nothing the
+        // scaling engine produces: the reflections' hkl, I, sigma and positions are final once the
+        // images are integrated, and the engine writes back per-frame fields only. So measure it
+        // before the engine is built rather than beside it - the gathered observations and their
+        // rocking events are gigabytes on a long axis, and beside the engine's own arrays they set
+        // the pass's memory high-water mark.
+        if (postrefine_probe_ && !geometry_prepass && is_rotation)
+            post_refine_geometry();
         if (is_rotation) {
             if (experiment_.GetRefineRotationWedgeInScaling()
                 || rot_ss.GetRotationWedgeForScaling().has_value())
@@ -5029,7 +5122,6 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // it is read: on a fine-sliced long axis the vectors are gigabytes, held to the end of the
         // pass for those 32 bytes a partial. A run with a reference MTZ keeps them: resolving the
         // indexing ambiguity re-reads them (and re-ingests).
-        std::optional<PostRefineObservations> prepass_postrefine_obs;
         if (geometry_prepass && rsm && config_.reference_data.empty())
             prepass_postrefine_obs = GatherPostRefineObservations(
                     indexer->GetIntegrationOutcome(), config_.nthreads,
@@ -5211,89 +5303,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // reflections integrated at the geometry after it. The probe measures - it applies nothing and
         // leaves the smoothed mosaicity and the pre-pass lattice alone, which stay pass 1's for every
         // pass that consumes them; RunAllPasses decides what to do with the answer.
-        if ((geometry_prepass || postrefine_probe_) && rsm && experiment_.IsRotationIndexing()) {
-            const auto &outcomes = indexer->GetIntegrationOutcome();
-            if (geometry_prepass) {
-                prepass_mosaicity_.assign(outcomes.size(), NAN);
-                for (size_t o = 0; o < outcomes.size(); ++o)
-                    if (outcomes[o].mosaicity_deg) prepass_mosaicity_[o] = *outcomes[o].mosaicity_deg;
-            }
-            if (result.consensus_cell.has_value()) {
-                if (const auto rot = indexer->FinalizeRotationIndexing(); rot && rot->axis) {
-                    if (geometry_prepass)
-                        prepass_result_ = *rot;   // full result (lattice+geom+axis), for the supercell fallback
-                    PostRefineSettings prs;
-                    prs.crystal_system = rot->search_result.system;
-                    prs.num_threads = static_cast<int>(config_.nthreads);
-                    prs.refine_geometry = true;
-                    // The centre the pre-scan measured, where the fit was precise enough to be used as
-                    // a centre at all (the same ceiling --estimate-beam-center adopts one on). It does
-                    // not move the geometry - it only tells the bound on step B's beam move where else
-                    // the centre is independently believed to be.
-                    if (measured_beam_center_
-                        && measured_beam_center_->sigma_pxl <= std::max(MAX_BEAM_CENTER_SIGMA_PXL,
-                                                                        BeamCenterNeed_pxl(experiment_)))
-                        prs.measured_beam_px = std::array<double, 2>{
-                            static_cast<double>(measured_beam_center_->beam_x_pxl),
-                            static_cast<double>(measured_beam_center_->beam_y_pxl)};
-                    // The first pass's own geometry, not the header's. The outcomes being post-refined
-                    // were integrated at it, and step B holds the tilt fixed while it fits the beam and
-                    // the distance - so handing it the header tilt fits a beam that has to absorb a tilt
-                    // error the images do not have, and the answer describes neither geometry.
-                    //
-                    // On the pre-pass the observations were gathered right after Ingest (see there) and
-                    // the scaling engine is finished - nothing after this point reads it on that pass
-                    // (the search and the reference re-merge run only on the canonical one) - so it is
-                    // freed BEFORE the fit: the engine holds about twice the partial payload again,
-                    // and with it gone the fit no longer sits on the pass's memory peak.
-                    if (prepass_postrefine_obs)
-                        rsm.reset();
-                    auto pr_obs = prepass_postrefine_obs
-                            ? std::move(*prepass_postrefine_obs)
-                            : GatherPostRefineObservations(indexer->GetIntegrationOutcome(),
-                                                           config_.nthreads,
-                                                           /*release_reflections=*/false, logger);
-                    prepass_postrefine_obs.reset();
-                    const auto pr = PostRefineRotationGeometry(std::move(pr_obs), *rot->axis,
-                                        rot->geom, rot->lattice, prs, logger);
-                    result.post_refine = pr;
-                    if (pr.ok && pr.detector_refined) {
-                        // Store, don't apply: this pass continues to write its own (header-geometry) output;
-                        // Run() applies the refined geometry before the second pass.
-                        prepass_detector_geometry_ = std::array<float, 5>{
-                            static_cast<float>(pr.beam_x_after_px),
-                            static_cast<float>(pr.beam_y_after_px),
-                            static_cast<float>(pr.distance_after_mm),
-                            rot->geom.GetPoniRot1_rad(),
-                            rot->geom.GetPoniRot2_rad()};
-                        logger.Info("Two-pass: post-refined detector geometry (distance {:.3f} mm, "
-                                    "beam {:.2f},{:.2f} px, tilt {:.4f},{:.4f} deg) - {}",
-                                    pr.distance_after_mm, pr.beam_x_after_px, pr.beam_y_after_px,
-                                    rot->geom.GetPoniRot1_rad() * 180.0 / PI,
-                                    rot->geom.GetPoniRot2_rad() * 180.0 / PI,
-                                    geometry_prepass ? "it will drive the second integration pass"
-                                                     : "what the fit still asks for at the geometry "
-                                                       "this pass ran at");
-                    } else {
-                        logger.Info("Two-pass: geometry post-refine committed no detector change{}",
-                                    geometry_prepass ? " - the second pass reproduces the first" : "");
-                    }
-                    // DECISION POINT for the goniometer rotation scale. It does not ride on pr.ok - the
-                    // scale is its own cross-validated fit and the crystals that have a stage fault are
-                    // exactly the ones whose cell and detector steps do NOT pass, because the angle error
-                    // is what their residual is made of. A calibration fault is rare (36 of 37 rotation
-                    // datasets sit at 1.0000) and applying a 1 % angle correction to a healthy dataset
-                    // would silently damage it, so the asymmetry is deliberate: committed only when the
-                    // fit is both cross-validated and outside the tolerance. A manual --rotation-scale is
-                    // already on the goniometer and is left alone.
-                    // Only the pre-pass fits the rotation scale. It is applied from the goniometer
-                    // the file came with, so a scale measured again on angles that have already been
-                    // corrected once is not a correction that can be applied on top of that one.
-                    if (pr.rotation_scale_suspect && !config_.rotation_scale.has_value() && geometry_prepass)
-                        prepass_rotation_scale_ = static_cast<float>(pr.rotation_scale);
-                }
-            }
-        }
+        if (geometry_prepass && rsm && experiment_.IsRotationIndexing())
+            post_refine_geometry();
 
         // For a de-novo search, gate the P1 scaling+merge (the pass that feeds the space-group search) at
         // <I/sigma> >= 1 over thin resolution shells: noise-dominated high-res shells otherwise mislead
-- 
2.54.0


From 2f612d6aae407d49744842c95c29cae420c9b125 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 11:24:32 +0200
Subject: [PATCH 044/122] tools/battery: the 16 keV thaumatin reference obeys
 Friedel's law

At 16 keV a native crystal has no usable anomalous signal, so XDS's CORRECT
was rerun with FRIEDEL'S_LAW=TRUE and the set no longer runs with -A.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 tools/battery/inhouse.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index 29dbac2f1..e6d1aefaf 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -7,7 +7,7 @@
  {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
  {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
  {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": true, "isa": 44.79, "completeness": 94.3, "r_meas": 0.073, "cc_half": 1.0, "multiplicity": 9.76, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": false, "isa": 44.51, "completeness": 94.3, "r_meas": 0.072, "cc_half": 1.0, "multiplicity": 18.36, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
  {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
  {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
  {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
-- 
2.54.0


From 629ea58239e5507d7d9f4d0e70845a40d57bb645 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:14:02 +0200
Subject: [PATCH 045/122] RotationScaleMerge: a 32-byte resident ingest record,
 and smaller staging slices

On the resident (GPU) path the ingest's narrow host record sits on top of the source reflections
for the whole smoothing and partiality recompute, and on a long axis that moment is the run's
memory high-water mark. Store its Miller indices in 16 bits and move the rocking-event flag into
their padding: 40 -> 32 bytes a partial. Stage the device upload in slices of two million
observations rather than eight, which takes the thirteen staging arrays from ~400 MB to ~100 MB.
Neither changes a value.

Measured on a 3600-frame long-axis rotation set (-N 6): VmHWM 13.79 -> 12.80 GiB on top of the
previous commits (15.0-15.1 GiB before any of them); merged MTZ/HKL/CIF, P1 MTZ, per-image table and
the report are byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/scale_merge/RotationScaleMerge.cpp |  9 +++++++--
 image_analysis/scale_merge/RotationScaleMerge.h   | 12 ++++++++----
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 8b3e371aa..c251c7fb7 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -712,7 +712,9 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
                 if (!keep[src]) { ++src; continue; }
                 ++src;
                 ObsIngest &obs = partials_ingest[at];
-                obs.h = r.h; obs.k = r.k; obs.l = r.l;
+                obs.h = static_cast<int16_t>(r.h);
+                obs.k = static_cast<int16_t>(r.k);
+                obs.l = static_cast<int16_t>(r.l);
                 obs.frame = o;
                 obs.image_number = r.image_number;
                 obs.d = r.d;
@@ -734,7 +736,10 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
 
         gpu_->SetPartialsLayout(n_keep, n_frames, frame_start.data(), frame_count.data());
         using F = RotationScaleMergeGPU::ObsField;
-        constexpr int STAGE_SLICE = 8 << 20;
+        // Two million observations a slice: the thirteen staging arrays are then under a hundred
+        // megabytes together, where eight million put four hundred on top of the ingest's peak, and a
+        // slice still spans tens of frames for the threads to share.
+        constexpr int STAGE_SLICE = 2 << 20;
         constexpr int NFLOAT = 11;
         int max_frame_obs = 0;
         for (int o = 0; o < n_frames; ++o) max_frame_obs = std::max(max_frame_obs, static_cast<int>(frame_count[o]));
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 533242ad3..81cf8164c 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -144,16 +144,20 @@ private:
     // observation dump): every immutable per-obs field is uploaded straight from the source
     // reflections inside BuildInRangeObservations, and the host keeps only what its own remaining
     // stages touch - the geometry smoothing (delta_phi, then the recomputed partiality), plus the
-    // rocking-event walk's inputs. Forty bytes against the Obs's eighty, and on that path the fat
+    // rocking-event walk's inputs. Thirty-two bytes against the Obs's eighty, and on that path the fat
     // record is never materialised at all: on a fine-sliced long axis it alone is many gigabytes,
     // held beside the source reflections it was copied from.
     struct ObsIngest {
-        int32_t h, k, l, frame;
-        float image_number, d, zeta, delta_phi, partiality;
+        // Sixteen bits are plenty for a Miller index - |h| <= a / d_min, in the hundreds even on the
+        // longest axis at atomic resolution - and on a long axis this array sets the ingest's memory
+        // high-water mark, so each index costs two bytes here, not four.
+        int16_t h, k, l;
         // The rocking-event usability test (RockingEventFrames), evaluated on the ingest-time
         // values - which is what that walk reads on the resident path, where the host corr is
-        // never refreshed (see partials_released).
+        // never refreshed (see partials_released). Beside the indices, where it fills their padding.
         uint8_t rock_ok;
+        int32_t frame;
+        float image_number, d, zeta, delta_phi, partiality;
     };
 
     // The narrow per-observation record the ingest sort orders: the raw hkl the runs are cut on, the
-- 
2.54.0


From ffe649efaeb8626e38e59fa35d7a258737f3de46 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 17:21:46 +0200
Subject: [PATCH 046/122] tools/battery: a set with a known-wrong reference can
 be left unscored

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md | 2 ++
 tools/battery/score.py  | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 982e7d7e5..65d6c2005 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -341,6 +341,8 @@ whole range; the manifest keeps the rule used as `dmin_rule`.
   control), then run `battery.py refs --arm inhouse --write` to fill in `ref` from the
   `CORRECT.LP` beside the input. Without `--write`, `refs` only shows what would change.
   A reference measured by hand goes in `ref_override`, which `refs` leaves alone.
+  A set whose reference is known to be wrong gets `"unscored": "<why>"`: it still runs, but
+  scores `unscored` instead of pass or fail.
 - **Renamed data directories**: `battery.py remap --arm inhouse MAP.json --write`, where
   `MAP.json` is `{"old": "new"}` (renames the set and its directory) or
   `{"old id": {"id": "...", "input": "..."}}`. Each old id is recorded under `aliases` in the
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 81cae0ff1..331722d7d 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -159,6 +159,8 @@ def judge(entry, rep, run_note):
         return verdict("fail", "crash", run_note or "no lattice in the report")
     if not ref.get("sgno") or not ref.get("cell"):
         return verdict("unscored", "no_reference", "no reference to score against")
+    if entry.get("unscored"):              # a reference known to be wrong: run, but do not score
+        return verdict("unscored", "reference_problem", entry["unscored"])
 
     vr, edge = lattice_match(r["cell"], space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
                              ref["cell"], space_group(ref.get("sg"), ref["sgno"]))
-- 
2.54.0


From 1a85fbfbee94a3941eb97e02639d511ba3df51c6 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:32:15 +0200
Subject: [PATCH 047/122] tools/battery: the XDS references carry the lowest
 shell's R_meas

parse_correct_lp also reads the first row of CORRECT.LP's last resolution
table: its high-resolution limit (dmin_low) and R_meas (r_meas_low).
inhouse.json regenerated with `refs --arm inhouse --write`; the only
change is the two new keys per set (the private manifest was regenerated
the same way, outside the repository).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/inhouse.json | 66 +++++++++++++++++++-------------------
 tools/battery/inputs.py    |  8 ++++-
 2 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index e6d1aefaf..20a7fbd38 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -1,37 +1,37 @@
 {"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_x10sa_90deg_1", "E08_lyso_2_007": "lyso_x10sa_90deg_2", "lyso_2": "lyso_x06da_atten_wedge", "lyso_6_5keV": "lyso_x06da_5keV", "lysoC_14_f46f0a": "lyso_x06da_ice", "Thau_9": "thau_x10sa_0p1deg", "thau_BL1A_1p9A": "thau_bl1a_6p5keV", "thau_BL1A_2p7A": "thau_bl1a_4p6keV", "thau_BL1A_3p3A": "thau_bl1a_3p8keV", "Ins_H_2_fa9841": "insu_H_x06da_twin", "Ins_H_3_d05684": "insu_H_x06da_notwin", "Ins_I_16": "insu_I_x06da_weak", "Ins_I_2_1a530d": "insu_I_x06da_low_isa", "Ins_I_3_5e90e3": "insu_I_x06da_ref", "Ins_I_6_13keV": "insu_I_x06da_13keV", "Ins_I_6_5keV": "insu_I_x06da_5keV", "Ins_I_6_6keV": "insu_I_x06da_6keV", "Ins_I_7_5keV": "insu_I_x06da_5keV_2", "cytC_10": "cytc_x10sa", "cytC_2_0770b5": "cytc_x06da_1", "cytC_3_874285": "cytc_x06da_2", "MyoB_13": "myob_x10sa", "MyoB_9_446b70": "myob_x06da", "MyoB2-1": "myob_x06da_powder_1", "MyoB2-2": "myob_x06da_powder_2", "MyoB2-4": "myob_x06da_split", "MyoB2-5": "myob_x06da_sparse", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1", "lyso_90deg_1": "lyso_x10sa_90deg_1", "lyso_90deg_2": "lyso_x10sa_90deg_2", "lyso_atten_wedge": "lyso_x06da_atten_wedge", "lyso_5keV": "lyso_x06da_5keV", "lyso_ice": "lyso_x06da_ice", "lyso_ref": "lyso_x06da_ref", "lyso_strong": "lyso_x10sa_strong", "lyso_half_image": "lyso_x06da_half_image", "thau_16keV": "thau_x10sa_16keV", "thau_0p1deg": "thau_x10sa_0p1deg", "thau_1p9A": "thau_bl1a_6p5keV", "thau_2p7A": "thau_bl1a_4p6keV", "thau_3p3A": "thau_bl1a_3p8keV", "thau_injection": "thau_x10sa_injection", "thau_pink": "thau_micromax_pink", "insu_H_twin": "insu_H_x06da_twin", "insu_H_notwin": "insu_H_x06da_notwin", "insu_I_weak": "insu_I_x06da_weak", "insu_I_low_isa": "insu_I_x06da_low_isa", "insu_I_ref": "insu_I_x06da_ref", "insu_I_13keV": "insu_I_x06da_13keV", "insu_I_5keV": "insu_I_x06da_5keV", "insu_I_6keV": "insu_I_x06da_6keV", "insu_I_5keV_2": "insu_I_x06da_5keV_2", "cytc_eiger": "cytc_x10sa", "cytc_pilatus_1": "cytc_x06da_1", "cytc_pilatus_2": "cytc_x06da_2", "myob_eiger": "myob_x10sa", "myob_pilatus": "myob_x06da", "myob_powder_1": "myob_x06da_powder_1", "myob_powder_2": "myob_x06da_powder_2", "myob_split": "myob_x06da_split", "myob_aggregate": "myob_x06da_sparse", "myob_x06da_aggregate": "myob_x06da_sparse"}, "sets": [
- {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_5keV", "input": "lyso_x06da_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
- {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
- {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": false, "isa": 44.51, "completeness": 94.3, "r_meas": 0.072, "cc_half": 1.0, "multiplicity": 18.36, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_bl1a_3p8keV", "input": "thau_bl1a_3p8keV/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
- {"id": "thau_x10sa_injection", "input": "thau_x10sa_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_micromax_pink", "input": "thau_micromax_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
- {"id": "insu_H_x06da_twin", "input": "insu_H_x06da_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_H_x06da_notwin", "input": "insu_H_x06da_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
- {"id": "insu_I_x06da_weak", "input": "insu_I_x06da_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_low_isa", "input": "insu_I_x06da_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_ref", "input": "insu_I_x06da_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_13keV", "input": "insu_I_x06da_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_5keV", "input": "insu_I_x06da_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_x06da_6keV", "input": "insu_I_x06da_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_x06da_5keV_2", "input": "insu_I_x06da_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
- {"id": "cytc_x10sa", "input": "cytc_x10sa/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_x06da_1", "input": "cytc_x06da_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_x06da_2", "input": "cytc_x06da_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "myob_x10sa", "input": "myob_x10sa/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
- {"id": "myob_x06da", "input": "myob_x06da/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
- {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
- {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_x06da_sparse", "input": "myob_x06da_sparse/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 3, "cell": [35.388, 28.752, 64.083, 90.0, 106.352, 90.0], "anomalous": false, "isa": 5.46, "completeness": 73.7, "r_meas": 0.326, "cc_half": 0.972, "multiplicity": 5.21, "dmin": 2.0, "dmin_rule": "xds_range", "dmin_xds": 2.0, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin_low": 5.83, "r_meas_low": 0.049, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin_low": 5.86, "r_meas_low": 0.051, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin_low": 3.76, "r_meas_low": 0.069, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_5keV", "input": "lyso_x06da_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin_low": 7.22, "r_meas_low": 0.047, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
+ {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin_low": 4.26, "r_meas_low": 0.055, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin_low": 3.58, "r_meas_low": 0.029, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
+ {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin_low": 3.52, "r_meas_low": 0.077, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin_low": 4.91, "r_meas_low": 0.258, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": false, "isa": 44.51, "completeness": 94.3, "r_meas": 0.072, "cc_half": 1.0, "multiplicity": 18.36, "dmin_low": 3.89, "r_meas_low": 0.027, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin_low": 6.51, "r_meas_low": 0.104, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin_low": 5.33, "r_meas_low": 0.041, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin_low": 7.56, "r_meas_low": 0.039, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_3p8keV", "input": "thau_bl1a_3p8keV/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin_low": 9.23, "r_meas_low": 0.039, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
+ {"id": "thau_x10sa_injection", "input": "thau_x10sa_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin_low": 3.83, "r_meas_low": 0.022, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_micromax_pink", "input": "thau_micromax_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin_low": 4.17, "r_meas_low": 0.04, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
+ {"id": "insu_H_x06da_twin", "input": "insu_H_x06da_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin_low": 4.34, "r_meas_low": 0.106, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_H_x06da_notwin", "input": "insu_H_x06da_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin_low": 4.61, "r_meas_low": 0.045, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
+ {"id": "insu_I_x06da_weak", "input": "insu_I_x06da_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin_low": 3.22, "r_meas_low": 0.054, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_low_isa", "input": "insu_I_x06da_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin_low": 3.92, "r_meas_low": 0.167, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_ref", "input": "insu_I_x06da_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin_low": 4.82, "r_meas_low": 0.143, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_13keV", "input": "insu_I_x06da_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin_low": 4.85, "r_meas_low": 0.093, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_5keV", "input": "insu_I_x06da_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin_low": 7.21, "r_meas_low": 0.048, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_6keV", "input": "insu_I_x06da_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin_low": 6.03, "r_meas_low": 0.047, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_5keV_2", "input": "insu_I_x06da_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin_low": 7.21, "r_meas_low": 0.048, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
+ {"id": "cytc_x10sa", "input": "cytc_x10sa/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin_low": 6.05, "r_meas_low": 0.036, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_1", "input": "cytc_x06da_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin_low": 5.58, "r_meas_low": 0.033, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_2", "input": "cytc_x06da_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin_low": 5.03, "r_meas_low": 0.032, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "myob_x10sa", "input": "myob_x10sa/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin_low": 5.16, "r_meas_low": 0.186, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
+ {"id": "myob_x06da", "input": "myob_x06da/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin_low": 4.23, "r_meas_low": 0.105, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
+ {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin_low": 4.44, "r_meas_low": 0.125, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
+ {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin_low": 2.98, "r_meas_low": 0.706, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin_low": 4.48, "r_meas_low": 0.091, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_sparse", "input": "myob_x06da_sparse/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 3, "cell": [35.388, 28.752, 64.083, 90.0, 106.352, 90.0], "anomalous": false, "isa": 5.46, "completeness": 73.7, "r_meas": 0.326, "cc_half": 0.972, "multiplicity": 5.21, "dmin_low": 5.92, "r_meas_low": 0.146, "dmin": 2.0, "dmin_rule": "xds_range", "dmin_xds": 2.0, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
  {"id": "nothing_2", "input": "nothing_2/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
  {"id": "nothing_1", "input": "nothing_1/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
 ]}
diff --git a/tools/battery/inputs.py b/tools/battery/inputs.py
index 9d37cef7a..71012ccf5 100644
--- a/tools/battery/inputs.py
+++ b/tools/battery/inputs.py
@@ -107,7 +107,8 @@ def input_format(path):
 def parse_correct_lp(path):
     """Reference values from an XDS CORRECT.LP: the space group and cell CORRECT refined, the
     resolution range it merged (dmin_xds, dmax), the reference d_min read off its statistics
-    (dmin, dmin_rule - see reference_dmin) and its overall merging statistics.
+    (dmin, dmin_rule - see reference_dmin), its overall merging statistics, and the R_meas of its
+    lowest-resolution shell (r_meas_low, over dmax to dmin_low).
 
     CORRECT.LP states the group and cell twice - first as the INPUT to INTEGRATE (routinely P1),
     then as CORRECT's own answer. The last SPACE_GROUP_NUMBER and the refined UNIT CELL PARAMETERS
@@ -143,6 +144,11 @@ def parse_correct_lp(path):
         ref["r_meas"] = round(num(total[9]) / 100, 4)
         ref["cc_half"] = round(num(total[10]) / 100, 4)
         ref["multiplicity"] = round(int(total[1]) / int(total[2]), 2) if int(total[2]) else None
+    if shells:
+        # the lowest-resolution shell, dmax to dmin_low: strong reflections only, so its R_meas
+        # is the merge's accuracy rather than where the signal fades
+        ref["dmin_low"] = float(shells[0][0])
+        ref["r_meas_low"] = round(num(shells[0][9]) / 100, 4)
 
     # The range XDS merged: the explicit INCLUDE_RESOLUTION_RANGE, or - when XDS.INP left the high
     # limit at 0.0, "the whole detector" - the finest shell actually tabulated. The pooled statistics
-- 
2.54.0


From a827e20becc28a16555fa12628644ea79f3c8532 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:32:15 +0200
Subject: [PATCH 048/122] tools/battery: merge quality is CC1/2 against XDS
 only

The owner's scoring decision: no R_meas criterion, and merge quality
judged only by CC1/2 relative to XDS.

- The global rule (R_meas > 60% or CC1/2 < 0.5 fails) is gone.
- XDS arms: a set fails `merge` when (1/CC1/2 - 1) of the reference-range
  table is more than twice XDS's, XDS's CC1/2 taken at the bottom of its
  0.1% rounding. CC1/2 = S/(S+E), so 1/CC1/2 - 1 = E/S at any CC1/2, and
  E goes as 1/observations: 2x is XDS's merge with half its observations.
  Stored as cc_half_noise_ratio. No REFRES table or no XDS CC1/2: no
  criterion.
- Open arm: no merge criterion; CC1/2 and R_meas stay reported numbers.
- Low-resolution R_meas is reported, not scored: the lowest shell of the
  own table, the reference-range table and XDS's (lowres_*), with
  lowres_r_meas_ratio in the like-for-like table and a ratio plot.
- Every schema-3 run is re-scored when it is read (report, compare,
  baseline delta) with today's scorer and today's manifest rows, so both
  sides of a comparison are scored alike. results.json keeps the verdicts
  as scored at run time; rows without a lattice keep them.

Re-scoring the rc172 reference run: inhouse 29 -> 27 pass (three new
merge fails, one R_meas fail lifted), open 137 -> 138 (one R_meas fail
lifted).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md  | 50 +++++++++++++++++++++++------
 tools/battery/battery.py |  2 ++
 tools/battery/report.py  | 65 +++++++++++++++++++++++++++++++++----
 tools/battery/score.py   | 69 ++++++++++++++++++++++++++++++++--------
 4 files changed, 156 insertions(+), 30 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 65d6c2005..80d33c4b0 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -15,14 +15,35 @@ with each other.
 | **inhouse** | standard test crystals measured at the SLS (lysozyme, thaumatin, insulin, cytochrome C, myoglobin), plus no-crystal controls | XDS, from the `CORRECT.LP` beside each dataset | `inhouse.json` (committed) |
 | **private** | user data | XDS, like inhouse | outside the repository; the local site config gives its path |
 
-Scoring checks four things in order, and the first one that fails decides the verdict: did it
-run, is the lattice right, is the symmetry right, is the merge usable (R_meas at most 60%, CC1/2 at
-least 0.5). The lattice test compares Niggli-reduced primitive cells: the primitive volume ratio
+Scoring checks these things in order, and the first one that fails decides the verdict: did it
+run, is the lattice right, is the symmetry right, and on the XDS arms, is the merge as good as
+XDS's. The lattice test compares Niggli-reduced primitive cells: the primitive volume ratio
 must be 0.95-1.05 and the reduced edges must agree within 2%. On the open arm the space group is
 scored with `sgequiv`. On the XDS arms only the point group is scored, because XDS never tests a
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
+**Merge quality is judged only against XDS, and only by CC1/2.** No R_meas is a pass/fail
+criterion, and no absolute CC1/2 either. On the XDS arms the set fails `merge` when
+
+    (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) > 2
+
+with rugnux's CC1/2 from the reference-range table (`REFRES_CC_HALF`, XDS's own range) and XDS's
+from the `CORRECT.LP` total. CC1/2 = S / (S + E), with S the signal variance and E the half-set
+error variance, so 1/CC1/2 - 1 = E/S at any CC1/2, and E goes as 1/(observations): a ratio above 2
+is a merge noisier than XDS's would be with half of its observations. XDS prints CC1/2 to 0.1%, so
+its value is taken at the bottom of that rounding (-0.0005), and a printed 100.0 does not demand a
+perfect CC1/2. The ratio is stored as `cc_half_noise_ratio`. A set without the reference-range
+table or without an XDS CC1/2 (the controls, a hand-measured reference) has no merge criterion.
+**The open arm has no merge criterion at all**: it is scored on lattice and symmetry, and its
+resolution, CC1/2 and R_meas are reported, not judged.
+
+**Low-resolution R_meas** is reported, not scored: the lowest-resolution shell of rugnux's own
+table (`lowres_r_meas`), of the reference-range table (`refres_lowres_r_meas`) and of XDS's
+`CORRECT.LP` (`lowres_r_meas_ref`, stored in the manifest as `r_meas_low`), with the shells'
+high-resolution limits. The reference-range table uses XDS's shell limits, so its lowest shell and
+XDS's cover the same reflections; `lowres_r_meas_ratio` is the one over the other, plotted per set.
+
 ## One command per arm
 
 Every set runs **once**, with one command per arm:
@@ -52,9 +73,9 @@ the reference:
 - **`--report-resolution`** (XDS arms): a second statistics table from the same merge, binned over
   XDS's own range (`dmin_xds` and XDS's d_max as given, 999 included, so it covers exactly what
   XDS's CORRECT.LP totals cover), and `-A` where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the
-  manifest), so the two tables count the same way. Its REFRES_* numbers are scored against XDS's
-  CORRECT.LP totals: completeness, multiplicity, R_meas, CC1/2 and ISa (I/sigma is shown; the
-  manifest holds no XDS value for it). Where rugnux's own cut is coarser than the reference
+  manifest), so the two tables count the same way. Its REFRES_* numbers are shown beside XDS's
+  CORRECT.LP totals: completeness, multiplicity, R_meas, the lowest shell's R_meas, CC1/2 and ISa
+  (I/sigma is shown; the manifest holds no XDS value for it). Only CC1/2 is scored (above). Where rugnux's own cut is coarser than the reference
   (`REFRES_SHELLS_PAST_LIMIT` > 0), the shells past it are not merged, so the completeness is read
   as **coverage** of the reference range, not as a quality regression, and the other numbers are
   over the shells rugnux reached.
@@ -211,6 +232,13 @@ This is a flat list with one object per set, and every arm uses the same keys. M
 `null`. `manifest.json` records the schema version as `results_schema`, and each arm's command as
 `command_doc`.
 
+**Verdicts are scored again whenever a run is read** (`report`, `compare`, the baseline delta):
+every row whose `p_report.txt` has a lattice (or that is a control) goes through today's
+`score.judge` with today's manifest row (reference, `unscored`, `expect`), so the two sides of a
+comparison are always scored by the same rules against the same references. A row whose report
+has no lattice keeps its stored verdict, because why it failed came from the run. `results.json`
+keeps the verdicts as they were scored when the run finished.
+
 Schema 3 is one row per set again: `variant` and `first_read` are gone, and `refres_*`,
 `isa_ratio`, `r_meas_ratio`, `multiplicity_ref`, `cc_model`, `sg_label`, `model` and `model_note`
 are new. `sgno`/`sg` are now the data's own space group where `--model` relabelled the hand.
@@ -228,7 +256,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
 | `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge` (XDS arms: CC1/2 noise ratio above 2), `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
@@ -240,6 +268,8 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref`, `multiplicity_ref` | XDS's overall values, over XDS's own range |
 | `refres_range`, `refres_shells_past_limit`, `refres_unique_reflections`, `refres_completeness`, `refres_multiplicity`, `refres_i_over_sigma`, `refres_r_meas`, `refres_cc_half`, `refres_isa` | XDS arms: the REFRES_* keys, the same merge over the reference range |
 | `isa_ratio`, `r_meas_ratio` | refres_isa / isa_ref and refres_r_meas / r_meas_ref |
+| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), the merge criterion |
+| `lowres_d`, `lowres_r_meas`, `refres_lowres_d`, `refres_lowres_r_meas`, `lowres_d_ref`, `lowres_r_meas_ref`, `lowres_r_meas_ratio` | the lowest-resolution shell's high-resolution limit and R_meas: rugnux's own table, the reference-range table, XDS's; and refres_lowres_r_meas / lowres_r_meas_ref |
 | `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
 | `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
 | `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm) |
@@ -256,8 +286,8 @@ SVG, no external files):
 - a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
   the main metrics;
 - plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
-  for each arm; on the XDS arms the reference-range ISa and R_meas over XDS's; on the open arm
-  R_free / published R_free;
+  for each arm; on the XDS arms the reference-range ISa, R_meas, lowest-shell R_meas and CC1/2
+  noise over XDS's; on the open arm R_free / published R_free;
 - on the XDS arms the **like-for-like table**: the reference-range numbers beside XDS's, with the
   rows where rugnux's cut is coarser marked as coverage;
 - the **failures**, and **one row per set** with all the numbers;
@@ -286,7 +316,7 @@ $B compare RUN_A RUN_B --rerun-changed              # rerun the changed sets wit
 `compare` pairs rows by arm and set id, following the manifests' `aliases` across renames. A run
 from before schema 3 is compared through its `bare` rows (see the schema above). It lists every
 row whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell, R-free,
-reference-range R_meas or ISa (where both runs have them), or time moved by more than the noise
+reference-range R_meas, lowest-shell R_meas or ISa (where both runs have them), or time moved by more than the noise
 thresholds in `report.py` (`NOISE`). Those thresholds
 are a first guess. `--rerun-changed` measures the noise directly: it reruns the changed sets with
 A's saved binary and options. A set that moves again under the same binary is noise. A set that
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 27ae2c150..72ed37663 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -662,6 +662,8 @@ def main():
     a = ap.parse_args()
     site = load_site(a.site)
     report.ALIASES = load_aliases(site)
+    report.MANIFESTS = {arm: {e["id"]: e for e in load_sets(site, arm)}
+                        for arm, cfg in site["arms"].items() if os.path.exists(cfg["manifest"])}
     {"run": cmd_run, "list": cmd_list, "compare": cmd_compare, "report": cmd_report,
      "abort": cmd_abort, "discover": cmd_discover, "refs": cmd_refs, "remap": cmd_remap}[a.cmd](a, site)
 
diff --git a/tools/battery/report.py b/tools/battery/report.py
index df86c2e13..23ea0089a 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -5,6 +5,7 @@ import socket
 import statistics
 import sys
 
+import score
 from render import Doc, ratio_dots, verdict_bars
 
 # A change smaller than these is treated as run-to-run noise. They are a starting point, to be
@@ -19,6 +20,7 @@ NOISE = {
     "rfree": ("abs", 0.005),
     "refres_r_meas": ("rel", 0.05),
     "refres_isa": ("rel", 0.05),
+    "refres_lowres_r_meas": ("rel", 0.05),
     "wall_s": ("rel", 0.25),        # and at least 10 s - see beyond_noise()
 }
 
@@ -53,9 +55,27 @@ def load_run(run_dir, allow_incomplete=False):
         schema1(man, res)
     if schema < 3:
         res[:] = schema2(res)
+    else:
+        rescore(run_dir, man, res)
     return man, res
 
 
+def rescore(run_dir, man, res):
+    """Score every row again from its saved report, with today's scorer and today's manifest rows
+    (references, `unscored`, `expect`), so a report or a compare never mixes two scorings or two
+    references. results.json keeps the verdicts as they were scored when the run finished.
+
+    A row whose report has no lattice keeps its verdict: why it failed (crash, reader, timeout)
+    came from the run, not from the report."""
+    own = {(e["arm"], e["id"]): e for e in man["sets"]}
+    for r in res:
+        e = MANIFESTS.get(r["arm"], {}).get(key(r)[1]) or own.get((r["arm"], r["set"]))
+        rep = score.read_report(os.path.join(run_dir, "work", r["arm"], r["set"], "p_report.txt"))
+        lattice = rep.get("SPACE_GROUP_NUMBER") and rep.get("UNIT_CELL_CONSTANTS")
+        if e and (lattice or e.get("expect") == "no_lattice"):
+            r.update(score.judge(dict(e, arm=r["arm"]), rep, ""))
+
+
 def schema1(man, res):
     """Read a run from before the variants (results schema 1) as one: it ran each set once, plain
     on the open arm and with XDS's settings on the XDS arms - unless --unforced, which left the
@@ -114,6 +134,9 @@ RESULTS_SCHEMA = 3
 # dataset was renamed still pairs with one made after
 ALIASES = {}
 
+# {arm: {set id: manifest row}} of today's manifests (battery.py sets it); rescore() scores with them
+MANIFESTS = {}
+
 
 def key(r):
     return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]))
@@ -166,7 +189,7 @@ def changes(ra, rb):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
     # the like-for-like table only where both runs have one (a pre-schema-3 run has none)
-    for name in ("refres_r_meas", "refres_isa"):
+    for name in ("refres_r_meas", "refres_isa", "refres_lowres_r_meas"):
         if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
             out.append(name)
     if beyond_noise("wall_s", ra.get("wall_s"), rb.get("wall_s")):
@@ -192,7 +215,7 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 def compare_table(doc, rows, only_changed=True):
     head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "R_free", "ref-range R_meas", "time s", "beyond noise"]
+            "cell dev %", "R_free", "ref-range R_meas", "ref-range low-res R_meas", "time s", "beyond noise"]
     out = []
     for (arm, s), ra, rb, ch in rows:
         if only_changed and not ch:
@@ -207,6 +230,8 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("refres_r_meas"), rb.get("refres_r_meas"), lambda v: f"{100 * v:.1f}%"),
+                    arrow(ra.get("refres_lowres_r_meas"), rb.get("refres_lowres_r_meas"),
+                          lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("wall_s"), rb.get("wall_s"), lambda v: f"{v:.0f}"),
                     ", ".join(ch)])
     doc.table(head, out, row_class=lambda r: "fail" if "verdict" in r[-1] else "")
@@ -301,6 +326,9 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                               ("cc_half", "CC1/2", "{:.3f}"), ("res_gain_pct", "res. gain %", "{:+.1f}"),
                               ("isa_ratio", "ref-range ISa / XDS", "{:.3f}"),
                               ("r_meas_ratio", "ref-range R_meas / XDS", "{:.3f}"),
+                              ("lowres_r_meas", "low-res shell R_meas", None),
+                              ("lowres_r_meas_ratio", "ref-range low-res R_meas / XDS", "{:.3f}"),
+                              ("cc_half_noise_ratio", "ref-range CC1/2 noise / XDS", "{:.2f}"),
                               ("rfree", "R_free (placement)", "{:.3f}"),
                               ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
             q = quartiles(r.get(name) for r in rs)
@@ -322,7 +350,13 @@ def build(run_dir, baseline=None, allow_incomplete=False):
             ("isa_ratio", "ISa", "ISa of the reference-range table (the error model refitted on it) / "
                                  "XDS's ISa; above 1 = rugnux's error model is the better one"),
             ("r_meas_ratio", "R_meas", "R_meas over the reference range / XDS's R_meas; below 1 = "
-                                       "rugnux's merge is the more consistent one")):
+                                       "rugnux's merge is the more consistent one"),
+            ("lowres_r_meas_ratio", "low-res R_meas", "R_meas of the lowest-resolution shell of the "
+                                                      "reference-range table / of XDS's table; below 1 = "
+                                                      "rugnux's strong reflections agree better"),
+            ("cc_half_noise_ratio", "CC1/2 noise", "half-set noise over the reference range read off CC1/2 "
+                                                   "(1 / CC1/2 - 1) / XDS's; above 2 fails (the merge is as "
+                                                   "noisy as XDS's with half its observations)")):
         for arm in arms:
             pts = [(r["set"], r[name], r["verdict"], f"{what} ratio, {refres_note(r)}")
                    for r in res if r["arm"] == arm and r.get(name)]
@@ -363,11 +397,21 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                          f(r.get("refres_multiplicity"), "{:.1f}") + " / " + f(r.get("multiplicity_ref"), "{:.1f}"),
                          f(r.get("refres_i_over_sigma"), "{:.1f}"),
                          pct(r.get("refres_r_meas")) + " / " + pct(r.get("r_meas_ref")),
-                         f(r.get("refres_cc_half"), "{:.3f}") + " / " + f(r.get("cc_half_ref"), "{:.3f}"),
+                         lowres_cell(r),
+                         f(r.get("refres_cc_half"), "{:.4f}") + " / " + f(r.get("cc_half_ref"), "{:.3f}"),
+                         f(r.get("cc_half_noise_ratio"), "{:.2f}"),
                          f(r.get("refres_isa"), "{:.1f}") + " / " + f(r.get("isa_ref"), "{:.1f}"),
                          refres_note(r)])
         doc.table(["set", "arm", "range A", "own d_min", "compl % (rugnux / XDS)", "mult", "I/sigma",
-                   "R_meas", "CC1/2", "ISa", "reading"], rows, num=(3, 6))
+                   "R_meas", "low-res R_meas (to d A)", "CC1/2", "CC1/2 noise ratio", "ISa", "reading"],
+                  rows, num=(3, 6, 10))
+        doc.p("Merge quality is scored here and only here, by CC1/2 against XDS's over the same range. "
+              "CC1/2 = S / (S + E) (signal and half-set error variances), so 1 / CC1/2 - 1 = E / S is the "
+              "half-set noise; the noise ratio is rugnux's over XDS's, with XDS's CC1/2 taken at the "
+              "bottom of its printed rounding (-0.0005). A set fails `merge` when the ratio is above "
+              f"{score.CC_HALF_NOISE_LIMIT:g}: noisier than XDS's merge would be with half its "
+              "observations. The low-resolution R_meas is the lowest shell of each table (the shells "
+              "are XDS's, so both cover the same reflections); it is reported, not scored.")
 
     derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
     if derived:
@@ -394,7 +438,7 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
               ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
     head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
-            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
+            "gain", "compl %", "mult", "R_meas", "low-res R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
            [h for h, _ in model] + (["model fit"] if model else []) + ["time s", "note"]
     rows = []
     for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
@@ -404,7 +448,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                      f(r.get("cell_dev_pct")), f(r.get("volume_ratio"), "{:.3f}"),
                      f(r.get("d_min")), f(r.get("d_min_ref")), f(r.get("res_gain_pct"), "{:+.1f}%"),
                      f(r.get("completeness"), "{:.1f}"), f(r.get("multiplicity"), "{:.1f}"),
-                     pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
+                     pct(r.get("r_meas")), pct(r.get("lowres_r_meas")), f(r.get("cc_half"), "{:.3f}"),
+                     f(r.get("isa"), "{:.1f}"),
                      f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0)]
                     + [f(r.get(k), "{:.3f}") for _, k in model]
                     + ([r.get("model_fit") or "-"] if model else [])
@@ -430,6 +475,12 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     return doc
 
 
+def lowres_cell(r):
+    """rugnux / XDS R_meas of the lowest-resolution shell, with the shells' high-resolution limits."""
+    return (pct(r.get("refres_lowres_r_meas")) + " / " + pct(r.get("lowres_r_meas_ref"))
+            + f" ({f(r.get('refres_lowres_d'))} / {f(r.get('lowres_d_ref'))})")
+
+
 def refres_note(r):
     """How to read a row of the reference-range table."""
     if r.get("refres_shells_past_limit"):
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 331722d7d..865daf681 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -1,9 +1,9 @@
 """Scoring one rugnux run against its reference.
 
 One dataset, one verdict, one cause, decided in this order: did it run -> is the lattice right ->
-is the symmetry right -> is the merge usable. The order matters: a halved axis also makes the
-screw along it unobservable, and counting that row twice would hide the defect that cost the
-reflections.
+is the symmetry right -> (XDS arms only) is the merge as good as XDS's by CC1/2. The order matters:
+a halved axis also makes the screw along it unobservable, and counting that row twice would hide
+the defect that cost the reflections.
 """
 import itertools
 import os
@@ -17,13 +17,28 @@ REPORT_LINE = re.compile(r"^([A-Z_0-9]+)=\s*(.*)$")
 
 
 def read_report(path):
-    """KEY= value lines of a rugnux _report.txt."""
+    """KEY= value lines of a rugnux _report.txt, plus the lowest-resolution shell of its two shell
+    tables: LOWRES_D / LOWRES_R_MEAS from the table over its own range, REFRES_LOWRES_D /
+    REFRES_LOWRES_R_MEAS from the one over the reference range (it follows REFRES_RANGE=)."""
     out = {}
-    if os.path.exists(path):
-        for line in open(path, errors="replace"):
-            m = REPORT_LINE.match(line.rstrip("\n"))
-            if m:
-                out[m.group(1)] = m.group(2).strip()
+    if not os.path.exists(path):
+        return out
+    header = None
+    for line in open(path, errors="replace"):
+        line = line.rstrip("\n")
+        m = REPORT_LINE.match(line)
+        if m:
+            out[m.group(1)] = m.group(2).strip()
+            continue
+        f = line.lstrip("#").split()
+        if f[:2] == ["d_min", "N_obs"]:
+            header = f
+        elif header and f and re.match(r"^\d+\.\d+$", f[0]):
+            prefix = "REFRES_" if "REFRES_RANGE" in out else ""
+            out[prefix + "LOWRES_D"] = f[0]
+            r_meas = f[header.index("R_meas")].rstrip("%")          # "3.7%", or "-" for none
+            out[prefix + "LOWRES_R_MEAS"] = "" if r_meas == "-" else str(round(float(r_meas) / 100, 4))
+            header = None                  # only the first row of each table
     return out
 
 
@@ -74,6 +89,24 @@ def cell_dev_pct(cell, ref):
                for p in itertools.permutations(cell[:3]))
 
 
+# XDS prints CC1/2 in % with one decimal; its value is taken at the bottom of that rounding, so a
+# printed 100.0 does not demand a perfect CC1/2 of rugnux
+XDS_CC_HALF_ROUNDING = 0.0005
+CC_HALF_NOISE_LIMIT = 2.0
+
+
+def cc_half_noise_ratio(cc, cc_xds):
+    """rugnux's half-set noise over XDS's, both read off CC1/2 over XDS's range; None without both.
+
+    CC1/2 = S / (S + E), with S the variance of the signal and E that of the half-set error, so
+    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2
+    (CC_HALF_NOISE_LIMIT) is a merge as noisy as XDS's would be with half of its observations.
+    A CC1/2 at or below 0 is no signal at all, counted as 0.001."""
+    if cc is None or cc_xds is None:
+        return None
+    return round((1 / max(cc, 0.001) - 1) / (1 / (cc_xds - XDS_CC_HALF_ROUNDING) - 1), 3)
+
+
 def point_group(sgno):
     return gemmi.find_spacegroup_by_number(int(sgno)).point_group_hm()
 
@@ -115,6 +148,15 @@ def judge(entry, rep, run_note):
     r["isa_ratio"] = round(r["refres_isa"] / r["isa_ref"], 4) if r["refres_isa"] and r["isa_ref"] else None
     r["r_meas_ratio"] = (round(r["refres_r_meas"] / r["r_meas_ref"], 4)
                          if r["refres_r_meas"] and r["r_meas_ref"] else None)
+    # R_meas of the lowest-resolution shell: rugnux's own table, the reference-range table and XDS's
+    # (reported, not scored)
+    r.update(lowres_d=fnum(rep.get("LOWRES_D")), lowres_r_meas=fnum(rep.get("LOWRES_R_MEAS")),
+             refres_lowres_d=fnum(rep.get("REFRES_LOWRES_D")),
+             refres_lowres_r_meas=fnum(rep.get("REFRES_LOWRES_R_MEAS")),
+             lowres_d_ref=ref.get("dmin_low"), lowres_r_meas_ref=ref.get("r_meas_low"))
+    r["lowres_r_meas_ratio"] = (round(r["refres_lowres_r_meas"] / r["lowres_r_meas_ref"], 4)
+                                if r["refres_lowres_r_meas"] and r["lowres_r_meas_ref"] else None)
+    r["cc_half_noise_ratio"] = cc_half_noise_ratio(r["refres_cc_half"], r["cc_half_ref"])
     if rep.get("SPACE_GROUP_NUMBER"):
         r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
         r["sg"] = rep.get("SPACE_GROUP_NAME") or sg_name(r["sgno"])
@@ -191,10 +233,11 @@ def judge(entry, rep, run_note):
                  "sym_over" if order > order_ref else "sym_other")
         return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
 
-    if r["r_meas"] is not None and r["r_meas"] > 0.6:
-        return verdict("fail", "merge", f"R_meas {r['r_meas']:.0%} overall")
-    if r["cc_half"] is not None and r["cc_half"] < 0.5:
-        return verdict("fail", "merge", f"CC1/2 {r['cc_half']:.2f} overall")
+    # Merge quality is judged only against XDS, by CC1/2 over XDS's own range (cc_half_noise_ratio).
+    # The open arm has no merge criterion.
+    if r["cc_half_noise_ratio"] is not None and r["cc_half_noise_ratio"] > CC_HALF_NOISE_LIMIT:
+        return verdict("fail", "merge", f"CC1/2 {r['refres_cc_half']:.4f} vs XDS {r['cc_half_ref']:.3f} "
+                                        f"over XDS's range: {r['cc_half_noise_ratio']:.1f}x XDS's half-set noise")
     note = ""
     if r["sgno"] != ref["sgno"]:
         note = f"{r['sg']} vs reference {r['sg_ref']} ({r.get('sg_relation') or 'screws not judged against XDS'})"
-- 
2.54.0


From e016bc6c787670381300b9125e773a7b4dd9a269 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:41:43 +0200
Subject: [PATCH 049/122] tools/battery: verdicts judge lattice and symmetry
 only

Data quality - resolution, CC1/2, R_meas, completeness, ISa - is no longer a
pass/fail criterion anywhere; it is reported beside the reference in the tables
and plots for a human to judge. The CC1/2 noise ratio against XDS stays as a
reported guide.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md | 24 ++++++++----------------
 tools/battery/report.py | 13 ++++++-------
 tools/battery/score.py  | 13 ++++---------
 3 files changed, 18 insertions(+), 32 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 80d33c4b0..71869800e 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -23,20 +23,12 @@ scored with `sgequiv`. On the XDS arms only the point group is scored, because X
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
-**Merge quality is judged only against XDS, and only by CC1/2.** No R_meas is a pass/fail
-criterion, and no absolute CC1/2 either. On the XDS arms the set fails `merge` when
-
-    (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) > 2
-
-with rugnux's CC1/2 from the reference-range table (`REFRES_CC_HALF`, XDS's own range) and XDS's
-from the `CORRECT.LP` total. CC1/2 = S / (S + E), with S the signal variance and E the half-set
-error variance, so 1/CC1/2 - 1 = E/S at any CC1/2, and E goes as 1/(observations): a ratio above 2
-is a merge noisier than XDS's would be with half of its observations. XDS prints CC1/2 to 0.1%, so
-its value is taken at the bottom of that rounding (-0.0005), and a printed 100.0 does not demand a
-perfect CC1/2. The ratio is stored as `cc_half_noise_ratio`. A set without the reference-range
-table or without an XDS CC1/2 (the controls, a hand-measured reference) has no merge criterion.
-**The open arm has no merge criterion at all**: it is scored on lattice and symmetry, and its
-resolution, CC1/2 and R_meas are reported, not judged.
+**Data quality is not scored.** A verdict is about the lattice and the symmetry only. Resolution,
+CC1/2, R_meas (overall and lowest shell), completeness, multiplicity and ISa are reported beside
+XDS's or the deposition's values, in the per-set tables and plots, for a human to judge. On the XDS
+arms `cc_half_noise_ratio` = (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) over XDS's own
+range is shown as a guide: CC1/2 = S/(S+E), so 1/CC1/2 - 1 = E/S, and 2 means a merge as noisy as
+XDS's would be with half of its observations.
 
 **Low-resolution R_meas** is reported, not scored: the lowest-resolution shell of rugnux's own
 table (`lowres_r_meas`), of the reference-range table (`refres_lowres_r_meas`) and of XDS's
@@ -256,7 +248,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
 | `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge` (XDS arms: CC1/2 noise ratio above 2), `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
@@ -268,7 +260,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref`, `multiplicity_ref` | XDS's overall values, over XDS's own range |
 | `refres_range`, `refres_shells_past_limit`, `refres_unique_reflections`, `refres_completeness`, `refres_multiplicity`, `refres_i_over_sigma`, `refres_r_meas`, `refres_cc_half`, `refres_isa` | XDS arms: the REFRES_* keys, the same merge over the reference range |
 | `isa_ratio`, `r_meas_ratio` | refres_isa / isa_ref and refres_r_meas / r_meas_ref |
-| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), the merge criterion |
+| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), reported, not scored |
 | `lowres_d`, `lowres_r_meas`, `refres_lowres_d`, `refres_lowres_r_meas`, `lowres_d_ref`, `lowres_r_meas_ref`, `lowres_r_meas_ratio` | the lowest-resolution shell's high-resolution limit and R_meas: rugnux's own table, the reference-range table, XDS's; and refres_lowres_r_meas / lowres_r_meas_ref |
 | `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
 | `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
diff --git a/tools/battery/report.py b/tools/battery/report.py
index 23ea0089a..724d0e6a2 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -355,8 +355,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                                                       "reference-range table / of XDS's table; below 1 = "
                                                       "rugnux's strong reflections agree better"),
             ("cc_half_noise_ratio", "CC1/2 noise", "half-set noise over the reference range read off CC1/2 "
-                                                   "(1 / CC1/2 - 1) / XDS's; above 2 fails (the merge is as "
-                                                   "noisy as XDS's with half its observations)")):
+                                                   "(1 / CC1/2 - 1) / XDS's; 2 = as noisy as XDS's merge "
+                                                   "would be with half its observations (not scored)")):
         for arm in arms:
             pts = [(r["set"], r[name], r["verdict"], f"{what} ratio, {refres_note(r)}")
                    for r in res if r["arm"] == arm and r.get(name)]
@@ -405,13 +405,12 @@ def build(run_dir, baseline=None, allow_incomplete=False):
         doc.table(["set", "arm", "range A", "own d_min", "compl % (rugnux / XDS)", "mult", "I/sigma",
                    "R_meas", "low-res R_meas (to d A)", "CC1/2", "CC1/2 noise ratio", "ISa", "reading"],
                   rows, num=(3, 6, 10))
-        doc.p("Merge quality is scored here and only here, by CC1/2 against XDS's over the same range. "
+        doc.p("Data quality is not scored; this table is for a human to judge. "
               "CC1/2 = S / (S + E) (signal and half-set error variances), so 1 / CC1/2 - 1 = E / S is the "
               "half-set noise; the noise ratio is rugnux's over XDS's, with XDS's CC1/2 taken at the "
-              "bottom of its printed rounding (-0.0005). A set fails `merge` when the ratio is above "
-              f"{score.CC_HALF_NOISE_LIMIT:g}: noisier than XDS's merge would be with half its "
-              "observations. The low-resolution R_meas is the lowest shell of each table (the shells "
-              "are XDS's, so both cover the same reflections); it is reported, not scored.")
+              "bottom of its printed rounding (-0.0005); 2 would mean noisier than XDS's merge with half "
+              "its observations. The low-resolution R_meas is the lowest shell of each table (the shells "
+              "are XDS's, so both cover the same reflections); reported like everything here.")
 
     derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
     if derived:
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 865daf681..af44f3d57 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -1,7 +1,7 @@
 """Scoring one rugnux run against its reference.
 
 One dataset, one verdict, one cause, decided in this order: did it run -> is the lattice right ->
-is the symmetry right -> (XDS arms only) is the merge as good as XDS's by CC1/2. The order matters:
+is the symmetry right. Data quality is not scored: it is reported for a human to judge. The order matters:
 a halved axis also makes the screw along it unobservable, and counting that row twice would hide
 the defect that cost the reflections.
 """
@@ -92,15 +92,14 @@ def cell_dev_pct(cell, ref):
 # XDS prints CC1/2 in % with one decimal; its value is taken at the bottom of that rounding, so a
 # printed 100.0 does not demand a perfect CC1/2 of rugnux
 XDS_CC_HALF_ROUNDING = 0.0005
-CC_HALF_NOISE_LIMIT = 2.0
 
 
 def cc_half_noise_ratio(cc, cc_xds):
     """rugnux's half-set noise over XDS's, both read off CC1/2 over XDS's range; None without both.
 
     CC1/2 = S / (S + E), with S the variance of the signal and E that of the half-set error, so
-    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2
-    (CC_HALF_NOISE_LIMIT) is a merge as noisy as XDS's would be with half of its observations.
+    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2 is a merge as
+    noisy as XDS's would be with half of its observations. Reported, not scored.
     A CC1/2 at or below 0 is no signal at all, counted as 0.001."""
     if cc is None or cc_xds is None:
         return None
@@ -233,11 +232,7 @@ def judge(entry, rep, run_note):
                  "sym_over" if order > order_ref else "sym_other")
         return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
 
-    # Merge quality is judged only against XDS, by CC1/2 over XDS's own range (cc_half_noise_ratio).
-    # The open arm has no merge criterion.
-    if r["cc_half_noise_ratio"] is not None and r["cc_half_noise_ratio"] > CC_HALF_NOISE_LIMIT:
-        return verdict("fail", "merge", f"CC1/2 {r['refres_cc_half']:.4f} vs XDS {r['cc_half_ref']:.3f} "
-                                        f"over XDS's range: {r['cc_half_noise_ratio']:.1f}x XDS's half-set noise")
+    # Data quality (CC1/2, R_meas, resolution, ISa) is reported, never scored: that is for a human.
     note = ""
     if r["sgno"] != ref["sgno"]:
         note = f"{r['sg']} vs reference {r['sg_ref']} ({r.get('sg_relation') or 'screws not judged against XDS'})"
-- 
2.54.0


From 9e2a7a13c25c7cc52f3475d8a14f82857cb5f654 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:33:39 +0200
Subject: [PATCH 050/122] rugnux: a rotation run decides with Friedel mates
 merged, -A or not

-A set MergeFriedel(false), and RotationScaleMerge builds one grouping for the
whole pass from it, so every decision on an anomalous rotation run was taken on
hand-separated groups: per-frame scaling, the correction surfaces, the outlier
median, the error model, the CC1/2 half-sets and the resolution cut, the
delta-CC1/2 frame ledger and the space-group search. That halves the
multiplicity each of those gates was calibrated at, and flipped the bare run's
symmetry, resolution and frame-rejection calls on several sets - none of them
through the anomalous signal (a 422 refused on an added-operator R, a 23
refused on a chi^2 gate, a screw row read on hand rows, thin hands exempt from
the outlier median letting one hot pair own a CC1/2 bin).

A rotation run now always merges with Friedel's law: the Rugnux constructor
turns MergeFriedel back on when the run is rotation (IsRotationIndexing, which
--force-still clears), and --mode scale does the same for its rotation merge.
Nothing is lost for anomalous use: the merge always keeps the Bijvoet split, and
I(+)/I(-), F(+)/F(-), SigAno and CCanom are written and reported from it
whether or not -A was given. -A on a rotation run is therefore a no-op on the
processing, which is the point; stills keep -A as their only anomalous route.
A bare run is untouched.

This is step 1 of the -A design (decide with pairs merged, present with them
split). The per-hand statistics table that -A should select is not built yet,
so an -A rotation run now reports the Friedel-merged table (FRIEDELS_LAW=
TRUE, Laue multiplicity and completeness). The thin-hand pair median of the
previous commit is unreachable from rugnux on rotation data but kept for any
direct MergeFriedel(false) caller of RotationScaleMerge.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp     | 17 +++++++++++++++++
 rugnux/rugnux_cli.cpp |  3 ++-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 8e40c0399..557c79afe 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -497,6 +497,23 @@ Rugnux::Rugnux(JFJochReader &reader, DiffractionExperiment experiment,
 
     LogHeaderBeamCenter(experiment_, pixel_mask_);
 
+    // Every decision on a rotation run - per-frame scaling, the correction surfaces, the outlier test,
+    // the error model, the CC1/2 half-sets and the resolution cut, the frame ledger, the space-group
+    // search - is taken with Friedel mates merged, -A or not. Splitting them halves the multiplicity
+    // every one of those gates was calibrated at, which is a noisier instrument rather than a more
+    // careful one: it flipped symmetry, resolution and frame-rejection calls against the bare run on
+    // several sets, none of them through the anomalous signal. It is also what XDS, AIMLESS, POINTLESS
+    // and DIALS decide on. The anomalous signal is not lost: the merge always keeps the Bijvoet split,
+    // and I(+)/I(-), SigAno and CCanom come from it in either mode. Stills keep -A as it was - their
+    // merge has no separate split.
+    if (experiment_.IsRotationIndexing() && !experiment_.GetScalingSettings().GetMergeFriedel()) {
+        ScalingSettings s = experiment_.GetScalingSettings();
+        experiment_.ImportScalingSettings(s.MergeFriedel(true));
+        Logger("Rugnux").Info("-A on rotation data: every processing decision is made with Friedel mates "
+                              "merged; I(+)/I(-), SigAno and CCanom are reported from the Bijvoet split "
+                              "the merge keeps, exactly as without -A");
+    }
+
     // A manually asserted stage calibration applies to everything, before anything reads an angle.
     if (config_.rotation_scale.has_value())
         if (const auto g = experiment_.GetGoniometer()) {
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index 6ffbc469d..e4b6fdc9d 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -1577,7 +1577,8 @@ static int RunRugnux(int argc, char **argv) {
         if (report_resolution_arg)
             scaling_settings.ReportResolutionRange_A(
                 ParseReportResolution(*report_resolution_arg, scaling_settings, logger));
-        scaling_settings.MergeFriedel(!anomalous_mode);
+        // Rotation merges decide with Friedel mates merged, -A or not (see the Rugnux constructor).
+        scaling_settings.MergeFriedel(!anomalous_mode || rot);
         scaling_settings.MinPartiality(min_partiality);
         scaling_settings.MinCapturedFraction(
             min_captured_fraction_arg.value_or(scaling_settings.GetMinCapturedFraction()));
-- 
2.54.0


From 08771694b32d80d874132f11b5b38717a86b1e1b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 14:31:36 +0200
Subject: [PATCH 051/122] writer: GetCompressionAlgorithm passed a byte count
 as the filter-parameter count

H5Pget_filter2 takes cd_nelmts as the number of elements the cd_values buffer can hold and
writes up to that many. It was given sizeof(cd_values) = 32 for an 8-element array, so a
filter carrying more than 8 parameters would have been written past the end of the buffer.
Bitshuffle carries 5, so nothing overflowed in practice.

The "Weird value" message printed cd_values[1] while the test above it is on cd_values[4].

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015eAE2K7i5JGDwgwifiCfuA
(cherry picked from commit dd1af9576c04fd2206eb4c266ab52e48b3a9a079)
---
 writer/HDF5Objects.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp
index dd7e2393e..3b0f8beae 100644
--- a/writer/HDF5Objects.cpp
+++ b/writer/HDF5Objects.cpp
@@ -1009,7 +1009,7 @@ CompressionAlgorithm HDF5Dcpl::GetCompression() {
         return CompressionAlgorithm::NO_COMPRESSION;
 
     uint32_t cd_values[8];
-    size_t cd_nelemts = sizeof(cd_values);
+    size_t cd_nelemts = std::size(cd_values);
     memset(cd_values, 0, sizeof(cd_values));
 
     const auto filter = H5Pget_filter2(id, 0, nullptr, &cd_nelemts, cd_values, 0, nullptr, nullptr);
@@ -1031,7 +1031,7 @@ CompressionAlgorithm HDF5Dcpl::GetCompression() {
         return CompressionAlgorithm::BSHUF_LZ4;
     if (cd_values[4] == BSHUF_H5_COMPRESS_ZSTD)
         return CompressionAlgorithm::BSHUF_ZSTD;
-    throw JFJochException(JFJochExceptionCategory::HDF5,"Weird value of parameter " + std::to_string(cd_values[1]));
+    throw JFJochException(JFJochExceptionCategory::HDF5,"Weird value of parameter " + std::to_string(cd_values[4]));
 }
 
 std::string ExtractFilename(const std::string& str) {
-- 
2.54.0


From 377d1e1b25b1dbcd4e46af91ed6215f4a12359a5 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:32:15 +0200
Subject: [PATCH 052/122] tools/battery: the XDS references carry the lowest
 shell's R_meas

parse_correct_lp also reads the first row of CORRECT.LP's last resolution
table: its high-resolution limit (dmin_low) and R_meas (r_meas_low).
inhouse.json regenerated with `refs --arm inhouse --write`; the only
change is the two new keys per set (the private manifest was regenerated
the same way, outside the repository).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/inhouse.json | 66 +++++++++++++++++++-------------------
 tools/battery/inputs.py    |  8 ++++-
 2 files changed, 40 insertions(+), 34 deletions(-)

diff --git a/tools/battery/inhouse.json b/tools/battery/inhouse.json
index e6d1aefaf..20a7fbd38 100644
--- a/tools/battery/inhouse.json
+++ b/tools/battery/inhouse.json
@@ -1,37 +1,37 @@
 {"arm": "inhouse", "aliases": {"E08_lyso_2_006": "lyso_x10sa_90deg_1", "E08_lyso_2_007": "lyso_x10sa_90deg_2", "lyso_2": "lyso_x06da_atten_wedge", "lyso_6_5keV": "lyso_x06da_5keV", "lysoC_14_f46f0a": "lyso_x06da_ice", "Thau_9": "thau_x10sa_0p1deg", "thau_BL1A_1p9A": "thau_bl1a_6p5keV", "thau_BL1A_2p7A": "thau_bl1a_4p6keV", "thau_BL1A_3p3A": "thau_bl1a_3p8keV", "Ins_H_2_fa9841": "insu_H_x06da_twin", "Ins_H_3_d05684": "insu_H_x06da_notwin", "Ins_I_16": "insu_I_x06da_weak", "Ins_I_2_1a530d": "insu_I_x06da_low_isa", "Ins_I_3_5e90e3": "insu_I_x06da_ref", "Ins_I_6_13keV": "insu_I_x06da_13keV", "Ins_I_6_5keV": "insu_I_x06da_5keV", "Ins_I_6_6keV": "insu_I_x06da_6keV", "Ins_I_7_5keV": "insu_I_x06da_5keV_2", "cytC_10": "cytc_x10sa", "cytC_2_0770b5": "cytc_x06da_1", "cytC_3_874285": "cytc_x06da_2", "MyoB_13": "myob_x10sa", "MyoB_9_446b70": "myob_x06da", "MyoB2-1": "myob_x06da_powder_1", "MyoB2-2": "myob_x06da_powder_2", "MyoB2-4": "myob_x06da_split", "MyoB2-5": "myob_x06da_sparse", "onlyice": "nothing_ice", "nothing_3400ac": "nothing_2", "nothing_9bf604": "nothing_1", "lyso_90deg_1": "lyso_x10sa_90deg_1", "lyso_90deg_2": "lyso_x10sa_90deg_2", "lyso_atten_wedge": "lyso_x06da_atten_wedge", "lyso_5keV": "lyso_x06da_5keV", "lyso_ice": "lyso_x06da_ice", "lyso_ref": "lyso_x06da_ref", "lyso_strong": "lyso_x10sa_strong", "lyso_half_image": "lyso_x06da_half_image", "thau_16keV": "thau_x10sa_16keV", "thau_0p1deg": "thau_x10sa_0p1deg", "thau_1p9A": "thau_bl1a_6p5keV", "thau_2p7A": "thau_bl1a_4p6keV", "thau_3p3A": "thau_bl1a_3p8keV", "thau_injection": "thau_x10sa_injection", "thau_pink": "thau_micromax_pink", "insu_H_twin": "insu_H_x06da_twin", "insu_H_notwin": "insu_H_x06da_notwin", "insu_I_weak": "insu_I_x06da_weak", "insu_I_low_isa": "insu_I_x06da_low_isa", "insu_I_ref": "insu_I_x06da_ref", "insu_I_13keV": "insu_I_x06da_13keV", "insu_I_5keV": "insu_I_x06da_5keV", "insu_I_6keV": "insu_I_x06da_6keV", "insu_I_5keV_2": "insu_I_x06da_5keV_2", "cytc_eiger": "cytc_x10sa", "cytc_pilatus_1": "cytc_x06da_1", "cytc_pilatus_2": "cytc_x06da_2", "myob_eiger": "myob_x10sa", "myob_pilatus": "myob_x06da", "myob_powder_1": "myob_x06da_powder_1", "myob_powder_2": "myob_x06da_powder_2", "myob_split": "myob_x06da_split", "myob_aggregate": "myob_x06da_sparse", "myob_x06da_aggregate": "myob_x06da_sparse"}, "sets": [
- {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_5keV", "input": "lyso_x06da_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
- {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
- {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
- {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
- {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": false, "isa": 44.51, "completeness": 94.3, "r_meas": 0.072, "cc_half": 1.0, "multiplicity": 18.36, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
- {"id": "thau_bl1a_3p8keV", "input": "thau_bl1a_3p8keV/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
- {"id": "thau_x10sa_injection", "input": "thau_x10sa_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
- {"id": "thau_micromax_pink", "input": "thau_micromax_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
- {"id": "insu_H_x06da_twin", "input": "insu_H_x06da_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_H_x06da_notwin", "input": "insu_H_x06da_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
- {"id": "insu_I_x06da_weak", "input": "insu_I_x06da_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_low_isa", "input": "insu_I_x06da_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_ref", "input": "insu_I_x06da_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_13keV", "input": "insu_I_x06da_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
- {"id": "insu_I_x06da_5keV", "input": "insu_I_x06da_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_x06da_6keV", "input": "insu_I_x06da_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
- {"id": "insu_I_x06da_5keV_2", "input": "insu_I_x06da_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
- {"id": "cytc_x10sa", "input": "cytc_x10sa/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_x06da_1", "input": "cytc_x06da_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "cytc_x06da_2", "input": "cytc_x06da_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
- {"id": "myob_x10sa", "input": "myob_x10sa/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
- {"id": "myob_x06da", "input": "myob_x06da/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
- {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
- {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
- {"id": "myob_x06da_sparse", "input": "myob_x06da_sparse/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 3, "cell": [35.388, 28.752, 64.083, 90.0, 106.352, 90.0], "anomalous": false, "isa": 5.46, "completeness": 73.7, "r_meas": 0.326, "cc_half": 0.972, "multiplicity": 5.21, "dmin": 2.0, "dmin_rule": "xds_range", "dmin_xds": 2.0, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "lyso_x10sa_90deg_1", "input": "lyso_x10sa_90deg_1/lyso_2_006_master.h5", "ref": {"sgno": 92, "cell": [76.879, 76.879, 36.961, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.75, "completeness": 99.3, "r_meas": 0.182, "cc_half": 0.995, "multiplicity": 3.51, "dmin_low": 5.83, "r_meas_low": 0.049, "dmin": 1.966, "dmin_rule": "xds_range", "dmin_xds": 1.966, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x10sa_90deg_2", "input": "lyso_x10sa_90deg_2/lyso_2_007_master.h5", "ref": {"sgno": 92, "cell": [76.904, 76.904, 36.976, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.14, "completeness": 99.3, "r_meas": 0.18, "cc_half": 0.994, "multiplicity": 3.51, "dmin_low": 5.86, "r_meas_low": 0.051, "dmin": 1.973, "dmin_rule": "xds_range", "dmin_xds": 1.973, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_atten_wedge", "input": "lyso_x06da_atten_wedge/lyso_2_002_master.h5", "ref": {"sgno": 92, "cell": [78.235, 78.235, 37.798, 90.0, 90.0, 90.0], "anomalous": true, "isa": 16.56, "completeness": 99.9, "r_meas": 0.239, "cc_half": 0.998, "multiplicity": 10.97, "dmin_low": 3.76, "r_meas_low": 0.069, "dmin": 1.264, "dmin_rule": "xds_range", "dmin_xds": 1.264, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_5keV", "input": "lyso_x06da_5keV/lyso_6_001_master.h5", "ref": {"sgno": 92, "cell": [78.225, 78.225, 37.897, 90.0, 90.0, 90.0], "anomalous": true, "isa": 19.36, "completeness": 86.4, "r_meas": 0.064, "cc_half": 0.998, "multiplicity": 8.85, "dmin_low": 7.22, "r_meas_low": 0.047, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "lysozyme", "long-wavelength"]},
+ {"id": "lyso_x06da_ice", "input": "lyso_x06da_ice/lysoC_14_56b5b9_master.h5", "ref": {"sgno": 89, "cell": [78.387, 78.387, 37.427, 90.0, 90.0, 90.0], "anomalous": true, "isa": 23.33, "completeness": 100.0, "r_meas": 0.219, "cc_half": 0.998, "multiplicity": 11.86, "dmin_low": 4.26, "r_meas_low": 0.055, "dmin": 1.431, "dmin_rule": "xds_range", "dmin_xds": 1.431, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_ref", "input": "lyso_x06da_ref/hewl_35_001_master.h5", "ref": {"sgno": 89, "cell": [78.091, 78.091, 37.704, 90.0, 90.0, 90.0], "anomalous": true, "isa": 28.31, "completeness": 100.0, "r_meas": 0.045, "cc_half": 1.0, "multiplicity": 13.76, "dmin_low": 3.58, "r_meas_low": 0.029, "dmin": 1.2, "dmin_rule": "xds_range", "dmin_xds": 1.2, "dmax": 50.0}, "tags": ["h5", "lysozyme"], "tiers": {"smoke": "lysozyme reference set"}},
+ {"id": "lyso_x10sa_strong", "input": "lyso_x10sa_strong/lyso_5_f6ac7e_master.h5", "ref": {"sgno": 92, "cell": [77.769, 77.769, 37.442, 90.0, 90.0, 90.0], "anomalous": false, "isa": 8.63, "completeness": 65.8, "r_meas": 0.112, "cc_half": 0.998, "multiplicity": 11.46, "dmin_low": 3.52, "r_meas_low": 0.077, "dmin": 1.24, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.18, "dmax": 999.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "lyso_x06da_half_image", "input": "lyso_x06da_half_image/lyso3_7_b81d83_master.h5", "ref": {"sgno": 96, "cell": [77.74, 77.74, 37.386, 90.0, 90.0, 90.0], "anomalous": true, "isa": 6.61, "completeness": 99.6, "r_meas": 0.595, "cc_half": 0.958, "multiplicity": 5.31, "dmin_low": 4.91, "r_meas_low": 0.258, "dmin": 1.65, "dmin_rule": "xds_range", "dmin_xds": 1.65, "dmax": 50.0}, "tags": ["h5", "lysozyme"]},
+ {"id": "thau_x10sa_16keV", "input": "thau_x10sa_16keV/lyso_4_d2bb9b_master.h5", "ref": {"sgno": 92, "cell": [57.958, 57.958, 150.547, 90.0, 90.0, 90.0], "anomalous": false, "isa": 44.51, "completeness": 94.3, "r_meas": 0.072, "cc_half": 1.0, "multiplicity": 18.36, "dmin_low": 3.89, "r_meas_low": 0.027, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_x10sa_0p1deg", "input": "thau_x10sa_0p1deg/Thau_9_002_master.h5", "ref": {"sgno": 92, "cell": [58.488, 58.488, 150.788, 90.0, 90.0, 90.0], "anomalous": true, "isa": 9.15, "completeness": 99.0, "r_meas": 0.23, "cc_half": 0.997, "multiplicity": 11.37, "dmin_low": 6.51, "r_meas_low": 0.104, "dmin": 2.197, "dmin_rule": "xds_range", "dmin_xds": 2.197, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_bl1a_6p5keV", "input": "thau_bl1a_6p5keV/JTH14_1p9_50ds_90T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.031, 58.031, 150.577, 90.0, 90.0, 90.0], "anomalous": true, "isa": 34.46, "completeness": 91.8, "r_meas": 0.072, "cc_half": 0.999, "multiplicity": 7.95, "dmin_low": 5.33, "r_meas_low": 0.041, "dmin": 1.78, "dmin_rule": "xds_range", "dmin_xds": 1.78, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_4p6keV", "input": "thau_bl1a_4p6keV/JTH14_2p7_50ds_19T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [58.007, 58.007, 150.511, 90.0, 90.0, 90.0], "anomalous": true, "isa": 35.64, "completeness": 92.0, "r_meas": 0.062, "cc_half": 0.998, "multiplicity": 7.94, "dmin_low": 7.56, "r_meas_low": 0.039, "dmin": 2.53, "dmin_rule": "xds_range", "dmin_xds": 2.53, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"]},
+ {"id": "thau_bl1a_3p8keV", "input": "thau_bl1a_3p8keV/JTH14_3p3_50ds_12T_k0_JF4M_01_50001_master.h5", "ref": {"sgno": 89, "cell": [57.895, 57.895, 150.213, 90.0, 90.0, 90.0], "anomalous": true, "isa": 30.8, "completeness": 92.2, "r_meas": 0.057, "cc_half": 0.997, "multiplicity": 7.92, "dmin_low": 9.23, "r_meas_low": 0.039, "dmin": 3.1, "dmin_rule": "xds_range", "dmin_xds": 3.1, "dmax": 100.0}, "tags": ["h5", "thaumatin", "long-wavelength"], "tiers": {"smoke": "long wavelength (3.3 A), KEK BL-1A thaumatin"}},
+ {"id": "thau_x10sa_injection", "input": "thau_x10sa_injection/lyso_13_0c7e7a_master.h5", "ref": {"sgno": 92, "cell": [57.922, 57.922, 150.678, 90.0, 90.0, 90.0], "anomalous": true, "isa": 36.23, "completeness": 86.2, "r_meas": 0.037, "cc_half": 1.0, "multiplicity": 9.96, "dmin_low": 3.83, "r_meas_low": 0.022, "dmin": 1.28, "dmin_rule": "xds_range", "dmin_xds": 1.28, "dmax": 50.0}, "tags": ["h5", "thaumatin"]},
+ {"id": "thau_micromax_pink", "input": "thau_micromax_pink/Thau-Thaumatin_2_master.h5", "ref": {"sgno": 92, "cell": [58.784, 58.784, 152.226, 90.0, 90.0, 90.0], "anomalous": true, "isa": 21.18, "completeness": 98.5, "r_meas": 0.08, "cc_half": 0.999, "multiplicity": 9.38, "dmin_low": 4.17, "r_meas_low": 0.04, "dmin": 1.4, "dmin_rule": "xds_range", "dmin_xds": 1.4, "dmax": 50.0}, "tags": ["h5", "thaumatin", "pink-beam"], "tiers": {"smoke": "pink beam"}},
+ {"id": "insu_H_x06da_twin", "input": "insu_H_x06da_twin/Ins_H_2_fa9841_master.h5", "ref": {"sgno": 146, "cell": [81.393, 81.393, 33.272, 90.0, 90.0, 120.0], "anomalous": true, "isa": 6.82, "completeness": 95.0, "r_meas": 0.118, "cc_half": 0.988, "multiplicity": 3.61, "dmin_low": 4.34, "r_meas_low": 0.106, "dmin": 1.455, "dmin_rule": "xds_range", "dmin_xds": 1.455, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_H_x06da_notwin", "input": "insu_H_x06da_notwin/Ins_H_3_d05684_master.h5", "ref": {"sgno": 146, "cell": [81.378, 81.378, 33.269, 90.0, 90.0, 120.0], "anomalous": true, "isa": 17.69, "completeness": 97.4, "r_meas": 0.068, "cc_half": 0.998, "multiplicity": 3.52, "dmin_low": 4.61, "r_meas_low": 0.045, "dmin": 1.544, "dmin_rule": "xds_range", "dmin_xds": 1.544, "dmax": 50.0}, "tags": ["h5", "insulin"], "tiers": {"smoke": "rhombohedral insulin (H3)"}},
+ {"id": "insu_I_x06da_weak", "input": "insu_I_x06da_weak/Ins_16_776a92_master.h5", "ref": {"sgno": 197, "cell": [77.085, 77.085, 77.085, 90.0, 90.0, 90.0], "anomalous": false, "isa": 18.91, "completeness": 92.4, "r_meas": 0.401, "cc_half": 0.999, "multiplicity": 29.04, "dmin_low": 3.22, "r_meas_low": 0.054, "dmin": 1.807, "dmin_rule": "cc_half_0.30", "dmin_xds": 1.08, "dmax": 999.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_low_isa", "input": "insu_I_x06da_low_isa/Ins_I_2_1a530d_master.h5", "ref": {"sgno": 197, "cell": [77.582, 77.582, 77.582, 90.0, 90.0, 90.0], "anomalous": true, "isa": 4.15, "completeness": 90.8, "r_meas": 0.22, "cc_half": 0.998, "multiplicity": 13.33, "dmin_low": 3.92, "r_meas_low": 0.167, "dmin": 1.3, "dmin_rule": "xds_range", "dmin_xds": 1.3, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_ref", "input": "insu_I_x06da_ref/Ins_I_3_5e90e3_master.h5", "ref": {"sgno": 197, "cell": [77.52, 77.52, 77.52, 90.0, 90.0, 90.0], "anomalous": true, "isa": 25.08, "completeness": 100.0, "r_meas": 0.349, "cc_half": 0.998, "multiplicity": 13.82, "dmin_low": 4.82, "r_meas_low": 0.143, "dmin": 1.621, "dmin_rule": "xds_range", "dmin_xds": 1.621, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_13keV", "input": "insu_I_x06da_13keV/Ins_I_6_001_master.h5", "ref": {"sgno": 197, "cell": [77.468, 77.468, 77.468, 90.0, 90.0, 90.0], "anomalous": true, "isa": 18.83, "completeness": 100.0, "r_meas": 0.279, "cc_half": 0.998, "multiplicity": 17.21, "dmin_low": 4.85, "r_meas_low": 0.093, "dmin": 1.635, "dmin_rule": "xds_range", "dmin_xds": 1.635, "dmax": 50.0}, "tags": ["h5", "insulin"]},
+ {"id": "insu_I_x06da_5keV", "input": "insu_I_x06da_5keV/Ins_I_6_006_master.h5", "ref": {"sgno": 197, "cell": [77.785, 77.785, 77.785, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.54, "completeness": 91.7, "r_meas": 0.073, "cc_half": 0.999, "multiplicity": 11.17, "dmin_low": 7.21, "r_meas_low": 0.048, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_6keV", "input": "insu_I_x06da_6keV/Ins_I_6_004_master.h5", "ref": {"sgno": 197, "cell": [77.71, 77.71, 77.71, 90.0, 90.0, 90.0], "anomalous": true, "isa": 17.95, "completeness": 92.4, "r_meas": 0.065, "cc_half": 0.999, "multiplicity": 12.42, "dmin_low": 6.03, "r_meas_low": 0.047, "dmin": 2.04, "dmin_rule": "xds_range", "dmin_xds": 2.04, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"]},
+ {"id": "insu_I_x06da_5keV_2", "input": "insu_I_x06da_5keV_2/Ins_I_7_001_master.h5", "ref": {"sgno": 197, "cell": [77.694, 77.694, 77.694, 90.0, 90.0, 90.0], "anomalous": true, "isa": 20.01, "completeness": 91.8, "r_meas": 0.076, "cc_half": 0.999, "multiplicity": 12.73, "dmin_low": 7.21, "r_meas_low": 0.048, "dmin": 2.45, "dmin_rule": "xds_range", "dmin_xds": 2.45, "dmax": 50.0}, "tags": ["h5", "insulin", "long-wavelength"], "tiers": {"smoke": "cubic insulin at 5 keV (long wavelength), fast"}},
+ {"id": "cytc_x10sa", "input": "cytc_x10sa/cytC_10_002_master.h5", "ref": {"sgno": 152, "cell": [83.659, 83.659, 86.011, 90.0, 90.0, 120.0], "anomalous": true, "isa": 31.75, "completeness": 99.8, "r_meas": 0.232, "cc_half": 0.999, "multiplicity": 10.65, "dmin_low": 6.05, "r_meas_low": 0.036, "dmin": 2.267, "dmin_rule": "cc_half_0.30", "dmin_xds": 2.039, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_1", "input": "cytc_x06da_1/cytC_2_0770b5_master.h5", "ref": {"sgno": 152, "cell": [83.836, 83.836, 86.733, 90.0, 90.0, 120.0], "anomalous": true, "isa": 24.49, "completeness": 99.9, "r_meas": 0.084, "cc_half": 0.999, "multiplicity": 7.67, "dmin_low": 5.58, "r_meas_low": 0.033, "dmin": 1.875, "dmin_rule": "xds_range", "dmin_xds": 1.875, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "cytc_x06da_2", "input": "cytc_x06da_2/cytC_3_874285_master.h5", "ref": {"sgno": 152, "cell": [83.719, 83.719, 88.617, 90.0, 90.0, 120.0], "anomalous": true, "isa": 26.98, "completeness": 99.9, "r_meas": 0.097, "cc_half": 0.999, "multiplicity": 7.82, "dmin_low": 5.03, "r_meas_low": 0.032, "dmin": 1.69, "dmin_rule": "xds_range", "dmin_xds": 1.69, "dmax": 50.0}, "tags": ["h5", "cytochrome-c"]},
+ {"id": "myob_x10sa", "input": "myob_x10sa/MyoB_13_110ee0_master.h5", "ref": {"sgno": 4, "cell": [35.229, 28.461, 63.076, 90.0, 106.504, 90.0], "anomalous": true, "isa": 5.21, "completeness": 97.7, "r_meas": 0.247, "cc_half": 0.965, "multiplicity": 3.29, "dmin_low": 5.16, "r_meas_low": 0.186, "dmin": 1.742, "dmin_rule": "xds_range", "dmin_xds": 1.742, "dmax": 50.0}, "tags": ["h5", "myoglobin"]},
+ {"id": "myob_x06da", "input": "myob_x06da/MyoB_9_446b70_master.h5", "ref": {"sgno": 3, "cell": [35.182, 28.544, 62.83, 90.0, 106.138, 90.0], "anomalous": true, "isa": 7.59, "completeness": 99.4, "r_meas": 0.232, "cc_half": 0.987, "multiplicity": 3.47, "dmin_low": 4.23, "r_meas_low": 0.105, "dmin": 1.422, "dmin_rule": "xds_range", "dmin_xds": 1.422, "dmax": 50.0}, "tags": ["h5", "myoglobin"], "tiers": {"smoke": "monoclinic myoglobin, screw not arbitrable by XDS"}},
+ {"id": "myob_x06da_powder_1", "input": "myob_x06da_powder_1/MyoB2-1_75979a_master.h5", "ref": {"sgno": 1, "cell": [28.705, 34.796, 64.373, 74.314, 89.879, 90.057], "anomalous": false, "isa": 5.54, "completeness": 74.2, "r_meas": 0.493, "cc_half": 0.966, "multiplicity": 2.87, "dmin_low": 4.44, "r_meas_low": 0.125, "dmin": 1.495, "dmin_rule": "xds_range", "dmin_xds": 1.495, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"], "tiers": {"smoke": "known hard: triclinic twin"}},
+ {"id": "myob_x06da_powder_2", "input": "myob_x06da_powder_2/MyoB2-2_5ddd7d_master.h5", "ref": {"sgno": 3, "cell": [35.576, 28.811, 63.529, 90.0, 105.593, 90.0], "anomalous": false, "isa": 2.19, "completeness": 58.0, "r_meas": 1.106, "cc_half": 0.655, "multiplicity": 4.71, "dmin_low": 2.98, "r_meas_low": 0.706, "dmin": 0.99, "dmin_rule": "xds_range", "dmin_xds": 0.99, "dmax": 999.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_split", "input": "myob_x06da_split/MyoB2-4_079740_master.h5", "ref": {"sgno": 3, "cell": [35.39, 28.783, 63.626, 90.0, 105.544, 90.0], "anomalous": false, "isa": 12.41, "completeness": 77.7, "r_meas": 0.577, "cc_half": 0.984, "multiplicity": 4.38, "dmin_low": 4.48, "r_meas_low": 0.091, "dmin": 1.506, "dmin_rule": "xds_range", "dmin_xds": 1.506, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
+ {"id": "myob_x06da_sparse", "input": "myob_x06da_sparse/MyoB2-5_7cef9c_master.h5", "ref": {"sgno": 3, "cell": [35.388, 28.752, 64.083, 90.0, 106.352, 90.0], "anomalous": false, "isa": 5.46, "completeness": 73.7, "r_meas": 0.326, "cc_half": 0.972, "multiplicity": 5.21, "dmin_low": 5.92, "r_meas_low": 0.146, "dmin": 2.0, "dmin_rule": "xds_range", "dmin_xds": 2.0, "dmax": 50.0}, "tags": ["h5", "myoglobin", "twin"]},
  {"id": "nothing_2", "input": "nothing_2/test-28_3400ac_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]},
  {"id": "nothing_1", "input": "nothing_1/test-28_9bf604_master.h5", "expect": "no_lattice", "tags": ["h5", "control"]}
 ]}
diff --git a/tools/battery/inputs.py b/tools/battery/inputs.py
index 9d37cef7a..71012ccf5 100644
--- a/tools/battery/inputs.py
+++ b/tools/battery/inputs.py
@@ -107,7 +107,8 @@ def input_format(path):
 def parse_correct_lp(path):
     """Reference values from an XDS CORRECT.LP: the space group and cell CORRECT refined, the
     resolution range it merged (dmin_xds, dmax), the reference d_min read off its statistics
-    (dmin, dmin_rule - see reference_dmin) and its overall merging statistics.
+    (dmin, dmin_rule - see reference_dmin), its overall merging statistics, and the R_meas of its
+    lowest-resolution shell (r_meas_low, over dmax to dmin_low).
 
     CORRECT.LP states the group and cell twice - first as the INPUT to INTEGRATE (routinely P1),
     then as CORRECT's own answer. The last SPACE_GROUP_NUMBER and the refined UNIT CELL PARAMETERS
@@ -143,6 +144,11 @@ def parse_correct_lp(path):
         ref["r_meas"] = round(num(total[9]) / 100, 4)
         ref["cc_half"] = round(num(total[10]) / 100, 4)
         ref["multiplicity"] = round(int(total[1]) / int(total[2]), 2) if int(total[2]) else None
+    if shells:
+        # the lowest-resolution shell, dmax to dmin_low: strong reflections only, so its R_meas
+        # is the merge's accuracy rather than where the signal fades
+        ref["dmin_low"] = float(shells[0][0])
+        ref["r_meas_low"] = round(num(shells[0][9]) / 100, 4)
 
     # The range XDS merged: the explicit INCLUDE_RESOLUTION_RANGE, or - when XDS.INP left the high
     # limit at 0.0, "the whole detector" - the finest shell actually tabulated. The pooled statistics
-- 
2.54.0


From 6a21d453baa95ef802b0d732e93cf1d509978ac4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 14:31:36 +0200
Subject: [PATCH 053/122] macOS groundwork: what a static read says will stop
 an Apple Clang / libc++ build

None of this has been built on a Mac - there is none yet. It is the list a read-only audit of the
viewer/rugnux subtree produced, plus a serial -fsyntax-only pass of every reachable .cpp with
clang 16 + libc++ on Linux, which found exactly one error (the first item).

- JFJochDatasetInfoChartView: std::vector<fftwf_complex> does not compile with libc++, whose
  construct_at refuses an array element type (float[2]). Use std::vector<std::complex<float>> and
  the reinterpret_cast every other FFTW call site already uses.
- libcurl: GSSAPI off on Linux, and neither TLS nor GSSAPI on macOS. The viewer never sets
  CURLOPT_HTTPAUTH, so Negotiate was dead weight that cost a krb5-devel build dependency; on macOS
  curl's FindGSS refuses the system Heimdal outright, and with Secure Transport gone from curl
  (8.15) TLS would mean a Homebrew OpenSSL - the only host library a Mac build would need.
  Linux keeps OpenSSL. CURL_USE_GSSAPI is forced OFF rather than left unset so an existing build
  tree drops its cached ON.
- libjpeg-turbo ExternalProject: CMAKE_SYSTEM_NAME/PROCESSOR were forwarded unconditionally, which
  puts even a native sub-build into cross-compiling mode, and CMAKE_OSX_ARCHITECTURES / SYSROOT /
  DEPLOYMENT_TARGET were not forwarded at all. Now the same rule the zlib-ng sub-build follows.
- ShadowAccumulatorGPU.cu was added on the JFJOCH_USE_CUDA option (default ON) instead of
  JFJOCH_CUDA_AVAILABLE like every other .cu, so a machine without nvcc got a CUDA source in a
  target with no CUDA language.
- CMAKE_OSX_DEPLOYMENT_TARGET defaults to 12.0 (overridable). Left unset, CMake takes the build
  machine's OS version and the .dmg starts nowhere older.
- Standard headers that were only arriving transitively (<chrono>, <cmath>, <limits>, <cstring>,
  <atomic>, <thread>, <string>); newer libc++ releases keep removing such transitive includes.

Checked: the seven changed sources pass clang 16 + libc++ -fsyntax-only. The CMake changes are
not configured or built.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015eAE2K7i5JGDwgwifiCfuA
(cherry picked from commit 5a7282759ac5245277d8541b75d591fe4c61d671)
---
 CMakeLists.txt                               | 23 +++++++++++----
 common/DatasetSettings.h                     |  1 +
 common/Histogram.h                           |  1 +
 common/ThreadSafeFIFO.h                      |  1 +
 common/ZMQWrappers.h                         |  2 ++
 compression/JFJochZstdCompressor.cpp         |  1 +
 docs/SOFTWARE.md                             |  5 ++--
 image_analysis/CMakeLists.txt                |  2 +-
 image_analysis/UpdateReflectionResolution.h  |  1 +
 image_analysis/scale_merge/ScaleOnTheFly.cpp |  2 ++
 preview/CMakeLists.txt                       | 30 +++++++++++++-------
 tools/XdsIntegrateParser.cpp                 |  1 +
 viewer/charts/JFJochDatasetInfoChartView.cpp |  9 +++---
 viewer/widgets/SliderPlusBox.cpp             |  2 ++
 14 files changed, 57 insertions(+), 24 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8e62becf9..d01f22eff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,6 +8,11 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.26)
 FILE(STRINGS VERSION JFJOCH_VERSION)
 STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" JFJOCH_VERSION_NUMERIC "${JFJOCH_VERSION}")
 
+# Oldest macOS the binaries run on (ignored elsewhere). Without it CMake takes the version of the
+# build machine, and a .dmg would refuse to start on anything older. 12 is the floor of current Qt 6;
+# our own needs (<latch>, <filesystem>) stop at 11. Has to be set before PROJECT().
+SET(CMAKE_OSX_DEPLOYMENT_TARGET "12.0" CACHE STRING "Minimum macOS version")
+
 PROJECT(jfjoch VERSION ${JFJOCH_VERSION_NUMERIC} LANGUAGES C CXX)
 SET(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
 INCLUDE(GNUInstallDirs)
@@ -473,10 +478,10 @@ IF (WIN32)
 ENDIF()
 
 # libcurl: the jfjoch_viewer HTTP client (viewer/JFJochHttpReader). Fetched and STATICALLY linked
-# ONLY for viewer builds, so the broker/writer never pull in a TLS/Kerberos stack. Backends are
-# OS-native per platform to keep the Windows build self-contained: Schannel (TLS) + SSPI
-# (Negotiate/Kerberos) on Windows -- no external OpenSSL/krb5 -- and system OpenSSL + GSSAPI (krb5)
-# on Linux. Trimmed to HTTP(S) only, mirroring the libtiff codec pruning above.
+# ONLY for viewer builds, so the broker/writer never pull in a TLS stack. Windows gets its OS-native
+# backends, Schannel (TLS) + SSPI (Negotiate/Kerberos), because they cost nothing there. Linux gets
+# OpenSSL and no Kerberos; macOS gets neither. Trimmed to HTTP(S) only, mirroring the libtiff codec
+# pruning above.
 IF (JFJOCH_VIEWER_BUILD OR JFJOCH_VIEWER_ONLY)
     SET(BUILD_CURL_EXE       OFF CACHE BOOL "" FORCE)
     SET(BUILD_SHARED_LIBS    OFF CACHE BOOL "" FORCE)   # static libcurl only, never a shared lib
@@ -490,9 +495,15 @@ IF (JFJOCH_VIEWER_BUILD OR JFJOCH_VIEWER_ONLY)
     IF (WIN32)
         SET(CURL_USE_SCHANNEL ON CACHE BOOL "" FORCE)  # native Windows TLS (no OpenSSL)
         SET(CURL_USE_SSPI     ON CACHE BOOL "" FORCE)  # native Negotiate/Kerberos (no krb5)
+    ELSEIF (APPLE)
+        # Plain HTTP only: curl dropped Secure Transport in 8.15, so TLS would mean OpenSSL, which
+        # the macOS SDK does not have - it would be the one library a Mac build takes from Homebrew.
+        SET(CURL_ENABLE_SSL   OFF CACHE BOOL "" FORCE)
     ELSE()
-        SET(CURL_USE_OPENSSL  ON CACHE BOOL "" FORCE)
-        SET(CURL_USE_GSSAPI   ON CACHE BOOL "" FORCE)  # Kerberos via system krb5 (needs krb5-dev)
+        SET(CURL_USE_OPENSSL  ON  CACHE BOOL "" FORCE)
+        # The viewer never asks for Negotiate. Set explicitly so that a build tree configured when
+        # this was ON does not keep the cached value.
+        SET(CURL_USE_GSSAPI   OFF CACHE BOOL "" FORCE)
     ENDIF()
     FetchContent_Declare(curl
             URL https://github.com/curl/curl/archive/refs/tags/curl-8_22_0.tar.gz
diff --git a/common/DatasetSettings.h b/common/DatasetSettings.h
index b85e13eee..a103362a9 100644
--- a/common/DatasetSettings.h
+++ b/common/DatasetSettings.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <cstdint>
 #include <string>
 #include <optional>
diff --git a/common/Histogram.h b/common/Histogram.h
index 1e3b44d9b..af3f4720e 100644
--- a/common/Histogram.h
+++ b/common/Histogram.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <cstdint>
 #include <cstddef>
 #include <vector>
diff --git a/common/ThreadSafeFIFO.h b/common/ThreadSafeFIFO.h
index 208923f1a..cbff3dc03 100644
--- a/common/ThreadSafeFIFO.h
+++ b/common/ThreadSafeFIFO.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <queue>
 #include <mutex>
 #include <condition_variable>
diff --git a/common/ZMQWrappers.h b/common/ZMQWrappers.h
index 0aaaf6f00..a7f56daab 100644
--- a/common/ZMQWrappers.h
+++ b/common/ZMQWrappers.h
@@ -4,6 +4,8 @@
 
 #pragma once
 
+#include <chrono>
+#include <string>
 #include <vector>
 #include <thread>
 #include <mutex>
diff --git a/compression/JFJochZstdCompressor.cpp b/compression/JFJochZstdCompressor.cpp
index 9290b90f5..41e2d2438 100644
--- a/compression/JFJochZstdCompressor.cpp
+++ b/compression/JFJochZstdCompressor.cpp
@@ -3,6 +3,7 @@
 
 #include "JFJochZstdCompressor.h"
 
+#include <cstring>
 #include <map>
 #include <zstd.h>
 #include <lz4/lz4.h>
diff --git a/docs/SOFTWARE.md b/docs/SOFTWARE.md
index e1c8c2ad9..eb515b9c5 100644
--- a/docs/SOFTWARE.md
+++ b/docs/SOFTWARE.md
@@ -34,9 +34,8 @@ Optional:
 * FFTW library - for indexing if GPU/CUDA is absent (also auto-downloaded by CMake)
 * Node.js - to build the frontend
 * Qt version 6 (for jfjoch_viewer)
-* OpenSSL 3.0 or newer and the Kerberos development headers (`krb5-devel` / `libkrb5-dev`) -
-  required to build jfjoch_viewer on Linux, where the fetched libcurl uses them for TLS and
-  Negotiate; a build on OpenSSL 1.1 fails in libcurl
+* OpenSSL 3.0 or newer - required to build jfjoch_viewer on Linux, where the fetched libcurl uses
+  it for TLS; a build on OpenSSL 1.1 fails in libcurl
 
 Many further dependencies (spdlog, Zstandard, HDF5, slsDetectorPackage, libzmq, libtiff,
 libjpeg-turbo, Ceres, the fast feedback indexer, Catch2, ...) are downloaded automatically
diff --git a/image_analysis/CMakeLists.txt b/image_analysis/CMakeLists.txt
index 4e01b85d3..6abc665d9 100644
--- a/image_analysis/CMakeLists.txt
+++ b/image_analysis/CMakeLists.txt
@@ -98,7 +98,7 @@ ADD_LIBRARY(JFJochImageAnalysis STATIC
         dark_mask_analysis/DarkMaskAnalysis.h
         beam_stop/ShadowFinder.cpp
         beam_stop/ShadowFinder.h
-        $<$<BOOL:${JFJOCH_USE_CUDA}>:beam_stop/ShadowAccumulatorGPU.cu>
+        $<$<BOOL:${JFJOCH_CUDA_AVAILABLE}>:beam_stop/ShadowAccumulatorGPU.cu>
         beam_stop/ShadowAccumulatorGPU.h
         rotation_indexer/RotationIndexer.cpp
         rotation_indexer/RotationIndexer.h
diff --git a/image_analysis/UpdateReflectionResolution.h b/image_analysis/UpdateReflectionResolution.h
index 695d2ba01..d5c373269 100644
--- a/image_analysis/UpdateReflectionResolution.h
+++ b/image_analysis/UpdateReflectionResolution.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <limits>
 #include <vector>
 #include "../common/Reflection.h"
 #include "../common/UnitCell.h"
diff --git a/image_analysis/scale_merge/ScaleOnTheFly.cpp b/image_analysis/scale_merge/ScaleOnTheFly.cpp
index e2135dbd5..6d4ccf030 100644
--- a/image_analysis/scale_merge/ScaleOnTheFly.cpp
+++ b/image_analysis/scale_merge/ScaleOnTheFly.cpp
@@ -6,9 +6,11 @@
 #include "../../common/Logger.h"
 
 #include <algorithm>
+#include <atomic>
 #include <chrono>
 #include <cmath>
 #include <future>
+#include <thread>
 #include <vector>
 
 namespace {
diff --git a/preview/CMakeLists.txt b/preview/CMakeLists.txt
index 2b0c38547..ede0b312c 100644
--- a/preview/CMakeLists.txt
+++ b/preview/CMakeLists.txt
@@ -14,6 +14,25 @@ SET(LIBJPEG_TURBO_DIR "${CMAKE_CURRENT_BINARY_DIR}/libjpeg-turbo")
 SET(LIBJPEG_TURBO_LIBRARY "${LIBJPEG_TURBO_DIR}/lib/${CMAKE_STATIC_LIBRARY_PREFIX}jpeg${LIBJPEG_TURBO_STATIC_SUFFIX}${CMAKE_STATIC_LIBRARY_SUFFIX}")
 SET(LIBJPEG_TURBO_INCLUDE_DIRS "${LIBJPEG_TURBO_DIR}/include")
 
+# An ExternalProject is a separate cmake invocation and inherits nothing, so without these it
+# configures for the BUILD host: a cross build would link an x86_64 libjpeg.a into an aarch64
+# binary and only fail at the final link, and a macOS build would get a libjpeg.a for another
+# architecture or deployment target than the binary it goes into. CMAKE_SYSTEM_NAME only when
+# actually cross-compiling: setting it is what PUTS a build into cross mode (same as zlib-ng in the
+# top-level CMakeLists). libjpeg-turbo picks its own SIMD from the target arch, so NEON comes for
+# free on aarch64 and nasm is simply not consulted there.
+SET(LIBJPEG_TURBO_FORWARD CMAKE_TOOLCHAIN_FILE CMAKE_C_COMPILER
+                          CMAKE_OSX_ARCHITECTURES CMAKE_OSX_SYSROOT CMAKE_OSX_DEPLOYMENT_TARGET)
+IF (CMAKE_CROSSCOMPILING)
+    LIST(APPEND LIBJPEG_TURBO_FORWARD CMAKE_SYSTEM_NAME CMAKE_SYSTEM_PROCESSOR)
+ENDIF()
+SET(LIBJPEG_TURBO_FORWARD_ARGS "")
+FOREACH (_var IN LISTS LIBJPEG_TURBO_FORWARD)
+    IF (${_var})
+        LIST(APPEND LIBJPEG_TURBO_FORWARD_ARGS "-D${_var}:STRING=${${_var}}")
+    ENDIF()
+ENDFOREACH()
+
 ExternalProject_Add(libjpeg-turbo-project
         URL https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.2.0.tar.gz
         URL_HASH SHA256=980dd81f425082aa6d7c9e47fef27554ce7a9ffc8e2f6e863b97d263c5c50858
@@ -35,16 +54,7 @@ ExternalProject_Add(libjpeg-turbo-project
         -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
         -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
         -DCMAKE_INSTALL_LIBDIR:PATH=<INSTALL_DIR>/lib
-        # An ExternalProject is a separate cmake invocation and inherits nothing, so without these
-        # it configures for the BUILD host: a cross build would link an x86_64 libjpeg.a into an
-        # aarch64 binary and only fail at the final link. Forward the toolchain file (empty when not
-        # cross-compiling, which cmake ignores) and the compilers, so it follows the parent build.
-        # libjpeg-turbo picks its own SIMD from the target arch, so NEON comes for free on aarch64
-        # and nasm is simply not consulted there.
-        -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${CMAKE_TOOLCHAIN_FILE}
-        -DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-        -DCMAKE_SYSTEM_NAME:STRING=${CMAKE_SYSTEM_NAME}
-        -DCMAKE_SYSTEM_PROCESSOR:STRING=${CMAKE_SYSTEM_PROCESSOR})
+        ${LIBJPEG_TURBO_FORWARD_ARGS})
 
 # Create the include dir up front so setting INTERFACE_INCLUDE_DIRECTORIES below does not fail.
 FILE(MAKE_DIRECTORY ${LIBJPEG_TURBO_INCLUDE_DIRS})
diff --git a/tools/XdsIntegrateParser.cpp b/tools/XdsIntegrateParser.cpp
index f5f7f363b..cbd7f9ab8 100644
--- a/tools/XdsIntegrateParser.cpp
+++ b/tools/XdsIntegrateParser.cpp
@@ -4,6 +4,7 @@
 #include "XdsIntegrateParser.h"
 
 #include <fstream>
+#include <limits>
 #include <sstream>
 #include <stdexcept>
 
diff --git a/viewer/charts/JFJochDatasetInfoChartView.cpp b/viewer/charts/JFJochDatasetInfoChartView.cpp
index 068699d7d..738d7a4f4 100644
--- a/viewer/charts/JFJochDatasetInfoChartView.cpp
+++ b/viewer/charts/JFJochDatasetInfoChartView.cpp
@@ -9,6 +9,7 @@
 #include <QGraphicsLayout>
 #include <QGraphicsSimpleTextItem>
 #include <cmath>
+#include <complex>
 
 #include "JFJochDatasetInfoChartView.h"
 
@@ -963,12 +964,12 @@ void JFJochDatasetInfoChartView::buildFFTChart() {
     const int n = static_cast<int>(N);
     const int nComplex = n / 2 + 1;
 
-    std::vector<fftwf_complex> out(static_cast<size_t>(nComplex));
+    std::vector<std::complex<float>> out(static_cast<size_t>(nComplex));
 
     fftwf_plan plan = fftwf_plan_dft_r2c_1d(
             n,
             in.data(),
-            out.data(),
+            reinterpret_cast<fftwf_complex *>(out.data()),
             FFTW_ESTIMATE);
 
     if (!plan) {
@@ -987,8 +988,8 @@ void JFJochDatasetInfoChartView::buildFFTChart() {
     const double df = fs / static_cast<double>(n);      // frequency resolution
 
     for (int k = 0; k < nComplex; ++k) {
-        const double re = out[static_cast<size_t>(k)][0];
-        const double im = out[static_cast<size_t>(k)][1];
+        const double re = out[static_cast<size_t>(k)].real();
+        const double im = out[static_cast<size_t>(k)].imag();
         const double mag = std::hypot(re, im);          // amplitude
 
         m_fftMagnitudes[static_cast<size_t>(k)] = mag;
diff --git a/viewer/widgets/SliderPlusBox.cpp b/viewer/widgets/SliderPlusBox.cpp
index ab4571b3f..98e06cd09 100644
--- a/viewer/widgets/SliderPlusBox.cpp
+++ b/viewer/widgets/SliderPlusBox.cpp
@@ -1,6 +1,8 @@
 // SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
 // SPDX-License-Identifier: GPL-3.0-only
 
+#include <cmath>
+
 #include "SliderPlusBox.h"
 #include "../common/JFJochException.h"
 SliderPlusBox::SliderPlusBox(double min, double max, double step, int decimals, QWidget *parent, ScaleType scaleType)
-- 
2.54.0


From 57ab5e640ec57398b993ed5692e225f44fc4df34 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:32:15 +0200
Subject: [PATCH 054/122] tools/battery: merge quality is CC1/2 against XDS
 only

The owner's scoring decision: no R_meas criterion, and merge quality
judged only by CC1/2 relative to XDS.

- The global rule (R_meas > 60% or CC1/2 < 0.5 fails) is gone.
- XDS arms: a set fails `merge` when (1/CC1/2 - 1) of the reference-range
  table is more than twice XDS's, XDS's CC1/2 taken at the bottom of its
  0.1% rounding. CC1/2 = S/(S+E), so 1/CC1/2 - 1 = E/S at any CC1/2, and
  E goes as 1/observations: 2x is XDS's merge with half its observations.
  Stored as cc_half_noise_ratio. No REFRES table or no XDS CC1/2: no
  criterion.
- Open arm: no merge criterion; CC1/2 and R_meas stay reported numbers.
- Low-resolution R_meas is reported, not scored: the lowest shell of the
  own table, the reference-range table and XDS's (lowres_*), with
  lowres_r_meas_ratio in the like-for-like table and a ratio plot.
- Every schema-3 run is re-scored when it is read (report, compare,
  baseline delta) with today's scorer and today's manifest rows, so both
  sides of a comparison are scored alike. results.json keeps the verdicts
  as scored at run time; rows without a lattice keep them.

Re-scoring the rc172 reference run: inhouse 29 -> 27 pass (three new
merge fails, one R_meas fail lifted), open 137 -> 138 (one R_meas fail
lifted).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md  | 50 +++++++++++++++++++++++------
 tools/battery/battery.py |  2 ++
 tools/battery/report.py  | 65 +++++++++++++++++++++++++++++++++----
 tools/battery/score.py   | 69 ++++++++++++++++++++++++++++++++--------
 4 files changed, 156 insertions(+), 30 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 65d6c2005..80d33c4b0 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -15,14 +15,35 @@ with each other.
 | **inhouse** | standard test crystals measured at the SLS (lysozyme, thaumatin, insulin, cytochrome C, myoglobin), plus no-crystal controls | XDS, from the `CORRECT.LP` beside each dataset | `inhouse.json` (committed) |
 | **private** | user data | XDS, like inhouse | outside the repository; the local site config gives its path |
 
-Scoring checks four things in order, and the first one that fails decides the verdict: did it
-run, is the lattice right, is the symmetry right, is the merge usable (R_meas at most 60%, CC1/2 at
-least 0.5). The lattice test compares Niggli-reduced primitive cells: the primitive volume ratio
+Scoring checks these things in order, and the first one that fails decides the verdict: did it
+run, is the lattice right, is the symmetry right, and on the XDS arms, is the merge as good as
+XDS's. The lattice test compares Niggli-reduced primitive cells: the primitive volume ratio
 must be 0.95-1.05 and the reduced edges must agree within 2%. On the open arm the space group is
 scored with `sgequiv`. On the XDS arms only the point group is scored, because XDS never tests a
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
+**Merge quality is judged only against XDS, and only by CC1/2.** No R_meas is a pass/fail
+criterion, and no absolute CC1/2 either. On the XDS arms the set fails `merge` when
+
+    (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) > 2
+
+with rugnux's CC1/2 from the reference-range table (`REFRES_CC_HALF`, XDS's own range) and XDS's
+from the `CORRECT.LP` total. CC1/2 = S / (S + E), with S the signal variance and E the half-set
+error variance, so 1/CC1/2 - 1 = E/S at any CC1/2, and E goes as 1/(observations): a ratio above 2
+is a merge noisier than XDS's would be with half of its observations. XDS prints CC1/2 to 0.1%, so
+its value is taken at the bottom of that rounding (-0.0005), and a printed 100.0 does not demand a
+perfect CC1/2. The ratio is stored as `cc_half_noise_ratio`. A set without the reference-range
+table or without an XDS CC1/2 (the controls, a hand-measured reference) has no merge criterion.
+**The open arm has no merge criterion at all**: it is scored on lattice and symmetry, and its
+resolution, CC1/2 and R_meas are reported, not judged.
+
+**Low-resolution R_meas** is reported, not scored: the lowest-resolution shell of rugnux's own
+table (`lowres_r_meas`), of the reference-range table (`refres_lowres_r_meas`) and of XDS's
+`CORRECT.LP` (`lowres_r_meas_ref`, stored in the manifest as `r_meas_low`), with the shells'
+high-resolution limits. The reference-range table uses XDS's shell limits, so its lowest shell and
+XDS's cover the same reflections; `lowres_r_meas_ratio` is the one over the other, plotted per set.
+
 ## One command per arm
 
 Every set runs **once**, with one command per arm:
@@ -52,9 +73,9 @@ the reference:
 - **`--report-resolution`** (XDS arms): a second statistics table from the same merge, binned over
   XDS's own range (`dmin_xds` and XDS's d_max as given, 999 included, so it covers exactly what
   XDS's CORRECT.LP totals cover), and `-A` where XDS merged with `FRIEDEL'S_LAW=FALSE` (`"anomalous": true` in the
-  manifest), so the two tables count the same way. Its REFRES_* numbers are scored against XDS's
-  CORRECT.LP totals: completeness, multiplicity, R_meas, CC1/2 and ISa (I/sigma is shown; the
-  manifest holds no XDS value for it). Where rugnux's own cut is coarser than the reference
+  manifest), so the two tables count the same way. Its REFRES_* numbers are shown beside XDS's
+  CORRECT.LP totals: completeness, multiplicity, R_meas, the lowest shell's R_meas, CC1/2 and ISa
+  (I/sigma is shown; the manifest holds no XDS value for it). Only CC1/2 is scored (above). Where rugnux's own cut is coarser than the reference
   (`REFRES_SHELLS_PAST_LIMIT` > 0), the shells past it are not merged, so the completeness is read
   as **coverage** of the reference range, not as a quality regression, and the other numbers are
   over the shells rugnux reached.
@@ -211,6 +232,13 @@ This is a flat list with one object per set, and every arm uses the same keys. M
 `null`. `manifest.json` records the schema version as `results_schema`, and each arm's command as
 `command_doc`.
 
+**Verdicts are scored again whenever a run is read** (`report`, `compare`, the baseline delta):
+every row whose `p_report.txt` has a lattice (or that is a control) goes through today's
+`score.judge` with today's manifest row (reference, `unscored`, `expect`), so the two sides of a
+comparison are always scored by the same rules against the same references. A row whose report
+has no lattice keeps its stored verdict, because why it failed came from the run. `results.json`
+keeps the verdicts as they were scored when the run finished.
+
 Schema 3 is one row per set again: `variant` and `first_read` are gone, and `refres_*`,
 `isa_ratio`, `r_meas_ratio`, `multiplicity_ref`, `cc_model`, `sg_label`, `model` and `model_note`
 are new. `sgno`/`sg` are now the data's own space group where `--model` relabelled the hand.
@@ -228,7 +256,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
 | `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge`, `false_lattice`; or `no_reference` / `no_input` |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge` (XDS arms: CC1/2 noise ratio above 2), `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
@@ -240,6 +268,8 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref`, `multiplicity_ref` | XDS's overall values, over XDS's own range |
 | `refres_range`, `refres_shells_past_limit`, `refres_unique_reflections`, `refres_completeness`, `refres_multiplicity`, `refres_i_over_sigma`, `refres_r_meas`, `refres_cc_half`, `refres_isa` | XDS arms: the REFRES_* keys, the same merge over the reference range |
 | `isa_ratio`, `r_meas_ratio` | refres_isa / isa_ref and refres_r_meas / r_meas_ref |
+| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), the merge criterion |
+| `lowres_d`, `lowres_r_meas`, `refres_lowres_d`, `refres_lowres_r_meas`, `lowres_d_ref`, `lowres_r_meas_ref`, `lowres_r_meas_ratio` | the lowest-resolution shell's high-resolution limit and R_meas: rugnux's own table, the reference-range table, XDS's; and refres_lowres_r_meas / lowres_r_meas_ref |
 | `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
 | `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
 | `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm) |
@@ -256,8 +286,8 @@ SVG, no external files):
 - a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
   the main metrics;
 - plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
-  for each arm; on the XDS arms the reference-range ISa and R_meas over XDS's; on the open arm
-  R_free / published R_free;
+  for each arm; on the XDS arms the reference-range ISa, R_meas, lowest-shell R_meas and CC1/2
+  noise over XDS's; on the open arm R_free / published R_free;
 - on the XDS arms the **like-for-like table**: the reference-range numbers beside XDS's, with the
   rows where rugnux's cut is coarser marked as coverage;
 - the **failures**, and **one row per set** with all the numbers;
@@ -286,7 +316,7 @@ $B compare RUN_A RUN_B --rerun-changed              # rerun the changed sets wit
 `compare` pairs rows by arm and set id, following the manifests' `aliases` across renames. A run
 from before schema 3 is compared through its `bare` rows (see the schema above). It lists every
 row whose verdict, space group, lattice, d_min, ISa, R_meas, CC1/2, completeness, cell, R-free,
-reference-range R_meas or ISa (where both runs have them), or time moved by more than the noise
+reference-range R_meas, lowest-shell R_meas or ISa (where both runs have them), or time moved by more than the noise
 thresholds in `report.py` (`NOISE`). Those thresholds
 are a first guess. `--rerun-changed` measures the noise directly: it reruns the changed sets with
 A's saved binary and options. A set that moves again under the same binary is noise. A set that
diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 27ae2c150..72ed37663 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -662,6 +662,8 @@ def main():
     a = ap.parse_args()
     site = load_site(a.site)
     report.ALIASES = load_aliases(site)
+    report.MANIFESTS = {arm: {e["id"]: e for e in load_sets(site, arm)}
+                        for arm, cfg in site["arms"].items() if os.path.exists(cfg["manifest"])}
     {"run": cmd_run, "list": cmd_list, "compare": cmd_compare, "report": cmd_report,
      "abort": cmd_abort, "discover": cmd_discover, "refs": cmd_refs, "remap": cmd_remap}[a.cmd](a, site)
 
diff --git a/tools/battery/report.py b/tools/battery/report.py
index df86c2e13..23ea0089a 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -5,6 +5,7 @@ import socket
 import statistics
 import sys
 
+import score
 from render import Doc, ratio_dots, verdict_bars
 
 # A change smaller than these is treated as run-to-run noise. They are a starting point, to be
@@ -19,6 +20,7 @@ NOISE = {
     "rfree": ("abs", 0.005),
     "refres_r_meas": ("rel", 0.05),
     "refres_isa": ("rel", 0.05),
+    "refres_lowres_r_meas": ("rel", 0.05),
     "wall_s": ("rel", 0.25),        # and at least 10 s - see beyond_noise()
 }
 
@@ -53,9 +55,27 @@ def load_run(run_dir, allow_incomplete=False):
         schema1(man, res)
     if schema < 3:
         res[:] = schema2(res)
+    else:
+        rescore(run_dir, man, res)
     return man, res
 
 
+def rescore(run_dir, man, res):
+    """Score every row again from its saved report, with today's scorer and today's manifest rows
+    (references, `unscored`, `expect`), so a report or a compare never mixes two scorings or two
+    references. results.json keeps the verdicts as they were scored when the run finished.
+
+    A row whose report has no lattice keeps its verdict: why it failed (crash, reader, timeout)
+    came from the run, not from the report."""
+    own = {(e["arm"], e["id"]): e for e in man["sets"]}
+    for r in res:
+        e = MANIFESTS.get(r["arm"], {}).get(key(r)[1]) or own.get((r["arm"], r["set"]))
+        rep = score.read_report(os.path.join(run_dir, "work", r["arm"], r["set"], "p_report.txt"))
+        lattice = rep.get("SPACE_GROUP_NUMBER") and rep.get("UNIT_CELL_CONSTANTS")
+        if e and (lattice or e.get("expect") == "no_lattice"):
+            r.update(score.judge(dict(e, arm=r["arm"]), rep, ""))
+
+
 def schema1(man, res):
     """Read a run from before the variants (results schema 1) as one: it ran each set once, plain
     on the open arm and with XDS's settings on the XDS arms - unless --unforced, which left the
@@ -114,6 +134,9 @@ RESULTS_SCHEMA = 3
 # dataset was renamed still pairs with one made after
 ALIASES = {}
 
+# {arm: {set id: manifest row}} of today's manifests (battery.py sets it); rescore() scores with them
+MANIFESTS = {}
+
 
 def key(r):
     return (r["arm"], ALIASES.get(r["arm"], {}).get(r["set"], r["set"]))
@@ -166,7 +189,7 @@ def changes(ra, rb):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
     # the like-for-like table only where both runs have one (a pre-schema-3 run has none)
-    for name in ("refres_r_meas", "refres_isa"):
+    for name in ("refres_r_meas", "refres_isa", "refres_lowres_r_meas"):
         if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
             out.append(name)
     if beyond_noise("wall_s", ra.get("wall_s"), rb.get("wall_s")):
@@ -192,7 +215,7 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 def compare_table(doc, rows, only_changed=True):
     head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "R_free", "ref-range R_meas", "time s", "beyond noise"]
+            "cell dev %", "R_free", "ref-range R_meas", "ref-range low-res R_meas", "time s", "beyond noise"]
     out = []
     for (arm, s), ra, rb, ch in rows:
         if only_changed and not ch:
@@ -207,6 +230,8 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("refres_r_meas"), rb.get("refres_r_meas"), lambda v: f"{100 * v:.1f}%"),
+                    arrow(ra.get("refres_lowres_r_meas"), rb.get("refres_lowres_r_meas"),
+                          lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("wall_s"), rb.get("wall_s"), lambda v: f"{v:.0f}"),
                     ", ".join(ch)])
     doc.table(head, out, row_class=lambda r: "fail" if "verdict" in r[-1] else "")
@@ -301,6 +326,9 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                               ("cc_half", "CC1/2", "{:.3f}"), ("res_gain_pct", "res. gain %", "{:+.1f}"),
                               ("isa_ratio", "ref-range ISa / XDS", "{:.3f}"),
                               ("r_meas_ratio", "ref-range R_meas / XDS", "{:.3f}"),
+                              ("lowres_r_meas", "low-res shell R_meas", None),
+                              ("lowres_r_meas_ratio", "ref-range low-res R_meas / XDS", "{:.3f}"),
+                              ("cc_half_noise_ratio", "ref-range CC1/2 noise / XDS", "{:.2f}"),
                               ("rfree", "R_free (placement)", "{:.3f}"),
                               ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
             q = quartiles(r.get(name) for r in rs)
@@ -322,7 +350,13 @@ def build(run_dir, baseline=None, allow_incomplete=False):
             ("isa_ratio", "ISa", "ISa of the reference-range table (the error model refitted on it) / "
                                  "XDS's ISa; above 1 = rugnux's error model is the better one"),
             ("r_meas_ratio", "R_meas", "R_meas over the reference range / XDS's R_meas; below 1 = "
-                                       "rugnux's merge is the more consistent one")):
+                                       "rugnux's merge is the more consistent one"),
+            ("lowres_r_meas_ratio", "low-res R_meas", "R_meas of the lowest-resolution shell of the "
+                                                      "reference-range table / of XDS's table; below 1 = "
+                                                      "rugnux's strong reflections agree better"),
+            ("cc_half_noise_ratio", "CC1/2 noise", "half-set noise over the reference range read off CC1/2 "
+                                                   "(1 / CC1/2 - 1) / XDS's; above 2 fails (the merge is as "
+                                                   "noisy as XDS's with half its observations)")):
         for arm in arms:
             pts = [(r["set"], r[name], r["verdict"], f"{what} ratio, {refres_note(r)}")
                    for r in res if r["arm"] == arm and r.get(name)]
@@ -363,11 +397,21 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                          f(r.get("refres_multiplicity"), "{:.1f}") + " / " + f(r.get("multiplicity_ref"), "{:.1f}"),
                          f(r.get("refres_i_over_sigma"), "{:.1f}"),
                          pct(r.get("refres_r_meas")) + " / " + pct(r.get("r_meas_ref")),
-                         f(r.get("refres_cc_half"), "{:.3f}") + " / " + f(r.get("cc_half_ref"), "{:.3f}"),
+                         lowres_cell(r),
+                         f(r.get("refres_cc_half"), "{:.4f}") + " / " + f(r.get("cc_half_ref"), "{:.3f}"),
+                         f(r.get("cc_half_noise_ratio"), "{:.2f}"),
                          f(r.get("refres_isa"), "{:.1f}") + " / " + f(r.get("isa_ref"), "{:.1f}"),
                          refres_note(r)])
         doc.table(["set", "arm", "range A", "own d_min", "compl % (rugnux / XDS)", "mult", "I/sigma",
-                   "R_meas", "CC1/2", "ISa", "reading"], rows, num=(3, 6))
+                   "R_meas", "low-res R_meas (to d A)", "CC1/2", "CC1/2 noise ratio", "ISa", "reading"],
+                  rows, num=(3, 6, 10))
+        doc.p("Merge quality is scored here and only here, by CC1/2 against XDS's over the same range. "
+              "CC1/2 = S / (S + E) (signal and half-set error variances), so 1 / CC1/2 - 1 = E / S is the "
+              "half-set noise; the noise ratio is rugnux's over XDS's, with XDS's CC1/2 taken at the "
+              "bottom of its printed rounding (-0.0005). A set fails `merge` when the ratio is above "
+              f"{score.CC_HALF_NOISE_LIMIT:g}: noisier than XDS's merge would be with half its "
+              "observations. The low-resolution R_meas is the lowest shell of each table (the shells "
+              "are XDS's, so both cover the same reflections); it is reported, not scored.")
 
     derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
     if derived:
@@ -394,7 +438,7 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
               ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
     head = ["set", "arm", "verdict", "space group", "ref", "cell dev %", "V ratio", "d_min", "ref d_min",
-            "gain", "compl %", "mult", "R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
+            "gain", "compl %", "mult", "R_meas", "low-res R_meas", "CC1/2", "ISa", "ref ISa", "idx"] + \
            [h for h, _ in model] + (["model fit"] if model else []) + ["time s", "note"]
     rows = []
     for r in sorted(res, key=lambda r: (order.get(r["arm"], 9), r["set"])):
@@ -404,7 +448,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                      f(r.get("cell_dev_pct")), f(r.get("volume_ratio"), "{:.3f}"),
                      f(r.get("d_min")), f(r.get("d_min_ref")), f(r.get("res_gain_pct"), "{:+.1f}%"),
                      f(r.get("completeness"), "{:.1f}"), f(r.get("multiplicity"), "{:.1f}"),
-                     pct(r.get("r_meas")), f(r.get("cc_half"), "{:.3f}"), f(r.get("isa"), "{:.1f}"),
+                     pct(r.get("r_meas")), pct(r.get("lowres_r_meas")), f(r.get("cc_half"), "{:.3f}"),
+                     f(r.get("isa"), "{:.1f}"),
                      f(r.get("isa_ref"), "{:.1f}"), pct(r.get("indexing_rate"), 0)]
                     + [f(r.get(k), "{:.3f}") for _, k in model]
                     + ([r.get("model_fit") or "-"] if model else [])
@@ -430,6 +475,12 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     return doc
 
 
+def lowres_cell(r):
+    """rugnux / XDS R_meas of the lowest-resolution shell, with the shells' high-resolution limits."""
+    return (pct(r.get("refres_lowres_r_meas")) + " / " + pct(r.get("lowres_r_meas_ref"))
+            + f" ({f(r.get('refres_lowres_d'))} / {f(r.get('lowres_d_ref'))})")
+
+
 def refres_note(r):
     """How to read a row of the reference-range table."""
     if r.get("refres_shells_past_limit"):
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 331722d7d..865daf681 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -1,9 +1,9 @@
 """Scoring one rugnux run against its reference.
 
 One dataset, one verdict, one cause, decided in this order: did it run -> is the lattice right ->
-is the symmetry right -> is the merge usable. The order matters: a halved axis also makes the
-screw along it unobservable, and counting that row twice would hide the defect that cost the
-reflections.
+is the symmetry right -> (XDS arms only) is the merge as good as XDS's by CC1/2. The order matters:
+a halved axis also makes the screw along it unobservable, and counting that row twice would hide
+the defect that cost the reflections.
 """
 import itertools
 import os
@@ -17,13 +17,28 @@ REPORT_LINE = re.compile(r"^([A-Z_0-9]+)=\s*(.*)$")
 
 
 def read_report(path):
-    """KEY= value lines of a rugnux _report.txt."""
+    """KEY= value lines of a rugnux _report.txt, plus the lowest-resolution shell of its two shell
+    tables: LOWRES_D / LOWRES_R_MEAS from the table over its own range, REFRES_LOWRES_D /
+    REFRES_LOWRES_R_MEAS from the one over the reference range (it follows REFRES_RANGE=)."""
     out = {}
-    if os.path.exists(path):
-        for line in open(path, errors="replace"):
-            m = REPORT_LINE.match(line.rstrip("\n"))
-            if m:
-                out[m.group(1)] = m.group(2).strip()
+    if not os.path.exists(path):
+        return out
+    header = None
+    for line in open(path, errors="replace"):
+        line = line.rstrip("\n")
+        m = REPORT_LINE.match(line)
+        if m:
+            out[m.group(1)] = m.group(2).strip()
+            continue
+        f = line.lstrip("#").split()
+        if f[:2] == ["d_min", "N_obs"]:
+            header = f
+        elif header and f and re.match(r"^\d+\.\d+$", f[0]):
+            prefix = "REFRES_" if "REFRES_RANGE" in out else ""
+            out[prefix + "LOWRES_D"] = f[0]
+            r_meas = f[header.index("R_meas")].rstrip("%")          # "3.7%", or "-" for none
+            out[prefix + "LOWRES_R_MEAS"] = "" if r_meas == "-" else str(round(float(r_meas) / 100, 4))
+            header = None                  # only the first row of each table
     return out
 
 
@@ -74,6 +89,24 @@ def cell_dev_pct(cell, ref):
                for p in itertools.permutations(cell[:3]))
 
 
+# XDS prints CC1/2 in % with one decimal; its value is taken at the bottom of that rounding, so a
+# printed 100.0 does not demand a perfect CC1/2 of rugnux
+XDS_CC_HALF_ROUNDING = 0.0005
+CC_HALF_NOISE_LIMIT = 2.0
+
+
+def cc_half_noise_ratio(cc, cc_xds):
+    """rugnux's half-set noise over XDS's, both read off CC1/2 over XDS's range; None without both.
+
+    CC1/2 = S / (S + E), with S the variance of the signal and E that of the half-set error, so
+    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2
+    (CC_HALF_NOISE_LIMIT) is a merge as noisy as XDS's would be with half of its observations.
+    A CC1/2 at or below 0 is no signal at all, counted as 0.001."""
+    if cc is None or cc_xds is None:
+        return None
+    return round((1 / max(cc, 0.001) - 1) / (1 / (cc_xds - XDS_CC_HALF_ROUNDING) - 1), 3)
+
+
 def point_group(sgno):
     return gemmi.find_spacegroup_by_number(int(sgno)).point_group_hm()
 
@@ -115,6 +148,15 @@ def judge(entry, rep, run_note):
     r["isa_ratio"] = round(r["refres_isa"] / r["isa_ref"], 4) if r["refres_isa"] and r["isa_ref"] else None
     r["r_meas_ratio"] = (round(r["refres_r_meas"] / r["r_meas_ref"], 4)
                          if r["refres_r_meas"] and r["r_meas_ref"] else None)
+    # R_meas of the lowest-resolution shell: rugnux's own table, the reference-range table and XDS's
+    # (reported, not scored)
+    r.update(lowres_d=fnum(rep.get("LOWRES_D")), lowres_r_meas=fnum(rep.get("LOWRES_R_MEAS")),
+             refres_lowres_d=fnum(rep.get("REFRES_LOWRES_D")),
+             refres_lowres_r_meas=fnum(rep.get("REFRES_LOWRES_R_MEAS")),
+             lowres_d_ref=ref.get("dmin_low"), lowres_r_meas_ref=ref.get("r_meas_low"))
+    r["lowres_r_meas_ratio"] = (round(r["refres_lowres_r_meas"] / r["lowres_r_meas_ref"], 4)
+                                if r["refres_lowres_r_meas"] and r["lowres_r_meas_ref"] else None)
+    r["cc_half_noise_ratio"] = cc_half_noise_ratio(r["refres_cc_half"], r["cc_half_ref"])
     if rep.get("SPACE_GROUP_NUMBER"):
         r["sgno"] = int(fnum(rep["SPACE_GROUP_NUMBER"]))
         r["sg"] = rep.get("SPACE_GROUP_NAME") or sg_name(r["sgno"])
@@ -191,10 +233,11 @@ def judge(entry, rep, run_note):
                  "sym_over" if order > order_ref else "sym_other")
         return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
 
-    if r["r_meas"] is not None and r["r_meas"] > 0.6:
-        return verdict("fail", "merge", f"R_meas {r['r_meas']:.0%} overall")
-    if r["cc_half"] is not None and r["cc_half"] < 0.5:
-        return verdict("fail", "merge", f"CC1/2 {r['cc_half']:.2f} overall")
+    # Merge quality is judged only against XDS, by CC1/2 over XDS's own range (cc_half_noise_ratio).
+    # The open arm has no merge criterion.
+    if r["cc_half_noise_ratio"] is not None and r["cc_half_noise_ratio"] > CC_HALF_NOISE_LIMIT:
+        return verdict("fail", "merge", f"CC1/2 {r['refres_cc_half']:.4f} vs XDS {r['cc_half_ref']:.3f} "
+                                        f"over XDS's range: {r['cc_half_noise_ratio']:.1f}x XDS's half-set noise")
     note = ""
     if r["sgno"] != ref["sgno"]:
         note = f"{r['sg']} vs reference {r['sg_ref']} ({r.get('sg_relation') or 'screws not judged against XDS'})"
-- 
2.54.0


From 5c8011fe677fef691775b4aeced609ed91926f1e Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 12:55:13 +0200
Subject: [PATCH 055/122] compression: verify the bitshuffle seam for Apple
 Silicon; SIMD test knows NEON

The x86/ARM split asked for on macOS already exists: BitShuffleBlock.h (fbc507839) sends
the per-block transform to bitshuffle_hperf everywhere except aarch64 with NEON, where it
uses the classic bitshuffle's NEON path, and both call sites go through it. Nothing new is
needed for Apple Silicon - clang --target=arm64-apple-macos defines __aarch64__ and
__ARM_NEON exactly as aarch64 Linux does, both vendored files compile to arm64 Mach-O
objects, the seam resolves to bshuf_(un)trans_bit_elem and bshuf_using_NEON() is 1. The
header now says why the switch is a preprocessor one: a universal build compiles it once
per architecture, which a CMake-time answer cannot follow.

What had never happened is the NEON code actually running. It has now, under
qemu-aarch64 in the project's cross image: 504 blocks (elem 1/2/4/8, 8 elements up to the
128 kB block, odd multiples of 8, random and detector-like data) plus 54 whole-buffer
bitshuffle/LZ4 streams with element counts that are no multiple of 8 or of the block. The
output is byte-identical (same md5) across aarch64 NEON, aarch64 without NEON (seam falls
back to hperf's portable code), x86 hperf AVX2 via ifunc, hperf SSE2, hperf portable
fallback, and classic SSE2 / AVX2 / scalar; every implementation decodes every other.

Throughput, one thread on a loaded Zen 3, 16/32-bit, GB/s encode/decode: hperf AVX2
~9-12/~10-11, classic AVX2 ~8/~5.5-8, classic SSE2 ~4-5/~4.5-5.5, hperf portable fallback
auto-vectorised ~2.8/~5, not vectorised ~1/~1.8. Classic 128-bit SIMD beating hperf's
fallback is the x86 stand-in for the choice the seam makes on ARM; no ARM hardware was
available, so the NEON-vs-fallback ranking on a real core is still unmeasured.

The one thing that would have failed on aarch64 is the Bshuf_SSE test, which required
SSE2 outright. It now accepts NEON as well, which also makes it the check that a Mac or
DGX Spark build did not end up on the scalar path.

Not built: no CMake configure or jfjoch_test build was run on this machine (busy); the
test expression was compiled and run standalone on x86 only.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
(cherry picked from commit 5957b15493dfd0cc8a18fb780a18c2573a6eccde)
---
 compression/BitShuffleBlock.h     | 3 +++
 tests/FrameTransformationTest.cpp | 6 ++++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/compression/BitShuffleBlock.h b/compression/BitShuffleBlock.h
index b740a4f6a..a4a73f76a 100644
--- a/compression/BitShuffleBlock.h
+++ b/compression/BitShuffleBlock.h
@@ -18,6 +18,9 @@
 //
 // The condition mirrors USEARMNEON in bitshuffle_core.c exactly. With NEON off the classic path
 // falls back to a scalar of its own that is slower than hperf's, so it must not be selected then.
+// It is a preprocessor test rather than a CMake one on purpose: Apple Silicon defines the same two
+// macros as aarch64 Linux, and a macOS universal build compiles this header once per architecture,
+// which a single configure-time answer could not follow.
 #if (defined(__ARM_NEON__) || (__ARM_NEON)) && defined(__aarch64__)
 
 // The classic entry points allocate their own block-sized scratch, so the caller's goes unused.
diff --git a/tests/FrameTransformationTest.cpp b/tests/FrameTransformationTest.cpp
index 22f997521..3abebda59 100644
--- a/tests/FrameTransformationTest.cpp
+++ b/tests/FrameTransformationTest.cpp
@@ -22,8 +22,10 @@ inline uint64_t read_be64(const void *ptr) {
     return __builtin_bswap64(ptr64[0]);
 }
 
-TEST_CASE("Bshuf_SSE", "[bitshuffle]") {
-    REQUIRE (bshuf_using_SSE2() == 1);
+// The classic bitshuffle runs behind the HDF5 filter everywhere, and on aarch64 it is also the one
+// BitShuffleBlock.h picks, so a build that left it on its scalar path must not go unnoticed.
+TEST_CASE("Bshuf_SIMD", "[bitshuffle]") {
+    REQUIRE ((bshuf_using_SSE2() == 1 || bshuf_using_NEON() == 1));
 }
 
 TEST_CASE("FrameTransformation_Raw_NoCompression" ,"") {
-- 
2.54.0


From 1545bd2bbbb9d10fc1bfb65b0f87261666007b4d Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 18:41:43 +0200
Subject: [PATCH 056/122] tools/battery: verdicts judge lattice and symmetry
 only

Data quality - resolution, CC1/2, R_meas, completeness, ISa - is no longer a
pass/fail criterion anywhere; it is reported beside the reference in the tables
and plots for a human to judge. The CC1/2 noise ratio against XDS stays as a
reported guide.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/README.md | 24 ++++++++----------------
 tools/battery/report.py | 13 ++++++-------
 tools/battery/score.py  | 13 ++++---------
 3 files changed, 18 insertions(+), 32 deletions(-)

diff --git a/tools/battery/README.md b/tools/battery/README.md
index 80d33c4b0..71869800e 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -23,20 +23,12 @@ scored with `sgequiv`. On the XDS arms only the point group is scored, because X
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
-**Merge quality is judged only against XDS, and only by CC1/2.** No R_meas is a pass/fail
-criterion, and no absolute CC1/2 either. On the XDS arms the set fails `merge` when
-
-    (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) > 2
-
-with rugnux's CC1/2 from the reference-range table (`REFRES_CC_HALF`, XDS's own range) and XDS's
-from the `CORRECT.LP` total. CC1/2 = S / (S + E), with S the signal variance and E the half-set
-error variance, so 1/CC1/2 - 1 = E/S at any CC1/2, and E goes as 1/(observations): a ratio above 2
-is a merge noisier than XDS's would be with half of its observations. XDS prints CC1/2 to 0.1%, so
-its value is taken at the bottom of that rounding (-0.0005), and a printed 100.0 does not demand a
-perfect CC1/2. The ratio is stored as `cc_half_noise_ratio`. A set without the reference-range
-table or without an XDS CC1/2 (the controls, a hand-measured reference) has no merge criterion.
-**The open arm has no merge criterion at all**: it is scored on lattice and symmetry, and its
-resolution, CC1/2 and R_meas are reported, not judged.
+**Data quality is not scored.** A verdict is about the lattice and the symmetry only. Resolution,
+CC1/2, R_meas (overall and lowest shell), completeness, multiplicity and ISa are reported beside
+XDS's or the deposition's values, in the per-set tables and plots, for a human to judge. On the XDS
+arms `cc_half_noise_ratio` = (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1) over XDS's own
+range is shown as a guide: CC1/2 = S/(S+E), so 1/CC1/2 - 1 = E/S, and 2 means a merge as noisy as
+XDS's would be with half of its observations.
 
 **Low-resolution R_meas** is reported, not scored: the lowest-resolution shell of rugnux's own
 table (`lowres_r_meas`), of the reference-range table (`refres_lowres_r_meas`) and of XDS's
@@ -256,7 +248,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
 | `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `merge` (XDS arms: CC1/2 noise ratio above 2), `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
@@ -268,7 +260,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | `r_meas_ref`, `cc_half_ref`, `isa_ref`, `completeness_ref`, `multiplicity_ref` | XDS's overall values, over XDS's own range |
 | `refres_range`, `refres_shells_past_limit`, `refres_unique_reflections`, `refres_completeness`, `refres_multiplicity`, `refres_i_over_sigma`, `refres_r_meas`, `refres_cc_half`, `refres_isa` | XDS arms: the REFRES_* keys, the same merge over the reference range |
 | `isa_ratio`, `r_meas_ratio` | refres_isa / isa_ref and refres_r_meas / r_meas_ref |
-| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), the merge criterion |
+| `cc_half_noise_ratio` | XDS arms: (1/refres_cc_half - 1) / (1/(cc_half_ref - 0.0005) - 1), reported, not scored |
 | `lowres_d`, `lowres_r_meas`, `refres_lowres_d`, `refres_lowres_r_meas`, `lowres_d_ref`, `lowres_r_meas_ref`, `lowres_r_meas_ratio` | the lowest-resolution shell's high-resolution limit and R_meas: rugnux's own table, the reference-range table, XDS's; and refres_lowres_r_meas / lowres_r_meas_ref |
 | `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
 | `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
diff --git a/tools/battery/report.py b/tools/battery/report.py
index 23ea0089a..724d0e6a2 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -355,8 +355,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                                                       "reference-range table / of XDS's table; below 1 = "
                                                       "rugnux's strong reflections agree better"),
             ("cc_half_noise_ratio", "CC1/2 noise", "half-set noise over the reference range read off CC1/2 "
-                                                   "(1 / CC1/2 - 1) / XDS's; above 2 fails (the merge is as "
-                                                   "noisy as XDS's with half its observations)")):
+                                                   "(1 / CC1/2 - 1) / XDS's; 2 = as noisy as XDS's merge "
+                                                   "would be with half its observations (not scored)")):
         for arm in arms:
             pts = [(r["set"], r[name], r["verdict"], f"{what} ratio, {refres_note(r)}")
                    for r in res if r["arm"] == arm and r.get(name)]
@@ -405,13 +405,12 @@ def build(run_dir, baseline=None, allow_incomplete=False):
         doc.table(["set", "arm", "range A", "own d_min", "compl % (rugnux / XDS)", "mult", "I/sigma",
                    "R_meas", "low-res R_meas (to d A)", "CC1/2", "CC1/2 noise ratio", "ISa", "reading"],
                   rows, num=(3, 6, 10))
-        doc.p("Merge quality is scored here and only here, by CC1/2 against XDS's over the same range. "
+        doc.p("Data quality is not scored; this table is for a human to judge. "
               "CC1/2 = S / (S + E) (signal and half-set error variances), so 1 / CC1/2 - 1 = E / S is the "
               "half-set noise; the noise ratio is rugnux's over XDS's, with XDS's CC1/2 taken at the "
-              "bottom of its printed rounding (-0.0005). A set fails `merge` when the ratio is above "
-              f"{score.CC_HALF_NOISE_LIMIT:g}: noisier than XDS's merge would be with half its "
-              "observations. The low-resolution R_meas is the lowest shell of each table (the shells "
-              "are XDS's, so both cover the same reflections); it is reported, not scored.")
+              "bottom of its printed rounding (-0.0005); 2 would mean noisier than XDS's merge with half "
+              "its observations. The low-resolution R_meas is the lowest shell of each table (the shells "
+              "are XDS's, so both cover the same reflections); reported like everything here.")
 
     derived = {r["set"]: r for r in res if (r.get("d_min_ref_rule") or "xds_range") != "xds_range"}
     if derived:
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 865daf681..af44f3d57 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -1,7 +1,7 @@
 """Scoring one rugnux run against its reference.
 
 One dataset, one verdict, one cause, decided in this order: did it run -> is the lattice right ->
-is the symmetry right -> (XDS arms only) is the merge as good as XDS's by CC1/2. The order matters:
+is the symmetry right. Data quality is not scored: it is reported for a human to judge. The order matters:
 a halved axis also makes the screw along it unobservable, and counting that row twice would hide
 the defect that cost the reflections.
 """
@@ -92,15 +92,14 @@ def cell_dev_pct(cell, ref):
 # XDS prints CC1/2 in % with one decimal; its value is taken at the bottom of that rounding, so a
 # printed 100.0 does not demand a perfect CC1/2 of rugnux
 XDS_CC_HALF_ROUNDING = 0.0005
-CC_HALF_NOISE_LIMIT = 2.0
 
 
 def cc_half_noise_ratio(cc, cc_xds):
     """rugnux's half-set noise over XDS's, both read off CC1/2 over XDS's range; None without both.
 
     CC1/2 = S / (S + E), with S the variance of the signal and E that of the half-set error, so
-    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2
-    (CC_HALF_NOISE_LIMIT) is a merge as noisy as XDS's would be with half of its observations.
+    E / S = 1 / CC1/2 - 1 at any CC1/2. E goes as 1 / (observations): a ratio of 2 is a merge as
+    noisy as XDS's would be with half of its observations. Reported, not scored.
     A CC1/2 at or below 0 is no signal at all, counted as 0.001."""
     if cc is None or cc_xds is None:
         return None
@@ -233,11 +232,7 @@ def judge(entry, rep, run_note):
                  "sym_over" if order > order_ref else "sym_other")
         return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
 
-    # Merge quality is judged only against XDS, by CC1/2 over XDS's own range (cc_half_noise_ratio).
-    # The open arm has no merge criterion.
-    if r["cc_half_noise_ratio"] is not None and r["cc_half_noise_ratio"] > CC_HALF_NOISE_LIMIT:
-        return verdict("fail", "merge", f"CC1/2 {r['refres_cc_half']:.4f} vs XDS {r['cc_half_ref']:.3f} "
-                                        f"over XDS's range: {r['cc_half_noise_ratio']:.1f}x XDS's half-set noise")
+    # Data quality (CC1/2, R_meas, resolution, ISa) is reported, never scored: that is for a human.
     note = ""
     if r["sgno"] != ref["sgno"]:
         note = f"{r['sg']} vs reference {r['sg_ref']} ({r.get('sg_relation') or 'screws not judged against XDS'})"
-- 
2.54.0


From c63f9973bd75740ea69feab1de0615143eb301a9 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 19:13:49 +0200
Subject: [PATCH 057/122] v1.0.0-rc.172

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 VERSION                                                       | 2 +-
 broker/gen/model/Azim_int_settings.cpp                        | 2 +-
 broker/gen/model/Azim_int_settings.h                          | 2 +-
 broker/gen/model/Bragg_integration_settings.cpp               | 2 +-
 broker/gen/model/Bragg_integration_settings.h                 | 2 +-
 broker/gen/model/Broker_status.cpp                            | 2 +-
 broker/gen/model/Broker_status.h                              | 2 +-
 broker/gen/model/Calibration_statistics_inner.cpp             | 2 +-
 broker/gen/model/Calibration_statistics_inner.h               | 2 +-
 broker/gen/model/Dark_mask_settings.cpp                       | 2 +-
 broker/gen/model/Dark_mask_settings.h                         | 2 +-
 broker/gen/model/Dataset_settings.cpp                         | 2 +-
 broker/gen/model/Dataset_settings.h                           | 2 +-
 broker/gen/model/Dataset_settings_smargon.cpp                 | 2 +-
 broker/gen/model/Dataset_settings_smargon.h                   | 2 +-
 .../gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp | 2 +-
 .../gen/model/Dataset_settings_xray_fluorescence_spectrum.h   | 2 +-
 broker/gen/model/Detector.cpp                                 | 2 +-
 broker/gen/model/Detector.h                                   | 2 +-
 broker/gen/model/Detector_list.cpp                            | 2 +-
 broker/gen/model/Detector_list.h                              | 2 +-
 broker/gen/model/Detector_list_element.cpp                    | 2 +-
 broker/gen/model/Detector_list_element.h                      | 2 +-
 broker/gen/model/Detector_module.cpp                          | 2 +-
 broker/gen/model/Detector_module.h                            | 2 +-
 broker/gen/model/Detector_module_direction.cpp                | 2 +-
 broker/gen/model/Detector_module_direction.h                  | 2 +-
 broker/gen/model/Detector_power_state.cpp                     | 2 +-
 broker/gen/model/Detector_power_state.h                       | 2 +-
 broker/gen/model/Detector_selection.cpp                       | 2 +-
 broker/gen/model/Detector_selection.h                         | 2 +-
 broker/gen/model/Detector_settings.cpp                        | 2 +-
 broker/gen/model/Detector_settings.h                          | 2 +-
 broker/gen/model/Detector_state.cpp                           | 2 +-
 broker/gen/model/Detector_state.h                             | 2 +-
 broker/gen/model/Detector_status.cpp                          | 2 +-
 broker/gen/model/Detector_status.h                            | 2 +-
 broker/gen/model/Detector_timing.cpp                          | 2 +-
 broker/gen/model/Detector_timing.h                            | 2 +-
 broker/gen/model/Detector_type.cpp                            | 2 +-
 broker/gen/model/Detector_type.h                              | 2 +-
 broker/gen/model/Error_message.cpp                            | 2 +-
 broker/gen/model/Error_message.h                              | 2 +-
 broker/gen/model/File_writer_format.cpp                       | 2 +-
 broker/gen/model/File_writer_format.h                         | 2 +-
 broker/gen/model/File_writer_settings.cpp                     | 2 +-
 broker/gen/model/File_writer_settings.h                       | 2 +-
 broker/gen/model/Fpga_status_inner.cpp                        | 2 +-
 broker/gen/model/Fpga_status_inner.h                          | 2 +-
 broker/gen/model/Geom_refinement_algorithm.cpp                | 2 +-
 broker/gen/model/Geom_refinement_algorithm.h                  | 2 +-
 broker/gen/model/Grid_scan.cpp                                | 2 +-
 broker/gen/model/Grid_scan.h                                  | 2 +-
 broker/gen/model/Helpers.cpp                                  | 2 +-
 broker/gen/model/Helpers.h                                    | 2 +-
 broker/gen/model/Image_buffer_status.cpp                      | 2 +-
 broker/gen/model/Image_buffer_status.h                        | 2 +-
 broker/gen/model/Image_format_settings.cpp                    | 2 +-
 broker/gen/model/Image_format_settings.h                      | 2 +-
 broker/gen/model/Image_pusher_status.cpp                      | 2 +-
 broker/gen/model/Image_pusher_status.h                        | 2 +-
 broker/gen/model/Image_pusher_type.cpp                        | 2 +-
 broker/gen/model/Image_pusher_type.h                          | 2 +-
 broker/gen/model/Indexing_algorithm.cpp                       | 2 +-
 broker/gen/model/Indexing_algorithm.h                         | 2 +-
 broker/gen/model/Indexing_settings.cpp                        | 2 +-
 broker/gen/model/Indexing_settings.h                          | 2 +-
 broker/gen/model/Instrument_metadata.cpp                      | 2 +-
 broker/gen/model/Instrument_metadata.h                        | 2 +-
 broker/gen/model/Integration_model.cpp                        | 2 +-
 broker/gen/model/Integration_model.h                          | 2 +-
 broker/gen/model/Jfjoch_settings.cpp                          | 2 +-
 broker/gen/model/Jfjoch_settings.h                            | 2 +-
 broker/gen/model/Jfjoch_statistics.cpp                        | 2 +-
 broker/gen/model/Jfjoch_statistics.h                          | 2 +-
 broker/gen/model/Measurement_statistics.cpp                   | 2 +-
 broker/gen/model/Measurement_statistics.h                     | 2 +-
 broker/gen/model/Pcie_devices_inner.cpp                       | 2 +-
 broker/gen/model/Pcie_devices_inner.h                         | 2 +-
 broker/gen/model/Pixel_mask_statistics.cpp                    | 2 +-
 broker/gen/model/Pixel_mask_statistics.h                      | 2 +-
 broker/gen/model/Plot.cpp                                     | 2 +-
 broker/gen/model/Plot.h                                       | 2 +-
 broker/gen/model/Plot_unit_x.cpp                              | 2 +-
 broker/gen/model/Plot_unit_x.h                                | 2 +-
 broker/gen/model/Plots.cpp                                    | 2 +-
 broker/gen/model/Plots.h                                      | 2 +-
 broker/gen/model/Powder_calibration_fit_sigma.cpp             | 2 +-
 broker/gen/model/Powder_calibration_fit_sigma.h               | 2 +-
 broker/gen/model/Powder_calibration_output.cpp                | 2 +-
 broker/gen/model/Powder_calibration_output.h                  | 2 +-
 broker/gen/model/Powder_calibration_quality.cpp               | 2 +-
 broker/gen/model/Powder_calibration_quality.h                 | 2 +-
 broker/gen/model/Powder_calibration_spot_check.cpp            | 2 +-
 broker/gen/model/Powder_calibration_spot_check.h              | 2 +-
 broker/gen/model/Roi_azim_list.cpp                            | 2 +-
 broker/gen/model/Roi_azim_list.h                              | 2 +-
 broker/gen/model/Roi_azimuthal.cpp                            | 2 +-
 broker/gen/model/Roi_azimuthal.h                              | 2 +-
 broker/gen/model/Roi_box.cpp                                  | 2 +-
 broker/gen/model/Roi_box.h                                    | 2 +-
 broker/gen/model/Roi_box_list.cpp                             | 2 +-
 broker/gen/model/Roi_box_list.h                               | 2 +-
 broker/gen/model/Roi_circle.cpp                               | 2 +-
 broker/gen/model/Roi_circle.h                                 | 2 +-
 broker/gen/model/Roi_circle_list.cpp                          | 2 +-
 broker/gen/model/Roi_circle_list.h                            | 2 +-
 broker/gen/model/Roi_definitions.cpp                          | 2 +-
 broker/gen/model/Roi_definitions.h                            | 2 +-
 broker/gen/model/Rotation_axis.cpp                            | 2 +-
 broker/gen/model/Rotation_axis.h                              | 2 +-
 broker/gen/model/Scan_result.cpp                              | 2 +-
 broker/gen/model/Scan_result.h                                | 2 +-
 broker/gen/model/Scan_result_images_inner.cpp                 | 2 +-
 broker/gen/model/Scan_result_images_inner.h                   | 2 +-
 broker/gen/model/Spot_finding_settings.cpp                    | 2 +-
 broker/gen/model/Spot_finding_settings.h                      | 2 +-
 broker/gen/model/Standard_detector_geometry.cpp               | 2 +-
 broker/gen/model/Standard_detector_geometry.h                 | 2 +-
 broker/gen/model/Tcp_settings.cpp                             | 2 +-
 broker/gen/model/Tcp_settings.h                               | 2 +-
 broker/gen/model/Unit_cell.cpp                                | 2 +-
 broker/gen/model/Unit_cell.h                                  | 2 +-
 broker/gen/model/Zeromq_metadata_settings.cpp                 | 2 +-
 broker/gen/model/Zeromq_metadata_settings.h                   | 2 +-
 broker/gen/model/Zeromq_preview_settings.cpp                  | 2 +-
 broker/gen/model/Zeromq_preview_settings.h                    | 2 +-
 broker/gen/model/Zeromq_settings.cpp                          | 2 +-
 broker/gen/model/Zeromq_settings.h                            | 2 +-
 broker/jfjoch_api.yaml                                        | 2 +-
 broker/redoc-static.html                                      | 4 ++--
 docs/conf.py                                                  | 2 +-
 docs/python_client/README.md                                  | 4 ++--
 fpga/hdl/action_config.v                                      | 2 +-
 fpga/pcie_driver/dkms.conf                                    | 2 +-
 fpga/pcie_driver/install_dkms.sh                              | 2 +-
 fpga/pcie_driver/jfjoch_drv.c                                 | 2 +-
 fpga/pcie_driver/postinstall.sh                               | 2 +-
 fpga/pcie_driver/preuninstall.sh                              | 2 +-
 frontend/package-lock.json                                    | 4 ++--
 frontend/package.json                                         | 2 +-
 frontend/src/version.ts                                       | 2 +-
 142 files changed, 145 insertions(+), 145 deletions(-)

diff --git a/VERSION b/VERSION
index c5f2e144c..47ec788ac 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.0.0-rc.171
+1.0.0-rc.172
diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp
index 5f2c8dcfe..b7321eebc 100644
--- a/broker/gen/model/Azim_int_settings.cpp
+++ b/broker/gen/model/Azim_int_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Azim_int_settings.h b/broker/gen/model/Azim_int_settings.h
index eb60d8797..45fedd0c7 100644
--- a/broker/gen/model/Azim_int_settings.h
+++ b/broker/gen/model/Azim_int_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Bragg_integration_settings.cpp b/broker/gen/model/Bragg_integration_settings.cpp
index 6d16ac879..c64f3c0d2 100644
--- a/broker/gen/model/Bragg_integration_settings.cpp
+++ b/broker/gen/model/Bragg_integration_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Bragg_integration_settings.h b/broker/gen/model/Bragg_integration_settings.h
index 83f51893e..6a32b5bac 100644
--- a/broker/gen/model/Bragg_integration_settings.h
+++ b/broker/gen/model/Bragg_integration_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Broker_status.cpp b/broker/gen/model/Broker_status.cpp
index 83dca796d..81ed2a694 100644
--- a/broker/gen/model/Broker_status.cpp
+++ b/broker/gen/model/Broker_status.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Broker_status.h b/broker/gen/model/Broker_status.h
index 5e2f56f63..167481ece 100644
--- a/broker/gen/model/Broker_status.h
+++ b/broker/gen/model/Broker_status.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Calibration_statistics_inner.cpp b/broker/gen/model/Calibration_statistics_inner.cpp
index cc7efca16..28a41cd93 100644
--- a/broker/gen/model/Calibration_statistics_inner.cpp
+++ b/broker/gen/model/Calibration_statistics_inner.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Calibration_statistics_inner.h b/broker/gen/model/Calibration_statistics_inner.h
index 12b3ee942..dc258c9ef 100644
--- a/broker/gen/model/Calibration_statistics_inner.h
+++ b/broker/gen/model/Calibration_statistics_inner.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dark_mask_settings.cpp b/broker/gen/model/Dark_mask_settings.cpp
index 62254b71b..088de5be0 100644
--- a/broker/gen/model/Dark_mask_settings.cpp
+++ b/broker/gen/model/Dark_mask_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dark_mask_settings.h b/broker/gen/model/Dark_mask_settings.h
index 435dd7eed..1a9e497e2 100644
--- a/broker/gen/model/Dark_mask_settings.h
+++ b/broker/gen/model/Dark_mask_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings.cpp b/broker/gen/model/Dataset_settings.cpp
index 68f5070cc..1c8edc7f8 100644
--- a/broker/gen/model/Dataset_settings.cpp
+++ b/broker/gen/model/Dataset_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings.h b/broker/gen/model/Dataset_settings.h
index e466f9c4e..1be9ffc8a 100644
--- a/broker/gen/model/Dataset_settings.h
+++ b/broker/gen/model/Dataset_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings_smargon.cpp b/broker/gen/model/Dataset_settings_smargon.cpp
index d6563b755..7e0bfa1b6 100644
--- a/broker/gen/model/Dataset_settings_smargon.cpp
+++ b/broker/gen/model/Dataset_settings_smargon.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings_smargon.h b/broker/gen/model/Dataset_settings_smargon.h
index dd1793298..b3698611f 100644
--- a/broker/gen/model/Dataset_settings_smargon.h
+++ b/broker/gen/model/Dataset_settings_smargon.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp
index 4b148ec48..579b76ea8 100644
--- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp
+++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h
index ff0789061..98421d547 100644
--- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h
+++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector.cpp b/broker/gen/model/Detector.cpp
index d3ea62683..20a7f31bc 100644
--- a/broker/gen/model/Detector.cpp
+++ b/broker/gen/model/Detector.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector.h b/broker/gen/model/Detector.h
index fe1992969..2ccdb261a 100644
--- a/broker/gen/model/Detector.h
+++ b/broker/gen/model/Detector.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_list.cpp b/broker/gen/model/Detector_list.cpp
index be1dfa826..84016ad54 100644
--- a/broker/gen/model/Detector_list.cpp
+++ b/broker/gen/model/Detector_list.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_list.h b/broker/gen/model/Detector_list.h
index 61dfa2520..46577ad2c 100644
--- a/broker/gen/model/Detector_list.h
+++ b/broker/gen/model/Detector_list.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_list_element.cpp b/broker/gen/model/Detector_list_element.cpp
index 3a3efc082..f238bbe48 100644
--- a/broker/gen/model/Detector_list_element.cpp
+++ b/broker/gen/model/Detector_list_element.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_list_element.h b/broker/gen/model/Detector_list_element.h
index d81bb0d7d..a165d626c 100644
--- a/broker/gen/model/Detector_list_element.h
+++ b/broker/gen/model/Detector_list_element.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_module.cpp b/broker/gen/model/Detector_module.cpp
index 4aba3949e..ea53e50aa 100644
--- a/broker/gen/model/Detector_module.cpp
+++ b/broker/gen/model/Detector_module.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_module.h b/broker/gen/model/Detector_module.h
index 66cb243a8..b1c1ad9b4 100644
--- a/broker/gen/model/Detector_module.h
+++ b/broker/gen/model/Detector_module.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_module_direction.cpp b/broker/gen/model/Detector_module_direction.cpp
index 2f1f29e5e..839449b78 100644
--- a/broker/gen/model/Detector_module_direction.cpp
+++ b/broker/gen/model/Detector_module_direction.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_module_direction.h b/broker/gen/model/Detector_module_direction.h
index 3d559b5a4..b4f8359de 100644
--- a/broker/gen/model/Detector_module_direction.h
+++ b/broker/gen/model/Detector_module_direction.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_power_state.cpp b/broker/gen/model/Detector_power_state.cpp
index eeba5cea0..92766f47b 100644
--- a/broker/gen/model/Detector_power_state.cpp
+++ b/broker/gen/model/Detector_power_state.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_power_state.h b/broker/gen/model/Detector_power_state.h
index aec7cd92c..78537cf22 100644
--- a/broker/gen/model/Detector_power_state.h
+++ b/broker/gen/model/Detector_power_state.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_selection.cpp b/broker/gen/model/Detector_selection.cpp
index bc6fc871e..9ad726fda 100644
--- a/broker/gen/model/Detector_selection.cpp
+++ b/broker/gen/model/Detector_selection.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_selection.h b/broker/gen/model/Detector_selection.h
index 3c5a31f3e..ecc069541 100644
--- a/broker/gen/model/Detector_selection.h
+++ b/broker/gen/model/Detector_selection.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_settings.cpp b/broker/gen/model/Detector_settings.cpp
index 3035d1607..890634730 100644
--- a/broker/gen/model/Detector_settings.cpp
+++ b/broker/gen/model/Detector_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_settings.h b/broker/gen/model/Detector_settings.h
index 7b6556346..1b2cc2351 100644
--- a/broker/gen/model/Detector_settings.h
+++ b/broker/gen/model/Detector_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_state.cpp b/broker/gen/model/Detector_state.cpp
index 1f9dd15c1..2388e96e3 100644
--- a/broker/gen/model/Detector_state.cpp
+++ b/broker/gen/model/Detector_state.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_state.h b/broker/gen/model/Detector_state.h
index 4218bb570..b64cec643 100644
--- a/broker/gen/model/Detector_state.h
+++ b/broker/gen/model/Detector_state.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_status.cpp b/broker/gen/model/Detector_status.cpp
index 1877e79a7..964d16712 100644
--- a/broker/gen/model/Detector_status.cpp
+++ b/broker/gen/model/Detector_status.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_status.h b/broker/gen/model/Detector_status.h
index 0b0efbfb0..3b8d6badf 100644
--- a/broker/gen/model/Detector_status.h
+++ b/broker/gen/model/Detector_status.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_timing.cpp b/broker/gen/model/Detector_timing.cpp
index 23b7abd54..b833a01d7 100644
--- a/broker/gen/model/Detector_timing.cpp
+++ b/broker/gen/model/Detector_timing.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_timing.h b/broker/gen/model/Detector_timing.h
index 38cabb661..5e38611af 100644
--- a/broker/gen/model/Detector_timing.h
+++ b/broker/gen/model/Detector_timing.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_type.cpp b/broker/gen/model/Detector_type.cpp
index e74b6ef7c..2c9d0344f 100644
--- a/broker/gen/model/Detector_type.cpp
+++ b/broker/gen/model/Detector_type.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Detector_type.h b/broker/gen/model/Detector_type.h
index 724af84f8..c8cb01a0c 100644
--- a/broker/gen/model/Detector_type.h
+++ b/broker/gen/model/Detector_type.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Error_message.cpp b/broker/gen/model/Error_message.cpp
index 6710b23fe..453f4405a 100644
--- a/broker/gen/model/Error_message.cpp
+++ b/broker/gen/model/Error_message.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Error_message.h b/broker/gen/model/Error_message.h
index e34bc2bb2..21cdc6b8e 100644
--- a/broker/gen/model/Error_message.h
+++ b/broker/gen/model/Error_message.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/File_writer_format.cpp b/broker/gen/model/File_writer_format.cpp
index a0b9e758d..6bee13faf 100644
--- a/broker/gen/model/File_writer_format.cpp
+++ b/broker/gen/model/File_writer_format.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/File_writer_format.h b/broker/gen/model/File_writer_format.h
index c9d68bb5a..5ffc18464 100644
--- a/broker/gen/model/File_writer_format.h
+++ b/broker/gen/model/File_writer_format.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/File_writer_settings.cpp b/broker/gen/model/File_writer_settings.cpp
index 25cd61c8a..4f475e94b 100644
--- a/broker/gen/model/File_writer_settings.cpp
+++ b/broker/gen/model/File_writer_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/File_writer_settings.h b/broker/gen/model/File_writer_settings.h
index b92c56517..67e50ec25 100644
--- a/broker/gen/model/File_writer_settings.h
+++ b/broker/gen/model/File_writer_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Fpga_status_inner.cpp b/broker/gen/model/Fpga_status_inner.cpp
index 14223c360..d120d827e 100644
--- a/broker/gen/model/Fpga_status_inner.cpp
+++ b/broker/gen/model/Fpga_status_inner.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Fpga_status_inner.h b/broker/gen/model/Fpga_status_inner.h
index 5c25f2e08..07a071a90 100644
--- a/broker/gen/model/Fpga_status_inner.h
+++ b/broker/gen/model/Fpga_status_inner.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Geom_refinement_algorithm.cpp b/broker/gen/model/Geom_refinement_algorithm.cpp
index b31cba5df..81e9d0f27 100644
--- a/broker/gen/model/Geom_refinement_algorithm.cpp
+++ b/broker/gen/model/Geom_refinement_algorithm.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Geom_refinement_algorithm.h b/broker/gen/model/Geom_refinement_algorithm.h
index 84c013c67..e4543d069 100644
--- a/broker/gen/model/Geom_refinement_algorithm.h
+++ b/broker/gen/model/Geom_refinement_algorithm.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Grid_scan.cpp b/broker/gen/model/Grid_scan.cpp
index 6cb3ac35e..2e8e0b393 100644
--- a/broker/gen/model/Grid_scan.cpp
+++ b/broker/gen/model/Grid_scan.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Grid_scan.h b/broker/gen/model/Grid_scan.h
index 29843bafb..daaa02153 100644
--- a/broker/gen/model/Grid_scan.h
+++ b/broker/gen/model/Grid_scan.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Helpers.cpp b/broker/gen/model/Helpers.cpp
index 22351de93..061759d51 100644
--- a/broker/gen/model/Helpers.cpp
+++ b/broker/gen/model/Helpers.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Helpers.h b/broker/gen/model/Helpers.h
index 25dcd14e0..f41a1cc30 100644
--- a/broker/gen/model/Helpers.h
+++ b/broker/gen/model/Helpers.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_buffer_status.cpp b/broker/gen/model/Image_buffer_status.cpp
index 160a44f0d..0670404c3 100644
--- a/broker/gen/model/Image_buffer_status.cpp
+++ b/broker/gen/model/Image_buffer_status.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_buffer_status.h b/broker/gen/model/Image_buffer_status.h
index fcda27d03..e755563dc 100644
--- a/broker/gen/model/Image_buffer_status.h
+++ b/broker/gen/model/Image_buffer_status.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_format_settings.cpp b/broker/gen/model/Image_format_settings.cpp
index 58f057b3b..decbca571 100644
--- a/broker/gen/model/Image_format_settings.cpp
+++ b/broker/gen/model/Image_format_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_format_settings.h b/broker/gen/model/Image_format_settings.h
index cb84ef136..f07e8d072 100644
--- a/broker/gen/model/Image_format_settings.h
+++ b/broker/gen/model/Image_format_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_pusher_status.cpp b/broker/gen/model/Image_pusher_status.cpp
index fd62db503..79132be08 100644
--- a/broker/gen/model/Image_pusher_status.cpp
+++ b/broker/gen/model/Image_pusher_status.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_pusher_status.h b/broker/gen/model/Image_pusher_status.h
index 7ffbead31..ad364129d 100644
--- a/broker/gen/model/Image_pusher_status.h
+++ b/broker/gen/model/Image_pusher_status.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_pusher_type.cpp b/broker/gen/model/Image_pusher_type.cpp
index 1f64f3ae9..38857c156 100644
--- a/broker/gen/model/Image_pusher_type.cpp
+++ b/broker/gen/model/Image_pusher_type.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Image_pusher_type.h b/broker/gen/model/Image_pusher_type.h
index a9176b824..31a812600 100644
--- a/broker/gen/model/Image_pusher_type.h
+++ b/broker/gen/model/Image_pusher_type.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Indexing_algorithm.cpp b/broker/gen/model/Indexing_algorithm.cpp
index 8db644426..eb132e508 100644
--- a/broker/gen/model/Indexing_algorithm.cpp
+++ b/broker/gen/model/Indexing_algorithm.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Indexing_algorithm.h b/broker/gen/model/Indexing_algorithm.h
index 7fd5e6ec7..3a27c8c39 100644
--- a/broker/gen/model/Indexing_algorithm.h
+++ b/broker/gen/model/Indexing_algorithm.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp
index 68760a308..e2f132a5a 100644
--- a/broker/gen/model/Indexing_settings.cpp
+++ b/broker/gen/model/Indexing_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h
index 05bdb6603..5f30bba9d 100644
--- a/broker/gen/model/Indexing_settings.h
+++ b/broker/gen/model/Indexing_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Instrument_metadata.cpp b/broker/gen/model/Instrument_metadata.cpp
index 6632accc5..cb6c3aaaf 100644
--- a/broker/gen/model/Instrument_metadata.cpp
+++ b/broker/gen/model/Instrument_metadata.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Instrument_metadata.h b/broker/gen/model/Instrument_metadata.h
index 032fc830f..93e1dfca4 100644
--- a/broker/gen/model/Instrument_metadata.h
+++ b/broker/gen/model/Instrument_metadata.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Integration_model.cpp b/broker/gen/model/Integration_model.cpp
index e54f45e13..b7ea8f106 100644
--- a/broker/gen/model/Integration_model.cpp
+++ b/broker/gen/model/Integration_model.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Integration_model.h b/broker/gen/model/Integration_model.h
index a62fb6ff3..222adbd10 100644
--- a/broker/gen/model/Integration_model.h
+++ b/broker/gen/model/Integration_model.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Jfjoch_settings.cpp b/broker/gen/model/Jfjoch_settings.cpp
index 4f37a1432..6cf955f02 100644
--- a/broker/gen/model/Jfjoch_settings.cpp
+++ b/broker/gen/model/Jfjoch_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h
index 974e6814b..efee24fa9 100644
--- a/broker/gen/model/Jfjoch_settings.h
+++ b/broker/gen/model/Jfjoch_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Jfjoch_statistics.cpp b/broker/gen/model/Jfjoch_statistics.cpp
index 799e54424..b58ede3ca 100644
--- a/broker/gen/model/Jfjoch_statistics.cpp
+++ b/broker/gen/model/Jfjoch_statistics.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Jfjoch_statistics.h b/broker/gen/model/Jfjoch_statistics.h
index f3bdaa380..f9b95783d 100644
--- a/broker/gen/model/Jfjoch_statistics.h
+++ b/broker/gen/model/Jfjoch_statistics.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Measurement_statistics.cpp b/broker/gen/model/Measurement_statistics.cpp
index 160c24bce..fd7c156ab 100644
--- a/broker/gen/model/Measurement_statistics.cpp
+++ b/broker/gen/model/Measurement_statistics.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Measurement_statistics.h b/broker/gen/model/Measurement_statistics.h
index 677729c8e..63277f074 100644
--- a/broker/gen/model/Measurement_statistics.h
+++ b/broker/gen/model/Measurement_statistics.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Pcie_devices_inner.cpp b/broker/gen/model/Pcie_devices_inner.cpp
index 71cc3b53d..596ca8249 100644
--- a/broker/gen/model/Pcie_devices_inner.cpp
+++ b/broker/gen/model/Pcie_devices_inner.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Pcie_devices_inner.h b/broker/gen/model/Pcie_devices_inner.h
index a52fc6e24..5bfae1511 100644
--- a/broker/gen/model/Pcie_devices_inner.h
+++ b/broker/gen/model/Pcie_devices_inner.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Pixel_mask_statistics.cpp b/broker/gen/model/Pixel_mask_statistics.cpp
index 95728d9aa..43091914f 100644
--- a/broker/gen/model/Pixel_mask_statistics.cpp
+++ b/broker/gen/model/Pixel_mask_statistics.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Pixel_mask_statistics.h b/broker/gen/model/Pixel_mask_statistics.h
index 67ba4cd55..97e213ecf 100644
--- a/broker/gen/model/Pixel_mask_statistics.h
+++ b/broker/gen/model/Pixel_mask_statistics.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plot.cpp b/broker/gen/model/Plot.cpp
index f351ca7bd..1c7a7482a 100644
--- a/broker/gen/model/Plot.cpp
+++ b/broker/gen/model/Plot.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plot.h b/broker/gen/model/Plot.h
index df6a87e95..58d37489a 100644
--- a/broker/gen/model/Plot.h
+++ b/broker/gen/model/Plot.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plot_unit_x.cpp b/broker/gen/model/Plot_unit_x.cpp
index efb863ef0..70aec353f 100644
--- a/broker/gen/model/Plot_unit_x.cpp
+++ b/broker/gen/model/Plot_unit_x.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plot_unit_x.h b/broker/gen/model/Plot_unit_x.h
index 5d8002ba3..dc1e9d7ea 100644
--- a/broker/gen/model/Plot_unit_x.h
+++ b/broker/gen/model/Plot_unit_x.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plots.cpp b/broker/gen/model/Plots.cpp
index f0eb9fe83..a4c3858ad 100644
--- a/broker/gen/model/Plots.cpp
+++ b/broker/gen/model/Plots.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Plots.h b/broker/gen/model/Plots.h
index 05b45a5e2..e198a3603 100644
--- a/broker/gen/model/Plots.h
+++ b/broker/gen/model/Plots.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_fit_sigma.cpp b/broker/gen/model/Powder_calibration_fit_sigma.cpp
index 14dc33217..5b2b9565e 100644
--- a/broker/gen/model/Powder_calibration_fit_sigma.cpp
+++ b/broker/gen/model/Powder_calibration_fit_sigma.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_fit_sigma.h b/broker/gen/model/Powder_calibration_fit_sigma.h
index 2117ffda6..7975aba2b 100644
--- a/broker/gen/model/Powder_calibration_fit_sigma.h
+++ b/broker/gen/model/Powder_calibration_fit_sigma.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_output.cpp b/broker/gen/model/Powder_calibration_output.cpp
index 3676aeb5d..fb6ba091b 100644
--- a/broker/gen/model/Powder_calibration_output.cpp
+++ b/broker/gen/model/Powder_calibration_output.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_output.h b/broker/gen/model/Powder_calibration_output.h
index 2cc6e3789..c0afafefb 100644
--- a/broker/gen/model/Powder_calibration_output.h
+++ b/broker/gen/model/Powder_calibration_output.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_quality.cpp b/broker/gen/model/Powder_calibration_quality.cpp
index faf0b59ba..e06092255 100644
--- a/broker/gen/model/Powder_calibration_quality.cpp
+++ b/broker/gen/model/Powder_calibration_quality.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_quality.h b/broker/gen/model/Powder_calibration_quality.h
index ed254cedb..8c44941b4 100644
--- a/broker/gen/model/Powder_calibration_quality.h
+++ b/broker/gen/model/Powder_calibration_quality.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_spot_check.cpp b/broker/gen/model/Powder_calibration_spot_check.cpp
index e07545aaf..bc200db3e 100644
--- a/broker/gen/model/Powder_calibration_spot_check.cpp
+++ b/broker/gen/model/Powder_calibration_spot_check.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Powder_calibration_spot_check.h b/broker/gen/model/Powder_calibration_spot_check.h
index 3dd71c409..1e82566c0 100644
--- a/broker/gen/model/Powder_calibration_spot_check.h
+++ b/broker/gen/model/Powder_calibration_spot_check.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_azim_list.cpp b/broker/gen/model/Roi_azim_list.cpp
index 7ecb8959e..73897007b 100644
--- a/broker/gen/model/Roi_azim_list.cpp
+++ b/broker/gen/model/Roi_azim_list.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_azim_list.h b/broker/gen/model/Roi_azim_list.h
index cc3f2ed1e..6de70bce7 100644
--- a/broker/gen/model/Roi_azim_list.h
+++ b/broker/gen/model/Roi_azim_list.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_azimuthal.cpp b/broker/gen/model/Roi_azimuthal.cpp
index 8aebee8dc..b287c8f5a 100644
--- a/broker/gen/model/Roi_azimuthal.cpp
+++ b/broker/gen/model/Roi_azimuthal.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_azimuthal.h b/broker/gen/model/Roi_azimuthal.h
index b60be673f..e7e1feb6f 100644
--- a/broker/gen/model/Roi_azimuthal.h
+++ b/broker/gen/model/Roi_azimuthal.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_box.cpp b/broker/gen/model/Roi_box.cpp
index 29c8cc676..0ade34d1b 100644
--- a/broker/gen/model/Roi_box.cpp
+++ b/broker/gen/model/Roi_box.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_box.h b/broker/gen/model/Roi_box.h
index 9989aa4e0..f5e852454 100644
--- a/broker/gen/model/Roi_box.h
+++ b/broker/gen/model/Roi_box.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_box_list.cpp b/broker/gen/model/Roi_box_list.cpp
index 43269d432..7cf41c36c 100644
--- a/broker/gen/model/Roi_box_list.cpp
+++ b/broker/gen/model/Roi_box_list.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_box_list.h b/broker/gen/model/Roi_box_list.h
index 6e8020a8c..efa9cef8f 100644
--- a/broker/gen/model/Roi_box_list.h
+++ b/broker/gen/model/Roi_box_list.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_circle.cpp b/broker/gen/model/Roi_circle.cpp
index a6bebd99e..fdf82366a 100644
--- a/broker/gen/model/Roi_circle.cpp
+++ b/broker/gen/model/Roi_circle.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_circle.h b/broker/gen/model/Roi_circle.h
index 9229817ec..26fdc68ca 100644
--- a/broker/gen/model/Roi_circle.h
+++ b/broker/gen/model/Roi_circle.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_circle_list.cpp b/broker/gen/model/Roi_circle_list.cpp
index 81844d018..6ccf0a1f0 100644
--- a/broker/gen/model/Roi_circle_list.cpp
+++ b/broker/gen/model/Roi_circle_list.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_circle_list.h b/broker/gen/model/Roi_circle_list.h
index 44f7d32c8..84699aac4 100644
--- a/broker/gen/model/Roi_circle_list.h
+++ b/broker/gen/model/Roi_circle_list.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_definitions.cpp b/broker/gen/model/Roi_definitions.cpp
index 7cc0ba2f9..61996f157 100644
--- a/broker/gen/model/Roi_definitions.cpp
+++ b/broker/gen/model/Roi_definitions.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Roi_definitions.h b/broker/gen/model/Roi_definitions.h
index 70cab5328..9f772a756 100644
--- a/broker/gen/model/Roi_definitions.h
+++ b/broker/gen/model/Roi_definitions.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Rotation_axis.cpp b/broker/gen/model/Rotation_axis.cpp
index bbbe77be3..0aa589866 100644
--- a/broker/gen/model/Rotation_axis.cpp
+++ b/broker/gen/model/Rotation_axis.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Rotation_axis.h b/broker/gen/model/Rotation_axis.h
index b098dcc9e..0006fa3e1 100644
--- a/broker/gen/model/Rotation_axis.h
+++ b/broker/gen/model/Rotation_axis.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Scan_result.cpp b/broker/gen/model/Scan_result.cpp
index 76d6ccedd..7b7398943 100644
--- a/broker/gen/model/Scan_result.cpp
+++ b/broker/gen/model/Scan_result.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Scan_result.h b/broker/gen/model/Scan_result.h
index 345b78ecf..13458f09d 100644
--- a/broker/gen/model/Scan_result.h
+++ b/broker/gen/model/Scan_result.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Scan_result_images_inner.cpp b/broker/gen/model/Scan_result_images_inner.cpp
index 263ab2d19..50e37830a 100644
--- a/broker/gen/model/Scan_result_images_inner.cpp
+++ b/broker/gen/model/Scan_result_images_inner.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Scan_result_images_inner.h b/broker/gen/model/Scan_result_images_inner.h
index 06054bdf0..8217af4a9 100644
--- a/broker/gen/model/Scan_result_images_inner.h
+++ b/broker/gen/model/Scan_result_images_inner.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp
index 6b22884df..6be2ab03a 100644
--- a/broker/gen/model/Spot_finding_settings.cpp
+++ b/broker/gen/model/Spot_finding_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h
index d21a54b2a..8175e8d13 100644
--- a/broker/gen/model/Spot_finding_settings.h
+++ b/broker/gen/model/Spot_finding_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Standard_detector_geometry.cpp b/broker/gen/model/Standard_detector_geometry.cpp
index 01c2d1556..8e60acc43 100644
--- a/broker/gen/model/Standard_detector_geometry.cpp
+++ b/broker/gen/model/Standard_detector_geometry.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Standard_detector_geometry.h b/broker/gen/model/Standard_detector_geometry.h
index bf798d4b2..70d9f0b30 100644
--- a/broker/gen/model/Standard_detector_geometry.h
+++ b/broker/gen/model/Standard_detector_geometry.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Tcp_settings.cpp b/broker/gen/model/Tcp_settings.cpp
index e7687541c..931bebb6e 100644
--- a/broker/gen/model/Tcp_settings.cpp
+++ b/broker/gen/model/Tcp_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Tcp_settings.h b/broker/gen/model/Tcp_settings.h
index 344877e71..7e159d701 100644
--- a/broker/gen/model/Tcp_settings.h
+++ b/broker/gen/model/Tcp_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Unit_cell.cpp b/broker/gen/model/Unit_cell.cpp
index 168df3fa4..a5d33f42e 100644
--- a/broker/gen/model/Unit_cell.cpp
+++ b/broker/gen/model/Unit_cell.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Unit_cell.h b/broker/gen/model/Unit_cell.h
index 45c811dec..81de6d2f6 100644
--- a/broker/gen/model/Unit_cell.h
+++ b/broker/gen/model/Unit_cell.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_metadata_settings.cpp b/broker/gen/model/Zeromq_metadata_settings.cpp
index 8e2cdeef5..12414fc10 100644
--- a/broker/gen/model/Zeromq_metadata_settings.cpp
+++ b/broker/gen/model/Zeromq_metadata_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_metadata_settings.h b/broker/gen/model/Zeromq_metadata_settings.h
index 003290218..baf54c0f9 100644
--- a/broker/gen/model/Zeromq_metadata_settings.h
+++ b/broker/gen/model/Zeromq_metadata_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_preview_settings.cpp b/broker/gen/model/Zeromq_preview_settings.cpp
index 46aa548ac..3327d8b78 100644
--- a/broker/gen/model/Zeromq_preview_settings.cpp
+++ b/broker/gen/model/Zeromq_preview_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_preview_settings.h b/broker/gen/model/Zeromq_preview_settings.h
index 1d5133736..076c75517 100644
--- a/broker/gen/model/Zeromq_preview_settings.h
+++ b/broker/gen/model/Zeromq_preview_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_settings.cpp b/broker/gen/model/Zeromq_settings.cpp
index 063dbe19a..f35db153f 100644
--- a/broker/gen/model/Zeromq_settings.cpp
+++ b/broker/gen/model/Zeromq_settings.cpp
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/gen/model/Zeromq_settings.h b/broker/gen/model/Zeromq_settings.h
index 5aac242e6..79f2b0572 100644
--- a/broker/gen/model/Zeromq_settings.h
+++ b/broker/gen/model/Zeromq_settings.h
@@ -2,7 +2,7 @@
 * Jungfraujoch
 * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.  # License Clarification  While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing.  This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL.  This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. 
 *
-* The version of the OpenAPI document: 1.0.0-rc.171
+* The version of the OpenAPI document: 1.0.0-rc.172
 * Contact: filip.leonarski@psi.ch
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml
index ba2cfb815..b488ec8c6 100644
--- a/broker/jfjoch_api.yaml
+++ b/broker/jfjoch_api.yaml
@@ -22,7 +22,7 @@ info:
     requirements on applications that merely interact with the API, regardless of whether they
     communicate through network calls or other mechanisms.
 
-  version: 1.0.0-rc.171
+  version: 1.0.0-rc.172
   contact:
     name: Filip Leonarski (Paul Scherrer Institute)
     email: filip.leonarski@psi.ch
diff --git a/broker/redoc-static.html b/broker/redoc-static.html
index dc0b40c4d..23aa0cb99 100644
--- a/broker/redoc-static.html
+++ b/broker/redoc-static.html
@@ -399,7 +399,7 @@ This format doesn&#x27;t transmit information about X-axis, only values, so it i
           55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864
           -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688,
           -104.0616 -231.873,-231.248 z
-        " fill="currentColor"></path></g></svg></div></div><div class="sc-eulNck iEaKWZ api-content"><div class="sc-dcJsrY bBkGhy"><div class="sc-kAyceB hBQWIZ"><div class="sc-fqkvVR oJKYx api-info"><h1 class="sc-imWYAI sc-ktJbId cILgPb UQJzT">Jungfraujoch<!-- --> <span>(<!-- -->1.0.0-rc.171<!-- -->)</span></h1><p>Download OpenAPI specification<!-- -->:</p><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru"><div class="sc-fiCwlc iQovLz"><div class="sc-jIGnZt cKLRU"><span class="sc-kMkxaj csEIgT">Filip Leonarski (Paul Scherrer Institute)<!-- -->:<!-- --> <a href="mailto:filip.leonarski@psi.ch">filip.leonarski@psi.ch</a></span> <!-- --> <span class="sc-kMkxaj csEIgT">License:<!-- --> <a href="https://www.gnu.org/licenses/gpl-3.0.html">GPL-3.0</a></span> </div></div></div><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru" data-role="redoc-summary"></div><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru" data-role="redoc-description"><p>API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).
+        " fill="currentColor"></path></g></svg></div></div><div class="sc-eulNck iEaKWZ api-content"><div class="sc-dcJsrY bBkGhy"><div class="sc-kAyceB hBQWIZ"><div class="sc-fqkvVR oJKYx api-info"><h1 class="sc-imWYAI sc-ktJbId cILgPb UQJzT">Jungfraujoch<!-- --> <span>(<!-- -->1.0.0-rc.172<!-- -->)</span></h1><p>Download OpenAPI specification<!-- -->:</p><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru"><div class="sc-fiCwlc iQovLz"><div class="sc-jIGnZt cKLRU"><span class="sc-kMkxaj csEIgT">Filip Leonarski (Paul Scherrer Institute)<!-- -->:<!-- --> <a href="mailto:filip.leonarski@psi.ch">filip.leonarski@psi.ch</a></span> <!-- --> <span class="sc-kMkxaj csEIgT">License:<!-- --> <a href="https://www.gnu.org/licenses/gpl-3.0.html">GPL-3.0</a></span> </div></div></div><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru" data-role="redoc-summary"></div><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru" data-role="redoc-description"><p>API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).
 Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU.
 Jungfraujoch uses FPGA boards to acquire data at high data rates.</p>
 </div></div></div></div><div id="section/License-Clarification" data-section-id="section/License-Clarification" class="sc-dcJsrY bBkGhy"><div class="sc-kAyceB hBQWIZ"><div class="sc-fqkvVR oJKYx"><h2 class="sc-jXbUNg fWnwAh"><a class="sc-jlZhew kbdRLs" href="#section/License-Clarification" aria-label="section/License-Clarification"></a>License Clarification</h2></div></div><div class="sc-fqkvVR diIqQJ"><div class="sc-eeDRCY sc-eBMEME gTGgei fMmru redoc-markdown "><p>While this API definition is licensed under GPL-3.0, <strong>the GPL copyleft provisions do not apply</strong>
@@ -996,7 +996,7 @@ then image might be replaced in the buffer between calling /images and /image.cb
 </div></button></div></div></div><div class="sc-iGgWBj sc-gsFSXq ibAZSi eDeKjd"><div class="sc-ejfMa-d bNUPQg"><button class="sc-EgOXT cFEcOl"><span type="get" class="sc-eZYNyq qGfV http-verb get">get</span><span class="sc-iEXKAA gUNSDu">/version</span><svg class="sc-cwHptR iVFMLx" style="margin-right:-25px" version="1.1" viewBox="0 0 24 24" x="0" xmlns="http://www.w3.org/2000/svg" y="0" aria-hidden="true"><polygon points="17.3 8.3 12 13.6 6.7 8.3 5.3 9.7 12 16.4 18.7 9.7 "></polygon></svg></button><div aria-hidden="true" class="sc-dlWCHZ kWacYr"><div class="sc-hHOBiw cndTNO"><div class="sc-eeDRCY sc-eBMEME gTGgei fbXBig"><p>Test Jungfraujoch system</p>
 </div><div tabindex="0" role="button"><div class="sc-kWtpeL gEncxT"><span>http://localhost:5232</span>/version</div></div></div></div></div></div></div></div></div><div class="sc-dExYaf gZbfaQ"></div></div></div>
       <script>
-      const __redoc_state = {"menu":{"activeItemIdx":-1},"spec":{"data":{"openapi":"3.0.3","info":{"title":"Jungfraujoch","description":"API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).\nJungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU.\nJungfraujoch uses FPGA boards to acquire data at high data rates.\n\n# License Clarification\n\nWhile this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply**\nwhen this file is used solely to generate OpenAPI clients or when implementing applications that\ninteract with the API. Generated client code and applications using this API definition are not\nsubject to the GPL license requirements and may be distributed under terms of your choosing.\n\nThis exception is similar in spirit to the Linux Kernel's approach to userspace API headers and\nthe GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that\nuser programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not\nderivative works of the kernel and are not subject to the terms of the GPL.\n\nThis exception is intended to allow wider use of this API specification without imposing GPL\nrequirements on applications that merely interact with the API, regardless of whether they\ncommunicate through network calls or other mechanisms.\n","version":"1.0.0-rc.171","contact":{"name":"Filip Leonarski (Paul Scherrer Institute)","email":"filip.leonarski@psi.ch"},"license":{"name":"GPL-3.0","url":"https://www.gnu.org/licenses/gpl-3.0.html"}},"servers":[{"url":"http://localhost:5232","description":"Test Jungfraujoch system"}],"components":{"parameters":{"binning":{"in":"query","name":"binning","required":false,"schema":{"default":1,"type":"integer"},"description":"Binning of frames for the plot (0 = default binning)"},"experimental_coord":{"in":"query","name":"experimental_coord","required":false,"schema":{"type":"boolean","default":false},"description":"If measurement has goniometer axis defined, plot X-axis will represent rotation angle\nIf measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value\nFor still measurement the number is ignored\n"},"azint_unit":{"in":"query","name":"azint_unit","required":false,"schema":{"type":"string","enum":["Q_recipA","d_A","two_theta_deg"],"default":"Q_recipA"},"description":"Unit used for azim int.\n"},"fill_value":{"in":"query","name":"fill","required":false,"schema":{"type":"number","format":"float"},"description":"Fill value for elements that were missed during data collection\n"},"plot_type":{"in":"query","name":"type","required":true,"description":"Type of requested plot","schema":{"type":"string","enum":["bkg_estimate","spindle_blind_fraction","azint","azint_1d","spot_count","spot_count_low_res","spot_count_indexed","spot_count_ice","indexing_rate","indexing_lattice_count","indexing_unit_cell_length","indexing_unit_cell_angle","profile_radius","mosaicity","b_factor","error_pixels","saturated_pixels","image_collection_efficiency","receiver_delay","receiver_free_send_buf","strong_pixels","roi_sum","roi_mean","roi_max_count","roi_pixels","roi_weighted_x","roi_weighted_y","packets_received","max_pixel_value","resolution_estimate","pixel_sum","processing_time","beam_center_x","beam_center_y","integrated_reflections","image_scale_factor","image_scale_cc","compression_ratio","ice_ring_score"]}},"roi":{"in":"query","name":"roi","required":false,"schema":{"type":"string","minLength":1},"description":"Name of ROI for which plot is requested"},"image_id":{"in":"query","name":"id","required":false,"schema":{"type":"integer","format":"int64","default":-1,"minimum":-2},"description":"Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer"},"saturation":{"in":"query","name":"saturation","required":false,"schema":{"type":"number","format":"float","minimum":-32767,"maximum":32767},"description":"Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used"},"background":{"in":"query","name":"background","required":false,"schema":{"type":"number","format":"float","default":0,"minimum":-32767,"maximum":32767},"description":"Background value to set contrast in the preview image"},"show_spots":{"in":"query","name":"show_spots","schema":{"type":"boolean","default":true},"description":"Show spot finding results on the image"},"show_predictions":{"in":"query","name":"show_predictions","schema":{"type":"boolean","default":false},"description":"Show Bragg spot predictions on the image (if available for the image)"},"show_beam_center":{"in":"query","name":"show_beam_center","schema":{"type":"boolean","default":true},"description":"Show beam center on the image"},"show_roi":{"in":"query","name":"show_roi","schema":{"type":"boolean","default":false},"description":"Show ROI areas on the image"},"jpeg_quality":{"in":"query","name":"jpeg_quality","description":"Quality of JPEG image (100 - highest; 0 - lowest)","schema":{"type":"integer","format":"int64","default":100,"minimum":0,"maximum":100}},"show_user_mask":{"in":"query","name":"show_user_mask","schema":{"type":"boolean","default":false},"description":"Show user mask"},"resolution_ring":{"in":"query","name":"show_res_ring","description":"Show resolution ring, provided in Angstrom","schema":{"type":"number","format":"float","default":0.1,"minimum":0.1,"maximum":100}},"resolution_estimate":{"in":"query","name":"show_res_est","description":"Show resolution estimation as a ring","schema":{"type":"boolean","default":false}},"color_scale":{"in":"query","name":"color","description":"Color scale for preview image","schema":{"type":"string","enum":["indigo","viridis","bw","wb","green","heat","magma","inferno"],"default":"indigo"}}},"schemas":{"grid_scan":{"description":"Definition of a grid scan. Combine it with a goniometer axis to state the angle the spindle\nstood at: send `goniometer` with `step` 0 and the `start` angle of the grid scan, and that\nangle is written per image into the NXmx sample transformation chain. Without one the\nspindle is recorded at 0, which says that nobody stated an angle rather than that the\nspindle stood at 0.\n","type":"object","required":["n_fast","step_x_um","step_y_um"],"properties":{"n_fast":{"type":"integer","format":"int64","minimum":1,"example":20,"description":"Number of elements in the fast direction"},"step_x_um":{"type":"number","format":"float","example":5,"description":"Step in grid along the fast direction. Can be negative. \nPositive number: left to right\nNegative number: right to left\n"},"step_y_um":{"type":"number","format":"float","example":-3,"description":"Step in grid along the slow direction. Can be negative. \nPositive number: top to bottom\nNegative number: bottom to top\n"},"vertical":{"type":"boolean","default":false,"description":"If disabled: fast direction = X, slow direction = Y\nIf enabled: fast direction = Y, slow direction = X\n"},"snake":{"type":"boolean","default":false,"description":"Flip fast direction for every second row\n"}}},"rotation_axis":{"description":"Definition of a crystal rotation axis","type":"object","required":["step","vector"],"properties":{"name":{"type":"string","default":"omega","minLength":1,"description":"Name of rotation axis (e.g., omega, phi)"},"step":{"type":"number","format":"float","example":0.1,"description":"Angle step (per image) in degrees. 0 for an axis that does not turn: the axis then\nrecords the angle the spindle stood at, which is how a grid scan or a set of stills\nstates its head position.\n"},"start":{"type":"number","format":"float","example":50,"description":"Start angle in degrees","default":0},"vector":{"type":"array","description":"Rotation axis","example":[1,0,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"helical_step_um":{"type":"array","description":"Translation (per image) for helical scan","example":[-5,-2,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"screening_wedge_deg":{"type":"number","format":"float","description":"Wedge angle value; used if rotation per image is smaller than increment between images (so particularly in screening)"}}},"indexing_algorithm":{"type":"string","description":"Selection of an indexing algorithm used by Jungfraujoch\n","enum":["FFBIDX","FFT","FFTW","Auto","None"],"default":"FFBIDX"},"geom_refinement_algorithm":{"type":"string","description":"Selection of an post-indexing least-square diffraction geometry refinement algorithm used by Jungfraujoch.\nBeamCenter - This option is refining both beam center and lattice (restricted to a chosen/detected Bravais lattice).\nOrientationOnly - This option is refining only orientation of the lattice.\nFlex - Tries all per-image refinements and keeps whichever indexes the most spots, letting the pipeline decide (the rugnux flex mode).\n","enum":["BeamCenter","OrientationOnly","Flex","None"]},"integration_model":{"type":"string","description":"Bragg spot integration model.\nProfileGaussian - profile fit with a measured-width Gaussian (Kabsch-style), the default; more\n  accurate intensities than box summation.\nProfileEmpirical - profile fit with a per-resolution-shell empirical profile learned from strong spots.\nBoxSum - classical uniform box summation minus a ring-mean background; the simpler, faster fallback.\n","enum":["ProfileGaussian","ProfileEmpirical","BoxSum"],"default":"ProfileGaussian"},"dataset_settings":{"type":"object","required":["beam_x_pxl","beam_y_pxl","detector_distance_mm","incident_energy_keV"],"properties":{"images_per_trigger":{"type":"integer","format":"int64","minimum":1,"default":1,"description":"For standard synchrotron data collection - this is number of images collected per one TTL trigger\nFor XFEL (pulsed source) - this number is ignored and set to 1\nFor storage cell mode - this number is ignored and set to number of storage cells\n"},"ntrigger":{"type":"integer","format":"int64","default":1,"minimum":1,"description":"Number of TTL trigger that the detector is expected to receive during data collection\n"},"image_time_us":{"type":"integer","format":"int64","minimum":0,"description":"Image time. \nIf not provided (or zero value) the frame time is assumed as default.\nFor JUNGFRAU image time must be multiple of frame time and max value is 256 * frame_time.            \nIn XFEL mode: summation happens for frames collected with multiple triggers.\nIgnored for storage cells and if raw data are saved.\n"},"beam_x_pxl":{"type":"number","format":"float","description":"/entry/detector/beam_center_x in NXmx\nBeam center in X direction [pixels]\n"},"beam_y_pxl":{"type":"number","format":"float","description":"/entry/detector/beam_center_y in NXmx\nBeam center in X direction [pixels]\n"},"detector_distance_mm":{"type":"number","format":"float","minimum":0,"description":"/entry/detector/distance in NXmx Detector distance [mm]"},"incident_energy_keV":{"type":"number","format":"float","minimum":0.001,"maximum":500,"description":"Used to calculate /entry/beam/incident_wavelength in NXmx\nIncident particle (photon, electron) energy in keV\n"},"file_prefix":{"type":"string","default":"","description":"Prefix for filenames. If left empty, no file will be saved."},"images_per_file":{"type":"integer","format":"int64","minimum":1,"description":"Number of images in a single HDF5 data file, taken literally when given.\nIf omitted, it is chosen from the acquisition: a rotation sweep of at most 20000 images\ngoes into a single data file, so the dataset stays readable by programs that follow only\nthe first data file of a legacy master; a grid scan is split on a whole number of fast-axis\nrows; anything else (stills, serial) uses 1000.\n"},"space_group_number":{"type":"integer","format":"int64","minimum":1,"maximum":230,"description":"Number of space group for the crystal. Currently used solely as metadata, not relevant for image processing done in Jungfraujoch."},"sample_name":{"type":"string","default":"","description":"/entry/sample/name in NXmx\nSample name\n"},"compression":{"type":"string","enum":["bslz4","bszstd","bszstd_rle","bszstd_rlehuf","none"],"default":"bslz4","description":"Compression type for the images transferred over ZeroMQ and saved to HDF5 file.\n"},"total_flux":{"type":"number","format":"float","description":"/entry/beam/total_flux in NXmx\nFlux incident on beam plane in photons per second. In other words this is the flux integrated over area. [photons/s]\n"},"transmission":{"type":"number","format":"float","minimum":0,"maximum":1,"description":"/entry/instrument/attenuator/attenuator_transmission\nTransmission of attenuator (filter) [no units]\n"},"beam_size_x_um":{"type":"number","format":"float","minimum":0,"description":"First element of /entry/instrument/beam/incident_beam_size in NXmx\nHorizontal size of the X-ray beam where it meets the sample - the FWHM of a focused beam,\nthe full width of a slit-defined one. [um]\n"},"beam_size_y_um":{"type":"number","format":"float","minimum":0,"description":"Second element of /entry/instrument/beam/incident_beam_size in NXmx\nVertical size of the X-ray beam where it meets the sample. [um]\n"},"goniometer":{"$ref":"#/components/schemas/rotation_axis"},"grid_scan":{"$ref":"#/components/schemas/grid_scan"},"header_appendix":{"description":"Header appendix, added as user_data/user to start ZeroMQ message (can be any valid JSON)\nIn general, it is not saved in HDF5 file.\n\nHowever, if values are placed in \"hdf5\" object, `jfjoch_writer` will write them in /entry/user of the HDF5 file. \nThis applies solely to string and number (double floating-point). No arrays/sub-objects is allowed.\nFor example {\"hdf5\": {\"val1\":1, \"val2\":\"xyz\"}}, will write /entry/user/val1 and /entry/user/val2.\n"},"image_appendix":{"description":"Image appendix, added as user_data to image ZeroMQ message (can be any valid JSON)\nNot saved in HDF5 file\n"},"data_reduction_factor_serialmx":{"type":"number","format":"float","default":1,"minimum":0,"maximum":1,"description":"Rate at which non-indexed images are accepted to be forwarded to writer. \nValue of 1.0 (default) means that all images are written.\nValues below zero mean that non-indexed images will be accepted with a given probability.\n"},"pixel_value_low_threshold":{"type":"integer","format":"int64","minimum":0,"description":"Set all counts lower than the value to zero. \nWhen the value is set, negative numbers other than error pixel value are always set to zero.\nSetting to zero is equivalent to turning the option off.\n"},"run_number":{"type":"integer","format":"int64","minimum":0,"description":"Number of run within an experimental session. \nTransferred over CBOR stream as \"series ID\", though not saved in HDF5 file.\nIt is highly recommended to keep this number unique for each data collection during experimental series.\nIf not provided, the number will be automatically incremented.\n"},"run_name":{"type":"string","description":"Unique ID of run.\nTransferred over CBOR stream as \"unique series ID\", though not saved in HDF5 file.\nIt is highly recommended to keep this name unique for each data collection during experimental series.\nIf not provided, the name will be automatically generated as number + colon + file_prefix.\n"},"experiment_group":{"type":"string","description":"Name of group owning the data (e.g. p-group or proposal number). \nTransferred over CBOR stream, though not saved in HDF5 file.\n"},"poisson_compression":{"type":"integer","format":"int64","minimum":0,"maximum":16,"description":"Enable lossy compression of pixel values that preserves Poisson statistics. \nRequires to provide a numerical factor SQ.\nPixel value P will be transformed to round(sqrt(P) * SQ), with rounding to the closest integer.\nCompression is turned off if the value is missing or it is set to zero.\n"},"write_nxmx_hdf5_master":{"type":"boolean","default":true,"description":"Write NXmx formatted HDF5 master file. Recommended to use for macromolecular crystallography experiments\nand to turn off for other experiments.\n"},"save_calibration":{"type":"boolean","description":"Forward image calibration (at the moment pedestal and pedestal RMS for JUNGFRAU) using the ZeroMQ stream to writer.\nIf parameter is not provided calibration will be saved only if more than 4 images are recorded.\n"},"polarization_factor":{"type":"number","description":"Polarization factor for integration; 1.0 is horizontal polarization; -1.0 is vertical polarization","format":"float","minimum":-1,"maximum":1},"ring_current_mA":{"type":"number","format":"float","description":"Ring current at the beginning of the data collection","minimum":0},"sample_temperature_K":{"type":"number","format":"float","description":"Sample temperature in Kelvin","minimum":0},"poni_rot1_rad":{"type":"number","description":"PONI angle rot1 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"poni_rot2_rad":{"type":"number","description":"PONI angle rot2 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"poni_rot3_rad":{"type":"number","description":"PONI angle rot3 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"unit_cell":{"$ref":"#/components/schemas/unit_cell"},"spot_finding":{"type":"boolean","description":"Enable spot finding and save spots","default":true},"smargon":{"type":"object","description":"Geometry of Smargon goniometer at SLS 2.0 / MX beamlines. \nAssuming that Smargon is used as static positioner and not moving during the scan, allowing to reconstruct geometry.\n","required":["phi_deg","chi_deg"],"properties":{"phi_deg":{"type":"number","format":"float","description":"Phi angle in degrees"},"chi_deg":{"type":"number","format":"float","description":"Chi angle in degrees"},"phi_axis":{"type":"array","description":"Phi rotation axis","default":[1,0,0],"example":[1,0,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"chi_axis":{"type":"array","description":"Chi rotation axis","default":[0,0,1],"example":[0,0,1],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3}}},"max_spot_count":{"type":"integer","minimum":10,"maximum":2000,"default":250,"description":"Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected"},"detect_ice_rings":{"type":"boolean","description":"Flag spots as ice rings and reduce their effect on indexing"},"async_start":{"type":"boolean","default":false,"description":"When set to true, `/start` will not wait for detector and Jungfraujoch to be ready for the measurement."},"xray_fluorescence_spectrum":{"type":"object","required":["energy_eV","data"],"properties":{"energy_eV":{"type":"array","items":{"type":"number","format":"float"},"description":"X-ray fluorescence scan energy for each measurement point"},"data":{"type":"array","items":{"type":"number","format":"float"},"description":"X-ray fluorescence scan result in arbitrary units; must be exactly the same length, as energy_eV"}}}}},"crystal_lattice":{"type":"array","items":{"type":"number","format":"float"},"minItems":9,"maxItems":9,"description":"Real-space crystal lattice 3D vectors in Angstrom.\nOrder is 1st vector (x,y,z), 2nd vector (x,y,z) and 3rd vector (x,y,z)\n"},"unit_cell":{"type":"object","description":"Unit cell parameters. Necessary to run indexing. Units of angstrom and degree","required":["a","b","c","alpha","beta","gamma"],"properties":{"a":{"type":"number","format":"float","example":37,"minimum":0},"b":{"type":"number","format":"float","example":37,"minimum":0},"c":{"type":"number","format":"float","example":78,"minimum":0},"alpha":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360},"beta":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360},"gamma":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360}}},"file_writer_format":{"type":"string","enum":["NXmxOnlyData","NXmxLegacy","NXmxVDS","NXmxIntegrated","CBF","TIFF","NoFileWritten"],"default":"NXmxVDS","description":"NoFileWritten - no files are written at all\nNXmxOnlyData - only data files are written, no master file\nNXmxLegacy - legacy format with soft links to data files in the master file; necessary for DECTRIS Albula 4.0 and DECTRIS Neggia\nNXmxVDS - newer format with virtual dataset linking data files in the master file, also includes better metadata handling\nNXmxIntegrated - single HDF5 per dataset\nCBF - DEPRECATED, no longer supported; kept for back compatibility only. Requests using this value are rejected. Only HDF5 formats are written.\nTIFF - DEPRECATED, no longer supported; kept for back compatibility only. Requests using this value are rejected. Only HDF5 formats are written.\n"},"file_writer_settings":{"type":"object","properties":{"overwrite":{"type":"boolean","default":false,"description":"Inform jfjoch_write to overwrite existing files. Otherwise files would be saved with .h5.{timestamp}.tmp suffix.\n"},"format":{"$ref":"#/components/schemas/file_writer_format"}}},"pixel_mask_statistics":{"type":"object","properties":{"user_mask":{"description":"Number of pixels masked using the user mask","type":"integer","format":"int64","minimum":0},"too_high_pedestal_rms":{"description":"Number of pixels with G0 pedestal RMS higher than provided threshold","type":"integer","format":"int64","minimum":0},"wrong_gain":{"description":"Number of pixels that show wrong gain level during the pedestal procedure","type":"integer","format":"int64","minimum":0}}},"image_buffer_status":{"type":"object","required":["image_numbers","total_slots","in_preparation_slots","in_sending_slots","available_slots","max_image_number","min_image_number"],"properties":{"min_image_number":{"type":"integer","format":"int64","minimum":0,"description":"Smallest image number available in the buffer"},"max_image_number":{"type":"integer","format":"int64","minimum":0,"description":"Largest image number available in the buffer"},"image_numbers":{"type":"array","description":"Image numbers currently present in the buffer.","items":{"type":"integer","format":"int64"}},"total_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer. This number, compared to number of images in data collection and\nframe rate will determine \"retention\" rate of the image buffer.\n"},"available_slots":{"type":"integer","format":"int64","description":"Slots available for the data collection"},"in_preparation_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer that are currently in preparation for sending.\n"},"in_sending_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer that are currently sending/writing data.\n"},"current_counter":{"type":"integer","format":"int64","description":"Counter of changes in the image buffer - either new start message or new image added.\nFor optimization one can only load new images/datasets from the HTTP if this value changes.\nCounter is optional as it was not implemented in older versions to avoid breaking change\n"}}},"image_format_settings":{"type":"object","required":["summation","jungfrau_conversion","geometry_transform","mask_chip_edges","mask_module_edges","apply_mask"],"properties":{"summation":{"type":"boolean","description":"Enable summation of images to a given image_time\nIf disabled images are saved according to original detector speed, but image count is adjusted\n"},"geometry_transform":{"type":"boolean","description":"Place module read-out into their location on composed detector and extend multipixels\n"},"jungfrau_conversion":{"type":"boolean","description":"Convert pixel value in ADU to photon counts/energy\nOnly affects JUNGFRAU detector\n"},"jungfrau_conversion_factor_keV":{"type":"number","format":"float","minimum":0.001,"maximum":500,"description":"Used to convert energy deposited into pixel to counts\nIf not provided incident_energy_keV is used\n"},"bit_depth_image":{"type":"integer","format":"int64","enum":[8,16,32],"description":"Bit depth of resulting image (it doesn't affect the detector read-out value)\nIf not provided value is adjusted automatically\n"},"signed_output":{"type":"boolean","description":"Controls if pixels have signed output\nIf not provided value is adjusted automatically\n"},"mask_module_edges":{"type":"boolean","default":true,"description":"Mask 1 pixel on the module boundary\n"},"mask_chip_edges":{"type":"boolean","default":true,"description":"Mask multipixels on chip boundary\n"},"jungfrau_mask_pixels_without_g0":{"type":"boolean","default":true,"description":"JUNGFRAU: mask pixels that don't operate in G0, but do operate in G1 and G1.\nThis should be turned off for cases, where detector is operated at room temperature with long exposure time.\n"},"apply_mask":{"type":"boolean","default":false,"description":"Masked pixels are set to special value in the images produced by Jungfraujoch\n"},"jungfrau_pedestal_g0_rms_limit":{"type":"integer","format":"int64","default":100,"minimum":0,"description":"Pixels with pedestal G0 RMS above the threshold are marked as masked pixels"}}},"detector_power_state":{"type":"string","description":"Power on of ASICs","enum":["PowerOn","PowerOff","Partial"]},"detector_state":{"type":"string","description":"Current state of the detector","enum":["Idle","Waiting","Busy","Error","Not connected"]},"detector_status":{"type":"object","required":["state","powerchip","server_version","number_of_triggers_left","fpga_temp_degC","high_voltage_V"],"properties":{"state":{"$ref":"#/components/schemas/detector_state"},"powerchip":{"$ref":"#/components/schemas/detector_power_state"},"server_version":{"type":"string","description":"Detector server (on read-out boards) version"},"number_of_triggers_left":{"type":"integer","format":"int64","description":"Remaining triggers to the detector (max of all modules)"},"fpga_temp_degC":{"type":"array","description":"Temperature of detector FPGAs","items":{"type":"integer","format":"int64"}},"high_voltage_V":{"type":"array","description":"High voltage for detector modules","items":{"type":"integer","format":"int64"}}}},"detector_timing":{"type":"string","enum":["auto","trigger","burst","gated"],"default":"trigger"},"detector_settings":{"type":"object","required":["frame_time_us"],"properties":{"frame_time_us":{"type":"integer","description":"Interval between consecutive frames.\nThis is internal frame time for the JUNGFRAU detector, image time has to be integer multiply of this number.\nFor EIGER detector this is default frame time, not used otherwise\n","format":"int64","minimum":1},"count_time_us":{"type":"integer","description":"Integration time of the detector. \nIf not provided count time will be set to maximum value for a given frame time.\n","format":"int64"},"internal_frame_generator":{"type":"boolean","default":false,"description":"Use internal frame generator in FPGA instead of getting data from a real detector"},"internal_frame_generator_images":{"type":"integer","format":"int64","default":1,"minimum":1,"maximum":64,"description":"Number of images stored in the internal frame generator."},"detector_trigger_delay_ns":{"type":"integer","format":"int64","minimum":0,"default":0,"description":"Delay between TTL trigger and acquisition start [ns]"},"timing":{"$ref":"#/components/schemas/detector_timing"},"eiger_threshold_keV":{"type":"number","format":"float","minimum":1,"maximum":100,"description":"Threshold for the PSI EIGER detector and all DECTRIS detectors.\nIf value is provided, it will be used for all subsequent acquisitions, irrespective of beam energy.\nIf value is not provided, threshold will be determined on start of acquisition as half of incident energy. \nThis might lead to increased start time.\n"},"eiger_bit_depth":{"type":"integer","format":"int64","enum":[8,16,32],"description":"Bit depth of PSI EIGER read-out. This is  \nIf value is not provided, depth will be determined based on the image time:\n* Exposure time < 500 microseconds depth of 8 bit will be used,\n* 500 <= exposure time < 2622 microseconds depth of 16 bit will be used\n* Exposure time >= 2622 microseconds depth of 32 bit will be used.\n"},"jungfrau_pedestal_g0_frames":{"type":"integer","format":"int64","default":2000,"minimum":0},"jungfrau_pedestal_g1_frames":{"type":"integer","format":"int64","default":300,"minimum":0},"jungfrau_pedestal_g2_frames":{"type":"integer","format":"int64","default":300,"minimum":0},"jungfrau_pedestal_min_image_count":{"type":"integer","format":"int64","default":128,"minimum":32,"description":"Minimum number of collected images for pedestal to consider it viable"},"jungfrau_storage_cell_count":{"type":"integer","format":"int64","default":1,"minimum":1,"maximum":16},"jungfrau_storage_cell_delay_ns":{"type":"integer","format":"int64","minimum":2100,"default":5000,"description":"Delay between two storage cells [ns]"},"jungfrau_fixed_gain_g1":{"type":"boolean","default":false,"description":"Fix gain to G1 (can be useful for storage cells)"},"jungfrau_use_gain_hg0":{"type":"boolean","default":false,"description":"Use high G0 (for low energy applications)"}}},"spot_finding_settings":{"type":"object","required":["enable","indexing","signal_to_noise_threshold","photon_count_threshold","max_pix_per_spot","min_pix_per_spot","quick_integration","high_resolution_limit_for_spot_count_low_res","ice_ring_width_q_recipA"],"properties":{"enable":{"type":"boolean","default":true,"description":"Enable spot finding. This is temporary setting, i.e. can be changed anytime during data collection. \nEven if disabled spot finding information will still be send and written, though always with zero spots.\n"},"indexing":{"type":"boolean","default":true,"description":"Enable indexing. This is temporary setting, i.e. can be changed anytime during data collection.\n"},"signal_to_noise_threshold":{"type":"number","format":"float","minimum":0},"photon_count_threshold":{"type":"integer","format":"int64","minimum":0},"min_pix_per_spot":{"type":"integer","format":"int64","minimum":1},"max_pix_per_spot":{"type":"integer","format":"int64","minimum":1},"high_resolution_limit":{"type":"number","format":"float","description":"High resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding extends\nas far as the detector reaches, i.e. the detection is not clipped in resolution.\n"},"low_resolution_limit":{"type":"number","format":"float","description":"Low resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding is not\nclipped at the low-resolution end. A value of 0 is accepted and means the same thing.\n"},"high_resolution_limit_for_spot_count_low_res":{"type":"number","format":"float","description":"High resolution threshold to consider spot \"low resolution\" [Angstrom]","minimum":2,"maximum":8},"quick_integration":{"type":"boolean","default":false,"description":"Quick integration of Bragg spots in diffraction images.\nIf enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate.\n(experimental feature)\n"},"ice_ring_width_q_recipA":{"type":"number","format":"float","minimum":0,"maximum":1,"default":0.03,"description":"Half-width of the ice ring band in q (1/A). Matches the offline default in image_analysis/spot_finding/SpotFindingSettings.h, which was set from a measured ring FWHM of ~0.06; the two must agree or the same data gets a narrower ice band online."},"high_res_gap_Q_recipA":{"type":"number","format":"float","minimum":0.1,"maximum":5,"default":1.5,"description":"This parameter is used to remove spurious spots at a very high resolution, that sometimes appear due to very low background close to the edge of the detector.\nIf there is a gap in (1/d)-space between spots of at least this size, spots on the side of the gap with high resolution will be discarded. This is optional parameter.\nThis option should be turned OFF for small molecule datasets or for crystals with very low mosaicity, when it is expected to see only few spots in any case.\n"},"adaptive_threshold":{"type":"boolean","default":false,"description":"Self-calibrating spot detection: replace the fixed photon_count_threshold by a per-resolution-ring\nthreshold derived from each image's own noise, so the same setting works across datasets without\nper-dataset tuning. photon_count_threshold is then ignored and false_pixels_per_frame sets the\noperating point instead.\nOnly available on detectors whose images are analysed in software (the DECTRIS/SIMPLON workflow).\nThe JUNGFRAU and EIGER workflows find spots on the FPGA, which applies its own fixed threshold,\nso enabling this there is rejected rather than silently ignored.\n"},"false_pixels_per_frame":{"type":"number","format":"float","minimum":1,"maximum":100000,"default":100,"description":"Operating point of the adaptive threshold: the number of noise pixels tolerated per frame.\nAbout 100 suits a multi-megapixel detector. Ignored unless adaptive_threshold is set.\n"}}},"azim_int_settings":{"type":"object","required":["solid_angle_corr","polarization_corr","low_q_recipA","q_spacing"],"properties":{"polarization_corr":{"type":"boolean","description":"Apply polarization correction for azimuthal integration (polarization factor must be configured in dataset settings)","default":true},"solid_angle_corr":{"type":"boolean","description":"Apply solid angle correction for azimuthal integration","default":true},"high_q_recipA":{"type":"number","minimum":0.00002,"maximum":10,"format":"float","description":"Upper q limit of the azimuthal integration [1/Angstrom]. Optional: if omitted, the integration\n(and the adaptive spot detection that shares these q bins) extends to the highest q the\ndetector reaches.\n"},"low_q_recipA":{"type":"number","format":"float","minimum":0.00001,"maximum":10},"q_spacing":{"type":"number","format":"float","minimum":0.00001},"azimuthal_bins":{"type":"integer","format":"int64","minimum":1,"maximum":512,"default":1,"description":"Numer of azimuthal (phi) bins; 1 = standard 1D azimuthal integration"},"force_cpu":{"type":"boolean","default":false,"description":"Force CPU processing of azimuthal integration in the FPGA data acquisition workflow.\nThis allows to extend number of azimuthal integration bins, as well as to calculate standard deviation\nof the azimuthal integration results.\n"}}},"detector_list_element":{"type":"object","required":["id","nmodules","description","width","height","serial_number","base_ipv4_addr","udp_interface_count","readout_time_ns","min_frame_time_ns","min_count_time_ns"],"properties":{"id":{"type":"integer","format":"int64","minimum":0},"description":{"type":"string","example":"JUNGFRAU 4 Mpixel"},"serial_number":{"type":"string","example":"JF17T16V01"},"base_ipv4_addr":{"type":"string","example":"10.10.10.1"},"udp_interface_count":{"type":"integer","format":"int64","example":2,"description":"Number of UDP interfaces per detector module"},"nmodules":{"type":"integer","format":"int64","example":18},"width":{"type":"integer","format":"int64","example":2068},"height":{"type":"integer","format":"int64","example":2164},"pixel_size_mm":{"type":"number","format":"float","example":0.075},"readout_time_ns":{"type":"integer","format":"int64"},"min_frame_time_ns":{"type":"integer","format":"int64"},"min_count_time_ns":{"type":"integer","format":"int64"},"type":{"$ref":"#/components/schemas/detector_type"}}},"detector_list":{"type":"object","required":["detectors","current_id"],"properties":{"detectors":{"type":"array","items":{"$ref":"#/components/schemas/detector_list_element"}},"current_id":{"type":"integer","format":"int64","example":0}}},"detector_selection":{"type":"object","required":["id"],"properties":{"id":{"type":"integer","format":"int64","example":1}}},"measurement_statistics":{"type":"object","properties":{"file_prefix":{"type":"string"},"run_number":{"type":"integer","format":"int64","description":"Number of data collection run. This can be either automatically incremented or provided externally for each data collection.\n"},"experiment_group":{"type":"string","description":"Name of group owning the data (e.g. p-group or proposal number).\n"},"images_expected":{"type":"integer","format":"int64"},"images_collected":{"type":"integer","format":"int64","description":"Images collected by the receiver. This number will be lower than images expected if there were issues with data collection performance.\n"},"images_sent":{"type":"integer","format":"int64","description":"Images sent to the writer. \nThe value does not include images discarded by lossy compression filter and images not forwarded due to full ZeroMQ queue.\n"},"images_written":{"type":"integer","format":"int64","description":"Images successfully written to disk.\nThe value is live updated for TCP/IP socket and direct HDF5 writer, while for ZeroMQ it is only updated at the end of experiment.\n"},"images_discarded_lossy_compression":{"type":"integer","format":"int64","description":"Images discarded by the lossy compression filter"},"max_image_number_sent":{"type":"integer","format":"int64"},"collection_efficiency":{"type":"number","format":"float","example":1,"minimum":0,"maximum":1},"compression_ratio":{"type":"number","format":"float","example":5.3,"minimum":0},"cancelled":{"type":"boolean"},"max_receiver_delay":{"type":"integer","format":"int64"},"indexing_rate":{"type":"number","format":"float"},"detector_width":{"type":"integer","format":"int64"},"detector_height":{"type":"integer","format":"int64"},"detector_pixel_depth":{"type":"integer","format":"int64","enum":[2,4]},"bkg_estimate":{"type":"number","format":"float"},"unit_cell":{"type":"string"},"error_pixels":{"type":"number","format":"float","description":"Moving average of 1000 images counting number of error pixels on the detector"},"saturated_pixels":{"type":"number","format":"float","description":"Moving average of 1000 images counting number of saturated pixels on the detector"},"roi_beam_pixels":{"type":"number","format":"float","description":"If there is an ROI defined with name \"beam\", this number will hold moving average of 1000 images\nfor number of valid pixels within this ROI\n"},"roi_beam_sum":{"type":"number","format":"float","description":"If there is an ROI defined with name \"beam\", this number will hold moving average of 1000 images\nfor sum of valid pixels within this ROI\n"}}},"fpga_status":{"type":"array","items":{"type":"object","required":["pci_dev_id","serial_number","base_mac_addr","eth_link_status","eth_link_count","eth_link_speed","power_usage_W","fpga_temp_C","hbm_temp_C","packets_sls","packets_udp","idle","fw_version","pcie_link_speed","pcie_link_width"],"properties":{"pci_dev_id":{"type":"string"},"serial_number":{"type":"string"},"fw_version":{"type":"string"},"base_mac_addr":{"type":"string"},"eth_link_count":{"type":"integer","format":"int64"},"eth_link_status":{"type":"integer","format":"int64"},"power_usage_W":{"type":"number","format":"float"},"fpga_temp_C":{"type":"number","format":"float"},"hbm_temp_C":{"type":"number","format":"float"},"packets_udp":{"type":"integer","format":"int64"},"packets_sls":{"type":"integer","format":"int64"},"idle":{"type":"boolean"},"pcie_link_speed":{"type":"integer","format":"int64","description":"PCIe link speed measured by generation (expected value is 4 == PCIe Gen4)"},"pcie_link_width":{"type":"integer","format":"int64","description":"PCIe link width (expected value is 8 == x8)"}}}},"broker_status":{"type":"object","required":["state"],"properties":{"state":{"type":"string","enum":["Inactive","Idle","Busy","Measuring","Pedestal","Error"]},"progress":{"type":"number","format":"float","description":"Progress of data collection (only available if receiving is running)","example":1,"minimum":0,"maximum":1},"message":{"type":"string","description":"Message to display besides state of the jfjoch_broker; mostly used for errors and warnings\nThis matters especially for async functions (start/initialize), where API won't return reason\nfor the error during async operation.\n"},"message_severity":{"type":"string","enum":["success","info","warning","error"],"default":"error","description":"Level of the message to display"},"gpu_count":{"type":"integer","format":"int32","description":"Number of installed GPUs"},"broker_version":{"type":"string","description":"Version of the jfjoch_broker","example":"1.0.0-rc.128"}}},"image_pusher_status":{"type":"object","required":["pusher_type","addr","connected_writers"],"description":"Informs about status of the image pusher.\n","properties":{"pusher_type":{"$ref":"#/components/schemas/image_pusher_type"},"addr":{"type":"array","items":{"type":"string"},"example":["tcp://1.2.3.4:5000","tcp://1.2.3.4:5001"],"description":"List of addresses of image pushers.\nFor HDF5 socket - no addresses will be returned.\nFor ZeroMQ - list of addresses for each socket will be provided.\nFor TCP/IP - single address to connect all writers will be provided.\n"},"connected_writers":{"type":"integer","format":"int64","minimum":0,"description":"Number of connected writers \nFor ZeroMQ image socket: number is constant\nFor TCP/IP image socket: number is updated live during operation\n"},"images_written":{"type":"integer","format":"int64","minimum":0,"description":"Number of images written to the image socket.\nThis number is updated live during operation for TCP/IP image socket and direct HDF5 writer.\nIt is updated at the end of experiment for ZeroMQ image socket.\n"},"images_write_error":{"type":"integer","format":"int64","minimum":0,"description":"Number of images that could not be written to the image socket.\nThis number is updated live during operation for TCP/IP image socket.\nNo other socket use it.\n"},"writer_fifo_utilization":{"type":"array","items":{"type":"integer","format":"int64","minimum":0},"description":"Utilization of internal writer FIFO.\nThis number is updated live during operation for TCP/IP image socket.\nNo other socket use it.\n"}}},"plot":{"type":"object","required":["x","y","title"],"description":"x and y coordinates for plotting, it is OK to assume that both arrays have the same size; layout is optimized for Plotly","properties":{"title":{"type":"string","default":""},"x":{"type":"array","items":{"type":"number","format":"float"}},"y":{"type":"array","items":{"type":"number","format":"float","nullable":true}},"z":{"type":"array","items":{"type":"number","format":"float","nullable":true}}}},"plot_unit_x":{"type":"string","enum":["image_number","q_recipA","d_A","angle_deg","ADU","grid_um"],"default":"image_number"},"plots":{"type":"object","required":["plot","unit_x"],"properties":{"title":{"type":"string"},"unit_x":{"$ref":"#/components/schemas/plot_unit_x"},"size_x":{"type":"number","format":"float","description":"Max X range of the plot"},"size_y":{"type":"number","format":"float","description":"Max Y range of the plot"},"plot":{"type":"array","items":{"$ref":"#/components/schemas/plot"}}}},"scan_result":{"type":"object","description":"Results of a scan","required":["images"],"properties":{"file_prefix":{"type":"string"},"rotation_unit_cell":{"$ref":"#/components/schemas/unit_cell"},"rotation_crystal_lattice":{"$ref":"#/components/schemas/crystal_lattice"},"rotation_bravais":{"type":"string","description":"Bravais lattice type of the global rotation-indexing solution: crystal-system\nletter + centering, e.g. \"tP\", \"oC\", \"cF\", \"hR\", \"mP\". Empty if not determined.\n"},"images":{"type":"array","items":{"type":"object","required":["efficiency","number"],"properties":{"efficiency":{"type":"number","format":"float"},"number":{"type":"integer","format":"int64","description":"Detector image number for a given cell"},"nx":{"type":"integer","format":"int64","description":"Cell position in X for grid scan"},"ny":{"type":"integer","format":"int64","description":"Cell position in Y for grid scan"},"angle":{"type":"number","format":"float","description":"Rotation angle associated with the image"},"bkg":{"type":"number","format":"float","description":"Background estimate"},"spindle_blind":{"type":"number","format":"float","description":"Fraction (0-1) of a rotation sweep's blind double cone that this orientation makes unrecoverable, assuming the nearest plausible lattice row is a lone 2-fold (a worst-case bound, not an estimate). At 0.5 and above a recovery protocol (second sweep, reorientation) should engage. Absent means the frame could not be assessed, which automation must treat the same as above threshold - it is not a zero.\n"},"spots":{"type":"integer","format":"int64","description":"Spot count"},"spots_low_res":{"type":"integer","format":"int64","description":"Spot count in low resolution range"},"spots_indexed":{"type":"integer","format":"int64","description":"Spot count within indexing tolerance"},"spots_ice":{"type":"integer","format":"int64","description":"Spot count within common ice ring resolutions"},"ice":{"type":"number","format":"float","description":"Strongest hexagonal-ice ring intensity over the smooth radial background (1 = no ice)"},"index":{"type":"integer","format":"int64","description":"Indexing solution"},"latt_count":{"type":"integer","format":"int64","description":"Indexing lattice count"},"pr":{"type":"number","format":"float","description":"Profile radius, i.e. how far reflections are from the Ewald sphere"},"b":{"type":"number","format":"float","description":"B-Factor estimate"},"uc":{"$ref":"#/components/schemas/unit_cell"},"xfel_pulseid":{"type":"integer","format":"int64","description":"XFEL pulse ID"},"pixel_sum":{"type":"integer","format":"int64","description":"Total sum of all pixels"},"max":{"type":"integer","format":"int64","description":"Max viable pixel"},"sat":{"type":"integer","format":"int64","description":"Number of saturated pixels"},"err":{"type":"integer","format":"int64","description":"Number of error pixels"},"res":{"type":"number","format":"float","description":"Diffraction resolution estimate"}}}}}},"powder_calibration_fit_sigma":{"type":"object","description":"What the powder ring fit knows about its own answer, from the covariance of the converged\nproblem. Each sigma is in its parameter's own unit and is scaled by the residual scatter of\nthat fit, so it is the usual \"how far could this move before the fit got visibly worse\".\nThe two correlations are the ones that matter: a tilt and a beam-centre shift both displace a\nring's radius as cos(phi) and are told apart only by how that amplitude grows with the ring's\nradius, so as the rings run out the pair stops being separable and these approach 1.\nThe rotation sigmas and the correlations are absent when the tilt was not a free parameter.\n","properties":{"beam_x_pxl":{"type":"number","format":"float","description":"Standard error of the fitted PONI x [pixels]"},"beam_y_pxl":{"type":"number","format":"float","description":"Standard error of the fitted PONI y [pixels]"},"detector_distance_mm":{"type":"number","format":"float","description":"Standard error of the fitted detector distance [mm]"},"poni_rot1_rad":{"type":"number","format":"float","description":"Standard error of the fitted rot1 [rad]"},"poni_rot2_rad":{"type":"number","format":"float","description":"Standard error of the fitted rot2 [rad]"},"correlation_beam_x_rot1":{"type":"number","format":"float","description":"Correlation between the fitted PONI x and rot1, -1 to 1"},"correlation_beam_y_rot2":{"type":"number","format":"float","description":"Correlation between the fitted PONI y and rot2, -1 to 1"}}},"powder_calibration_spot_check":{"type":"object","description":"Where the circle through the found spots puts the beam, and how far that is from the geometry\nactually fitted. An independent cross-check: it reads nothing from the file's own geometry, so\nit holds where the summed azimuthal profile does not - a profile binned about a badly wrong\ncentre shows each ring smeared across its sectors, and a fit on it converges on the wrong\nanswer without saying so. Two methods sharing no assumption, so the disagreement is the\nstatement. Absent when no spots were available.\n","properties":{"beam_x_pxl":{"type":"number","format":"float","description":"Beam centre x the spots vote for [pixels]"},"beam_y_pxl":{"type":"number","format":"float","description":"Beam centre y the spots vote for [pixels]"},"detector_distance_mm":{"type":"number","format":"float","description":"Detector distance the spots imply [mm]"},"disagreement_pxl":{"type":"number","format":"float","description":"Distance between the spots' beam centre and the fitted one [pixels]"}}},"powder_calibration_quality":{"type":"object","description":"What a powder calibration knows about the geometry it produced. A calibration that has gone\nwrong - the wrong standard named, a header too far out for the rings to be found - looks\nexactly like one that has not until these are read.\n","properties":{"converged":{"type":"boolean","description":"Whether the geometry beside this is a measurement of the data at all. False means at least\none of its parameters was carried over from the input file rather than fitted - which looks\nexactly like a good fit in every other field here - and see not_converged_reason for which.\nrugnux --mode calibration writes no .poni file in that case, a PONI file having no field in\nwhich to say it, and exits non-zero.\n"},"not_converged_reason":{"type":"string","description":"What made converged false, in words. Absent when the calibration converged."},"calibrant":{"type":"string","description":"The powder standard the rings were fitted to, or the unit cell given in its place"},"method":{"type":"string","description":"How the rings were measured. rings fits the arcs of the run-summed (q x azimuth) azimuthal\nprofile; spots fits the pooled per-image spot lists.\n","enum":["rings","spots"]},"ring_points":{"type":"integer","format":"int64","description":"Ring measurements the fit used"},"rms_radial_pxl":{"type":"number","format":"float","description":"Scatter of those measurements about the fitted rings, as a radial distance [pixels]. The\nsingle number that separates a calibration that worked from one that did not.\n"},"beam_sigma_pxl":{"type":"number","format":"float","description":"Standard error the scatter implies on the beam centre [pixels], for a ring of that many\npoints. See powder_calibration_fit_sigma for what the fit itself says, which is not the same and\nis the larger of the two whenever the tilt is poorly separated.\n"},"direct_beam_x_pxl":{"type":"number","format":"float","description":"Where the direct beam lands [pixels]. NOT dataset_settings.beam_x_pxl, which is the PONI:\nthe two part company by distance*tan(tilt)/pixel as soon as the detector is tilted.\n"},"direct_beam_y_pxl":{"type":"number","format":"float","description":"Where the direct beam lands, y [pixels]"},"header_distance_mm":{"type":"number","format":"float","description":"The detector distance the input file declared, for comparison [mm]"},"ring_seed_distance_mm":{"type":"number","format":"float","description":"The distance measured from the ring radii before the fit ran [mm]. It is taken from the\nradii, the wavelength and the pixel size alone, so a large gap from header_distance_mm is\nthe answer to the question the calibration was run to ask. Absent when the profile showed\ntoo few rings to fix a scale.\n"},"tilt_refined":{"type":"boolean","description":"Whether the reported rot1/rot2 were measured by this fit. False means they were declined\nand pinned at the input file's values, because the rings could not separate a tilt from a\nshift of the beam centre.\n"},"tilt_significance":{"type":"number","format":"float","description":"How many of its own sigmas the fitted tilt stands from zero. Below about 3 it is not a\nmeasurement of a tilt but of a beam-centre shift, and the tilt is declined. Passing does\nnot certify a tilt: that estimator is limited by systematics rather than by this sigma.\n"},"fit_sigma":{"$ref":"#/components/schemas/powder_calibration_fit_sigma"},"spot_cross_check":{"$ref":"#/components/schemas/powder_calibration_spot_check"}}},"powder_calibration_output":{"type":"object","required":["dataset_settings"],"description":"The result of a powder-ring detector calibration - what rugnux --mode calibration writes as\n<prefix>.json, and what a calibration run over the image buffer would return.\n\ndataset_settings holds the geometry and nothing else, under the property names this API gives\nthem, so it can be POSTed or merged without translating a field. Its beam_x_pxl/beam_y_pxl is\nthe PONI, the foot of the perpendicular from the sample; where the beam actually lands is\ncalibration.direct_beam_x_pxl. The poni_rot*_rad are present whenever any of them is non-zero\nand absent when all are zero, since a body omitting them states a FLAT detector rather than an\nunstated one.\n","properties":{"dataset_settings":{"$ref":"#/components/schemas/dataset_settings"},"calibration":{"$ref":"#/components/schemas/powder_calibration_quality"},"jfjoch_version":{"type":"string","description":"Version of the program that produced this"}}},"calibration_statistics":{"type":"array","items":{"required":["module_number","storage_cell_number","pedestal_g0_mean","pedestal_g1_mean","pedestal_g2_mean","gain_g0_mean","gain_g1_mean","gain_g2_mean","masked_pixels"],"type":"object","properties":{"module_number":{"type":"integer","format":"int64"},"storage_cell_number":{"type":"integer","format":"int64"},"pedestal_g0_mean":{"type":"number","format":"float"},"pedestal_g1_mean":{"type":"number","format":"float"},"pedestal_g2_mean":{"type":"number","format":"float"},"gain_g0_mean":{"type":"number","format":"float"},"gain_g1_mean":{"type":"number","format":"float"},"gain_g2_mean":{"type":"number","format":"float"},"masked_pixels":{"type":"integer","format":"int64"}}}},"jfjoch_statistics":{"type":"object","description":"Pool statistics for Jungfraujoch to reduce transfers between frontend and jfjoch_broker","properties":{"detector":{"$ref":"#/components/schemas/detector_status"},"detector_list":{"$ref":"#/components/schemas/detector_list"},"detector_settings":{"$ref":"#/components/schemas/detector_settings"},"image_format_settings":{"$ref":"#/components/schemas/image_format_settings"},"instrument_metadata":{"$ref":"#/components/schemas/instrument_metadata"},"file_writer_settings":{"$ref":"#/components/schemas/file_writer_settings"},"data_processing_settings":{"$ref":"#/components/schemas/spot_finding_settings"},"measurement":{"$ref":"#/components/schemas/measurement_statistics"},"broker":{"$ref":"#/components/schemas/broker_status"},"fpga":{"$ref":"#/components/schemas/fpga_status"},"calibration":{"$ref":"#/components/schemas/calibration_statistics"},"zeromq_preview":{"$ref":"#/components/schemas/zeromq_preview_settings"},"zeromq_metadata":{"$ref":"#/components/schemas/zeromq_metadata_settings"},"dark_mask":{"$ref":"#/components/schemas/dark_mask_settings"},"pixel_mask":{"$ref":"#/components/schemas/pixel_mask_statistics"},"roi":{"$ref":"#/components/schemas/roi_definitions"},"az_int":{"$ref":"#/components/schemas/azim_int_settings"},"buffer":{"$ref":"#/components/schemas/image_buffer_status"},"indexing":{"$ref":"#/components/schemas/indexing_settings"},"bragg_integration":{"$ref":"#/components/schemas/bragg_integration_settings"},"image_pusher":{"$ref":"#/components/schemas/image_pusher_status"}}},"error_message":{"type":"object","required":["msg","reason"],"properties":{"msg":{"type":"string","description":"Human readable message","example":"Detector in wrong state"},"reason":{"type":"string","description":"Enumerate field for automated analysis","enum":["WrongDAQState","Other"]}}},"roi_azimuthal":{"type":"object","description":"ROI as Q-range (or resolution range), optionally restricted to an azimuthal-angle sector","required":["name","q_min_recipA","q_max_recipA"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"q_min_recipA":{"type":"number","format":"float","minimum":0.00001,"description":"Minimum Q-range for the ROI"},"q_max_recipA":{"type":"number","format":"float","minimum":0.00001,"description":"Maximum Q-range for the ROI"},"phi_min_deg":{"type":"number","format":"float","description":"Lower azimuthal-angle bound of the sector [degrees]. Optional: provide both phi_min_deg and phi_max_deg to restrict the ROI to an angular sector, or omit both for a full ring. A sector with phi_min_deg > phi_max_deg wraps across 0.\n"},"phi_max_deg":{"type":"number","format":"float","description":"Upper azimuthal-angle bound of the sector [degrees]. Optional; see phi_min_deg.\n"}}},"roi_circle":{"type":"object","description":"Circular ROI","required":["name","center_x_pxl","center_y_pxl","radius_pxl"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"center_x_pxl":{"type":"number","format":"float","description":"X coordinate of center of the circle [pixels]"},"center_y_pxl":{"type":"number","format":"float","description":"Y coordinate of center of the circle [pixels]"},"radius_pxl":{"type":"number","format":"float","minimum":0,"exclusiveMinimum":true,"description":"Radius of the circle [pixels]"}}},"roi_box":{"type":"object","description":"Box ROI","required":["name","min_x_pxl","max_x_pxl","min_y_pxl","max_y_pxl"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"min_x_pxl":{"type":"integer","format":"int64","description":"Lower bound (inclusive) in X coordinate for the box","minimum":0},"max_x_pxl":{"type":"integer","format":"int64","description":"Upper bound (inclusive) in X coordinate for the box","minimum":0},"min_y_pxl":{"type":"integer","format":"int64","description":"Lower bound (inclusive) in Y coordinate for the box","minimum":0},"max_y_pxl":{"type":"integer","format":"int64","description":"Upper bound (inclusive) in Y coordinate for the box","minimum":0}}},"roi_circle_list":{"type":"object","description":"List of circular ROIs","required":["rois"],"properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_circle"}}}},"roi_box_list":{"type":"object","description":"List of box ROIs","properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_box"}}}},"roi_azim_list":{"type":"object","description":"List of azimuthal ROIs","properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_azimuthal"}}}},"roi_definitions":{"type":"object","required":["box","circle","azim"],"description":"ROI defintions","properties":{"box":{"$ref":"#/components/schemas/roi_box_list"},"circle":{"$ref":"#/components/schemas/roi_circle_list"},"azim":{"$ref":"#/components/schemas/roi_azim_list"}}},"dark_mask_settings":{"type":"object","description":"Settings for collection of dark images to be used for mask calculation","required":["detector_threshold_keV","frame_threshold_keV","max_allowed_pixel_count","max_frames_with_signal","frame_time_us","number_of_frames"],"properties":{"detector_threshold_keV":{"type":"number","format":"float","description":"Energy threshold for dark image collection","minimum":2.5,"default":3.5,"maximum":100},"frame_time_us":{"type":"integer","format":"int64","description":"Time between frames for dark image collection","minimum":500,"default":10000,"maximum":100000},"number_of_frames":{"type":"integer","format":"int64","description":"Number of frames for dark image collection; zero means no dark collection","minimum":0,"default":1000},"max_allowed_pixel_count":{"type":"integer","format":"int64","description":"Maximum count in a pixel considered normal (not-masked)","minimum":0,"default":1},"max_frames_with_signal":{"type":"integer","format":"int64","description":"Maximum number of frames with signal in a pixel considered normal (not-masked)","minimum":0,"default":10}}},"indexing_settings":{"type":"object","description":"Settings for crystallography indexing","required":["algorithm","geom_refinement_algorithm","fft_high_resolution_A","fft_max_unit_cell_A","fft_min_unit_cell_A","fft_num_vectors","tolerance","thread_count","unit_cell_dist_tolerance","index_ice_rings","viable_cell_min_spots","rotation_indexing","rotation_indexing_min_angular_range_deg","rotation_indexing_angular_stride_deg","blocking"],"properties":{"algorithm":{"$ref":"#/components/schemas/indexing_algorithm"},"fft_max_unit_cell_A":{"type":"number","format":"float","default":250,"maximum":500,"minimum":50,"description":"Largest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT"},"fft_min_unit_cell_A":{"type":"number","format":"float","default":10,"minimum":5,"maximum":40,"description":"Smallest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT"},"fft_high_resolution_A":{"type":"number","format":"float","default":2,"minimum":0.5,"maximum":6,"description":"Sets how finely the FFT samples each search direction: it fixes the extent of the projection\nhistogram, and with it the transform size, so it affects execution time and memory of FFT.\nIt does NOT filter spots - every spot is projected whatever its resolution, so raising it\ndoes not make the transform see a coarser subset of the data.\nThere is also correlation between smallest unit cell and this value, which need to be checked for very small systems.\n"},"fft_num_vectors":{"type":"integer","format":"int64","minimum":128,"default":16384,"description":"Number of search directions for the FFT algorithm; parameter value affects execution time of FFT."},"tolerance":{"type":"number","format":"float","minimum":0,"maximum":0.5,"description":"Acceptance tolerance for spots after the indexing run - the larger the number, the more spots will be accepted"},"thread_count":{"type":"integer","format":"int64","minimum":1,"maximum":64,"description":"Thread count for indexing algorithm"},"geom_refinement_algorithm":{"$ref":"#/components/schemas/geom_refinement_algorithm"},"unit_cell_dist_tolerance":{"type":"number","format":"float","minimum":0.0001,"maximum":0.2001,"default":0.05,"description":"Relative distance tolerance for unit cell vs. reference; Lattices outside given tolerance will be ignored"},"viable_cell_min_spots":{"type":"integer","format":"int64","minimum":5,"default":10,"description":"Minimum number of indexed spots required for a cell to be considered viable"},"index_ice_rings":{"type":"boolean","default":false,"description":"Include spots marked as ice rings in the indexing run. \nIf `dataset_settings` doesn't have `detect_ice_rings` on, this option will have no effect on processing.\n"},"rotation_indexing":{"type":"boolean","default":false},"rotation_indexing_min_angular_range_deg":{"type":"number","format":"float","default":20,"minimum":1},"rotation_indexing_angular_stride_deg":{"type":"number","format":"float","default":0.5,"minimum":0},"blocking":{"type":"boolean","default":true,"description":"Indexing in Jungfraujoch goes with a dedicated thread pool.\nIf set to false, the thread pool is non-blocking, i.e. if there are no threads available, image indexing will be skipped. This option is recommended for real-time processing at high frame rates.\nIf set to true, the thread pool will block until a thread is available.\n"}}},"instrument_metadata":{"type":"object","description":"Metadata for a measurement instrument","required":["source_name","instrument_name"],"properties":{"source_name":{"type":"string","example":"Swiss Light Source"},"source_type":{"type":"string","description":"Type of radiation source. NXmx gives a fixed dictionary, though Jungfraujoch is not enforcing compliance. \nhttps://manual.nexusformat.org/classes/base_classes/NXsource.html#nxsource\nNXsource allows the following:\n\nSpallation Neutron Source\nPulsed Reactor Neutron Source\nReactor Neutron Source\nSynchrotron X-ray Source\nPulsed Muon Source\nRotating Anode X-ray\nFixed Tube X-ray\nUV Laser\nFree-Electron Laser\nOptical Laser\nIon Source\nUV Plasma Source\nMetal Jet X-ray\n","example":"Synchrotron X-ray Source","default":""},"instrument_name":{"type":"string","example":"CristallinaMX"},"pulsed_source":{"type":"boolean","description":"Settings specific to XFEL (e.g., every image has to come from TTL trigger, save pulse ID and event code)\n","default":false},"electron_source":{"type":"boolean","description":"Settings specific to electron source (e.g., wavelength definition)\n","default":false}}},"detector_module_direction":{"type":"string","enum":["Xp","Xn","Yp","Yn"]},"detector_type":{"type":"string","enum":["EIGER","JUNGFRAU","DECTRIS"]},"image_pusher_type":{"type":"string","default":"None","enum":["ZeroMQ","HDF5","CBOR","TCP","None"]},"standard_detector_geometry":{"type":"object","description":"Regular rectangular geometry, first module is in the bottom left corner of the detector","required":["nmodules"],"properties":{"nmodules":{"type":"integer","minimum":1,"description":"Number of modules in the detector"},"gap_x":{"type":"integer","default":8,"minimum":0,"description":"Gap size in X direction [pixels]"},"gap_y":{"type":"integer","minimum":0,"default":36,"description":"Gap size in Y direction [pixels]"},"modules_in_row":{"type":"integer","minimum":1,"default":1,"description":"Number of modules in one row"}}},"detector_module":{"type":"object","required":["x0","y0","fast_axis","slow_axis"],"properties":{"x0":{"type":"number"},"y0":{"type":"number"},"fast_axis":{"$ref":"#/components/schemas/detector_module_direction"},"slow_axis":{"$ref":"#/components/schemas/detector_module_direction"}}},"detector":{"type":"object","required":["description"],"properties":{"description":{"type":"string","minLength":1},"serial_number":{"type":"string","default":"Unknown","minLength":1},"type":{"$ref":"#/components/schemas/detector_type"},"high_voltage_V":{"type":"integer","format":"int64","minimum":0,"maximum":200,"default":0},"udp_interface_count":{"type":"integer","format":"int64","minimum":1,"maximum":2,"default":1},"module_sync":{"type":"boolean","default":true,"description":"Use module 0 as master for timing. Only applies to JUNGFRAU detector (this cannot be turned off for EIGER)."},"sensor_thickness_um":{"type":"number","format":"float","minimum":0,"default":320},"readout_time_ns":{"type":"integer","format":"int64","minimum":1,"description":"Minimum difference between frame time and count time in microseconds\nDefaults are 3'000 ns for EIGER and 20'000 ns for JUNGFRAU\n"},"min_count_time_ns":{"type":"integer","format":"int64","minimum":0,"description":"Minimum count time available for the detector."},"min_frame_time_ns":{"type":"integer","format":"int64","minimum":0,"description":"Minimum frame time available for the detector."},"calibration_file":{"type":"array","description":"Can be empty for all detectors - default calibration used.\nFor JUNGFRAU: list of gain files, one entry per module.\nFor EIGER: one directory (with detector settings) or list of trim bit files, one entry per half-module.\n","items":{"type":"string"}},"trim_energies_eV":{"type":"array","description":"List of energies at which trimming calibration is provided.\nOnly needed for PSI EIGER and compulsory in this case\n","items":{"type":"integer","format":"int32","minimum":100}},"hostname":{"type":"array","description":"Hostname for detector module. One entry per module\nOne entry per module. Either empty or number of module entries.\n","items":{"type":"string"}},"sensor_material":{"type":"string","default":"Si"},"tx_delay":{"type":"array","items":{"type":"integer","format":"int64"}},"base_data_ipv4_address":{"type":"string","example":"10.10.10.50"},"standard_geometry":{"$ref":"#/components/schemas/standard_detector_geometry"},"custom_geometry":{"type":"array","items":{"$ref":"#/components/schemas/detector_module"}},"roi_mode":{"type":"string","default":"","description":"ROI setting for DECTRIS detectors"},"mirror_y":{"type":"boolean","default":true,"description":"Mirror detector in Y direction to account for MX convention of (0,0) point in top left corner"},"temp_thresold_degC":{"type":"integer","format":"int64","description":"Temperature threshold for JUNGFRAU detector modules","minimum":40,"maximum":70,"default":55},"default_settings":{"$ref":"#/components/schemas/detector_settings"}}},"zeromq_settings":{"type":"object","description":"ZeroMQ configuration for Jungfraujoch software.\nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","properties":{"send_watermark":{"type":"integer","format":"int64","minimum":2,"maximum":16384,"default":100,"description":"Watermark for ZeroMQ send queue (number of outstanding messages queued on Jungfraujoch server per queue)"},"send_buffer_size":{"type":"integer","format":"int64","description":"Send buffer size for ZeroMQ socket"},"image_socket":{"type":"array","items":{"type":"string"},"example":["tcp://1.2.3.4:5000","tcp://1.2.3.4:5001"],"description":"PUSH ZeroMQ socket for images. In case multiple sockets are provided, images are streamed over multiple sockets.  \nImages are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tpc://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"},"writer_notification_socket":{"type":"string","example":"tcp://1.3.4.6:7000","description":"PULL ZeroMQ socket for notifications from writer that it finished operation. \nThis allows Jungfraujoch to operate in a synchronous manner, with end of acquisition being also end of writing.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tpc://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address should be avoided, as this socket address is forwarded to the writer process via START ZerOMQ message and in case of multiple ineterfaces the address might be ambigous.\nUsing * (star) instead of port number is allowed and it means a random free port number.\n"}}},"tcp_settings":{"type":"object","description":"TCP image stream configuration for Jungfraujoch software.\nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","required":["addr"],"properties":{"send_buffer_size":{"type":"integer","format":"int64","description":"Send buffer size for TCP/IP socket"},"image_socket":{"type":"string","example":"tcp://1.2.3.4:5000","description":"tcp://<IP address>:<port>\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces\n"},"nwriters":{"type":"integer","format":"int64","minimum":1,"maximum":100,"default":32,"description":"Number of TCP/IP writers to be used for streaming images"},"peer_liveness_timeout_ms":{"type":"integer","format":"int64","description":"Max time (in milliseconds) a send may block with no sign of life from the\nwriter (no BUSY heartbeat or ACK) before the connection is declared dead.\nOptional; the built-in default is used when unset.\n"},"max_backpressure_timeout_ms":{"type":"integer","format":"int64","description":"Hard upper bound (in milliseconds) on backpressure: if no bytes can be sent to\nthe writer for this long the connection is declared dead even while the writer\nkeeps heartbeating, so a wedged writer cannot block the run or its\nfinalization. Optional; the built-in default is used when unset.\n"}}},"pcie_devices":{"type":"array","minLength":1,"items":{"type":"object","required":["block_device"],"properties":{"blk":{"type":"string","example":"/dev/jfjoch0","description":"Block device name"},"ipv4":{"type":"string","example":"10.1.1.7","description":"IPv4 address of the block device"}}}},"bragg_integration_settings":{"type":"object","description":"Settings for Bragg spot integration","required":["integration_model"],"properties":{"integration_model":{"$ref":"#/components/schemas/integration_model"},"max_hkl":{"type":"integer","minimum":1,"maximum":511,"default":100,"description":"How far the Bragg predictor walks the lattice: reflections with |h|,|k|,|l| above this are\nnever predicted. An axis is truncated once a/d_min exceeds it, so a long axis - or a short\none taken to high resolution - loses its outermost reflections. The cost grows as the cube\n(2n+1)^3 of candidates per image, which is why online keeps a fixed, predictable value\ninstead of taking it from whichever crystal is mounted.\n\nOmitting the field selects the default above; it is never interpreted as \"choose per\ncrystal\". The offline tools (rugnux, viewer) do derive it from the refined cell when it is\nleft unset there, but that is their own default and is not reachable through this API.\n"}}},"jfjoch_settings":{"type":"object","required":["detector","frontend_directory","image_pusher"],"description":"Default settings for Jungfraujoch software. \nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","properties":{"pcie":{"$ref":"#/components/schemas/pcie_devices"},"zeromq":{"$ref":"#/components/schemas/zeromq_settings"},"tcp":{"$ref":"#/components/schemas/tcp_settings"},"instrument":{"$ref":"#/components/schemas/instrument_metadata"},"file_writer":{"$ref":"#/components/schemas/file_writer_settings"},"detector":{"type":"array","minLength":1,"items":{"$ref":"#/components/schemas/detector"}},"indexing":{"$ref":"#/components/schemas/indexing_settings"},"bragg_integration":{"$ref":"#/components/schemas/bragg_integration_settings"},"detector_settings":{"$ref":"#/components/schemas/detector_settings"},"azim_int":{"$ref":"#/components/schemas/azim_int_settings"},"image_format":{"$ref":"#/components/schemas/image_format_settings"},"image_buffer_MiB":{"type":"integer","minimum":128,"default":2048,"description":"Size of internal buffer in MiB for images before they are sent to a stream"},"verbose":{"type":"boolean","default":false,"description":"Print extra debug information"},"receiver_threads":{"type":"integer","minimum":1,"maximum":512,"default":64,"description":"Number of threads used by the receiver"},"numa_policy":{"type":"string","deprecated":true,"description":"Ignored value"},"frontend_directory":{"type":"string","description":"Location of built JavaScript web frontend"},"spot_finding":{"$ref":"#/components/schemas/spot_finding_settings"},"image_pusher":{"$ref":"#/components/schemas/image_pusher_type"},"zeromq_preview":{"$ref":"#/components/schemas/zeromq_preview_settings"},"zeromq_metadata":{"$ref":"#/components/schemas/zeromq_metadata_settings"},"dark_mask":{"$ref":"#/components/schemas/dark_mask_settings"}}},"zeromq_metadata_settings":{"type":"object","required":["enabled","period_ms"],"properties":{"enabled":{"type":"boolean","default":true,"description":"ZeroMQ metadata socket is enabled."},"period_ms":{"type":"integer","format":"int64","minimum":1,"default":1000,"description":"Period for generating metadata package sent to the ZeroMQ interface in milliseconds.\n"},"socket_address":{"type":"string","description":"PUB ZeroMQ socket for image metadata information.\nImage metadata are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tcp://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"}}},"zeromq_preview_settings":{"type":"object","required":["enabled","period_ms"],"properties":{"enabled":{"type":"boolean","default":true,"description":"ZeroMQ preview socket is enabled."},"period_ms":{"type":"integer","format":"int64","default":1000,"description":"Period for generating preview image sent to the ZeroMQ interface in milliseconds. Default is 1 second. \nIf set to zero, all images will be sent ZeroMQ (should be used only in case of relatively slow data collection).\nThis has no effect on HTTP based preview, which updates always at rate of 1 second.\n"},"socket_address":{"type":"string","description":"PUB ZeroMQ socket for preview images. This socket operates at a reduced frame rate.\nImages are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tcp://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"}}}}},"paths":{"/initialize":{"post":{"summary":"Initialize detector and data acquisition","description":"Should be used in two cases:\n  - Detector is in `Inactive` state\n  - Detector is in `Error` state\nX-ray shutter must be closed. \nThis operation will reconfigure network interface of the detector. \nDuring operation of the detector it is recommended to use the `POST /pedestal` operation instead.\nIf storage cells are used, the execution time might be few minutes.\n\nThis is async function - one needs to use `POST /wait_till_done` to ensure operation is done.\n","responses":{"200":{"description":"Initialization started"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/pedestal":{"post":{"summary":"Collect dark current for the detector","description":"Updates calibration of the JUNGFRAU detector. Must be in `Idle` state.\n\nX-ray shutter must be closed. Recommended to run once per hour for long integration times (> 100 us).\n\nThis is async function - one needs to use `POST /wait_till_done` to ensure operation is done.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/start":{"post":{"summary":"Start detector","description":"Start data acquisition.\nDetector must be in `Idle` state.\nDefault behavior is for the call to block until detector is ready to accept soft/TTL triggers.\nHowever, this behavior can be changed by settings `async_start` to true in the request body, \nin which case the call will return immediately and one needs to use `/wait_until_running` to ensure detector is ready to run.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/dataset_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/wait_until_running":{"post":{"summary":"Wait for acquisition running","parameters":[{"in":"query","name":"timeout","required":false,"schema":{"type":"integer","default":60,"minimum":0,"maximum":3600},"description":"Timeout in seconds (0 == immediate response)"}],"description":"Block execution of external script till detector and Jungfraujoch are ready to collect data.\nTo not block web server for a indefinite period of time, the procedure is provided with a timeout.\nExtending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection.\n","responses":{"200":{"description":"Detector in `Measuring` state"},"400":{"description":"Timeout parameter out of bounds"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}},"502":{"description":"Detector is inactive mode"},"504":{"description":"Timeout reached, need to restart operation"}}}},"/wait_till_done":{"post":{"summary":"Wait for acquisition done","parameters":[{"in":"query","name":"timeout","required":false,"schema":{"type":"integer","default":60,"minimum":0,"maximum":3600},"description":"Timeout in seconds (0 == immediate response)"}],"description":"Block execution of external script till initialization, data collection or pedestal is finished.\nRunning this command does not affect (cancel) running data collection, it is only to ensure synchronous execution of other software.\n\nTo not block web server for a indefinite period of time, the procedure is provided with a timeout.\nExtending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection.\n","responses":{"200":{"description":"Detector in `Idle` state, another data collection can start immediately.\nThe operation that finished either succeeded, was cancelled, or ended with a warning.\n"},"400":{"description":"Timeout parameter out of bounds"},"500":{"description":"Error within Jungfraujoch code, or the operation that finished ended in an error -\nmissing packets, or a writer that could not write - see output message.\nA cancelled data collection is not an error.\n","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}},"502":{"description":"Detector is inactive mode"},"504":{"description":"Timeout reached, need to restart operation"}}}},"/trigger":{"post":{"summary":"Send soft trigger to the detector","description":"Generate soft trigger","responses":{"200":{"description":"Trigger sent"}}}},"/cancel":{"post":{"summary":"Cancel running data collection","description":"Command will inform FPGA network card to stop pedestal or data collection at the current stage.\nAny frame that is currently being processed by CPU will be finished and sent to writer.\nGiven the command is making sure to gracefully stop data acquisition and detector, it might take some time to switch back after command finished to `Idle` state.\n\nIf data collection is not running, the command has no effect.\n","responses":{"200":{"description":"Cancel request sent to FPGAs (or ignored, as data collection is not running)"}}}},"/deactivate":{"post":{"summary":"Prepare detector to turn off","description":"Should be in `Idle` or `Error` state.\nCommand deactivates data acquisition and turns off detector high voltage and ASIC.\nShould be used always before turning off power from the detector.\n","responses":{"200":{"description":"Detector ready to turn off"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/detector":{"put":{"summary":"Change detector configuration","description":"Detector settings are ones that have effect on calibration, i.e., pedestal has to be collected again after changing these settings.\nThis can only be done when detector is `Idle`, `Error` or `Inactive` states.\nIf detector is in `Idle` state , pedestal procedure will be executed automatically - there must be no X-rays on the detector during the operation.\nIf detector is in `Inactive` or `Error` states, new settings will be saved, but no calibration will be executed.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get detector configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_settings"}}}}}}},"/config/indexing":{"put":{"summary":"Change indexing algorithm settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/indexing_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get indexing configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/indexing_settings"}}}}}}},"/config/bragg_integration":{"put":{"summary":"Change Bragg integration settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/bragg_integration_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get Bragg integration configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/bragg_integration_settings"}}}}}}},"/config/file_writer":{"put":{"summary":"Change file writer settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/file_writer_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get file writer settings","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/file_writer_settings"}}}}}}},"/config/instrument":{"put":{"summary":"Change instrument metadata","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/instrument_metadata"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get instrument metadata","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/instrument_metadata"}}}}}}},"/config/image_format":{"put":{"summary":"Change image output format","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_format_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get image output format","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_format_settings"}}}}}}},"/config/image_format/raw":{"post":{"summary":"Configure format for raw data collection","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/image_format/conversion":{"post":{"summary":"Configure format for data collection with full conversion","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/spot_finding":{"put":{"summary":"Configure spot finding","description":"Can be done anytime, also while data collection is running","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/spot_finding_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}},"get":{"summary":"Get data processing configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/spot_finding_settings"}}}}}}},"/config/azim_int":{"put":{"summary":"Configure azimuthal integration","description":"Can be done when detector is Inactive or Idle","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/azim_int_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get azimuthal integration configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/azim_int_settings"}}}}}}},"/config/internal_generator_image":{"put":{"summary":"Load binary image for internal FPGA generator","description":"Load image for internal FPGA generator. This can only happen in Idle state of the detector.\nRequires binary blob with 16-bit integer numbers of size of detector in raw/converted coordinates \n(depending on detector settings).\n","parameters":[{"name":"id","in":"query","description":"Image id to upload","required":false,"schema":{"type":"integer","format":"int64","minimum":0,"maximum":127}}],"requestBody":{"content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/internal_generator_image.tiff":{"put":{"summary":"Load TIFF image for internal FPGA generator","description":"Load image for internal FPGA generator. This can only happen in Idle state of the detector.\nRequires TIFF with 16-bit integer numbers of size of detector in raw/converted coordinates \n(depending on detector settings).\n","parameters":[{"in":"query","name":"id","description":"Image ID to upload","required":false,"schema":{"type":"integer","minimum":0,"maximum":127}}],"requestBody":{"content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/select_detector":{"put":{"summary":"Select detector","description":"Jungfraujoch allows to control multiple detectors and/or region-of-interests.\nThe command allows to choose one detector from the list (ID has to be consistent with one provided by GET response).\nChanging detector will set detector to `Inactive` state and will require reinitialization.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_selection"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"List available detectors","description":"Configured detectors that can be selected by used","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_list"}}}}}}},"/config/zeromq_preview":{"put":{"summary":"Set ZeroMQ preview settings","description":"Jungfraujoch can generate preview message stream on ZeroMQ SUB socket.\nHere settings of the socket can be adjusted.\nWhile the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request.\nOptions set with this PUT request have no effect on HTTP based preview.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_preview_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get ZeroMQ preview settings","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_preview_settings"}}}}}}},"/config/zeromq_metadata":{"put":{"summary":"Set ZeroMQ metadata settings","description":"Jungfraujoch can generate metadata message stream on ZeroMQ PUB socket. This stream covers all images.\nHere settings of the socket can be adjusted.\nWhile the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_metadata_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get ZeroMQ metadata socket settings","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_metadata_settings"}}}}}}},"/config/dark_mask":{"put":{"summary":"Set configuration for dark data collection to calculate mask","description":"This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point.\nThis can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/dark_mask_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get settings for dark data collection to calculate mask","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/dark_mask_settings"}}}}}}},"/status":{"get":{"summary":"Get Jungfraujoch status","description":"Status of the data acquisition","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/broker_status"}}}}}}},"/fpga_status":{"get":{"summary":"Get status of FPGA devices","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/fpga_status"}}}}}}},"/xfel/pulse_id":{"get":{"summary":"Return XFEL pulse IDs for the current data acquisition","description":"Return array of XFEL pulse IDs - (-1) if image not recorded","responses":{"200":{"description":"Pulse ID collected","content":{"application/json":{"schema":{"type":"array","items":{"type":"integer","format":"int64"}}}}},"404":{"description":"Not in XFEL mode or no acquisition recorded"}}}},"/xfel/event_code":{"get":{"summary":"Return XFEL event codes for the current data acquisition","description":"Return array of XFEL event codes","responses":{"200":{"description":"Event codes collected","content":{"application/json":{"schema":{"type":"array","items":{"type":"integer","format":"int64"}}}}},"404":{"description":"Not in XFEL mode or no acquisition recorded"}}}},"/image_pusher/status":{"get":{"summary":"Get status of image pusher","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_pusher_status"}}}},"500":{"description":"Error encountered when trying to read status","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/detector/status":{"get":{"summary":"Get detector status","description":"Status of the JUNGFRAU detector","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_status"}}}},"404":{"description":"Running in \"simulator\" mode - no detector present"},"500":{"description":"Error encountered when trying to read status","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/roi":{"get":{"summary":"Get ROI definitions","responses":{"200":{"description":"OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/roi_definitions"}}}}}},"put":{"summary":"Upload ROI definitions","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/roi_definitions"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/statistics":{"get":{"summary":"Get general statistics","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/jfjoch_statistics"}}}}}}},"/statistics/data_collection":{"get":{"summary":"Get data collection statistics","description":"Results of the last data collection","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/measurement_statistics"}}}},"404":{"description":"No data collection performed so far"}}}},"/statistics/calibration":{"get":{"summary":"Get calibration statistics","description":"Statistics are provided for each module/storage cell separately","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/calibration_statistics"}}}}}}},"/config/mask":{"get":{"summary":"Get mask of the detector (binary)","description":"Detector must be Initialized.\nGet full pixel mask of the detector.\nSee NXmx standard for meaning of pixel values.\n","responses":{"200":{"description":"Binary array (4 byte; unsigned)","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}}}}},"/config/user_mask":{"get":{"summary":"Detector must be Initialized.\nGet user mask of the detector (binary)\n","description":"Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked","responses":{"200":{"description":"User mask in binary format (4 byte; unsigned)","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}}}},"put":{"summary":"Upload user mask of the detector (binary)","description":"Should be in `Idle` state.\nUpload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions.\nIf detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates.\nIn the latter case - module gaps are ignored and don't need to be assigned value.\nMask is expected as binary array (4-byte; unsigned).\n0 - good pixel, other value - masked\nUser mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.\n","requestBody":{"content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"All good"},"400":{"description":"Mask is not 4-byte unsigned integer array or empty body"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/mask.tiff":{"get":{"summary":"Get mask of the detector (TIFF)","description":"Should be in `Idle` state.\nGet full pixel mask of the detector\nSee NXmx standard for meaning of pixel values\n","responses":{"200":{"description":"Pixel mask in TIFF format (4 byte; unsigned)","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}}}}},"/config/user_mask.tiff":{"get":{"summary":"Detector must be Initialized.\nGet user mask of the detector (TIFF)\n","description":"Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked","responses":{"200":{"description":"User mask in TIFF format (4 byte; unsigned)","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}}}},"put":{"summary":"Upload user mask of the detector","description":"Should be in `Idle` state.\nUpload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions.\nIf detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates.\nIn the latter case - module gaps are ignored and don't need to be assigned value.\nMask is expected as a single-channel TIFF (8-, 16- or 32-bit integer, signed or unsigned).\n0 - good pixel, other value - masked\nUser mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.\nUser mask is not automatically applied - i.e. pixels with user mask will have a valid pixel value in the images.\n","requestBody":{"content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"All good"},"400":{"description":"Not a valid single-channel TIFF or size doesn't match the detector"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/preview/pedestal.tiff":{"get":{"parameters":[{"in":"query","name":"gain_level","required":true,"schema":{"type":"integer"},"description":"Gain level (0, 1, 2)"},{"in":"query","name":"sc","schema":{"type":"integer"},"description":"Storage cell number"}],"summary":"Get pedestal in TIFF format","responses":{"200":{"description":"Calibration image","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Invalid gain level or storage cell number"},"404":{"description":"No calibration recorded so far"}}}},"/preview/plot":{"get":{"summary":"Generate 1D plot from Jungfraujoch","parameters":[{"$ref":"#/components/parameters/binning"},{"$ref":"#/components/parameters/plot_type"},{"$ref":"#/components/parameters/fill_value"},{"$ref":"#/components/parameters/experimental_coord"},{"$ref":"#/components/parameters/azint_unit"}],"responses":{"200":{"description":"Everything OK.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/plots"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/preview/plot.bin":{"get":{"summary":"Generate 1D plot from Jungfraujoch and send in raw binary format.\nData are provided as (32-bit) float binary array.\nThis format doesn't transmit information about X-axis, only values, so it is of limited use for azimuthal integration.\n","parameters":[{"$ref":"#/components/parameters/plot_type"},{"$ref":"#/components/parameters/roi"}],"responses":{"200":{"description":"Everything OK.","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/result/scan":{"get":{"summary":"Get full scan result","responses":{"200":{"description":"Everything OK.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/scan_result"}}}},"404":{"description":"No grid scan recorded"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/start.cbor":{"get":{"summary":"Get Start message in CBOR format","description":"Contains metadata for a dataset (e.g., experimental geometry)","responses":{"200":{"description":"Return start message","content":{"application/cbor":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"No measurement so far"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.cbor":{"get":{"summary":"Get image message in CBOR format","description":"Contains full image data and metadata. The image must come from the latest data collection.","parameters":[{"$ref":"#/components/parameters/image_id"}],"responses":{"200":{"description":"Return image message","content":{"application/cbor":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"Image not present in the buffer - either not yet measured or already replaced by a next image."},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.jpeg":{"get":{"summary":"Get preview image in JPEG format using custom settings","parameters":[{"$ref":"#/components/parameters/image_id"},{"$ref":"#/components/parameters/show_user_mask"},{"$ref":"#/components/parameters/show_roi"},{"$ref":"#/components/parameters/show_spots"},{"$ref":"#/components/parameters/show_predictions"},{"$ref":"#/components/parameters/show_beam_center"},{"$ref":"#/components/parameters/saturation"},{"$ref":"#/components/parameters/jpeg_quality"},{"$ref":"#/components/parameters/resolution_ring"},{"$ref":"#/components/parameters/color_scale"},{"$ref":"#/components/parameters/resolution_estimate"}],"responses":{"200":{"description":"Preview image","content":{"image/jpeg":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"404":{"description":"Image not present in the buffer - either not yet measured or already replaced by a next image."},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.tiff":{"get":{"summary":"Get preview image in TIFF format","parameters":[{"$ref":"#/components/parameters/image_id"}],"responses":{"200":{"description":"Preview image","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"No preview image recorded so far"}}}},"/image_buffer/clear":{"post":{"summary":"Clear image buffer","description":"Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data.","responses":{"200":{"description":"Done"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/status":{"get":{"summary":"Get status of the image buffers","description":"Can be run at any stage of Jungfraujoch operation, including during data collection.\nThe status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots,\nthen image might be replaced in the buffer between calling /images and /image.cbor.\n","responses":{"200":{"description":"Done","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_buffer_status"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/version":{"get":{"summary":"Get Jungfraujoch version of jfjoch_broker","responses":{"200":{"description":"Release number of Jungfraujoch","content":{"text/plain":{"schema":{"type":"string","example":"1.0.0-rc.25"}}}}}}}}}},"searchIndex":{"store":["section/License-Clarification","/paths/~1initialize/post","/paths/~1pedestal/post","/paths/~1start/post","/paths/~1wait_until_running/post","/paths/~1wait_till_done/post","/paths/~1trigger/post","/paths/~1cancel/post","/paths/~1deactivate/post","/paths/~1config~1detector/put","/paths/~1config~1detector/get","/paths/~1config~1indexing/put","/paths/~1config~1indexing/get","/paths/~1config~1bragg_integration/put","/paths/~1config~1bragg_integration/get","/paths/~1config~1file_writer/put","/paths/~1config~1file_writer/get","/paths/~1config~1instrument/put","/paths/~1config~1instrument/get","/paths/~1config~1image_format/put","/paths/~1config~1image_format/get","/paths/~1config~1image_format~1raw/post","/paths/~1config~1image_format~1conversion/post","/paths/~1config~1spot_finding/put","/paths/~1config~1spot_finding/get","/paths/~1config~1azim_int/put","/paths/~1config~1azim_int/get","/paths/~1config~1internal_generator_image/put","/paths/~1config~1internal_generator_image.tiff/put","/paths/~1config~1select_detector/put","/paths/~1config~1select_detector/get","/paths/~1config~1zeromq_preview/put","/paths/~1config~1zeromq_preview/get","/paths/~1config~1zeromq_metadata/put","/paths/~1config~1zeromq_metadata/get","/paths/~1config~1dark_mask/put","/paths/~1config~1dark_mask/get","/paths/~1status/get","/paths/~1fpga_status/get","/paths/~1xfel~1pulse_id/get","/paths/~1xfel~1event_code/get","/paths/~1image_pusher~1status/get","/paths/~1detector~1status/get","/paths/~1config~1roi/get","/paths/~1config~1roi/put","/paths/~1statistics/get","/paths/~1statistics~1data_collection/get","/paths/~1statistics~1calibration/get","/paths/~1config~1mask/get","/paths/~1config~1user_mask/get","/paths/~1config~1user_mask/put","/paths/~1config~1mask.tiff/get","/paths/~1config~1user_mask.tiff/get","/paths/~1config~1user_mask.tiff/put","/paths/~1preview~1pedestal.tiff/get","/paths/~1preview~1plot/get","/paths/~1preview~1plot.bin/get","/paths/~1result~1scan/get","/paths/~1image_buffer~1start.cbor/get","/paths/~1image_buffer~1image.cbor/get","/paths/~1image_buffer~1image.jpeg/get","/paths/~1image_buffer~1image.tiff/get","/paths/~1image_buffer~1clear/post","/paths/~1image_buffer~1status/get","/paths/~1version/get"],"index":{"version":"2.3.9","fields":["title","description"],"fieldVectors":[["title/0",[0,4.111,1,4.753]],["description/0",[0,1.805,2,4.17,3,2.159,4,2.087,5,1.193,6,3.337,7,1.193,8,1.193,9,1.032,10,0.926,11,1.621,12,1.193,13,0.963,14,1.193,15,1.619,16,1.193,17,2.781,18,2.087,19,0.926,20,2.087,21,1.278,22,1.193,23,2.087,24,1.032,25,2.781,26,1.193,27,1.193,28,2.087,29,1.193,30,1.193,31,1.193,32,1.193,33,1.193,34,1.193,35,1.193,36,2.781,37,1.193,38,1.193,39,0.354,40,0.611,41,1.193,42,2.087,43,1.032,44,1.193,45,1.193,46,1.193,47,1.193,48,1.193,49,1.193,50,1.032,51,1.193,52,1.193,53,1.193,54,1.193,55,1.193,56,1.193,57,1.193,58,1.193,59,0.926,60,0.926,61,1.193]],["title/1",[62,2.314,63,0.416,64,0.989,65,1.935]],["description/1",[11,2.226,39,0.937,43,1.688,59,1.515,62,1.195,63,0.505,66,1.952,67,1.385,68,2.042,69,0.858,70,0.901,71,1.515,72,1.688,73,1.385,74,3.01,75,1.952,76,1.515,77,1.688,78,2.735,79,1.195,80,1.952,81,1.952,82,1.688,83,1.385,84,1.281,85,1.952,86,1.952,87,1.688,88,1.688,89,1.281,90,1.281,91,1.515,92,1.281,93,0.555]],["title/2",[63,0.416,94,1.384,95,2.932,96,2.681]],["description/2",[11,1.242,39,0.758,63,0.282,68,2.004,71,1.984,72,2.212,73,1.814,74,1.679,77,2.212,78,2.212,79,1.566,84,1.679,87,2.212,88,2.212,89,1.679,90,1.679,91,1.984,92,1.679,93,0.727,97,2.557,98,1.984,99,2.212,100,0.824,101,1.31,102,2.557,103,2.557,104,2.557,105,2.557,106,1.385,107,2.557]],["title/3",[63,0.524,108,3.688]],["description/3",[11,1.132,39,0.691,60,2.827,63,0.494,64,0.61,65,1.194,67,1.654,89,1.531,90,1.531,92,1.531,100,0.751,101,1.194,108,2.827,109,2.331,110,3.642,111,1.809,112,2.331,113,3.15,114,2.331,115,2.331,116,1.809,117,1.076,118,0.783,119,2.331,120,2.331,121,1.809,122,2.331,123,1.531,124,2.331,125,2.016]],["title/4",[65,2.156,101,2.156,126,3.641]],["description/4",[15,1.984,21,1.566,63,0.282,64,0.67,73,1.814,83,1.814,84,1.679,92,1.679,94,0.937,111,3.036,113,2.212,125,2.212,127,2.212,128,2.212,129,2.212,130,1.242,131,2.212,132,2.212,133,2.212,134,2.212,135,1.984,136,1.679,137,3.384,138,2.212,139,1.984,140,2.212,141,3.384,142,2.212]],["title/5",[65,2.156,93,1.197,126,3.641]],["description/5",[15,1.636,21,1.291,62,1.291,64,0.881,73,1.496,79,1.291,83,2.387,84,1.384,91,1.636,92,2.209,94,1.232,101,1.723,111,2.61,127,1.823,128,1.823,129,1.823,131,1.823,132,1.823,133,1.823,134,1.823,135,1.636,136,1.384,137,2.909,138,1.823,139,1.636,140,1.823,141,2.909,142,1.823,143,1.823,144,1.496,145,2.107,146,1.636,147,2.107,148,2.107]],["title/6",[63,0.416,116,2.932,149,3.268,150,3.268]],["description/6",[13,2.476,116,5.063,150,4.639]],["title/7",[64,0.989,94,1.384,101,1.935,146,2.932]],["description/7",[39,0.625,59,1.636,63,0.232,64,1.099,65,1.079,79,1.291,84,1.384,94,1.232,96,2.387,100,0.679,101,1.079,143,2.909,144,3.4,146,1.636,151,1.823,152,1.291,153,2.107,154,2.61,155,1.823,156,2.107,157,2.107,158,1.823,159,2.107,160,2.107,161,1.636,162,2.107,163,2.107,164,2.107,165,2.107,166,2.107,167,2.107,168,2.107,169,1.636]],["title/8",[63,0.464,170,4.21,171,3.267]],["description/8",[11,1.618,39,0.987,63,0.524,64,0.872,65,1.706,70,1.538,100,1.073,144,2.364,171,3.693,172,4.759,173,3.331,174,3.331,175,3.331,176,3.331,177,3.331,178,3.331]],["title/9",[63,0.464,117,1.944,179,1.851]],["description/9",[39,1.271,63,0.586,68,1.768,69,1.518,70,1.594,71,1.69,74,1.429,76,1.69,79,2.114,83,2.449,89,1.429,93,0.619,94,0.797,98,2.679,100,1.112,117,1.005,118,1.441,135,1.69,169,1.69,180,1.883,181,2.177,182,1.883,183,2.177,184,2.177,185,1.883]],["title/10",[63,0.524,179,2.09]],["description/10",[93,1.59,185,4.835,186,2.863]],["title/11",[117,1.745,118,1.27,187,3.268,188,3.778]],["description/11",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,189,4.135]],["title/12",[179,2.09,187,4.111]],["description/12",[93,1.59,186,2.863,189,4.835]],["title/13",[106,2.046,117,1.745,118,1.27,190,3.268]],["description/13",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,191,4.135]],["title/14",[106,2.28,179,1.851,190,3.641]],["description/14",[93,1.59,186,2.863,191,4.835]],["title/15",[10,2.932,117,1.745,118,1.27,161,2.932]],["description/15",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,192,4.135]],["title/16",[10,3.267,118,1.415,161,3.267]],["description/16",[93,1.59,186,2.863,192,4.835]],["title/17",[117,1.944,193,3.641,194,2.419]],["description/17",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,195,4.135]],["title/18",[193,4.111,194,2.731]],["description/18",[93,1.59,186,2.863,195,4.835]],["title/19",[117,1.745,196,1.27,197,3.268,198,1.835]],["description/19",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,199,4.135]],["title/20",[196,1.415,197,3.641,198,2.045]],["description/20",[93,1.59,186,2.863,199,4.835]],["title/21",[64,0.897,94,1.255,179,1.507,198,1.665,200,2.432]],["description/21",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,201,4.78]],["title/22",[64,0.821,94,1.149,179,1.379,198,1.523,202,2.059,203,2.433]],["description/22",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,204,4.78]],["title/23",[179,1.851,205,3.267,206,3.267]],["description/23",[64,1.299,93,1.41,94,1.817,101,2.54,186,2.54,207,4.29]],["title/24",[64,1.102,158,3.641,179,1.851]],["description/24",[93,1.59,186,2.863,207,4.835]],["title/25",[106,2.28,179,1.851,208,2.764]],["description/25",[63,0.568,69,2.266,93,1.465,100,1.66,209,4.458]],["title/26",[106,2.28,179,1.851,208,2.764]],["description/26",[93,1.59,186,2.863,209,4.835]],["title/27",[13,1.448,152,1.92,196,1.054,210,2.225,211,1.802,212,2.225]],["description/27",[13,1.397,21,1.853,39,0.897,63,0.579,100,0.975,118,1.017,152,1.853,196,1.017,210,2.147,211,1.739,212,2.147,213,2.617,214,3.026,215,2.617,216,2.348,217,2.617,218,2.617,219,2.617,220,1.853,221,2.617,222,3.026]],["title/28",[13,1.448,152,1.92,196,1.054,210,2.225,212,2.225,223,1.802]],["description/28",[13,1.43,21,1.897,39,0.918,63,0.587,100,0.998,118,1.041,152,1.897,196,1.041,210,2.198,212,2.198,213,2.679,215,2.679,216,2.403,217,2.679,218,2.679,219,2.679,220,1.897,221,2.679,223,1.78,224,3.097]],["title/29",[63,0.524,225,4.111]],["description/29",[21,1.698,24,2.397,39,0.821,50,3.597,63,0.611,69,1.219,89,2.731,117,1.28,118,0.932,130,1.346,136,1.82,144,1.967,226,2.771,227,2.771,228,2.771,229,2.771,230,2.397,231,2.151,232,2.771,233,2.771,234,2.771,235,2.397]],["title/30",[63,0.464,230,3.641,236,3.267]],["description/30",[11,2.503,63,0.568,179,2.266,225,4.458,235,4.458]],["title/31",[118,1.747,237,2.314,238,2.481]],["description/31",[13,1.181,64,0.67,117,1.181,118,1.315,121,3.036,130,1.242,169,1.984,237,1.566,238,2.569,239,1.814,240,2.212,241,2.557,242,3.036,243,2.212,244,2.212,245,2.212,246,1.814,247,2.212,248,2.212,249,3.384,250,1.814,251,3.384,252,2.557,253,2.557,254,2.212]],["title/32",[118,1.415,237,2.579,238,2.764]],["description/32",[254,5.283]],["title/33",[118,1.747,194,2.171,237,2.314]],["description/33",[13,1.307,64,0.741,117,1.307,118,0.951,121,2.197,130,1.375,194,1.627,196,0.951,237,1.734,239,2.009,240,3.655,242,3.279,243,2.449,244,2.449,245,2.449,246,2.009,247,2.449,248,2.449,249,2.449,250,2.009,251,2.449,255,2.831,256,2.831,257,2.449]],["title/34",[118,1.27,194,2.171,237,2.314,242,2.932]],["description/34",[257,5.283]],["title/35",[64,0.757,94,1.059,95,2.243,118,0.971,179,1.271,258,2.5,259,1.157]],["description/35",[39,1.068,63,0.554,69,1.585,70,1.664,74,2.367,93,1.025,100,1.161,139,2.797,236,2.797,260,3.604,261,3.604,262,3.604,263,3.604,264,3.604,265,3.118]],["title/36",[64,0.821,94,1.149,95,2.433,118,1.054,258,2.712,259,1.256]],["description/36",[265,5.283]],["title/37",[130,2.309,266,2.574]],["description/37",[64,1.404,65,2.747,266,3.533]],["title/38",[152,2.579,266,2.28,267,4.21]],["description/38",[268,6.108]],["title/39",[64,0.757,65,1.48,96,2.051,123,1.897,231,2.243,269,2.051,270,2.5]],["description/39",[68,2.208,123,2.831,196,1.449,231,3.346,269,3.06,270,3.729,271,3.06,272,3.346,273,4.311,274,4.311]],["title/40",[19,2.243,64,0.757,65,1.48,96,2.051,123,1.897,269,2.051,275,2.5]],["description/40",[19,3.849,123,3.257,269,3.52,271,3.52,275,4.29,276,4.959]],["title/41",[196,1.415,266,2.28,277,4.21]],["description/41",[278,6.108]],["title/42",[63,0.524,266,2.574]],["description/42",[63,0.591,99,4.639,266,2.905,279,5.363]],["title/43",[3,3.688,280,4.111]],["description/43",[281,5.283]],["title/44",[3,3.267,280,3.641,282,2.764]],["description/44",[281,5.283]],["title/45",[13,2.194,283,3.121]],["description/45",[283,4.011]],["title/46",[64,1.102,94,1.542,283,2.764]],["description/46",[64,1.349,94,1.888,284,4.458,285,4.458,286,5.153]],["title/47",[98,3.688,283,3.121]],["description/47",[82,4.135,136,3.139,283,3.139,287,4.78,288,4.78,289,4.78,290,4.78]],["title/48",[63,0.464,211,2.419,259,1.686]],["description/48",[62,2.405,63,0.588,202,2.578,259,1.572,291,3.268,292,3.396,293,2.786,294,3.396,295,3.396,296,2.578,297,3.926]],["title/49",[40,1.606,62,1.92,63,0.502,211,1.802,259,1.256]],["description/49",[40,1.898,63,0.565,68,2.627,220,2.27,259,2.054,272,2.876,291,3.141,298,3.205,299,2.63,300,2.63,301,3.205]],["title/50",[40,1.755,63,0.378,211,1.969,259,1.372,282,2.25]],["description/50",[11,0.767,39,0.468,40,1.359,63,0.292,67,1.12,68,2.061,90,1.036,100,0.508,106,0.855,154,1.225,200,1.12,203,1.225,205,1.225,206,1.225,208,1.036,211,0.907,220,0.967,250,1.12,259,1.947,271,1.12,282,1.036,291,1.625,293,1.12,296,1.742,299,1.12,300,1.12,301,1.365,302,1.365,303,1.365,304,1.365,305,1.365,306,1.365,307,1.365,308,1.365,309,1.365,310,1.365,311,1.365,312,2.295,313,1.365,314,1.365,315,1.365,316,1.365,317,1.365,318,1.365,319,1.578,320,1.365,321,1.365,322,1.365,323,1.365,324,1.365]],["title/51",[63,0.464,223,2.419,259,1.686]],["description/51",[39,1.164,63,0.433,100,1.265,202,2.578,259,1.572,291,3.268,292,3.396,293,2.786,294,3.396,295,3.396,296,2.578,325,3.926]],["title/52",[40,1.606,62,1.92,63,0.502,223,1.802,259,1.256]],["description/52",[40,1.898,63,0.565,68,2.627,220,2.27,259,2.054,272,2.876,291,3.141,298,3.205,299,2.63,300,2.63,326,3.205]],["title/53",[40,1.935,63,0.416,259,1.513,282,2.481]],["description/53",[9,1.134,11,0.637,39,0.389,40,1.825,63,0.25,67,0.931,68,2.06,90,0.861,100,0.423,106,0.71,154,1.018,180,1.134,182,1.134,196,0.441,200,0.931,203,1.018,205,1.018,206,1.018,208,0.861,216,1.018,220,0.803,223,0.754,250,0.931,259,1.998,282,0.861,291,2.182,293,0.931,296,1.964,299,0.931,300,0.931,302,1.134,303,1.134,304,1.134,305,1.134,306,1.134,307,1.134,308,1.134,309,1.134,310,1.134,311,1.134,312,1.96,313,1.134,314,1.134,315,1.134,316,1.134,317,1.134,318,1.134,320,1.134,321,1.134,322,1.134,323,1.96,324,1.134,326,1.134,327,1.311,328,1.311,329,1.134,330,1.311,331,1.311]],["title/54",[79,2.579,198,2.045,223,2.419]],["description/54",[332,6.108]],["title/55",[13,1.745,130,1.835,333,3.268,334,3.268]],["description/55",[335,6.108]],["title/56",[11,0.602,13,0.572,64,0.324,106,0.671,130,0.602,136,0.813,149,1.072,151,1.072,198,1.048,200,0.879,208,0.813,211,1.239,271,0.879,296,0.813,329,1.072,333,1.072,334,1.072,336,1.239,337,1.239,338,1.239,339,1.239,340,1.239]],["description/56",[341,6.108]],["title/57",[202,2.764,284,3.641,342,4.21]],["description/57",[343,6.108]],["title/58",[108,2.932,198,1.835,239,2.681,344,3.268]],["description/58",[194,2.747,246,3.392,345,4.78,346,4.78,347,4.78,348,4.78,349,4.78]],["title/59",[196,1.27,198,1.835,239,2.681,344,3.268]],["description/59",[64,1.456,94,1.529,194,2.399,196,1.869,202,2.741,246,2.963,350,4.175,351,4.175,352,4.175]],["title/60",[11,1.404,118,0.971,196,0.971,198,1.404,238,1.897,353,2.89,354,2.89]],["description/60",[355,6.108]],["title/61",[196,1.27,198,1.835,223,2.171,238,2.481]],["description/61",[356,6.108]],["title/62",[196,1.415,357,4.21,358,2.988]],["description/62",[64,1.456,94,2.037,101,2.138,130,2.028,171,3.24,196,1.403,285,3.611,358,2.963,359,4.175]],["title/63",[196,1.415,266,2.28,358,2.988]],["description/63",[60,1.946,64,1.23,68,1.285,74,1.647,76,2.992,94,1.72,101,1.285,130,1.218,155,2.169,196,1.771,236,1.946,266,1.358,358,3.332,360,2.508,361,2.508,362,2.508,363,2.508,364,2.508,365,2.508,366,2.508,367,2.508,368,2.508]],["title/64",[130,2.045,369,3.641,370,4.21]],["description/64",[369,5.283]]],"invertedIndex":[["",{"_index":68,"title":{},"description":{"1":{},"2":{},"9":{},"39":{},"49":{},"50":{},"52":{},"53":{},"63":{}}}],["0",{"_index":299,"title":{},"description":{"49":{},"50":{},"52":{},"53":{}}}],["1",{"_index":272,"title":{},"description":{"39":{},"49":{},"52":{}}}],["100",{"_index":107,"title":{},"description":{"2":{}}}],["1024x512",{"_index":310,"title":{},"description":{"50":{},"53":{}}}],["16",{"_index":328,"title":{},"description":{"53":{}}}],["16-bit",{"_index":215,"title":{},"description":{"27":{},"28":{}}}],["1d",{"_index":333,"title":{"55":{},"56":{}},"description":{}}],["32-bit",{"_index":329,"title":{"56":{}},"description":{"53":{}}}],["4-byte",{"_index":319,"title":{},"description":{"50":{}}}],["8",{"_index":323,"title":{},"description":{"50":{},"53":{}}}],["accept",{"_index":114,"title":{},"description":{"3":{}}}],["account",{"_index":303,"title":{},"description":{"50":{},"53":{}}}],["acquisit",{"_index":65,"title":{"1":{},"4":{},"5":{},"39":{},"40":{}},"description":{"3":{},"7":{},"8":{},"37":{}}}],["actual",{"_index":298,"title":{},"description":{"49":{},"52":{}}}],["adjust",{"_index":244,"title":{},"description":{"31":{},"33":{}}}],["affect",{"_index":145,"title":{},"description":{"5":{}}}],["again",{"_index":181,"title":{},"description":{"9":{}}}],["algorithm",{"_index":188,"title":{"11":{}},"description":{}}],["allow",{"_index":50,"title":{},"description":{"0":{},"29":{}}}],["alway",{"_index":176,"title":{},"description":{"8":{}}}],["and/or",{"_index":228,"title":{},"description":{"29":{}}}],["anytim",{"_index":186,"title":{},"description":{"10":{},"12":{},"14":{},"16":{},"18":{},"20":{},"23":{},"24":{},"26":{}}}],["api",{"_index":2,"title":{},"description":{"0":{}}}],["appli",{"_index":9,"title":{},"description":{"0":{},"53":{}}}],["applic",{"_index":17,"title":{},"description":{"0":{}}}],["approach",{"_index":30,"title":{},"description":{"0":{}}}],["array",{"_index":271,"title":{"56":{}},"description":{"39":{},"40":{},"50":{}}}],["asic",{"_index":175,"title":{},"description":{"8":{}}}],["assign",{"_index":317,"title":{},"description":{"50":{},"53":{}}}],["async",{"_index":87,"title":{},"description":{"1":{},"2":{}}}],["async_start",{"_index":119,"title":{},"description":{"3":{}}}],["automat",{"_index":182,"title":{},"description":{"9":{},"53":{}}}],["avail",{"_index":236,"title":{"30":{}},"description":{"35":{},"63":{}}}],["azimuth",{"_index":208,"title":{"25":{},"26":{},"56":{}},"description":{"50":{},"53":{}}}],["back",{"_index":168,"title":{},"description":{"7":{}}}],["base",{"_index":253,"title":{},"description":{"31":{}}}],["be",{"_index":157,"title":{},"description":{"7":{}}}],["beam",{"_index":304,"title":{},"description":{"50":{},"53":{}}}],["befor",{"_index":177,"title":{},"description":{"8":{}}}],["behavior",{"_index":110,"title":{},"description":{"3":{}}}],["between",{"_index":366,"title":{},"description":{"63":{}}}],["binari",{"_index":211,"title":{"27":{},"48":{},"49":{},"50":{},"56":{}},"description":{"27":{},"50":{}}}],["bit",{"_index":322,"title":{},"description":{"50":{},"53":{}}}],["blob",{"_index":214,"title":{},"description":{"27":{}}}],["block",{"_index":111,"title":{},"description":{"3":{},"4":{},"5":{}}}],["bodi",{"_index":122,"title":{},"description":{"3":{}}}],["both",{"_index":309,"title":{},"description":{"50":{},"53":{}}}],["bragg",{"_index":190,"title":{"13":{},"14":{}},"description":{}}],["buffer",{"_index":358,"title":{"62":{},"63":{}},"description":{"62":{},"63":{}}}],["calcul",{"_index":258,"title":{"35":{},"36":{}},"description":{}}],["calibr",{"_index":98,"title":{"47":{}},"description":{"2":{},"9":{}}}],["call",{"_index":60,"title":{},"description":{"0":{},"3":{},"63":{}}}],["cancel",{"_index":146,"title":{"7":{}},"description":{"5":{},"7":{}}}],["card",{"_index":153,"title":{},"description":{"7":{}}}],["case",{"_index":67,"title":{},"description":{"1":{},"3":{},"50":{},"53":{}}}],["cbor",{"_index":344,"title":{"58":{},"59":{}},"description":{}}],["cell",{"_index":82,"title":{},"description":{"1":{},"47":{}}}],["chang",{"_index":117,"title":{"9":{},"11":{},"13":{},"15":{},"17":{},"19":{}},"description":{"3":{},"9":{},"29":{},"31":{},"33":{}}}],["choos",{"_index":24,"title":{},"description":{"0":{},"29":{}}}],["clarif",{"_index":1,"title":{"0":{}},"description":{}}],["clear",{"_index":357,"title":{"62":{}},"description":{}}],["client",{"_index":15,"title":{},"description":{"0":{},"4":{},"5":{}}}],["close",{"_index":73,"title":{},"description":{"1":{},"2":{},"4":{},"5":{}}}],["code",{"_index":19,"title":{"40":{}},"description":{"0":{},"40":{}}}],["collect",{"_index":94,"title":{"2":{},"7":{},"21":{},"22":{},"35":{},"36":{},"46":{}},"description":{"4":{},"5":{},"7":{},"9":{},"23":{},"46":{},"59":{},"62":{},"63":{}}}],["come",{"_index":350,"title":{},"description":{"59":{}}}],["command",{"_index":144,"title":{},"description":{"5":{},"7":{},"8":{},"29":{}}}],["commun",{"_index":57,"title":{},"description":{"0":{}}}],["config/azim_int",{"_index":209,"title":{},"description":{"25":{},"26":{}}}],["config/bragg_integr",{"_index":191,"title":{},"description":{"13":{},"14":{}}}],["config/dark_mask",{"_index":265,"title":{},"description":{"35":{},"36":{}}}],["config/detector",{"_index":185,"title":{},"description":{"9":{},"10":{}}}],["config/file_writ",{"_index":192,"title":{},"description":{"15":{},"16":{}}}],["config/image_format",{"_index":199,"title":{},"description":{"19":{},"20":{}}}],["config/image_format/convers",{"_index":204,"title":{},"description":{"22":{}}}],["config/image_format/raw",{"_index":201,"title":{},"description":{"21":{}}}],["config/index",{"_index":189,"title":{},"description":{"11":{},"12":{}}}],["config/instru",{"_index":195,"title":{},"description":{"17":{},"18":{}}}],["config/internal_generator_imag",{"_index":222,"title":{},"description":{"27":{}}}],["config/internal_generator_image.tiff",{"_index":224,"title":{},"description":{"28":{}}}],["config/mask",{"_index":297,"title":{},"description":{"48":{}}}],["config/mask.tiff",{"_index":325,"title":{},"description":{"51":{}}}],["config/roi",{"_index":281,"title":{},"description":{"43":{},"44":{}}}],["config/select_detector",{"_index":235,"title":{},"description":{"29":{},"30":{}}}],["config/spot_find",{"_index":207,"title":{},"description":{"23":{},"24":{}}}],["config/user_mask",{"_index":301,"title":{},"description":{"49":{},"50":{}}}],["config/user_mask.tiff",{"_index":326,"title":{},"description":{"52":{},"53":{}}}],["config/zeromq_metadata",{"_index":257,"title":{},"description":{"33":{},"34":{}}}],["config/zeromq_preview",{"_index":254,"title":{},"description":{"31":{},"32":{}}}],["configur",{"_index":179,"title":{"9":{},"10":{},"12":{},"14":{},"21":{},"22":{},"23":{},"24":{},"25":{},"26":{},"35":{}},"description":{"30":{}}}],["connect",{"_index":141,"title":{},"description":{"4":{},"5":{}}}],["consist",{"_index":232,"title":{},"description":{"29":{}}}],["contain",{"_index":246,"title":{},"description":{"31":{},"33":{},"58":{},"59":{}}}],["control",{"_index":226,"title":{},"description":{"29":{}}}],["convers",{"_index":203,"title":{"22":{}},"description":{"50":{},"53":{}}}],["convert",{"_index":313,"title":{},"description":{"50":{},"53":{}}}],["coordin",{"_index":220,"title":{},"description":{"27":{},"28":{},"49":{},"50":{},"52":{},"53":{}}}],["copyleft",{"_index":7,"title":{},"description":{"0":{}}}],["cover",{"_index":256,"title":{},"description":{"33":{}}}],["cpu",{"_index":159,"title":{},"description":{"7":{}}}],["current",{"_index":96,"title":{"2":{},"39":{},"40":{}},"description":{"7":{}}}],["custom",{"_index":354,"title":{"60":{}},"description":{}}],["dark",{"_index":95,"title":{"2":{},"35":{},"36":{}},"description":{}}],["data",{"_index":64,"title":{"1":{},"7":{},"21":{},"22":{},"24":{},"35":{},"36":{},"39":{},"40":{},"46":{},"56":{}},"description":{"3":{},"4":{},"5":{},"7":{},"8":{},"23":{},"31":{},"33":{},"37":{},"46":{},"59":{},"62":{},"63":{}}}],["dataset",{"_index":345,"title":{},"description":{"58":{}}}],["deactiv",{"_index":172,"title":{},"description":{"8":{}}}],["dectri",{"_index":260,"title":{},"description":{"35":{}}}],["default",{"_index":109,"title":{},"description":{"3":{}}}],["definit",{"_index":3,"title":{"43":{},"44":{}},"description":{"0":{}}}],["depend",{"_index":221,"title":{},"description":{"27":{},"28":{}}}],["deriv",{"_index":47,"title":{},"description":{"0":{}}}],["detector",{"_index":63,"title":{"1":{},"2":{},"3":{},"6":{},"8":{},"9":{},"10":{},"29":{},"30":{},"42":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}},"description":{"1":{},"2":{},"3":{},"4":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"27":{},"28":{},"29":{},"30":{},"35":{},"42":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["detector/statu",{"_index":279,"title":{},"description":{"42":{}}}],["develop",{"_index":37,"title":{},"description":{"0":{}}}],["devic",{"_index":267,"title":{"38":{}},"description":{}}],["distribut",{"_index":22,"title":{},"description":{"0":{}}}],["doesn't",{"_index":337,"title":{"56":{}},"description":{}}],["don't",{"_index":316,"title":{},"description":{"50":{},"53":{}}}],["done",{"_index":93,"title":{"5":{}},"description":{"1":{},"2":{},"9":{},"10":{},"11":{},"12":{},"13":{},"14":{},"15":{},"16":{},"17":{},"18":{},"19":{},"20":{},"21":{},"22":{},"23":{},"24":{},"25":{},"26":{},"35":{}}}],["dure",{"_index":76,"title":{},"description":{"1":{},"9":{},"63":{}}}],["e.g",{"_index":346,"title":{},"description":{"58":{}}}],["each",{"_index":287,"title":{},"description":{"47":{}}}],["effect",{"_index":169,"title":{},"description":{"7":{},"9":{},"31":{}}}],["eiger",{"_index":263,"title":{},"description":{"35":{}}}],["ensur",{"_index":92,"title":{},"description":{"1":{},"2":{},"3":{},"4":{},"5":{}}}],["error",{"_index":70,"title":{},"description":{"1":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"35":{}}}],["etc",{"_index":46,"title":{},"description":{"0":{}}}],["event",{"_index":275,"title":{"40":{}},"description":{"40":{}}}],["exampl",{"_index":302,"title":{},"description":{"50":{},"53":{}}}],["except",{"_index":25,"title":{},"description":{"0":{}}}],["execut",{"_index":83,"title":{},"description":{"1":{},"4":{},"5":{},"9":{}}}],["expect",{"_index":318,"title":{},"description":{"50":{},"53":{}}}],["experiment",{"_index":347,"title":{},"description":{"58":{}}}],["explicitli",{"_index":38,"title":{},"description":{"0":{}}}],["extend",{"_index":138,"title":{},"description":{"4":{},"5":{}}}],["extern",{"_index":127,"title":{},"description":{"4":{},"5":{}}}],["few",{"_index":85,"title":{},"description":{"1":{}}}],["file",{"_index":10,"title":{"15":{},"16":{}},"description":{"0":{}}}],["find",{"_index":206,"title":{"23":{}},"description":{"50":{},"53":{}}}],["finish",{"_index":143,"title":{},"description":{"5":{},"7":{}}}],["float",{"_index":336,"title":{"56":{}},"description":{}}],["format",{"_index":198,"title":{"19":{},"20":{},"21":{},"22":{},"54":{},"56":{},"58":{},"59":{},"60":{},"61":{}},"description":{}}],["fpga",{"_index":152,"title":{"27":{},"28":{},"38":{}},"description":{"7":{},"27":{},"28":{}}}],["fpga_statu",{"_index":268,"title":{},"description":{"38":{}}}],["frame",{"_index":156,"title":{},"description":{"7":{}}}],["full",{"_index":202,"title":{"22":{},"57":{}},"description":{"48":{},"51":{},"59":{}}}],["function",{"_index":88,"title":{},"description":{"1":{},"2":{}}}],["gap",{"_index":315,"title":{},"description":{"50":{},"53":{}}}],["gcc",{"_index":33,"title":{},"description":{"0":{}}}],["gener",{"_index":13,"title":{"27":{},"28":{},"45":{},"55":{},"56":{}},"description":{"0":{},"6":{},"27":{},"28":{},"31":{},"33":{}}}],["geometri",{"_index":348,"title":{},"description":{"58":{}}}],["given",{"_index":162,"title":{},"description":{"7":{}}}],["goe",{"_index":362,"title":{},"description":{"63":{}}}],["good",{"_index":300,"title":{},"description":{"49":{},"50":{},"52":{},"53":{}}}],["gpl",{"_index":6,"title":{},"description":{"0":{}}}],["gpl-3.0",{"_index":5,"title":{},"description":{"0":{}}}],["gracefulli",{"_index":165,"title":{},"description":{"7":{}}}],["happen",{"_index":213,"title":{},"description":{"27":{},"28":{}}}],["header",{"_index":32,"title":{},"description":{"0":{}}}],["here",{"_index":243,"title":{},"description":{"31":{},"33":{}}}],["high",{"_index":173,"title":{},"description":{"8":{}}}],["hour",{"_index":104,"title":{},"description":{"2":{}}}],["http",{"_index":249,"title":{},"description":{"31":{},"33":{}}}],["i.",{"_index":180,"title":{},"description":{"9":{},"53":{}}}],["id",{"_index":231,"title":{"39":{}},"description":{"29":{},"39":{}}}],["idl",{"_index":100,"title":{},"description":{"2":{},"3":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"27":{},"28":{},"35":{},"50":{},"51":{},"53":{}}}],["ignor",{"_index":250,"title":{},"description":{"31":{},"33":{},"50":{},"53":{}}}],["imag",{"_index":196,"title":{"19":{},"20":{},"27":{},"28":{},"41":{},"59":{},"60":{},"61":{},"62":{},"63":{}},"description":{"27":{},"28":{},"33":{},"39":{},"53":{},"59":{},"62":{},"63":{}}}],["image.cbor",{"_index":367,"title":{},"description":{"63":{}}}],["image_buffer/clear",{"_index":359,"title":{},"description":{"62":{}}}],["image_buffer/image.cbor",{"_index":352,"title":{},"description":{"59":{}}}],["image_buffer/image.jpeg",{"_index":355,"title":{},"description":{"60":{}}}],["image_buffer/image.tiff",{"_index":356,"title":{},"description":{"61":{}}}],["image_buffer/start.cbor",{"_index":349,"title":{},"description":{"58":{}}}],["image_buffer/statu",{"_index":368,"title":{},"description":{"63":{}}}],["image_pusher/statu",{"_index":278,"title":{},"description":{"41":{}}}],["immedi",{"_index":124,"title":{},"description":{"3":{}}}],["implement",{"_index":16,"title":{},"description":{"0":{}}}],["impos",{"_index":54,"title":{},"description":{"0":{}}}],["inact",{"_index":69,"title":{},"description":{"1":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"29":{},"35":{}}}],["includ",{"_index":360,"title":{},"description":{"63":{}}}],["indefinit",{"_index":133,"title":{},"description":{"4":{},"5":{}}}],["index",{"_index":187,"title":{"11":{},"12":{}},"description":{}}],["inform",{"_index":151,"title":{"56":{}},"description":{"7":{}}}],["initi",{"_index":62,"title":{"1":{},"49":{},"52":{}},"description":{"1":{},"5":{},"48":{}}}],["instead",{"_index":80,"title":{},"description":{"1":{}}}],["instrument",{"_index":193,"title":{"17":{},"18":{}},"description":{}}],["integ",{"_index":216,"title":{},"description":{"27":{},"28":{},"53":{}}}],["integr",{"_index":106,"title":{"13":{},"14":{},"25":{},"26":{},"56":{}},"description":{"2":{},"50":{},"53":{}}}],["intend",{"_index":49,"title":{},"description":{"0":{}}}],["interact",{"_index":18,"title":{},"description":{"0":{}}}],["interfac",{"_index":43,"title":{},"description":{"0":{},"1":{}}}],["intern",{"_index":212,"title":{"27":{},"28":{}},"description":{"27":{},"28":{}}}],["ioctl",{"_index":45,"title":{},"description":{"0":{}}}],["jfjoch_brok",{"_index":370,"title":{"64":{}},"description":{}}],["jpeg",{"_index":353,"title":{"60":{}},"description":{}}],["jungfrau",{"_index":99,"title":{},"description":{"2":{},"42":{}}}],["jungfraujoch",{"_index":130,"title":{"37":{},"55":{},"56":{},"64":{}},"description":{"4":{},"29":{},"31":{},"33":{},"62":{},"63":{}}}],["kernel",{"_index":36,"title":{},"description":{"0":{}}}],["kernel'",{"_index":29,"title":{},"description":{"0":{}}}],["last",{"_index":285,"title":{},"description":{"46":{},"62":{}}}],["latest",{"_index":351,"title":{},"description":{"59":{}}}],["latter",{"_index":314,"title":{},"description":{"50":{},"53":{}}}],["librari",{"_index":35,"title":{},"description":{"0":{}}}],["licens",{"_index":0,"title":{"0":{}},"description":{"0":{}}}],["limit",{"_index":340,"title":{"56":{}},"description":{}}],["linux",{"_index":28,"title":{},"description":{"0":{}}}],["list",{"_index":230,"title":{"30":{}},"description":{"29":{}}}],["load",{"_index":210,"title":{"27":{},"28":{}},"description":{"27":{},"28":{}}}],["long",{"_index":105,"title":{},"description":{"2":{}}}],["make",{"_index":163,"title":{},"description":{"7":{}}}],["mask",{"_index":259,"title":{"35":{},"36":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}},"description":{"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["mean",{"_index":295,"title":{},"description":{"48":{},"51":{}}}],["mechan",{"_index":61,"title":{},"description":{"0":{}}}],["mere",{"_index":42,"title":{},"description":{"0":{}}}],["messag",{"_index":239,"title":{"58":{},"59":{}},"description":{"31":{},"33":{}}}],["metadata",{"_index":194,"title":{"17":{},"18":{},"33":{},"34":{}},"description":{"33":{},"58":{},"59":{}}}],["minut",{"_index":86,"title":{},"description":{"1":{}}}],["misbehav",{"_index":306,"title":{},"description":{"50":{},"53":{}}}],["mode",{"_index":308,"title":{},"description":{"50":{},"53":{}}}],["modul",{"_index":312,"title":{},"description":{"50":{},"53":{}}}],["module/storag",{"_index":288,"title":{},"description":{"47":{}}}],["moment",{"_index":261,"title":{},"description":{"35":{}}}],["more",{"_index":363,"title":{},"description":{"63":{}}}],["multipl",{"_index":227,"title":{},"description":{"29":{}}}],["need",{"_index":90,"title":{},"description":{"1":{},"2":{},"3":{},"50":{},"53":{}}}],["network",{"_index":59,"title":{},"description":{"0":{},"1":{},"7":{}}}],["new",{"_index":183,"title":{},"description":{"9":{}}}],["number",{"_index":217,"title":{},"description":{"27":{},"28":{}}}],["nxmx",{"_index":293,"title":{},"description":{"48":{},"50":{},"51":{},"53":{}}}],["on",{"_index":89,"title":{},"description":{"1":{},"2":{},"3":{},"9":{},"29":{}}}],["onc",{"_index":102,"title":{},"description":{"2":{}}}],["openapi",{"_index":14,"title":{},"description":{"0":{}}}],["oper",{"_index":74,"title":{},"description":{"1":{},"2":{},"9":{},"35":{},"63":{}}}],["option",{"_index":252,"title":{},"description":{"31":{}}}],["output",{"_index":197,"title":{"19":{},"20":{}},"description":{}}],["pedest",{"_index":79,"title":{"54":{}},"description":{"1":{},"2":{},"5":{},"7":{},"9":{}}}],["per",{"_index":103,"title":{},"description":{"2":{}}}],["period",{"_index":134,"title":{},"description":{"4":{},"5":{}}}],["pixel",{"_index":291,"title":{},"description":{"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["plot",{"_index":334,"title":{"55":{},"56":{}},"description":{}}],["point",{"_index":264,"title":{},"description":{"35":{}}}],["possibl",{"_index":139,"title":{},"description":{"4":{},"5":{},"35":{}}}],["post",{"_index":78,"title":{},"description":{"1":{},"2":{}}}],["power",{"_index":178,"title":{},"description":{"8":{}}}],["prepar",{"_index":170,"title":{"8":{}},"description":{}}],["preview",{"_index":238,"title":{"31":{},"32":{},"60":{},"61":{}},"description":{"31":{}}}],["preview/pedestal.tiff",{"_index":332,"title":{},"description":{"54":{}}}],["preview/plot",{"_index":335,"title":{},"description":{"55":{}}}],["preview/plot.bin",{"_index":341,"title":{},"description":{"56":{}}}],["procedur",{"_index":135,"title":{},"description":{"4":{},"5":{},"9":{}}}],["process",{"_index":158,"title":{"24":{}},"description":{"7":{}}}],["program",{"_index":41,"title":{},"description":{"0":{}}}],["provid",{"_index":136,"title":{"56":{}},"description":{"4":{},"5":{},"29":{},"47":{}}}],["provis",{"_index":8,"title":{},"description":{"0":{}}}],["psi",{"_index":262,"title":{},"description":{"35":{}}}],["pub",{"_index":255,"title":{},"description":{"33":{}}}],["puls",{"_index":270,"title":{"39":{}},"description":{"39":{}}}],["pusher",{"_index":277,"title":{"41":{}},"description":{}}],["put",{"_index":251,"title":{},"description":{"31":{},"33":{}}}],["raw",{"_index":200,"title":{"21":{},"56":{}},"description":{"50":{},"53":{}}}],["raw/convert",{"_index":219,"title":{},"description":{"27":{},"28":{}}}],["readi",{"_index":113,"title":{},"description":{"3":{},"4":{}}}],["recommend",{"_index":77,"title":{},"description":{"1":{},"2":{}}}],["reconfigur",{"_index":75,"title":{},"description":{"1":{}}}],["record",{"_index":273,"title":{},"description":{"39":{}}}],["regardless",{"_index":55,"title":{},"description":{"0":{}}}],["region",{"_index":307,"title":{},"description":{"50":{},"53":{}}}],["region-of-interest",{"_index":229,"title":{},"description":{"29":{}}}],["reiniti",{"_index":234,"title":{},"description":{"29":{}}}],["replac",{"_index":365,"title":{},"description":{"63":{}}}],["request",{"_index":121,"title":{},"description":{"3":{},"31":{},"33":{}}}],["requir",{"_index":21,"title":{},"description":{"0":{},"4":{},"5":{},"27":{},"28":{},"29":{}}}],["respons",{"_index":233,"title":{},"description":{"29":{}}}],["result",{"_index":284,"title":{"57":{}},"description":{"46":{}}}],["result/scan",{"_index":343,"title":{},"description":{"57":{}}}],["retri",{"_index":142,"title":{},"description":{"4":{},"5":{}}}],["return",{"_index":123,"title":{"39":{},"40":{}},"description":{"3":{},"39":{},"40":{}}}],["roi",{"_index":280,"title":{"43":{},"44":{}},"description":{}}],["run",{"_index":101,"title":{"4":{},"7":{}},"description":{"2":{},"3":{},"5":{},"7":{},"23":{},"62":{},"63":{}}}],["runtim",{"_index":34,"title":{},"description":{"0":{}}}],["safeti",{"_index":140,"title":{},"description":{"4":{},"5":{}}}],["save",{"_index":184,"title":{},"description":{"9":{}}}],["scan",{"_index":342,"title":{"57":{}},"description":{}}],["script",{"_index":128,"title":{},"description":{"4":{},"5":{}}}],["see",{"_index":292,"title":{},"description":{"48":{},"51":{}}}],["select",{"_index":225,"title":{"29":{}},"description":{"30":{}}}],["send",{"_index":149,"title":{"6":{},"56":{}},"description":{}}],["sent",{"_index":160,"title":{},"description":{"7":{}}}],["separ",{"_index":289,"title":{},"description":{"47":{}}}],["server",{"_index":132,"title":{},"description":{"4":{},"5":{}}}],["set",{"_index":118,"title":{"11":{},"13":{},"15":{},"16":{},"31":{},"32":{},"33":{},"34":{},"35":{},"36":{},"60":{}},"description":{"3":{},"9":{},"27":{},"28":{},"29":{},"31":{},"33":{}}}],["shadow",{"_index":305,"title":{},"description":{"50":{},"53":{}}}],["shutter",{"_index":72,"title":{},"description":{"1":{},"2":{}}}],["sign",{"_index":330,"title":{},"description":{"53":{}}}],["similar",{"_index":26,"title":{},"description":{"0":{}}}],["single-channel",{"_index":327,"title":{},"description":{"53":{}}}],["size",{"_index":218,"title":{},"description":{"27":{},"28":{}}}],["slot",{"_index":364,"title":{},"description":{"63":{}}}],["socket",{"_index":242,"title":{"34":{}},"description":{"31":{},"33":{}}}],["socket_address",{"_index":247,"title":{},"description":{"31":{},"33":{}}}],["soft",{"_index":150,"title":{"6":{}},"description":{"6":{}}}],["soft/ttl",{"_index":115,"title":{},"description":{"3":{}}}],["softwar",{"_index":148,"title":{},"description":{"5":{}}}],["sole",{"_index":12,"title":{},"description":{"0":{}}}],["specif",{"_index":52,"title":{},"description":{"0":{}}}],["spirit",{"_index":27,"title":{},"description":{"0":{}}}],["spot",{"_index":205,"title":{"23":{}},"description":{"50":{},"53":{}}}],["stack",{"_index":311,"title":{},"description":{"50":{},"53":{}}}],["stage",{"_index":155,"title":{},"description":{"7":{},"63":{}}}],["standard",{"_index":294,"title":{},"description":{"48":{},"51":{}}}],["start",{"_index":108,"title":{"3":{},"58":{}},"description":{"3":{}}}],["state",{"_index":39,"title":{},"description":{"0":{},"1":{},"2":{},"3":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"27":{},"28":{},"29":{},"35":{},"50":{},"51":{},"53":{}}}],["statist",{"_index":283,"title":{"45":{},"46":{},"47":{}},"description":{"45":{},"47":{}}}],["statistics/calibr",{"_index":290,"title":{},"description":{"47":{}}}],["statistics/data_collect",{"_index":286,"title":{},"description":{"46":{}}}],["statu",{"_index":266,"title":{"37":{},"38":{},"41":{},"42":{},"63":{}},"description":{"37":{},"42":{},"63":{}}}],["stop",{"_index":154,"title":{},"description":{"7":{},"50":{},"53":{}}}],["storag",{"_index":81,"title":{},"description":{"1":{}}}],["store",{"_index":321,"title":{},"description":{"50":{},"53":{}}}],["stream",{"_index":240,"title":{},"description":{"31":{},"33":{}}}],["structur",{"_index":245,"title":{},"description":{"31":{},"33":{}}}],["sub",{"_index":241,"title":{},"description":{"31":{}}}],["subject",{"_index":20,"title":{},"description":{"0":{}}}],["sure",{"_index":164,"title":{},"description":{"7":{}}}],["switch",{"_index":167,"title":{},"description":{"7":{}}}],["synchron",{"_index":147,"title":{},"description":{"5":{}}}],["syscal",{"_index":44,"title":{},"description":{"0":{}}}],["take",{"_index":166,"title":{},"description":{"7":{}}}],["term",{"_index":23,"title":{},"description":{"0":{}}}],["through",{"_index":58,"title":{},"description":{"0":{}}}],["tiff",{"_index":223,"title":{"28":{},"51":{},"52":{},"54":{},"61":{}},"description":{"28":{},"53":{}}}],["till",{"_index":129,"title":{},"description":{"4":{},"5":{}}}],["time",{"_index":84,"title":{},"description":{"1":{},"2":{},"4":{},"5":{},"7":{}}}],["timeout",{"_index":137,"title":{},"description":{"4":{},"5":{}}}],["transmit",{"_index":338,"title":{"56":{}},"description":{}}],["trigger",{"_index":116,"title":{"6":{}},"description":{"3":{},"6":{}}}],["true",{"_index":120,"title":{},"description":{"3":{}}}],["turn",{"_index":171,"title":{"8":{}},"description":{"8":{},"62":{}}}],["two",{"_index":66,"title":{},"description":{"1":{}}}],["under",{"_index":4,"title":{},"description":{"0":{}}}],["unsign",{"_index":320,"title":{},"description":{"50":{},"53":{}}}],["until",{"_index":112,"title":{},"description":{"3":{}}}],["updat",{"_index":97,"title":{},"description":{"2":{}}}],["upload",{"_index":282,"title":{"44":{},"50":{},"53":{}},"description":{"50":{},"53":{}}}],["us",{"_index":11,"title":{"56":{},"60":{}},"description":{"0":{},"1":{},"2":{},"3":{},"8":{},"30":{},"50":{},"53":{}}}],["user",{"_index":40,"title":{"49":{},"50":{},"52":{},"53":{}},"description":{"0":{},"49":{},"50":{},"52":{},"53":{}}}],["userspac",{"_index":31,"title":{},"description":{"0":{}}}],["valid",{"_index":331,"title":{},"description":{"53":{}}}],["valu",{"_index":296,"title":{"56":{}},"description":{"48":{},"50":{},"51":{},"53":{}}}],["version",{"_index":369,"title":{"64":{}},"description":{"64":{}}}],["via",{"_index":248,"title":{},"description":{"31":{},"33":{}}}],["volatil",{"_index":361,"title":{},"description":{"63":{}}}],["voltag",{"_index":174,"title":{},"description":{"8":{}}}],["wait",{"_index":126,"title":{"4":{},"5":{}},"description":{}}],["wait_till_don",{"_index":91,"title":{},"description":{"1":{},"2":{},"5":{}}}],["wait_until_run",{"_index":125,"title":{},"description":{"3":{},"4":{}}}],["web",{"_index":131,"title":{},"description":{"4":{},"5":{}}}],["well",{"_index":324,"title":{},"description":{"50":{},"53":{}}}],["whether",{"_index":56,"title":{},"description":{"0":{}}}],["wider",{"_index":51,"title":{},"description":{"0":{}}}],["without",{"_index":53,"title":{},"description":{"0":{}}}],["work",{"_index":48,"title":{},"description":{"0":{}}}],["writer",{"_index":161,"title":{"15":{},"16":{}},"description":{"7":{}}}],["x-axi",{"_index":339,"title":{"56":{}},"description":{}}],["x-ray",{"_index":71,"title":{},"description":{"1":{},"2":{},"9":{}}}],["xfel",{"_index":269,"title":{"39":{},"40":{}},"description":{"39":{},"40":{}}}],["xfel/event_cod",{"_index":276,"title":{},"description":{"40":{}}}],["xfel/pulse_id",{"_index":274,"title":{},"description":{"39":{}}}],["zeromq",{"_index":237,"title":{"31":{},"32":{},"33":{},"34":{}},"description":{"31":{},"33":{}}}]],"pipeline":[]}},"options":{}};
+      const __redoc_state = {"menu":{"activeItemIdx":-1},"spec":{"data":{"openapi":"3.0.3","info":{"title":"Jungfraujoch","description":"API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland).\nJungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU.\nJungfraujoch uses FPGA boards to acquire data at high data rates.\n\n# License Clarification\n\nWhile this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply**\nwhen this file is used solely to generate OpenAPI clients or when implementing applications that\ninteract with the API. Generated client code and applications using this API definition are not\nsubject to the GPL license requirements and may be distributed under terms of your choosing.\n\nThis exception is similar in spirit to the Linux Kernel's approach to userspace API headers and\nthe GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that\nuser programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not\nderivative works of the kernel and are not subject to the terms of the GPL.\n\nThis exception is intended to allow wider use of this API specification without imposing GPL\nrequirements on applications that merely interact with the API, regardless of whether they\ncommunicate through network calls or other mechanisms.\n","version":"1.0.0-rc.172","contact":{"name":"Filip Leonarski (Paul Scherrer Institute)","email":"filip.leonarski@psi.ch"},"license":{"name":"GPL-3.0","url":"https://www.gnu.org/licenses/gpl-3.0.html"}},"servers":[{"url":"http://localhost:5232","description":"Test Jungfraujoch system"}],"components":{"parameters":{"binning":{"in":"query","name":"binning","required":false,"schema":{"default":1,"type":"integer"},"description":"Binning of frames for the plot (0 = default binning)"},"experimental_coord":{"in":"query","name":"experimental_coord","required":false,"schema":{"type":"boolean","default":false},"description":"If measurement has goniometer axis defined, plot X-axis will represent rotation angle\nIf measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value\nFor still measurement the number is ignored\n"},"azint_unit":{"in":"query","name":"azint_unit","required":false,"schema":{"type":"string","enum":["Q_recipA","d_A","two_theta_deg"],"default":"Q_recipA"},"description":"Unit used for azim int.\n"},"fill_value":{"in":"query","name":"fill","required":false,"schema":{"type":"number","format":"float"},"description":"Fill value for elements that were missed during data collection\n"},"plot_type":{"in":"query","name":"type","required":true,"description":"Type of requested plot","schema":{"type":"string","enum":["bkg_estimate","spindle_blind_fraction","azint","azint_1d","spot_count","spot_count_low_res","spot_count_indexed","spot_count_ice","indexing_rate","indexing_lattice_count","indexing_unit_cell_length","indexing_unit_cell_angle","profile_radius","mosaicity","b_factor","error_pixels","saturated_pixels","image_collection_efficiency","receiver_delay","receiver_free_send_buf","strong_pixels","roi_sum","roi_mean","roi_max_count","roi_pixels","roi_weighted_x","roi_weighted_y","packets_received","max_pixel_value","resolution_estimate","pixel_sum","processing_time","beam_center_x","beam_center_y","integrated_reflections","image_scale_factor","image_scale_cc","compression_ratio","ice_ring_score"]}},"roi":{"in":"query","name":"roi","required":false,"schema":{"type":"string","minLength":1},"description":"Name of ROI for which plot is requested"},"image_id":{"in":"query","name":"id","required":false,"schema":{"type":"integer","format":"int64","default":-1,"minimum":-2},"description":"Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer"},"saturation":{"in":"query","name":"saturation","required":false,"schema":{"type":"number","format":"float","minimum":-32767,"maximum":32767},"description":"Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used"},"background":{"in":"query","name":"background","required":false,"schema":{"type":"number","format":"float","default":0,"minimum":-32767,"maximum":32767},"description":"Background value to set contrast in the preview image"},"show_spots":{"in":"query","name":"show_spots","schema":{"type":"boolean","default":true},"description":"Show spot finding results on the image"},"show_predictions":{"in":"query","name":"show_predictions","schema":{"type":"boolean","default":false},"description":"Show Bragg spot predictions on the image (if available for the image)"},"show_beam_center":{"in":"query","name":"show_beam_center","schema":{"type":"boolean","default":true},"description":"Show beam center on the image"},"show_roi":{"in":"query","name":"show_roi","schema":{"type":"boolean","default":false},"description":"Show ROI areas on the image"},"jpeg_quality":{"in":"query","name":"jpeg_quality","description":"Quality of JPEG image (100 - highest; 0 - lowest)","schema":{"type":"integer","format":"int64","default":100,"minimum":0,"maximum":100}},"show_user_mask":{"in":"query","name":"show_user_mask","schema":{"type":"boolean","default":false},"description":"Show user mask"},"resolution_ring":{"in":"query","name":"show_res_ring","description":"Show resolution ring, provided in Angstrom","schema":{"type":"number","format":"float","default":0.1,"minimum":0.1,"maximum":100}},"resolution_estimate":{"in":"query","name":"show_res_est","description":"Show resolution estimation as a ring","schema":{"type":"boolean","default":false}},"color_scale":{"in":"query","name":"color","description":"Color scale for preview image","schema":{"type":"string","enum":["indigo","viridis","bw","wb","green","heat","magma","inferno"],"default":"indigo"}}},"schemas":{"grid_scan":{"description":"Definition of a grid scan. Combine it with a goniometer axis to state the angle the spindle\nstood at: send `goniometer` with `step` 0 and the `start` angle of the grid scan, and that\nangle is written per image into the NXmx sample transformation chain. Without one the\nspindle is recorded at 0, which says that nobody stated an angle rather than that the\nspindle stood at 0.\n","type":"object","required":["n_fast","step_x_um","step_y_um"],"properties":{"n_fast":{"type":"integer","format":"int64","minimum":1,"example":20,"description":"Number of elements in the fast direction"},"step_x_um":{"type":"number","format":"float","example":5,"description":"Step in grid along the fast direction. Can be negative. \nPositive number: left to right\nNegative number: right to left\n"},"step_y_um":{"type":"number","format":"float","example":-3,"description":"Step in grid along the slow direction. Can be negative. \nPositive number: top to bottom\nNegative number: bottom to top\n"},"vertical":{"type":"boolean","default":false,"description":"If disabled: fast direction = X, slow direction = Y\nIf enabled: fast direction = Y, slow direction = X\n"},"snake":{"type":"boolean","default":false,"description":"Flip fast direction for every second row\n"}}},"rotation_axis":{"description":"Definition of a crystal rotation axis","type":"object","required":["step","vector"],"properties":{"name":{"type":"string","default":"omega","minLength":1,"description":"Name of rotation axis (e.g., omega, phi)"},"step":{"type":"number","format":"float","example":0.1,"description":"Angle step (per image) in degrees. 0 for an axis that does not turn: the axis then\nrecords the angle the spindle stood at, which is how a grid scan or a set of stills\nstates its head position.\n"},"start":{"type":"number","format":"float","example":50,"description":"Start angle in degrees","default":0},"vector":{"type":"array","description":"Rotation axis","example":[1,0,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"helical_step_um":{"type":"array","description":"Translation (per image) for helical scan","example":[-5,-2,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"screening_wedge_deg":{"type":"number","format":"float","description":"Wedge angle value; used if rotation per image is smaller than increment between images (so particularly in screening)"}}},"indexing_algorithm":{"type":"string","description":"Selection of an indexing algorithm used by Jungfraujoch\n","enum":["FFBIDX","FFT","FFTW","Auto","None"],"default":"FFBIDX"},"geom_refinement_algorithm":{"type":"string","description":"Selection of an post-indexing least-square diffraction geometry refinement algorithm used by Jungfraujoch.\nBeamCenter - This option is refining both beam center and lattice (restricted to a chosen/detected Bravais lattice).\nOrientationOnly - This option is refining only orientation of the lattice.\nFlex - Tries all per-image refinements and keeps whichever indexes the most spots, letting the pipeline decide (the rugnux flex mode).\n","enum":["BeamCenter","OrientationOnly","Flex","None"]},"integration_model":{"type":"string","description":"Bragg spot integration model.\nProfileGaussian - profile fit with a measured-width Gaussian (Kabsch-style), the default; more\n  accurate intensities than box summation.\nProfileEmpirical - profile fit with a per-resolution-shell empirical profile learned from strong spots.\nBoxSum - classical uniform box summation minus a ring-mean background; the simpler, faster fallback.\n","enum":["ProfileGaussian","ProfileEmpirical","BoxSum"],"default":"ProfileGaussian"},"dataset_settings":{"type":"object","required":["beam_x_pxl","beam_y_pxl","detector_distance_mm","incident_energy_keV"],"properties":{"images_per_trigger":{"type":"integer","format":"int64","minimum":1,"default":1,"description":"For standard synchrotron data collection - this is number of images collected per one TTL trigger\nFor XFEL (pulsed source) - this number is ignored and set to 1\nFor storage cell mode - this number is ignored and set to number of storage cells\n"},"ntrigger":{"type":"integer","format":"int64","default":1,"minimum":1,"description":"Number of TTL trigger that the detector is expected to receive during data collection\n"},"image_time_us":{"type":"integer","format":"int64","minimum":0,"description":"Image time. \nIf not provided (or zero value) the frame time is assumed as default.\nFor JUNGFRAU image time must be multiple of frame time and max value is 256 * frame_time.            \nIn XFEL mode: summation happens for frames collected with multiple triggers.\nIgnored for storage cells and if raw data are saved.\n"},"beam_x_pxl":{"type":"number","format":"float","description":"/entry/detector/beam_center_x in NXmx\nBeam center in X direction [pixels]\n"},"beam_y_pxl":{"type":"number","format":"float","description":"/entry/detector/beam_center_y in NXmx\nBeam center in X direction [pixels]\n"},"detector_distance_mm":{"type":"number","format":"float","minimum":0,"description":"/entry/detector/distance in NXmx Detector distance [mm]"},"incident_energy_keV":{"type":"number","format":"float","minimum":0.001,"maximum":500,"description":"Used to calculate /entry/beam/incident_wavelength in NXmx\nIncident particle (photon, electron) energy in keV\n"},"file_prefix":{"type":"string","default":"","description":"Prefix for filenames. If left empty, no file will be saved."},"images_per_file":{"type":"integer","format":"int64","minimum":1,"description":"Number of images in a single HDF5 data file, taken literally when given.\nIf omitted, it is chosen from the acquisition: a rotation sweep of at most 20000 images\ngoes into a single data file, so the dataset stays readable by programs that follow only\nthe first data file of a legacy master; a grid scan is split on a whole number of fast-axis\nrows; anything else (stills, serial) uses 1000.\n"},"space_group_number":{"type":"integer","format":"int64","minimum":1,"maximum":230,"description":"Number of space group for the crystal. Currently used solely as metadata, not relevant for image processing done in Jungfraujoch."},"sample_name":{"type":"string","default":"","description":"/entry/sample/name in NXmx\nSample name\n"},"compression":{"type":"string","enum":["bslz4","bszstd","bszstd_rle","bszstd_rlehuf","none"],"default":"bslz4","description":"Compression type for the images transferred over ZeroMQ and saved to HDF5 file.\n"},"total_flux":{"type":"number","format":"float","description":"/entry/beam/total_flux in NXmx\nFlux incident on beam plane in photons per second. In other words this is the flux integrated over area. [photons/s]\n"},"transmission":{"type":"number","format":"float","minimum":0,"maximum":1,"description":"/entry/instrument/attenuator/attenuator_transmission\nTransmission of attenuator (filter) [no units]\n"},"beam_size_x_um":{"type":"number","format":"float","minimum":0,"description":"First element of /entry/instrument/beam/incident_beam_size in NXmx\nHorizontal size of the X-ray beam where it meets the sample - the FWHM of a focused beam,\nthe full width of a slit-defined one. [um]\n"},"beam_size_y_um":{"type":"number","format":"float","minimum":0,"description":"Second element of /entry/instrument/beam/incident_beam_size in NXmx\nVertical size of the X-ray beam where it meets the sample. [um]\n"},"goniometer":{"$ref":"#/components/schemas/rotation_axis"},"grid_scan":{"$ref":"#/components/schemas/grid_scan"},"header_appendix":{"description":"Header appendix, added as user_data/user to start ZeroMQ message (can be any valid JSON)\nIn general, it is not saved in HDF5 file.\n\nHowever, if values are placed in \"hdf5\" object, `jfjoch_writer` will write them in /entry/user of the HDF5 file. \nThis applies solely to string and number (double floating-point). No arrays/sub-objects is allowed.\nFor example {\"hdf5\": {\"val1\":1, \"val2\":\"xyz\"}}, will write /entry/user/val1 and /entry/user/val2.\n"},"image_appendix":{"description":"Image appendix, added as user_data to image ZeroMQ message (can be any valid JSON)\nNot saved in HDF5 file\n"},"data_reduction_factor_serialmx":{"type":"number","format":"float","default":1,"minimum":0,"maximum":1,"description":"Rate at which non-indexed images are accepted to be forwarded to writer. \nValue of 1.0 (default) means that all images are written.\nValues below zero mean that non-indexed images will be accepted with a given probability.\n"},"pixel_value_low_threshold":{"type":"integer","format":"int64","minimum":0,"description":"Set all counts lower than the value to zero. \nWhen the value is set, negative numbers other than error pixel value are always set to zero.\nSetting to zero is equivalent to turning the option off.\n"},"run_number":{"type":"integer","format":"int64","minimum":0,"description":"Number of run within an experimental session. \nTransferred over CBOR stream as \"series ID\", though not saved in HDF5 file.\nIt is highly recommended to keep this number unique for each data collection during experimental series.\nIf not provided, the number will be automatically incremented.\n"},"run_name":{"type":"string","description":"Unique ID of run.\nTransferred over CBOR stream as \"unique series ID\", though not saved in HDF5 file.\nIt is highly recommended to keep this name unique for each data collection during experimental series.\nIf not provided, the name will be automatically generated as number + colon + file_prefix.\n"},"experiment_group":{"type":"string","description":"Name of group owning the data (e.g. p-group or proposal number). \nTransferred over CBOR stream, though not saved in HDF5 file.\n"},"poisson_compression":{"type":"integer","format":"int64","minimum":0,"maximum":16,"description":"Enable lossy compression of pixel values that preserves Poisson statistics. \nRequires to provide a numerical factor SQ.\nPixel value P will be transformed to round(sqrt(P) * SQ), with rounding to the closest integer.\nCompression is turned off if the value is missing or it is set to zero.\n"},"write_nxmx_hdf5_master":{"type":"boolean","default":true,"description":"Write NXmx formatted HDF5 master file. Recommended to use for macromolecular crystallography experiments\nand to turn off for other experiments.\n"},"save_calibration":{"type":"boolean","description":"Forward image calibration (at the moment pedestal and pedestal RMS for JUNGFRAU) using the ZeroMQ stream to writer.\nIf parameter is not provided calibration will be saved only if more than 4 images are recorded.\n"},"polarization_factor":{"type":"number","description":"Polarization factor for integration; 1.0 is horizontal polarization; -1.0 is vertical polarization","format":"float","minimum":-1,"maximum":1},"ring_current_mA":{"type":"number","format":"float","description":"Ring current at the beginning of the data collection","minimum":0},"sample_temperature_K":{"type":"number","format":"float","description":"Sample temperature in Kelvin","minimum":0},"poni_rot1_rad":{"type":"number","description":"PONI angle rot1 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"poni_rot2_rad":{"type":"number","description":"PONI angle rot2 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"poni_rot3_rad":{"type":"number","description":"PONI angle rot3 (see PyFAI documentation for details) in radians","format":"float","minimum":-6.28318530718,"maximum":6.28318530718,"default":0},"unit_cell":{"$ref":"#/components/schemas/unit_cell"},"spot_finding":{"type":"boolean","description":"Enable spot finding and save spots","default":true},"smargon":{"type":"object","description":"Geometry of Smargon goniometer at SLS 2.0 / MX beamlines. \nAssuming that Smargon is used as static positioner and not moving during the scan, allowing to reconstruct geometry.\n","required":["phi_deg","chi_deg"],"properties":{"phi_deg":{"type":"number","format":"float","description":"Phi angle in degrees"},"chi_deg":{"type":"number","format":"float","description":"Chi angle in degrees"},"phi_axis":{"type":"array","description":"Phi rotation axis","default":[1,0,0],"example":[1,0,0],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3},"chi_axis":{"type":"array","description":"Chi rotation axis","default":[0,0,1],"example":[0,0,1],"items":{"type":"number","format":"float"},"minItems":3,"maxItems":3}}},"max_spot_count":{"type":"integer","minimum":10,"maximum":2000,"default":250,"description":"Maximum number of spots that are saved/used for indexing; spots with highest intensity are selected"},"detect_ice_rings":{"type":"boolean","description":"Flag spots as ice rings and reduce their effect on indexing"},"async_start":{"type":"boolean","default":false,"description":"When set to true, `/start` will not wait for detector and Jungfraujoch to be ready for the measurement."},"xray_fluorescence_spectrum":{"type":"object","required":["energy_eV","data"],"properties":{"energy_eV":{"type":"array","items":{"type":"number","format":"float"},"description":"X-ray fluorescence scan energy for each measurement point"},"data":{"type":"array","items":{"type":"number","format":"float"},"description":"X-ray fluorescence scan result in arbitrary units; must be exactly the same length, as energy_eV"}}}}},"crystal_lattice":{"type":"array","items":{"type":"number","format":"float"},"minItems":9,"maxItems":9,"description":"Real-space crystal lattice 3D vectors in Angstrom.\nOrder is 1st vector (x,y,z), 2nd vector (x,y,z) and 3rd vector (x,y,z)\n"},"unit_cell":{"type":"object","description":"Unit cell parameters. Necessary to run indexing. Units of angstrom and degree","required":["a","b","c","alpha","beta","gamma"],"properties":{"a":{"type":"number","format":"float","example":37,"minimum":0},"b":{"type":"number","format":"float","example":37,"minimum":0},"c":{"type":"number","format":"float","example":78,"minimum":0},"alpha":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360},"beta":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360},"gamma":{"type":"number","format":"float","example":90,"minimum":0,"maximum":360}}},"file_writer_format":{"type":"string","enum":["NXmxOnlyData","NXmxLegacy","NXmxVDS","NXmxIntegrated","CBF","TIFF","NoFileWritten"],"default":"NXmxVDS","description":"NoFileWritten - no files are written at all\nNXmxOnlyData - only data files are written, no master file\nNXmxLegacy - legacy format with soft links to data files in the master file; necessary for DECTRIS Albula 4.0 and DECTRIS Neggia\nNXmxVDS - newer format with virtual dataset linking data files in the master file, also includes better metadata handling\nNXmxIntegrated - single HDF5 per dataset\nCBF - DEPRECATED, no longer supported; kept for back compatibility only. Requests using this value are rejected. Only HDF5 formats are written.\nTIFF - DEPRECATED, no longer supported; kept for back compatibility only. Requests using this value are rejected. Only HDF5 formats are written.\n"},"file_writer_settings":{"type":"object","properties":{"overwrite":{"type":"boolean","default":false,"description":"Inform jfjoch_write to overwrite existing files. Otherwise files would be saved with .h5.{timestamp}.tmp suffix.\n"},"format":{"$ref":"#/components/schemas/file_writer_format"}}},"pixel_mask_statistics":{"type":"object","properties":{"user_mask":{"description":"Number of pixels masked using the user mask","type":"integer","format":"int64","minimum":0},"too_high_pedestal_rms":{"description":"Number of pixels with G0 pedestal RMS higher than provided threshold","type":"integer","format":"int64","minimum":0},"wrong_gain":{"description":"Number of pixels that show wrong gain level during the pedestal procedure","type":"integer","format":"int64","minimum":0}}},"image_buffer_status":{"type":"object","required":["image_numbers","total_slots","in_preparation_slots","in_sending_slots","available_slots","max_image_number","min_image_number"],"properties":{"min_image_number":{"type":"integer","format":"int64","minimum":0,"description":"Smallest image number available in the buffer"},"max_image_number":{"type":"integer","format":"int64","minimum":0,"description":"Largest image number available in the buffer"},"image_numbers":{"type":"array","description":"Image numbers currently present in the buffer.","items":{"type":"integer","format":"int64"}},"total_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer. This number, compared to number of images in data collection and\nframe rate will determine \"retention\" rate of the image buffer.\n"},"available_slots":{"type":"integer","format":"int64","description":"Slots available for the data collection"},"in_preparation_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer that are currently in preparation for sending.\n"},"in_sending_slots":{"type":"integer","format":"int64","description":"Number of slots in the image buffer that are currently sending/writing data.\n"},"current_counter":{"type":"integer","format":"int64","description":"Counter of changes in the image buffer - either new start message or new image added.\nFor optimization one can only load new images/datasets from the HTTP if this value changes.\nCounter is optional as it was not implemented in older versions to avoid breaking change\n"}}},"image_format_settings":{"type":"object","required":["summation","jungfrau_conversion","geometry_transform","mask_chip_edges","mask_module_edges","apply_mask"],"properties":{"summation":{"type":"boolean","description":"Enable summation of images to a given image_time\nIf disabled images are saved according to original detector speed, but image count is adjusted\n"},"geometry_transform":{"type":"boolean","description":"Place module read-out into their location on composed detector and extend multipixels\n"},"jungfrau_conversion":{"type":"boolean","description":"Convert pixel value in ADU to photon counts/energy\nOnly affects JUNGFRAU detector\n"},"jungfrau_conversion_factor_keV":{"type":"number","format":"float","minimum":0.001,"maximum":500,"description":"Used to convert energy deposited into pixel to counts\nIf not provided incident_energy_keV is used\n"},"bit_depth_image":{"type":"integer","format":"int64","enum":[8,16,32],"description":"Bit depth of resulting image (it doesn't affect the detector read-out value)\nIf not provided value is adjusted automatically\n"},"signed_output":{"type":"boolean","description":"Controls if pixels have signed output\nIf not provided value is adjusted automatically\n"},"mask_module_edges":{"type":"boolean","default":true,"description":"Mask 1 pixel on the module boundary\n"},"mask_chip_edges":{"type":"boolean","default":true,"description":"Mask multipixels on chip boundary\n"},"jungfrau_mask_pixels_without_g0":{"type":"boolean","default":true,"description":"JUNGFRAU: mask pixels that don't operate in G0, but do operate in G1 and G1.\nThis should be turned off for cases, where detector is operated at room temperature with long exposure time.\n"},"apply_mask":{"type":"boolean","default":false,"description":"Masked pixels are set to special value in the images produced by Jungfraujoch\n"},"jungfrau_pedestal_g0_rms_limit":{"type":"integer","format":"int64","default":100,"minimum":0,"description":"Pixels with pedestal G0 RMS above the threshold are marked as masked pixels"}}},"detector_power_state":{"type":"string","description":"Power on of ASICs","enum":["PowerOn","PowerOff","Partial"]},"detector_state":{"type":"string","description":"Current state of the detector","enum":["Idle","Waiting","Busy","Error","Not connected"]},"detector_status":{"type":"object","required":["state","powerchip","server_version","number_of_triggers_left","fpga_temp_degC","high_voltage_V"],"properties":{"state":{"$ref":"#/components/schemas/detector_state"},"powerchip":{"$ref":"#/components/schemas/detector_power_state"},"server_version":{"type":"string","description":"Detector server (on read-out boards) version"},"number_of_triggers_left":{"type":"integer","format":"int64","description":"Remaining triggers to the detector (max of all modules)"},"fpga_temp_degC":{"type":"array","description":"Temperature of detector FPGAs","items":{"type":"integer","format":"int64"}},"high_voltage_V":{"type":"array","description":"High voltage for detector modules","items":{"type":"integer","format":"int64"}}}},"detector_timing":{"type":"string","enum":["auto","trigger","burst","gated"],"default":"trigger"},"detector_settings":{"type":"object","required":["frame_time_us"],"properties":{"frame_time_us":{"type":"integer","description":"Interval between consecutive frames.\nThis is internal frame time for the JUNGFRAU detector, image time has to be integer multiply of this number.\nFor EIGER detector this is default frame time, not used otherwise\n","format":"int64","minimum":1},"count_time_us":{"type":"integer","description":"Integration time of the detector. \nIf not provided count time will be set to maximum value for a given frame time.\n","format":"int64"},"internal_frame_generator":{"type":"boolean","default":false,"description":"Use internal frame generator in FPGA instead of getting data from a real detector"},"internal_frame_generator_images":{"type":"integer","format":"int64","default":1,"minimum":1,"maximum":64,"description":"Number of images stored in the internal frame generator."},"detector_trigger_delay_ns":{"type":"integer","format":"int64","minimum":0,"default":0,"description":"Delay between TTL trigger and acquisition start [ns]"},"timing":{"$ref":"#/components/schemas/detector_timing"},"eiger_threshold_keV":{"type":"number","format":"float","minimum":1,"maximum":100,"description":"Threshold for the PSI EIGER detector and all DECTRIS detectors.\nIf value is provided, it will be used for all subsequent acquisitions, irrespective of beam energy.\nIf value is not provided, threshold will be determined on start of acquisition as half of incident energy. \nThis might lead to increased start time.\n"},"eiger_bit_depth":{"type":"integer","format":"int64","enum":[8,16,32],"description":"Bit depth of PSI EIGER read-out. This is  \nIf value is not provided, depth will be determined based on the image time:\n* Exposure time < 500 microseconds depth of 8 bit will be used,\n* 500 <= exposure time < 2622 microseconds depth of 16 bit will be used\n* Exposure time >= 2622 microseconds depth of 32 bit will be used.\n"},"jungfrau_pedestal_g0_frames":{"type":"integer","format":"int64","default":2000,"minimum":0},"jungfrau_pedestal_g1_frames":{"type":"integer","format":"int64","default":300,"minimum":0},"jungfrau_pedestal_g2_frames":{"type":"integer","format":"int64","default":300,"minimum":0},"jungfrau_pedestal_min_image_count":{"type":"integer","format":"int64","default":128,"minimum":32,"description":"Minimum number of collected images for pedestal to consider it viable"},"jungfrau_storage_cell_count":{"type":"integer","format":"int64","default":1,"minimum":1,"maximum":16},"jungfrau_storage_cell_delay_ns":{"type":"integer","format":"int64","minimum":2100,"default":5000,"description":"Delay between two storage cells [ns]"},"jungfrau_fixed_gain_g1":{"type":"boolean","default":false,"description":"Fix gain to G1 (can be useful for storage cells)"},"jungfrau_use_gain_hg0":{"type":"boolean","default":false,"description":"Use high G0 (for low energy applications)"}}},"spot_finding_settings":{"type":"object","required":["enable","indexing","signal_to_noise_threshold","photon_count_threshold","max_pix_per_spot","min_pix_per_spot","quick_integration","high_resolution_limit_for_spot_count_low_res","ice_ring_width_q_recipA"],"properties":{"enable":{"type":"boolean","default":true,"description":"Enable spot finding. This is temporary setting, i.e. can be changed anytime during data collection. \nEven if disabled spot finding information will still be send and written, though always with zero spots.\n"},"indexing":{"type":"boolean","default":true,"description":"Enable indexing. This is temporary setting, i.e. can be changed anytime during data collection.\n"},"signal_to_noise_threshold":{"type":"number","format":"float","minimum":0},"photon_count_threshold":{"type":"integer","format":"int64","minimum":0},"min_pix_per_spot":{"type":"integer","format":"int64","minimum":1},"max_pix_per_spot":{"type":"integer","format":"int64","minimum":1},"high_resolution_limit":{"type":"number","format":"float","description":"High resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding extends\nas far as the detector reaches, i.e. the detection is not clipped in resolution.\n"},"low_resolution_limit":{"type":"number","format":"float","description":"Low resolution limit for spot finding [Angstrom]. Optional: if omitted, spot finding is not\nclipped at the low-resolution end. A value of 0 is accepted and means the same thing.\n"},"high_resolution_limit_for_spot_count_low_res":{"type":"number","format":"float","description":"High resolution threshold to consider spot \"low resolution\" [Angstrom]","minimum":2,"maximum":8},"quick_integration":{"type":"boolean","default":false,"description":"Quick integration of Bragg spots in diffraction images.\nIf enabled it will likely reduce performance of Jungfraujoch for datasets with a very high indexing rate.\n(experimental feature)\n"},"ice_ring_width_q_recipA":{"type":"number","format":"float","minimum":0,"maximum":1,"default":0.03,"description":"Half-width of the ice ring band in q (1/A). Matches the offline default in image_analysis/spot_finding/SpotFindingSettings.h, which was set from a measured ring FWHM of ~0.06; the two must agree or the same data gets a narrower ice band online."},"high_res_gap_Q_recipA":{"type":"number","format":"float","minimum":0.1,"maximum":5,"default":1.5,"description":"This parameter is used to remove spurious spots at a very high resolution, that sometimes appear due to very low background close to the edge of the detector.\nIf there is a gap in (1/d)-space between spots of at least this size, spots on the side of the gap with high resolution will be discarded. This is optional parameter.\nThis option should be turned OFF for small molecule datasets or for crystals with very low mosaicity, when it is expected to see only few spots in any case.\n"},"adaptive_threshold":{"type":"boolean","default":false,"description":"Self-calibrating spot detection: replace the fixed photon_count_threshold by a per-resolution-ring\nthreshold derived from each image's own noise, so the same setting works across datasets without\nper-dataset tuning. photon_count_threshold is then ignored and false_pixels_per_frame sets the\noperating point instead.\nOnly available on detectors whose images are analysed in software (the DECTRIS/SIMPLON workflow).\nThe JUNGFRAU and EIGER workflows find spots on the FPGA, which applies its own fixed threshold,\nso enabling this there is rejected rather than silently ignored.\n"},"false_pixels_per_frame":{"type":"number","format":"float","minimum":1,"maximum":100000,"default":100,"description":"Operating point of the adaptive threshold: the number of noise pixels tolerated per frame.\nAbout 100 suits a multi-megapixel detector. Ignored unless adaptive_threshold is set.\n"}}},"azim_int_settings":{"type":"object","required":["solid_angle_corr","polarization_corr","low_q_recipA","q_spacing"],"properties":{"polarization_corr":{"type":"boolean","description":"Apply polarization correction for azimuthal integration (polarization factor must be configured in dataset settings)","default":true},"solid_angle_corr":{"type":"boolean","description":"Apply solid angle correction for azimuthal integration","default":true},"high_q_recipA":{"type":"number","minimum":0.00002,"maximum":10,"format":"float","description":"Upper q limit of the azimuthal integration [1/Angstrom]. Optional: if omitted, the integration\n(and the adaptive spot detection that shares these q bins) extends to the highest q the\ndetector reaches.\n"},"low_q_recipA":{"type":"number","format":"float","minimum":0.00001,"maximum":10},"q_spacing":{"type":"number","format":"float","minimum":0.00001},"azimuthal_bins":{"type":"integer","format":"int64","minimum":1,"maximum":512,"default":1,"description":"Numer of azimuthal (phi) bins; 1 = standard 1D azimuthal integration"},"force_cpu":{"type":"boolean","default":false,"description":"Force CPU processing of azimuthal integration in the FPGA data acquisition workflow.\nThis allows to extend number of azimuthal integration bins, as well as to calculate standard deviation\nof the azimuthal integration results.\n"}}},"detector_list_element":{"type":"object","required":["id","nmodules","description","width","height","serial_number","base_ipv4_addr","udp_interface_count","readout_time_ns","min_frame_time_ns","min_count_time_ns"],"properties":{"id":{"type":"integer","format":"int64","minimum":0},"description":{"type":"string","example":"JUNGFRAU 4 Mpixel"},"serial_number":{"type":"string","example":"JF17T16V01"},"base_ipv4_addr":{"type":"string","example":"10.10.10.1"},"udp_interface_count":{"type":"integer","format":"int64","example":2,"description":"Number of UDP interfaces per detector module"},"nmodules":{"type":"integer","format":"int64","example":18},"width":{"type":"integer","format":"int64","example":2068},"height":{"type":"integer","format":"int64","example":2164},"pixel_size_mm":{"type":"number","format":"float","example":0.075},"readout_time_ns":{"type":"integer","format":"int64"},"min_frame_time_ns":{"type":"integer","format":"int64"},"min_count_time_ns":{"type":"integer","format":"int64"},"type":{"$ref":"#/components/schemas/detector_type"}}},"detector_list":{"type":"object","required":["detectors","current_id"],"properties":{"detectors":{"type":"array","items":{"$ref":"#/components/schemas/detector_list_element"}},"current_id":{"type":"integer","format":"int64","example":0}}},"detector_selection":{"type":"object","required":["id"],"properties":{"id":{"type":"integer","format":"int64","example":1}}},"measurement_statistics":{"type":"object","properties":{"file_prefix":{"type":"string"},"run_number":{"type":"integer","format":"int64","description":"Number of data collection run. This can be either automatically incremented or provided externally for each data collection.\n"},"experiment_group":{"type":"string","description":"Name of group owning the data (e.g. p-group or proposal number).\n"},"images_expected":{"type":"integer","format":"int64"},"images_collected":{"type":"integer","format":"int64","description":"Images collected by the receiver. This number will be lower than images expected if there were issues with data collection performance.\n"},"images_sent":{"type":"integer","format":"int64","description":"Images sent to the writer. \nThe value does not include images discarded by lossy compression filter and images not forwarded due to full ZeroMQ queue.\n"},"images_written":{"type":"integer","format":"int64","description":"Images successfully written to disk.\nThe value is live updated for TCP/IP socket and direct HDF5 writer, while for ZeroMQ it is only updated at the end of experiment.\n"},"images_discarded_lossy_compression":{"type":"integer","format":"int64","description":"Images discarded by the lossy compression filter"},"max_image_number_sent":{"type":"integer","format":"int64"},"collection_efficiency":{"type":"number","format":"float","example":1,"minimum":0,"maximum":1},"compression_ratio":{"type":"number","format":"float","example":5.3,"minimum":0},"cancelled":{"type":"boolean"},"max_receiver_delay":{"type":"integer","format":"int64"},"indexing_rate":{"type":"number","format":"float"},"detector_width":{"type":"integer","format":"int64"},"detector_height":{"type":"integer","format":"int64"},"detector_pixel_depth":{"type":"integer","format":"int64","enum":[2,4]},"bkg_estimate":{"type":"number","format":"float"},"unit_cell":{"type":"string"},"error_pixels":{"type":"number","format":"float","description":"Moving average of 1000 images counting number of error pixels on the detector"},"saturated_pixels":{"type":"number","format":"float","description":"Moving average of 1000 images counting number of saturated pixels on the detector"},"roi_beam_pixels":{"type":"number","format":"float","description":"If there is an ROI defined with name \"beam\", this number will hold moving average of 1000 images\nfor number of valid pixels within this ROI\n"},"roi_beam_sum":{"type":"number","format":"float","description":"If there is an ROI defined with name \"beam\", this number will hold moving average of 1000 images\nfor sum of valid pixels within this ROI\n"}}},"fpga_status":{"type":"array","items":{"type":"object","required":["pci_dev_id","serial_number","base_mac_addr","eth_link_status","eth_link_count","eth_link_speed","power_usage_W","fpga_temp_C","hbm_temp_C","packets_sls","packets_udp","idle","fw_version","pcie_link_speed","pcie_link_width"],"properties":{"pci_dev_id":{"type":"string"},"serial_number":{"type":"string"},"fw_version":{"type":"string"},"base_mac_addr":{"type":"string"},"eth_link_count":{"type":"integer","format":"int64"},"eth_link_status":{"type":"integer","format":"int64"},"power_usage_W":{"type":"number","format":"float"},"fpga_temp_C":{"type":"number","format":"float"},"hbm_temp_C":{"type":"number","format":"float"},"packets_udp":{"type":"integer","format":"int64"},"packets_sls":{"type":"integer","format":"int64"},"idle":{"type":"boolean"},"pcie_link_speed":{"type":"integer","format":"int64","description":"PCIe link speed measured by generation (expected value is 4 == PCIe Gen4)"},"pcie_link_width":{"type":"integer","format":"int64","description":"PCIe link width (expected value is 8 == x8)"}}}},"broker_status":{"type":"object","required":["state"],"properties":{"state":{"type":"string","enum":["Inactive","Idle","Busy","Measuring","Pedestal","Error"]},"progress":{"type":"number","format":"float","description":"Progress of data collection (only available if receiving is running)","example":1,"minimum":0,"maximum":1},"message":{"type":"string","description":"Message to display besides state of the jfjoch_broker; mostly used for errors and warnings\nThis matters especially for async functions (start/initialize), where API won't return reason\nfor the error during async operation.\n"},"message_severity":{"type":"string","enum":["success","info","warning","error"],"default":"error","description":"Level of the message to display"},"gpu_count":{"type":"integer","format":"int32","description":"Number of installed GPUs"},"broker_version":{"type":"string","description":"Version of the jfjoch_broker","example":"1.0.0-rc.128"}}},"image_pusher_status":{"type":"object","required":["pusher_type","addr","connected_writers"],"description":"Informs about status of the image pusher.\n","properties":{"pusher_type":{"$ref":"#/components/schemas/image_pusher_type"},"addr":{"type":"array","items":{"type":"string"},"example":["tcp://1.2.3.4:5000","tcp://1.2.3.4:5001"],"description":"List of addresses of image pushers.\nFor HDF5 socket - no addresses will be returned.\nFor ZeroMQ - list of addresses for each socket will be provided.\nFor TCP/IP - single address to connect all writers will be provided.\n"},"connected_writers":{"type":"integer","format":"int64","minimum":0,"description":"Number of connected writers \nFor ZeroMQ image socket: number is constant\nFor TCP/IP image socket: number is updated live during operation\n"},"images_written":{"type":"integer","format":"int64","minimum":0,"description":"Number of images written to the image socket.\nThis number is updated live during operation for TCP/IP image socket and direct HDF5 writer.\nIt is updated at the end of experiment for ZeroMQ image socket.\n"},"images_write_error":{"type":"integer","format":"int64","minimum":0,"description":"Number of images that could not be written to the image socket.\nThis number is updated live during operation for TCP/IP image socket.\nNo other socket use it.\n"},"writer_fifo_utilization":{"type":"array","items":{"type":"integer","format":"int64","minimum":0},"description":"Utilization of internal writer FIFO.\nThis number is updated live during operation for TCP/IP image socket.\nNo other socket use it.\n"}}},"plot":{"type":"object","required":["x","y","title"],"description":"x and y coordinates for plotting, it is OK to assume that both arrays have the same size; layout is optimized for Plotly","properties":{"title":{"type":"string","default":""},"x":{"type":"array","items":{"type":"number","format":"float"}},"y":{"type":"array","items":{"type":"number","format":"float","nullable":true}},"z":{"type":"array","items":{"type":"number","format":"float","nullable":true}}}},"plot_unit_x":{"type":"string","enum":["image_number","q_recipA","d_A","angle_deg","ADU","grid_um"],"default":"image_number"},"plots":{"type":"object","required":["plot","unit_x"],"properties":{"title":{"type":"string"},"unit_x":{"$ref":"#/components/schemas/plot_unit_x"},"size_x":{"type":"number","format":"float","description":"Max X range of the plot"},"size_y":{"type":"number","format":"float","description":"Max Y range of the plot"},"plot":{"type":"array","items":{"$ref":"#/components/schemas/plot"}}}},"scan_result":{"type":"object","description":"Results of a scan","required":["images"],"properties":{"file_prefix":{"type":"string"},"rotation_unit_cell":{"$ref":"#/components/schemas/unit_cell"},"rotation_crystal_lattice":{"$ref":"#/components/schemas/crystal_lattice"},"rotation_bravais":{"type":"string","description":"Bravais lattice type of the global rotation-indexing solution: crystal-system\nletter + centering, e.g. \"tP\", \"oC\", \"cF\", \"hR\", \"mP\". Empty if not determined.\n"},"images":{"type":"array","items":{"type":"object","required":["efficiency","number"],"properties":{"efficiency":{"type":"number","format":"float"},"number":{"type":"integer","format":"int64","description":"Detector image number for a given cell"},"nx":{"type":"integer","format":"int64","description":"Cell position in X for grid scan"},"ny":{"type":"integer","format":"int64","description":"Cell position in Y for grid scan"},"angle":{"type":"number","format":"float","description":"Rotation angle associated with the image"},"bkg":{"type":"number","format":"float","description":"Background estimate"},"spindle_blind":{"type":"number","format":"float","description":"Fraction (0-1) of a rotation sweep's blind double cone that this orientation makes unrecoverable, assuming the nearest plausible lattice row is a lone 2-fold (a worst-case bound, not an estimate). At 0.5 and above a recovery protocol (second sweep, reorientation) should engage. Absent means the frame could not be assessed, which automation must treat the same as above threshold - it is not a zero.\n"},"spots":{"type":"integer","format":"int64","description":"Spot count"},"spots_low_res":{"type":"integer","format":"int64","description":"Spot count in low resolution range"},"spots_indexed":{"type":"integer","format":"int64","description":"Spot count within indexing tolerance"},"spots_ice":{"type":"integer","format":"int64","description":"Spot count within common ice ring resolutions"},"ice":{"type":"number","format":"float","description":"Strongest hexagonal-ice ring intensity over the smooth radial background (1 = no ice)"},"index":{"type":"integer","format":"int64","description":"Indexing solution"},"latt_count":{"type":"integer","format":"int64","description":"Indexing lattice count"},"pr":{"type":"number","format":"float","description":"Profile radius, i.e. how far reflections are from the Ewald sphere"},"b":{"type":"number","format":"float","description":"B-Factor estimate"},"uc":{"$ref":"#/components/schemas/unit_cell"},"xfel_pulseid":{"type":"integer","format":"int64","description":"XFEL pulse ID"},"pixel_sum":{"type":"integer","format":"int64","description":"Total sum of all pixels"},"max":{"type":"integer","format":"int64","description":"Max viable pixel"},"sat":{"type":"integer","format":"int64","description":"Number of saturated pixels"},"err":{"type":"integer","format":"int64","description":"Number of error pixels"},"res":{"type":"number","format":"float","description":"Diffraction resolution estimate"}}}}}},"powder_calibration_fit_sigma":{"type":"object","description":"What the powder ring fit knows about its own answer, from the covariance of the converged\nproblem. Each sigma is in its parameter's own unit and is scaled by the residual scatter of\nthat fit, so it is the usual \"how far could this move before the fit got visibly worse\".\nThe two correlations are the ones that matter: a tilt and a beam-centre shift both displace a\nring's radius as cos(phi) and are told apart only by how that amplitude grows with the ring's\nradius, so as the rings run out the pair stops being separable and these approach 1.\nThe rotation sigmas and the correlations are absent when the tilt was not a free parameter.\n","properties":{"beam_x_pxl":{"type":"number","format":"float","description":"Standard error of the fitted PONI x [pixels]"},"beam_y_pxl":{"type":"number","format":"float","description":"Standard error of the fitted PONI y [pixels]"},"detector_distance_mm":{"type":"number","format":"float","description":"Standard error of the fitted detector distance [mm]"},"poni_rot1_rad":{"type":"number","format":"float","description":"Standard error of the fitted rot1 [rad]"},"poni_rot2_rad":{"type":"number","format":"float","description":"Standard error of the fitted rot2 [rad]"},"correlation_beam_x_rot1":{"type":"number","format":"float","description":"Correlation between the fitted PONI x and rot1, -1 to 1"},"correlation_beam_y_rot2":{"type":"number","format":"float","description":"Correlation between the fitted PONI y and rot2, -1 to 1"}}},"powder_calibration_spot_check":{"type":"object","description":"Where the circle through the found spots puts the beam, and how far that is from the geometry\nactually fitted. An independent cross-check: it reads nothing from the file's own geometry, so\nit holds where the summed azimuthal profile does not - a profile binned about a badly wrong\ncentre shows each ring smeared across its sectors, and a fit on it converges on the wrong\nanswer without saying so. Two methods sharing no assumption, so the disagreement is the\nstatement. Absent when no spots were available.\n","properties":{"beam_x_pxl":{"type":"number","format":"float","description":"Beam centre x the spots vote for [pixels]"},"beam_y_pxl":{"type":"number","format":"float","description":"Beam centre y the spots vote for [pixels]"},"detector_distance_mm":{"type":"number","format":"float","description":"Detector distance the spots imply [mm]"},"disagreement_pxl":{"type":"number","format":"float","description":"Distance between the spots' beam centre and the fitted one [pixels]"}}},"powder_calibration_quality":{"type":"object","description":"What a powder calibration knows about the geometry it produced. A calibration that has gone\nwrong - the wrong standard named, a header too far out for the rings to be found - looks\nexactly like one that has not until these are read.\n","properties":{"converged":{"type":"boolean","description":"Whether the geometry beside this is a measurement of the data at all. False means at least\none of its parameters was carried over from the input file rather than fitted - which looks\nexactly like a good fit in every other field here - and see not_converged_reason for which.\nrugnux --mode calibration writes no .poni file in that case, a PONI file having no field in\nwhich to say it, and exits non-zero.\n"},"not_converged_reason":{"type":"string","description":"What made converged false, in words. Absent when the calibration converged."},"calibrant":{"type":"string","description":"The powder standard the rings were fitted to, or the unit cell given in its place"},"method":{"type":"string","description":"How the rings were measured. rings fits the arcs of the run-summed (q x azimuth) azimuthal\nprofile; spots fits the pooled per-image spot lists.\n","enum":["rings","spots"]},"ring_points":{"type":"integer","format":"int64","description":"Ring measurements the fit used"},"rms_radial_pxl":{"type":"number","format":"float","description":"Scatter of those measurements about the fitted rings, as a radial distance [pixels]. The\nsingle number that separates a calibration that worked from one that did not.\n"},"beam_sigma_pxl":{"type":"number","format":"float","description":"Standard error the scatter implies on the beam centre [pixels], for a ring of that many\npoints. See powder_calibration_fit_sigma for what the fit itself says, which is not the same and\nis the larger of the two whenever the tilt is poorly separated.\n"},"direct_beam_x_pxl":{"type":"number","format":"float","description":"Where the direct beam lands [pixels]. NOT dataset_settings.beam_x_pxl, which is the PONI:\nthe two part company by distance*tan(tilt)/pixel as soon as the detector is tilted.\n"},"direct_beam_y_pxl":{"type":"number","format":"float","description":"Where the direct beam lands, y [pixels]"},"header_distance_mm":{"type":"number","format":"float","description":"The detector distance the input file declared, for comparison [mm]"},"ring_seed_distance_mm":{"type":"number","format":"float","description":"The distance measured from the ring radii before the fit ran [mm]. It is taken from the\nradii, the wavelength and the pixel size alone, so a large gap from header_distance_mm is\nthe answer to the question the calibration was run to ask. Absent when the profile showed\ntoo few rings to fix a scale.\n"},"tilt_refined":{"type":"boolean","description":"Whether the reported rot1/rot2 were measured by this fit. False means they were declined\nand pinned at the input file's values, because the rings could not separate a tilt from a\nshift of the beam centre.\n"},"tilt_significance":{"type":"number","format":"float","description":"How many of its own sigmas the fitted tilt stands from zero. Below about 3 it is not a\nmeasurement of a tilt but of a beam-centre shift, and the tilt is declined. Passing does\nnot certify a tilt: that estimator is limited by systematics rather than by this sigma.\n"},"fit_sigma":{"$ref":"#/components/schemas/powder_calibration_fit_sigma"},"spot_cross_check":{"$ref":"#/components/schemas/powder_calibration_spot_check"}}},"powder_calibration_output":{"type":"object","required":["dataset_settings"],"description":"The result of a powder-ring detector calibration - what rugnux --mode calibration writes as\n<prefix>.json, and what a calibration run over the image buffer would return.\n\ndataset_settings holds the geometry and nothing else, under the property names this API gives\nthem, so it can be POSTed or merged without translating a field. Its beam_x_pxl/beam_y_pxl is\nthe PONI, the foot of the perpendicular from the sample; where the beam actually lands is\ncalibration.direct_beam_x_pxl. The poni_rot*_rad are present whenever any of them is non-zero\nand absent when all are zero, since a body omitting them states a FLAT detector rather than an\nunstated one.\n","properties":{"dataset_settings":{"$ref":"#/components/schemas/dataset_settings"},"calibration":{"$ref":"#/components/schemas/powder_calibration_quality"},"jfjoch_version":{"type":"string","description":"Version of the program that produced this"}}},"calibration_statistics":{"type":"array","items":{"required":["module_number","storage_cell_number","pedestal_g0_mean","pedestal_g1_mean","pedestal_g2_mean","gain_g0_mean","gain_g1_mean","gain_g2_mean","masked_pixels"],"type":"object","properties":{"module_number":{"type":"integer","format":"int64"},"storage_cell_number":{"type":"integer","format":"int64"},"pedestal_g0_mean":{"type":"number","format":"float"},"pedestal_g1_mean":{"type":"number","format":"float"},"pedestal_g2_mean":{"type":"number","format":"float"},"gain_g0_mean":{"type":"number","format":"float"},"gain_g1_mean":{"type":"number","format":"float"},"gain_g2_mean":{"type":"number","format":"float"},"masked_pixels":{"type":"integer","format":"int64"}}}},"jfjoch_statistics":{"type":"object","description":"Pool statistics for Jungfraujoch to reduce transfers between frontend and jfjoch_broker","properties":{"detector":{"$ref":"#/components/schemas/detector_status"},"detector_list":{"$ref":"#/components/schemas/detector_list"},"detector_settings":{"$ref":"#/components/schemas/detector_settings"},"image_format_settings":{"$ref":"#/components/schemas/image_format_settings"},"instrument_metadata":{"$ref":"#/components/schemas/instrument_metadata"},"file_writer_settings":{"$ref":"#/components/schemas/file_writer_settings"},"data_processing_settings":{"$ref":"#/components/schemas/spot_finding_settings"},"measurement":{"$ref":"#/components/schemas/measurement_statistics"},"broker":{"$ref":"#/components/schemas/broker_status"},"fpga":{"$ref":"#/components/schemas/fpga_status"},"calibration":{"$ref":"#/components/schemas/calibration_statistics"},"zeromq_preview":{"$ref":"#/components/schemas/zeromq_preview_settings"},"zeromq_metadata":{"$ref":"#/components/schemas/zeromq_metadata_settings"},"dark_mask":{"$ref":"#/components/schemas/dark_mask_settings"},"pixel_mask":{"$ref":"#/components/schemas/pixel_mask_statistics"},"roi":{"$ref":"#/components/schemas/roi_definitions"},"az_int":{"$ref":"#/components/schemas/azim_int_settings"},"buffer":{"$ref":"#/components/schemas/image_buffer_status"},"indexing":{"$ref":"#/components/schemas/indexing_settings"},"bragg_integration":{"$ref":"#/components/schemas/bragg_integration_settings"},"image_pusher":{"$ref":"#/components/schemas/image_pusher_status"}}},"error_message":{"type":"object","required":["msg","reason"],"properties":{"msg":{"type":"string","description":"Human readable message","example":"Detector in wrong state"},"reason":{"type":"string","description":"Enumerate field for automated analysis","enum":["WrongDAQState","Other"]}}},"roi_azimuthal":{"type":"object","description":"ROI as Q-range (or resolution range), optionally restricted to an azimuthal-angle sector","required":["name","q_min_recipA","q_max_recipA"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"q_min_recipA":{"type":"number","format":"float","minimum":0.00001,"description":"Minimum Q-range for the ROI"},"q_max_recipA":{"type":"number","format":"float","minimum":0.00001,"description":"Maximum Q-range for the ROI"},"phi_min_deg":{"type":"number","format":"float","description":"Lower azimuthal-angle bound of the sector [degrees]. Optional: provide both phi_min_deg and phi_max_deg to restrict the ROI to an angular sector, or omit both for a full ring. A sector with phi_min_deg > phi_max_deg wraps across 0.\n"},"phi_max_deg":{"type":"number","format":"float","description":"Upper azimuthal-angle bound of the sector [degrees]. Optional; see phi_min_deg.\n"}}},"roi_circle":{"type":"object","description":"Circular ROI","required":["name","center_x_pxl","center_y_pxl","radius_pxl"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"center_x_pxl":{"type":"number","format":"float","description":"X coordinate of center of the circle [pixels]"},"center_y_pxl":{"type":"number","format":"float","description":"Y coordinate of center of the circle [pixels]"},"radius_pxl":{"type":"number","format":"float","minimum":0,"exclusiveMinimum":true,"description":"Radius of the circle [pixels]"}}},"roi_box":{"type":"object","description":"Box ROI","required":["name","min_x_pxl","max_x_pxl","min_y_pxl","max_y_pxl"],"properties":{"name":{"type":"string","minLength":1,"description":"Name for the ROI; used in the plots"},"min_x_pxl":{"type":"integer","format":"int64","description":"Lower bound (inclusive) in X coordinate for the box","minimum":0},"max_x_pxl":{"type":"integer","format":"int64","description":"Upper bound (inclusive) in X coordinate for the box","minimum":0},"min_y_pxl":{"type":"integer","format":"int64","description":"Lower bound (inclusive) in Y coordinate for the box","minimum":0},"max_y_pxl":{"type":"integer","format":"int64","description":"Upper bound (inclusive) in Y coordinate for the box","minimum":0}}},"roi_circle_list":{"type":"object","description":"List of circular ROIs","required":["rois"],"properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_circle"}}}},"roi_box_list":{"type":"object","description":"List of box ROIs","properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_box"}}}},"roi_azim_list":{"type":"object","description":"List of azimuthal ROIs","properties":{"rois":{"type":"array","maxItems":12,"items":{"$ref":"#/components/schemas/roi_azimuthal"}}}},"roi_definitions":{"type":"object","required":["box","circle","azim"],"description":"ROI defintions","properties":{"box":{"$ref":"#/components/schemas/roi_box_list"},"circle":{"$ref":"#/components/schemas/roi_circle_list"},"azim":{"$ref":"#/components/schemas/roi_azim_list"}}},"dark_mask_settings":{"type":"object","description":"Settings for collection of dark images to be used for mask calculation","required":["detector_threshold_keV","frame_threshold_keV","max_allowed_pixel_count","max_frames_with_signal","frame_time_us","number_of_frames"],"properties":{"detector_threshold_keV":{"type":"number","format":"float","description":"Energy threshold for dark image collection","minimum":2.5,"default":3.5,"maximum":100},"frame_time_us":{"type":"integer","format":"int64","description":"Time between frames for dark image collection","minimum":500,"default":10000,"maximum":100000},"number_of_frames":{"type":"integer","format":"int64","description":"Number of frames for dark image collection; zero means no dark collection","minimum":0,"default":1000},"max_allowed_pixel_count":{"type":"integer","format":"int64","description":"Maximum count in a pixel considered normal (not-masked)","minimum":0,"default":1},"max_frames_with_signal":{"type":"integer","format":"int64","description":"Maximum number of frames with signal in a pixel considered normal (not-masked)","minimum":0,"default":10}}},"indexing_settings":{"type":"object","description":"Settings for crystallography indexing","required":["algorithm","geom_refinement_algorithm","fft_high_resolution_A","fft_max_unit_cell_A","fft_min_unit_cell_A","fft_num_vectors","tolerance","thread_count","unit_cell_dist_tolerance","index_ice_rings","viable_cell_min_spots","rotation_indexing","rotation_indexing_min_angular_range_deg","rotation_indexing_angular_stride_deg","blocking"],"properties":{"algorithm":{"$ref":"#/components/schemas/indexing_algorithm"},"fft_max_unit_cell_A":{"type":"number","format":"float","default":250,"maximum":500,"minimum":50,"description":"Largest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT"},"fft_min_unit_cell_A":{"type":"number","format":"float","default":10,"minimum":5,"maximum":40,"description":"Smallest unit cell to be indexed by FFT algorithm; parameter value affects execution time of FFT"},"fft_high_resolution_A":{"type":"number","format":"float","default":2,"minimum":0.5,"maximum":6,"description":"Sets how finely the FFT samples each search direction: it fixes the extent of the projection\nhistogram, and with it the transform size, so it affects execution time and memory of FFT.\nIt does NOT filter spots - every spot is projected whatever its resolution, so raising it\ndoes not make the transform see a coarser subset of the data.\nThere is also correlation between smallest unit cell and this value, which need to be checked for very small systems.\n"},"fft_num_vectors":{"type":"integer","format":"int64","minimum":128,"default":16384,"description":"Number of search directions for the FFT algorithm; parameter value affects execution time of FFT."},"tolerance":{"type":"number","format":"float","minimum":0,"maximum":0.5,"description":"Acceptance tolerance for spots after the indexing run - the larger the number, the more spots will be accepted"},"thread_count":{"type":"integer","format":"int64","minimum":1,"maximum":64,"description":"Thread count for indexing algorithm"},"geom_refinement_algorithm":{"$ref":"#/components/schemas/geom_refinement_algorithm"},"unit_cell_dist_tolerance":{"type":"number","format":"float","minimum":0.0001,"maximum":0.2001,"default":0.05,"description":"Relative distance tolerance for unit cell vs. reference; Lattices outside given tolerance will be ignored"},"viable_cell_min_spots":{"type":"integer","format":"int64","minimum":5,"default":10,"description":"Minimum number of indexed spots required for a cell to be considered viable"},"index_ice_rings":{"type":"boolean","default":false,"description":"Include spots marked as ice rings in the indexing run. \nIf `dataset_settings` doesn't have `detect_ice_rings` on, this option will have no effect on processing.\n"},"rotation_indexing":{"type":"boolean","default":false},"rotation_indexing_min_angular_range_deg":{"type":"number","format":"float","default":20,"minimum":1},"rotation_indexing_angular_stride_deg":{"type":"number","format":"float","default":0.5,"minimum":0},"blocking":{"type":"boolean","default":true,"description":"Indexing in Jungfraujoch goes with a dedicated thread pool.\nIf set to false, the thread pool is non-blocking, i.e. if there are no threads available, image indexing will be skipped. This option is recommended for real-time processing at high frame rates.\nIf set to true, the thread pool will block until a thread is available.\n"}}},"instrument_metadata":{"type":"object","description":"Metadata for a measurement instrument","required":["source_name","instrument_name"],"properties":{"source_name":{"type":"string","example":"Swiss Light Source"},"source_type":{"type":"string","description":"Type of radiation source. NXmx gives a fixed dictionary, though Jungfraujoch is not enforcing compliance. \nhttps://manual.nexusformat.org/classes/base_classes/NXsource.html#nxsource\nNXsource allows the following:\n\nSpallation Neutron Source\nPulsed Reactor Neutron Source\nReactor Neutron Source\nSynchrotron X-ray Source\nPulsed Muon Source\nRotating Anode X-ray\nFixed Tube X-ray\nUV Laser\nFree-Electron Laser\nOptical Laser\nIon Source\nUV Plasma Source\nMetal Jet X-ray\n","example":"Synchrotron X-ray Source","default":""},"instrument_name":{"type":"string","example":"CristallinaMX"},"pulsed_source":{"type":"boolean","description":"Settings specific to XFEL (e.g., every image has to come from TTL trigger, save pulse ID and event code)\n","default":false},"electron_source":{"type":"boolean","description":"Settings specific to electron source (e.g., wavelength definition)\n","default":false}}},"detector_module_direction":{"type":"string","enum":["Xp","Xn","Yp","Yn"]},"detector_type":{"type":"string","enum":["EIGER","JUNGFRAU","DECTRIS"]},"image_pusher_type":{"type":"string","default":"None","enum":["ZeroMQ","HDF5","CBOR","TCP","None"]},"standard_detector_geometry":{"type":"object","description":"Regular rectangular geometry, first module is in the bottom left corner of the detector","required":["nmodules"],"properties":{"nmodules":{"type":"integer","minimum":1,"description":"Number of modules in the detector"},"gap_x":{"type":"integer","default":8,"minimum":0,"description":"Gap size in X direction [pixels]"},"gap_y":{"type":"integer","minimum":0,"default":36,"description":"Gap size in Y direction [pixels]"},"modules_in_row":{"type":"integer","minimum":1,"default":1,"description":"Number of modules in one row"}}},"detector_module":{"type":"object","required":["x0","y0","fast_axis","slow_axis"],"properties":{"x0":{"type":"number"},"y0":{"type":"number"},"fast_axis":{"$ref":"#/components/schemas/detector_module_direction"},"slow_axis":{"$ref":"#/components/schemas/detector_module_direction"}}},"detector":{"type":"object","required":["description"],"properties":{"description":{"type":"string","minLength":1},"serial_number":{"type":"string","default":"Unknown","minLength":1},"type":{"$ref":"#/components/schemas/detector_type"},"high_voltage_V":{"type":"integer","format":"int64","minimum":0,"maximum":200,"default":0},"udp_interface_count":{"type":"integer","format":"int64","minimum":1,"maximum":2,"default":1},"module_sync":{"type":"boolean","default":true,"description":"Use module 0 as master for timing. Only applies to JUNGFRAU detector (this cannot be turned off for EIGER)."},"sensor_thickness_um":{"type":"number","format":"float","minimum":0,"default":320},"readout_time_ns":{"type":"integer","format":"int64","minimum":1,"description":"Minimum difference between frame time and count time in microseconds\nDefaults are 3'000 ns for EIGER and 20'000 ns for JUNGFRAU\n"},"min_count_time_ns":{"type":"integer","format":"int64","minimum":0,"description":"Minimum count time available for the detector."},"min_frame_time_ns":{"type":"integer","format":"int64","minimum":0,"description":"Minimum frame time available for the detector."},"calibration_file":{"type":"array","description":"Can be empty for all detectors - default calibration used.\nFor JUNGFRAU: list of gain files, one entry per module.\nFor EIGER: one directory (with detector settings) or list of trim bit files, one entry per half-module.\n","items":{"type":"string"}},"trim_energies_eV":{"type":"array","description":"List of energies at which trimming calibration is provided.\nOnly needed for PSI EIGER and compulsory in this case\n","items":{"type":"integer","format":"int32","minimum":100}},"hostname":{"type":"array","description":"Hostname for detector module. One entry per module\nOne entry per module. Either empty or number of module entries.\n","items":{"type":"string"}},"sensor_material":{"type":"string","default":"Si"},"tx_delay":{"type":"array","items":{"type":"integer","format":"int64"}},"base_data_ipv4_address":{"type":"string","example":"10.10.10.50"},"standard_geometry":{"$ref":"#/components/schemas/standard_detector_geometry"},"custom_geometry":{"type":"array","items":{"$ref":"#/components/schemas/detector_module"}},"roi_mode":{"type":"string","default":"","description":"ROI setting for DECTRIS detectors"},"mirror_y":{"type":"boolean","default":true,"description":"Mirror detector in Y direction to account for MX convention of (0,0) point in top left corner"},"temp_thresold_degC":{"type":"integer","format":"int64","description":"Temperature threshold for JUNGFRAU detector modules","minimum":40,"maximum":70,"default":55},"default_settings":{"$ref":"#/components/schemas/detector_settings"}}},"zeromq_settings":{"type":"object","description":"ZeroMQ configuration for Jungfraujoch software.\nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","properties":{"send_watermark":{"type":"integer","format":"int64","minimum":2,"maximum":16384,"default":100,"description":"Watermark for ZeroMQ send queue (number of outstanding messages queued on Jungfraujoch server per queue)"},"send_buffer_size":{"type":"integer","format":"int64","description":"Send buffer size for ZeroMQ socket"},"image_socket":{"type":"array","items":{"type":"string"},"example":["tcp://1.2.3.4:5000","tcp://1.2.3.4:5001"],"description":"PUSH ZeroMQ socket for images. In case multiple sockets are provided, images are streamed over multiple sockets.  \nImages are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tpc://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"},"writer_notification_socket":{"type":"string","example":"tcp://1.3.4.6:7000","description":"PULL ZeroMQ socket for notifications from writer that it finished operation. \nThis allows Jungfraujoch to operate in a synchronous manner, with end of acquisition being also end of writing.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tpc://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address should be avoided, as this socket address is forwarded to the writer process via START ZerOMQ message and in case of multiple ineterfaces the address might be ambigous.\nUsing * (star) instead of port number is allowed and it means a random free port number.\n"}}},"tcp_settings":{"type":"object","description":"TCP image stream configuration for Jungfraujoch software.\nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","required":["addr"],"properties":{"send_buffer_size":{"type":"integer","format":"int64","description":"Send buffer size for TCP/IP socket"},"image_socket":{"type":"string","example":"tcp://1.2.3.4:5000","description":"tcp://<IP address>:<port>\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces\n"},"nwriters":{"type":"integer","format":"int64","minimum":1,"maximum":100,"default":32,"description":"Number of TCP/IP writers to be used for streaming images"},"peer_liveness_timeout_ms":{"type":"integer","format":"int64","description":"Max time (in milliseconds) a send may block with no sign of life from the\nwriter (no BUSY heartbeat or ACK) before the connection is declared dead.\nOptional; the built-in default is used when unset.\n"},"max_backpressure_timeout_ms":{"type":"integer","format":"int64","description":"Hard upper bound (in milliseconds) on backpressure: if no bytes can be sent to\nthe writer for this long the connection is declared dead even while the writer\nkeeps heartbeating, so a wedged writer cannot block the run or its\nfinalization. Optional; the built-in default is used when unset.\n"}}},"pcie_devices":{"type":"array","minLength":1,"items":{"type":"object","required":["block_device"],"properties":{"blk":{"type":"string","example":"/dev/jfjoch0","description":"Block device name"},"ipv4":{"type":"string","example":"10.1.1.7","description":"IPv4 address of the block device"}}}},"bragg_integration_settings":{"type":"object","description":"Settings for Bragg spot integration","required":["integration_model"],"properties":{"integration_model":{"$ref":"#/components/schemas/integration_model"},"max_hkl":{"type":"integer","minimum":1,"maximum":511,"default":100,"description":"How far the Bragg predictor walks the lattice: reflections with |h|,|k|,|l| above this are\nnever predicted. An axis is truncated once a/d_min exceeds it, so a long axis - or a short\none taken to high resolution - loses its outermost reflections. The cost grows as the cube\n(2n+1)^3 of candidates per image, which is why online keeps a fixed, predictable value\ninstead of taking it from whichever crystal is mounted.\n\nOmitting the field selects the default above; it is never interpreted as \"choose per\ncrystal\". The offline tools (rugnux, viewer) do derive it from the refined cell when it is\nleft unset there, but that is their own default and is not reachable through this API.\n"}}},"jfjoch_settings":{"type":"object","required":["detector","frontend_directory","image_pusher"],"description":"Default settings for Jungfraujoch software. \nThis structure is used to provide default settings using configuration JSON file and is not used in HTTP.\n","properties":{"pcie":{"$ref":"#/components/schemas/pcie_devices"},"zeromq":{"$ref":"#/components/schemas/zeromq_settings"},"tcp":{"$ref":"#/components/schemas/tcp_settings"},"instrument":{"$ref":"#/components/schemas/instrument_metadata"},"file_writer":{"$ref":"#/components/schemas/file_writer_settings"},"detector":{"type":"array","minLength":1,"items":{"$ref":"#/components/schemas/detector"}},"indexing":{"$ref":"#/components/schemas/indexing_settings"},"bragg_integration":{"$ref":"#/components/schemas/bragg_integration_settings"},"detector_settings":{"$ref":"#/components/schemas/detector_settings"},"azim_int":{"$ref":"#/components/schemas/azim_int_settings"},"image_format":{"$ref":"#/components/schemas/image_format_settings"},"image_buffer_MiB":{"type":"integer","minimum":128,"default":2048,"description":"Size of internal buffer in MiB for images before they are sent to a stream"},"verbose":{"type":"boolean","default":false,"description":"Print extra debug information"},"receiver_threads":{"type":"integer","minimum":1,"maximum":512,"default":64,"description":"Number of threads used by the receiver"},"numa_policy":{"type":"string","deprecated":true,"description":"Ignored value"},"frontend_directory":{"type":"string","description":"Location of built JavaScript web frontend"},"spot_finding":{"$ref":"#/components/schemas/spot_finding_settings"},"image_pusher":{"$ref":"#/components/schemas/image_pusher_type"},"zeromq_preview":{"$ref":"#/components/schemas/zeromq_preview_settings"},"zeromq_metadata":{"$ref":"#/components/schemas/zeromq_metadata_settings"},"dark_mask":{"$ref":"#/components/schemas/dark_mask_settings"}}},"zeromq_metadata_settings":{"type":"object","required":["enabled","period_ms"],"properties":{"enabled":{"type":"boolean","default":true,"description":"ZeroMQ metadata socket is enabled."},"period_ms":{"type":"integer","format":"int64","minimum":1,"default":1000,"description":"Period for generating metadata package sent to the ZeroMQ interface in milliseconds.\n"},"socket_address":{"type":"string","description":"PUB ZeroMQ socket for image metadata information.\nImage metadata are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tcp://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"}}},"zeromq_preview_settings":{"type":"object","required":["enabled","period_ms"],"properties":{"enabled":{"type":"boolean","default":true,"description":"ZeroMQ preview socket is enabled."},"period_ms":{"type":"integer","format":"int64","default":1000,"description":"Period for generating preview image sent to the ZeroMQ interface in milliseconds. Default is 1 second. \nIf set to zero, all images will be sent ZeroMQ (should be used only in case of relatively slow data collection).\nThis has no effect on HTTP based preview, which updates always at rate of 1 second.\n"},"socket_address":{"type":"string","description":"PUB ZeroMQ socket for preview images. This socket operates at a reduced frame rate.\nImages are serialized using CBOR.\nAddress follows ZeroMQ convention for sockets - in practice ipc://<socket file> and tcp://<IP address>:<port> sockets are OK.\n0.0.0.0 instead of IP address is accepted and means listening on all network interfaces.\n"}}}}},"paths":{"/initialize":{"post":{"summary":"Initialize detector and data acquisition","description":"Should be used in two cases:\n  - Detector is in `Inactive` state\n  - Detector is in `Error` state\nX-ray shutter must be closed. \nThis operation will reconfigure network interface of the detector. \nDuring operation of the detector it is recommended to use the `POST /pedestal` operation instead.\nIf storage cells are used, the execution time might be few minutes.\n\nThis is async function - one needs to use `POST /wait_till_done` to ensure operation is done.\n","responses":{"200":{"description":"Initialization started"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/pedestal":{"post":{"summary":"Collect dark current for the detector","description":"Updates calibration of the JUNGFRAU detector. Must be in `Idle` state.\n\nX-ray shutter must be closed. Recommended to run once per hour for long integration times (> 100 us).\n\nThis is async function - one needs to use `POST /wait_till_done` to ensure operation is done.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/start":{"post":{"summary":"Start detector","description":"Start data acquisition.\nDetector must be in `Idle` state.\nDefault behavior is for the call to block until detector is ready to accept soft/TTL triggers.\nHowever, this behavior can be changed by settings `async_start` to true in the request body, \nin which case the call will return immediately and one needs to use `/wait_until_running` to ensure detector is ready to run.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/dataset_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/wait_until_running":{"post":{"summary":"Wait for acquisition running","parameters":[{"in":"query","name":"timeout","required":false,"schema":{"type":"integer","default":60,"minimum":0,"maximum":3600},"description":"Timeout in seconds (0 == immediate response)"}],"description":"Block execution of external script till detector and Jungfraujoch are ready to collect data.\nTo not block web server for a indefinite period of time, the procedure is provided with a timeout.\nExtending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection.\n","responses":{"200":{"description":"Detector in `Measuring` state"},"400":{"description":"Timeout parameter out of bounds"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}},"502":{"description":"Detector is inactive mode"},"504":{"description":"Timeout reached, need to restart operation"}}}},"/wait_till_done":{"post":{"summary":"Wait for acquisition done","parameters":[{"in":"query","name":"timeout","required":false,"schema":{"type":"integer","default":60,"minimum":0,"maximum":3600},"description":"Timeout in seconds (0 == immediate response)"}],"description":"Block execution of external script till initialization, data collection or pedestal is finished.\nRunning this command does not affect (cancel) running data collection, it is only to ensure synchronous execution of other software.\n\nTo not block web server for a indefinite period of time, the procedure is provided with a timeout.\nExtending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection.\n","responses":{"200":{"description":"Detector in `Idle` state, another data collection can start immediately.\nThe operation that finished either succeeded, was cancelled, or ended with a warning.\n"},"400":{"description":"Timeout parameter out of bounds"},"500":{"description":"Error within Jungfraujoch code, or the operation that finished ended in an error -\nmissing packets, or a writer that could not write - see output message.\nA cancelled data collection is not an error.\n","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}},"502":{"description":"Detector is inactive mode"},"504":{"description":"Timeout reached, need to restart operation"}}}},"/trigger":{"post":{"summary":"Send soft trigger to the detector","description":"Generate soft trigger","responses":{"200":{"description":"Trigger sent"}}}},"/cancel":{"post":{"summary":"Cancel running data collection","description":"Command will inform FPGA network card to stop pedestal or data collection at the current stage.\nAny frame that is currently being processed by CPU will be finished and sent to writer.\nGiven the command is making sure to gracefully stop data acquisition and detector, it might take some time to switch back after command finished to `Idle` state.\n\nIf data collection is not running, the command has no effect.\n","responses":{"200":{"description":"Cancel request sent to FPGAs (or ignored, as data collection is not running)"}}}},"/deactivate":{"post":{"summary":"Prepare detector to turn off","description":"Should be in `Idle` or `Error` state.\nCommand deactivates data acquisition and turns off detector high voltage and ASIC.\nShould be used always before turning off power from the detector.\n","responses":{"200":{"description":"Detector ready to turn off"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/detector":{"put":{"summary":"Change detector configuration","description":"Detector settings are ones that have effect on calibration, i.e., pedestal has to be collected again after changing these settings.\nThis can only be done when detector is `Idle`, `Error` or `Inactive` states.\nIf detector is in `Idle` state , pedestal procedure will be executed automatically - there must be no X-rays on the detector during the operation.\nIf detector is in `Inactive` or `Error` states, new settings will be saved, but no calibration will be executed.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get detector configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_settings"}}}}}}},"/config/indexing":{"put":{"summary":"Change indexing algorithm settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/indexing_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get indexing configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/indexing_settings"}}}}}}},"/config/bragg_integration":{"put":{"summary":"Change Bragg integration settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/bragg_integration_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get Bragg integration configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/bragg_integration_settings"}}}}}}},"/config/file_writer":{"put":{"summary":"Change file writer settings","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/file_writer_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get file writer settings","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/file_writer_settings"}}}}}}},"/config/instrument":{"put":{"summary":"Change instrument metadata","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/instrument_metadata"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get instrument metadata","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/instrument_metadata"}}}}}}},"/config/image_format":{"put":{"summary":"Change image output format","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_format_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get image output format","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_format_settings"}}}}}}},"/config/image_format/raw":{"post":{"summary":"Configure format for raw data collection","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/image_format/conversion":{"post":{"summary":"Configure format for data collection with full conversion","description":"This can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","responses":{"200":{"description":"Everything OK"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/spot_finding":{"put":{"summary":"Configure spot finding","description":"Can be done anytime, also while data collection is running","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/spot_finding_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}},"get":{"summary":"Get data processing configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/spot_finding_settings"}}}}}}},"/config/azim_int":{"put":{"summary":"Configure azimuthal integration","description":"Can be done when detector is Inactive or Idle","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/azim_int_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get azimuthal integration configuration","description":"Can be done anytime","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/azim_int_settings"}}}}}}},"/config/internal_generator_image":{"put":{"summary":"Load binary image for internal FPGA generator","description":"Load image for internal FPGA generator. This can only happen in Idle state of the detector.\nRequires binary blob with 16-bit integer numbers of size of detector in raw/converted coordinates \n(depending on detector settings).\n","parameters":[{"name":"id","in":"query","description":"Image id to upload","required":false,"schema":{"type":"integer","format":"int64","minimum":0,"maximum":127}}],"requestBody":{"content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/internal_generator_image.tiff":{"put":{"summary":"Load TIFF image for internal FPGA generator","description":"Load image for internal FPGA generator. This can only happen in Idle state of the detector.\nRequires TIFF with 16-bit integer numbers of size of detector in raw/converted coordinates \n(depending on detector settings).\n","parameters":[{"in":"query","name":"id","description":"Image ID to upload","required":false,"schema":{"type":"integer","minimum":0,"maximum":127}}],"requestBody":{"content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/select_detector":{"put":{"summary":"Select detector","description":"Jungfraujoch allows to control multiple detectors and/or region-of-interests.\nThe command allows to choose one detector from the list (ID has to be consistent with one provided by GET response).\nChanging detector will set detector to `Inactive` state and will require reinitialization.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_selection"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"List available detectors","description":"Configured detectors that can be selected by used","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_list"}}}}}}},"/config/zeromq_preview":{"put":{"summary":"Set ZeroMQ preview settings","description":"Jungfraujoch can generate preview message stream on ZeroMQ SUB socket.\nHere settings of the socket can be adjusted.\nWhile the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request.\nOptions set with this PUT request have no effect on HTTP based preview.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_preview_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get ZeroMQ preview settings","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_preview_settings"}}}}}}},"/config/zeromq_metadata":{"put":{"summary":"Set ZeroMQ metadata settings","description":"Jungfraujoch can generate metadata message stream on ZeroMQ PUB socket. This stream covers all images.\nHere settings of the socket can be adjusted.\nWhile the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_metadata_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get ZeroMQ metadata socket settings","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/zeromq_metadata_settings"}}}}}}},"/config/dark_mask":{"put":{"summary":"Set configuration for dark data collection to calculate mask","description":"This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point.\nThis can only be done when detector is `Idle`, `Error` or `Inactive` states.\n","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/dark_mask_settings"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}},"get":{"summary":"Get settings for dark data collection to calculate mask","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/dark_mask_settings"}}}}}}},"/status":{"get":{"summary":"Get Jungfraujoch status","description":"Status of the data acquisition","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/broker_status"}}}}}}},"/fpga_status":{"get":{"summary":"Get status of FPGA devices","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/fpga_status"}}}}}}},"/xfel/pulse_id":{"get":{"summary":"Return XFEL pulse IDs for the current data acquisition","description":"Return array of XFEL pulse IDs - (-1) if image not recorded","responses":{"200":{"description":"Pulse ID collected","content":{"application/json":{"schema":{"type":"array","items":{"type":"integer","format":"int64"}}}}},"404":{"description":"Not in XFEL mode or no acquisition recorded"}}}},"/xfel/event_code":{"get":{"summary":"Return XFEL event codes for the current data acquisition","description":"Return array of XFEL event codes","responses":{"200":{"description":"Event codes collected","content":{"application/json":{"schema":{"type":"array","items":{"type":"integer","format":"int64"}}}}},"404":{"description":"Not in XFEL mode or no acquisition recorded"}}}},"/image_pusher/status":{"get":{"summary":"Get status of image pusher","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_pusher_status"}}}},"500":{"description":"Error encountered when trying to read status","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/detector/status":{"get":{"summary":"Get detector status","description":"Status of the JUNGFRAU detector","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/detector_status"}}}},"404":{"description":"Running in \"simulator\" mode - no detector present"},"500":{"description":"Error encountered when trying to read status","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/config/roi":{"get":{"summary":"Get ROI definitions","responses":{"200":{"description":"OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/roi_definitions"}}}}}},"put":{"summary":"Upload ROI definitions","requestBody":{"content":{"application/json":{"schema":{"$ref":"#/components/schemas/roi_definitions"}}}},"responses":{"200":{"description":"Everything OK"},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/statistics":{"get":{"summary":"Get general statistics","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/jfjoch_statistics"}}}}}}},"/statistics/data_collection":{"get":{"summary":"Get data collection statistics","description":"Results of the last data collection","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/measurement_statistics"}}}},"404":{"description":"No data collection performed so far"}}}},"/statistics/calibration":{"get":{"summary":"Get calibration statistics","description":"Statistics are provided for each module/storage cell separately","responses":{"200":{"description":"Everything OK","content":{"application/json":{"schema":{"$ref":"#/components/schemas/calibration_statistics"}}}}}}},"/config/mask":{"get":{"summary":"Get mask of the detector (binary)","description":"Detector must be Initialized.\nGet full pixel mask of the detector.\nSee NXmx standard for meaning of pixel values.\n","responses":{"200":{"description":"Binary array (4 byte; unsigned)","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}}}}},"/config/user_mask":{"get":{"summary":"Detector must be Initialized.\nGet user mask of the detector (binary)\n","description":"Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked","responses":{"200":{"description":"User mask in binary format (4 byte; unsigned)","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}}}},"put":{"summary":"Upload user mask of the detector (binary)","description":"Should be in `Idle` state.\nUpload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions.\nIf detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates.\nIn the latter case - module gaps are ignored and don't need to be assigned value.\nMask is expected as binary array (4-byte; unsigned).\n0 - good pixel, other value - masked\nUser mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.\n","requestBody":{"content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"All good"},"400":{"description":"Mask is not 4-byte unsigned integer array or empty body"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/config/mask.tiff":{"get":{"summary":"Get mask of the detector (TIFF)","description":"Should be in `Idle` state.\nGet full pixel mask of the detector\nSee NXmx standard for meaning of pixel values\n","responses":{"200":{"description":"Pixel mask in TIFF format (4 byte; unsigned)","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}}}}},"/config/user_mask.tiff":{"get":{"summary":"Detector must be Initialized.\nGet user mask of the detector (TIFF)\n","description":"Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked","responses":{"200":{"description":"User mask in TIFF format (4 byte; unsigned)","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}}}},"put":{"summary":"Upload user mask of the detector","description":"Should be in `Idle` state.\nUpload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions.\nIf detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates.\nIn the latter case - module gaps are ignored and don't need to be assigned value.\nMask is expected as a single-channel TIFF (8-, 16- or 32-bit integer, signed or unsigned).\n0 - good pixel, other value - masked\nUser mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration.\nUser mask is not automatically applied - i.e. pixels with user mask will have a valid pixel value in the images.\n","requestBody":{"content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"responses":{"200":{"description":"All good"},"400":{"description":"Not a valid single-channel TIFF or size doesn't match the detector"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/preview/pedestal.tiff":{"get":{"parameters":[{"in":"query","name":"gain_level","required":true,"schema":{"type":"integer"},"description":"Gain level (0, 1, 2)"},{"in":"query","name":"sc","schema":{"type":"integer"},"description":"Storage cell number"}],"summary":"Get pedestal in TIFF format","responses":{"200":{"description":"Calibration image","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Invalid gain level or storage cell number"},"404":{"description":"No calibration recorded so far"}}}},"/preview/plot":{"get":{"summary":"Generate 1D plot from Jungfraujoch","parameters":[{"$ref":"#/components/parameters/binning"},{"$ref":"#/components/parameters/plot_type"},{"$ref":"#/components/parameters/fill_value"},{"$ref":"#/components/parameters/experimental_coord"},{"$ref":"#/components/parameters/azint_unit"}],"responses":{"200":{"description":"Everything OK.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/plots"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/preview/plot.bin":{"get":{"summary":"Generate 1D plot from Jungfraujoch and send in raw binary format.\nData are provided as (32-bit) float binary array.\nThis format doesn't transmit information about X-axis, only values, so it is of limited use for azimuthal integration.\n","parameters":[{"$ref":"#/components/parameters/plot_type"},{"$ref":"#/components/parameters/roi"}],"responses":{"200":{"description":"Everything OK.","content":{"application/octet-stream":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}}}}},"/result/scan":{"get":{"summary":"Get full scan result","responses":{"200":{"description":"Everything OK.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/scan_result"}}}},"404":{"description":"No grid scan recorded"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/start.cbor":{"get":{"summary":"Get Start message in CBOR format","description":"Contains metadata for a dataset (e.g., experimental geometry)","responses":{"200":{"description":"Return start message","content":{"application/cbor":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"No measurement so far"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.cbor":{"get":{"summary":"Get image message in CBOR format","description":"Contains full image data and metadata. The image must come from the latest data collection.","parameters":[{"$ref":"#/components/parameters/image_id"}],"responses":{"200":{"description":"Return image message","content":{"application/cbor":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"Image not present in the buffer - either not yet measured or already replaced by a next image."},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.jpeg":{"get":{"summary":"Get preview image in JPEG format using custom settings","parameters":[{"$ref":"#/components/parameters/image_id"},{"$ref":"#/components/parameters/show_user_mask"},{"$ref":"#/components/parameters/show_roi"},{"$ref":"#/components/parameters/show_spots"},{"$ref":"#/components/parameters/show_predictions"},{"$ref":"#/components/parameters/show_beam_center"},{"$ref":"#/components/parameters/saturation"},{"$ref":"#/components/parameters/jpeg_quality"},{"$ref":"#/components/parameters/resolution_ring"},{"$ref":"#/components/parameters/color_scale"},{"$ref":"#/components/parameters/resolution_estimate"}],"responses":{"200":{"description":"Preview image","content":{"image/jpeg":{"schema":{"type":"string","format":"binary"}}}},"400":{"description":"Input parsing or validation error","content":{"text/plain":{"schema":{"type":"string","description":"Exception error"}}}},"404":{"description":"Image not present in the buffer - either not yet measured or already replaced by a next image."},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/image.tiff":{"get":{"summary":"Get preview image in TIFF format","parameters":[{"$ref":"#/components/parameters/image_id"}],"responses":{"200":{"description":"Preview image","content":{"image/tiff":{"schema":{"type":"string","format":"binary"}}}},"404":{"description":"No preview image recorded so far"}}}},"/image_buffer/clear":{"post":{"summary":"Clear image buffer","description":"Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data.","responses":{"200":{"description":"Done"},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/image_buffer/status":{"get":{"summary":"Get status of the image buffers","description":"Can be run at any stage of Jungfraujoch operation, including during data collection.\nThe status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots,\nthen image might be replaced in the buffer between calling /images and /image.cbor.\n","responses":{"200":{"description":"Done","content":{"application/json":{"schema":{"$ref":"#/components/schemas/image_buffer_status"}}}},"500":{"description":"Error within Jungfraujoch code - see output message.","content":{"application/json":{"schema":{"$ref":"#/components/schemas/error_message"}}}}}}},"/version":{"get":{"summary":"Get Jungfraujoch version of jfjoch_broker","responses":{"200":{"description":"Release number of Jungfraujoch","content":{"text/plain":{"schema":{"type":"string","example":"1.0.0-rc.25"}}}}}}}}}},"searchIndex":{"store":["section/License-Clarification","/paths/~1initialize/post","/paths/~1pedestal/post","/paths/~1start/post","/paths/~1wait_until_running/post","/paths/~1wait_till_done/post","/paths/~1trigger/post","/paths/~1cancel/post","/paths/~1deactivate/post","/paths/~1config~1detector/put","/paths/~1config~1detector/get","/paths/~1config~1indexing/put","/paths/~1config~1indexing/get","/paths/~1config~1bragg_integration/put","/paths/~1config~1bragg_integration/get","/paths/~1config~1file_writer/put","/paths/~1config~1file_writer/get","/paths/~1config~1instrument/put","/paths/~1config~1instrument/get","/paths/~1config~1image_format/put","/paths/~1config~1image_format/get","/paths/~1config~1image_format~1raw/post","/paths/~1config~1image_format~1conversion/post","/paths/~1config~1spot_finding/put","/paths/~1config~1spot_finding/get","/paths/~1config~1azim_int/put","/paths/~1config~1azim_int/get","/paths/~1config~1internal_generator_image/put","/paths/~1config~1internal_generator_image.tiff/put","/paths/~1config~1select_detector/put","/paths/~1config~1select_detector/get","/paths/~1config~1zeromq_preview/put","/paths/~1config~1zeromq_preview/get","/paths/~1config~1zeromq_metadata/put","/paths/~1config~1zeromq_metadata/get","/paths/~1config~1dark_mask/put","/paths/~1config~1dark_mask/get","/paths/~1status/get","/paths/~1fpga_status/get","/paths/~1xfel~1pulse_id/get","/paths/~1xfel~1event_code/get","/paths/~1image_pusher~1status/get","/paths/~1detector~1status/get","/paths/~1config~1roi/get","/paths/~1config~1roi/put","/paths/~1statistics/get","/paths/~1statistics~1data_collection/get","/paths/~1statistics~1calibration/get","/paths/~1config~1mask/get","/paths/~1config~1user_mask/get","/paths/~1config~1user_mask/put","/paths/~1config~1mask.tiff/get","/paths/~1config~1user_mask.tiff/get","/paths/~1config~1user_mask.tiff/put","/paths/~1preview~1pedestal.tiff/get","/paths/~1preview~1plot/get","/paths/~1preview~1plot.bin/get","/paths/~1result~1scan/get","/paths/~1image_buffer~1start.cbor/get","/paths/~1image_buffer~1image.cbor/get","/paths/~1image_buffer~1image.jpeg/get","/paths/~1image_buffer~1image.tiff/get","/paths/~1image_buffer~1clear/post","/paths/~1image_buffer~1status/get","/paths/~1version/get"],"index":{"version":"2.3.9","fields":["title","description"],"fieldVectors":[["title/0",[0,4.111,1,4.753]],["description/0",[0,1.805,2,4.17,3,2.159,4,2.087,5,1.193,6,3.337,7,1.193,8,1.193,9,1.032,10,0.926,11,1.621,12,1.193,13,0.963,14,1.193,15,1.619,16,1.193,17,2.781,18,2.087,19,0.926,20,2.087,21,1.278,22,1.193,23,2.087,24,1.032,25,2.781,26,1.193,27,1.193,28,2.087,29,1.193,30,1.193,31,1.193,32,1.193,33,1.193,34,1.193,35,1.193,36,2.781,37,1.193,38,1.193,39,0.354,40,0.611,41,1.193,42,2.087,43,1.032,44,1.193,45,1.193,46,1.193,47,1.193,48,1.193,49,1.193,50,1.032,51,1.193,52,1.193,53,1.193,54,1.193,55,1.193,56,1.193,57,1.193,58,1.193,59,0.926,60,0.926,61,1.193]],["title/1",[62,2.314,63,0.416,64,0.989,65,1.935]],["description/1",[11,2.226,39,0.937,43,1.688,59,1.515,62,1.195,63,0.505,66,1.952,67,1.385,68,2.042,69,0.858,70,0.901,71,1.515,72,1.688,73,1.385,74,3.01,75,1.952,76,1.515,77,1.688,78,2.735,79,1.195,80,1.952,81,1.952,82,1.688,83,1.385,84,1.281,85,1.952,86,1.952,87,1.688,88,1.688,89,1.281,90,1.281,91,1.515,92,1.281,93,0.555]],["title/2",[63,0.416,94,1.384,95,2.932,96,2.681]],["description/2",[11,1.242,39,0.758,63,0.282,68,2.004,71,1.984,72,2.212,73,1.814,74,1.679,77,2.212,78,2.212,79,1.566,84,1.679,87,2.212,88,2.212,89,1.679,90,1.679,91,1.984,92,1.679,93,0.727,97,2.557,98,1.984,99,2.212,100,0.824,101,1.31,102,2.557,103,2.557,104,2.557,105,2.557,106,1.385,107,2.557]],["title/3",[63,0.524,108,3.688]],["description/3",[11,1.132,39,0.691,60,2.827,63,0.494,64,0.61,65,1.194,67,1.654,89,1.531,90,1.531,92,1.531,100,0.751,101,1.194,108,2.827,109,2.331,110,3.642,111,1.809,112,2.331,113,3.15,114,2.331,115,2.331,116,1.809,117,1.076,118,0.783,119,2.331,120,2.331,121,1.809,122,2.331,123,1.531,124,2.331,125,2.016]],["title/4",[65,2.156,101,2.156,126,3.641]],["description/4",[15,1.984,21,1.566,63,0.282,64,0.67,73,1.814,83,1.814,84,1.679,92,1.679,94,0.937,111,3.036,113,2.212,125,2.212,127,2.212,128,2.212,129,2.212,130,1.242,131,2.212,132,2.212,133,2.212,134,2.212,135,1.984,136,1.679,137,3.384,138,2.212,139,1.984,140,2.212,141,3.384,142,2.212]],["title/5",[65,2.156,93,1.197,126,3.641]],["description/5",[15,1.636,21,1.291,62,1.291,64,0.881,73,1.496,79,1.291,83,2.387,84,1.384,91,1.636,92,2.209,94,1.232,101,1.723,111,2.61,127,1.823,128,1.823,129,1.823,131,1.823,132,1.823,133,1.823,134,1.823,135,1.636,136,1.384,137,2.909,138,1.823,139,1.636,140,1.823,141,2.909,142,1.823,143,1.823,144,1.496,145,2.107,146,1.636,147,2.107,148,2.107]],["title/6",[63,0.416,116,2.932,149,3.268,150,3.268]],["description/6",[13,2.476,116,5.063,150,4.639]],["title/7",[64,0.989,94,1.384,101,1.935,146,2.932]],["description/7",[39,0.625,59,1.636,63,0.232,64,1.099,65,1.079,79,1.291,84,1.384,94,1.232,96,2.387,100,0.679,101,1.079,143,2.909,144,3.4,146,1.636,151,1.823,152,1.291,153,2.107,154,2.61,155,1.823,156,2.107,157,2.107,158,1.823,159,2.107,160,2.107,161,1.636,162,2.107,163,2.107,164,2.107,165,2.107,166,2.107,167,2.107,168,2.107,169,1.636]],["title/8",[63,0.464,170,4.21,171,3.267]],["description/8",[11,1.618,39,0.987,63,0.524,64,0.872,65,1.706,70,1.538,100,1.073,144,2.364,171,3.693,172,4.759,173,3.331,174,3.331,175,3.331,176,3.331,177,3.331,178,3.331]],["title/9",[63,0.464,117,1.944,179,1.851]],["description/9",[39,1.271,63,0.586,68,1.768,69,1.518,70,1.594,71,1.69,74,1.429,76,1.69,79,2.114,83,2.449,89,1.429,93,0.619,94,0.797,98,2.679,100,1.112,117,1.005,118,1.441,135,1.69,169,1.69,180,1.883,181,2.177,182,1.883,183,2.177,184,2.177,185,1.883]],["title/10",[63,0.524,179,2.09]],["description/10",[93,1.59,185,4.835,186,2.863]],["title/11",[117,1.745,118,1.27,187,3.268,188,3.778]],["description/11",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,189,4.135]],["title/12",[179,2.09,187,4.111]],["description/12",[93,1.59,186,2.863,189,4.835]],["title/13",[106,2.046,117,1.745,118,1.27,190,3.268]],["description/13",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,191,4.135]],["title/14",[106,2.28,179,1.851,190,3.641]],["description/14",[93,1.59,186,2.863,191,4.835]],["title/15",[10,2.932,117,1.745,118,1.27,161,2.932]],["description/15",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,192,4.135]],["title/16",[10,3.267,118,1.415,161,3.267]],["description/16",[93,1.59,186,2.863,192,4.835]],["title/17",[117,1.944,193,3.641,194,2.419]],["description/17",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,195,4.135]],["title/18",[193,4.111,194,2.731]],["description/18",[93,1.59,186,2.863,195,4.835]],["title/19",[117,1.745,196,1.27,197,3.268,198,1.835]],["description/19",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,199,4.135]],["title/20",[196,1.415,197,3.641,198,2.045]],["description/20",[93,1.59,186,2.863,199,4.835]],["title/21",[64,0.897,94,1.255,179,1.507,198,1.665,200,2.432]],["description/21",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,201,4.78]],["title/22",[64,0.821,94,1.149,179,1.379,198,1.523,202,2.059,203,2.433]],["description/22",[39,1.417,63,0.527,69,2.102,70,2.207,93,1.359,100,1.54,204,4.78]],["title/23",[179,1.851,205,3.267,206,3.267]],["description/23",[64,1.299,93,1.41,94,1.817,101,2.54,186,2.54,207,4.29]],["title/24",[64,1.102,158,3.641,179,1.851]],["description/24",[93,1.59,186,2.863,207,4.835]],["title/25",[106,2.28,179,1.851,208,2.764]],["description/25",[63,0.568,69,2.266,93,1.465,100,1.66,209,4.458]],["title/26",[106,2.28,179,1.851,208,2.764]],["description/26",[93,1.59,186,2.863,209,4.835]],["title/27",[13,1.448,152,1.92,196,1.054,210,2.225,211,1.802,212,2.225]],["description/27",[13,1.397,21,1.853,39,0.897,63,0.579,100,0.975,118,1.017,152,1.853,196,1.017,210,2.147,211,1.739,212,2.147,213,2.617,214,3.026,215,2.617,216,2.348,217,2.617,218,2.617,219,2.617,220,1.853,221,2.617,222,3.026]],["title/28",[13,1.448,152,1.92,196,1.054,210,2.225,212,2.225,223,1.802]],["description/28",[13,1.43,21,1.897,39,0.918,63,0.587,100,0.998,118,1.041,152,1.897,196,1.041,210,2.198,212,2.198,213,2.679,215,2.679,216,2.403,217,2.679,218,2.679,219,2.679,220,1.897,221,2.679,223,1.78,224,3.097]],["title/29",[63,0.524,225,4.111]],["description/29",[21,1.698,24,2.397,39,0.821,50,3.597,63,0.611,69,1.219,89,2.731,117,1.28,118,0.932,130,1.346,136,1.82,144,1.967,226,2.771,227,2.771,228,2.771,229,2.771,230,2.397,231,2.151,232,2.771,233,2.771,234,2.771,235,2.397]],["title/30",[63,0.464,230,3.641,236,3.267]],["description/30",[11,2.503,63,0.568,179,2.266,225,4.458,235,4.458]],["title/31",[118,1.747,237,2.314,238,2.481]],["description/31",[13,1.181,64,0.67,117,1.181,118,1.315,121,3.036,130,1.242,169,1.984,237,1.566,238,2.569,239,1.814,240,2.212,241,2.557,242,3.036,243,2.212,244,2.212,245,2.212,246,1.814,247,2.212,248,2.212,249,3.384,250,1.814,251,3.384,252,2.557,253,2.557,254,2.212]],["title/32",[118,1.415,237,2.579,238,2.764]],["description/32",[254,5.283]],["title/33",[118,1.747,194,2.171,237,2.314]],["description/33",[13,1.307,64,0.741,117,1.307,118,0.951,121,2.197,130,1.375,194,1.627,196,0.951,237,1.734,239,2.009,240,3.655,242,3.279,243,2.449,244,2.449,245,2.449,246,2.009,247,2.449,248,2.449,249,2.449,250,2.009,251,2.449,255,2.831,256,2.831,257,2.449]],["title/34",[118,1.27,194,2.171,237,2.314,242,2.932]],["description/34",[257,5.283]],["title/35",[64,0.757,94,1.059,95,2.243,118,0.971,179,1.271,258,2.5,259,1.157]],["description/35",[39,1.068,63,0.554,69,1.585,70,1.664,74,2.367,93,1.025,100,1.161,139,2.797,236,2.797,260,3.604,261,3.604,262,3.604,263,3.604,264,3.604,265,3.118]],["title/36",[64,0.821,94,1.149,95,2.433,118,1.054,258,2.712,259,1.256]],["description/36",[265,5.283]],["title/37",[130,2.309,266,2.574]],["description/37",[64,1.404,65,2.747,266,3.533]],["title/38",[152,2.579,266,2.28,267,4.21]],["description/38",[268,6.108]],["title/39",[64,0.757,65,1.48,96,2.051,123,1.897,231,2.243,269,2.051,270,2.5]],["description/39",[68,2.208,123,2.831,196,1.449,231,3.346,269,3.06,270,3.729,271,3.06,272,3.346,273,4.311,274,4.311]],["title/40",[19,2.243,64,0.757,65,1.48,96,2.051,123,1.897,269,2.051,275,2.5]],["description/40",[19,3.849,123,3.257,269,3.52,271,3.52,275,4.29,276,4.959]],["title/41",[196,1.415,266,2.28,277,4.21]],["description/41",[278,6.108]],["title/42",[63,0.524,266,2.574]],["description/42",[63,0.591,99,4.639,266,2.905,279,5.363]],["title/43",[3,3.688,280,4.111]],["description/43",[281,5.283]],["title/44",[3,3.267,280,3.641,282,2.764]],["description/44",[281,5.283]],["title/45",[13,2.194,283,3.121]],["description/45",[283,4.011]],["title/46",[64,1.102,94,1.542,283,2.764]],["description/46",[64,1.349,94,1.888,284,4.458,285,4.458,286,5.153]],["title/47",[98,3.688,283,3.121]],["description/47",[82,4.135,136,3.139,283,3.139,287,4.78,288,4.78,289,4.78,290,4.78]],["title/48",[63,0.464,211,2.419,259,1.686]],["description/48",[62,2.405,63,0.588,202,2.578,259,1.572,291,3.268,292,3.396,293,2.786,294,3.396,295,3.396,296,2.578,297,3.926]],["title/49",[40,1.606,62,1.92,63,0.502,211,1.802,259,1.256]],["description/49",[40,1.898,63,0.565,68,2.627,220,2.27,259,2.054,272,2.876,291,3.141,298,3.205,299,2.63,300,2.63,301,3.205]],["title/50",[40,1.755,63,0.378,211,1.969,259,1.372,282,2.25]],["description/50",[11,0.767,39,0.468,40,1.359,63,0.292,67,1.12,68,2.061,90,1.036,100,0.508,106,0.855,154,1.225,200,1.12,203,1.225,205,1.225,206,1.225,208,1.036,211,0.907,220,0.967,250,1.12,259,1.947,271,1.12,282,1.036,291,1.625,293,1.12,296,1.742,299,1.12,300,1.12,301,1.365,302,1.365,303,1.365,304,1.365,305,1.365,306,1.365,307,1.365,308,1.365,309,1.365,310,1.365,311,1.365,312,2.295,313,1.365,314,1.365,315,1.365,316,1.365,317,1.365,318,1.365,319,1.578,320,1.365,321,1.365,322,1.365,323,1.365,324,1.365]],["title/51",[63,0.464,223,2.419,259,1.686]],["description/51",[39,1.164,63,0.433,100,1.265,202,2.578,259,1.572,291,3.268,292,3.396,293,2.786,294,3.396,295,3.396,296,2.578,325,3.926]],["title/52",[40,1.606,62,1.92,63,0.502,223,1.802,259,1.256]],["description/52",[40,1.898,63,0.565,68,2.627,220,2.27,259,2.054,272,2.876,291,3.141,298,3.205,299,2.63,300,2.63,326,3.205]],["title/53",[40,1.935,63,0.416,259,1.513,282,2.481]],["description/53",[9,1.134,11,0.637,39,0.389,40,1.825,63,0.25,67,0.931,68,2.06,90,0.861,100,0.423,106,0.71,154,1.018,180,1.134,182,1.134,196,0.441,200,0.931,203,1.018,205,1.018,206,1.018,208,0.861,216,1.018,220,0.803,223,0.754,250,0.931,259,1.998,282,0.861,291,2.182,293,0.931,296,1.964,299,0.931,300,0.931,302,1.134,303,1.134,304,1.134,305,1.134,306,1.134,307,1.134,308,1.134,309,1.134,310,1.134,311,1.134,312,1.96,313,1.134,314,1.134,315,1.134,316,1.134,317,1.134,318,1.134,320,1.134,321,1.134,322,1.134,323,1.96,324,1.134,326,1.134,327,1.311,328,1.311,329,1.134,330,1.311,331,1.311]],["title/54",[79,2.579,198,2.045,223,2.419]],["description/54",[332,6.108]],["title/55",[13,1.745,130,1.835,333,3.268,334,3.268]],["description/55",[335,6.108]],["title/56",[11,0.602,13,0.572,64,0.324,106,0.671,130,0.602,136,0.813,149,1.072,151,1.072,198,1.048,200,0.879,208,0.813,211,1.239,271,0.879,296,0.813,329,1.072,333,1.072,334,1.072,336,1.239,337,1.239,338,1.239,339,1.239,340,1.239]],["description/56",[341,6.108]],["title/57",[202,2.764,284,3.641,342,4.21]],["description/57",[343,6.108]],["title/58",[108,2.932,198,1.835,239,2.681,344,3.268]],["description/58",[194,2.747,246,3.392,345,4.78,346,4.78,347,4.78,348,4.78,349,4.78]],["title/59",[196,1.27,198,1.835,239,2.681,344,3.268]],["description/59",[64,1.456,94,1.529,194,2.399,196,1.869,202,2.741,246,2.963,350,4.175,351,4.175,352,4.175]],["title/60",[11,1.404,118,0.971,196,0.971,198,1.404,238,1.897,353,2.89,354,2.89]],["description/60",[355,6.108]],["title/61",[196,1.27,198,1.835,223,2.171,238,2.481]],["description/61",[356,6.108]],["title/62",[196,1.415,357,4.21,358,2.988]],["description/62",[64,1.456,94,2.037,101,2.138,130,2.028,171,3.24,196,1.403,285,3.611,358,2.963,359,4.175]],["title/63",[196,1.415,266,2.28,358,2.988]],["description/63",[60,1.946,64,1.23,68,1.285,74,1.647,76,2.992,94,1.72,101,1.285,130,1.218,155,2.169,196,1.771,236,1.946,266,1.358,358,3.332,360,2.508,361,2.508,362,2.508,363,2.508,364,2.508,365,2.508,366,2.508,367,2.508,368,2.508]],["title/64",[130,2.045,369,3.641,370,4.21]],["description/64",[369,5.283]]],"invertedIndex":[["",{"_index":68,"title":{},"description":{"1":{},"2":{},"9":{},"39":{},"49":{},"50":{},"52":{},"53":{},"63":{}}}],["0",{"_index":299,"title":{},"description":{"49":{},"50":{},"52":{},"53":{}}}],["1",{"_index":272,"title":{},"description":{"39":{},"49":{},"52":{}}}],["100",{"_index":107,"title":{},"description":{"2":{}}}],["1024x512",{"_index":310,"title":{},"description":{"50":{},"53":{}}}],["16",{"_index":328,"title":{},"description":{"53":{}}}],["16-bit",{"_index":215,"title":{},"description":{"27":{},"28":{}}}],["1d",{"_index":333,"title":{"55":{},"56":{}},"description":{}}],["32-bit",{"_index":329,"title":{"56":{}},"description":{"53":{}}}],["4-byte",{"_index":319,"title":{},"description":{"50":{}}}],["8",{"_index":323,"title":{},"description":{"50":{},"53":{}}}],["accept",{"_index":114,"title":{},"description":{"3":{}}}],["account",{"_index":303,"title":{},"description":{"50":{},"53":{}}}],["acquisit",{"_index":65,"title":{"1":{},"4":{},"5":{},"39":{},"40":{}},"description":{"3":{},"7":{},"8":{},"37":{}}}],["actual",{"_index":298,"title":{},"description":{"49":{},"52":{}}}],["adjust",{"_index":244,"title":{},"description":{"31":{},"33":{}}}],["affect",{"_index":145,"title":{},"description":{"5":{}}}],["again",{"_index":181,"title":{},"description":{"9":{}}}],["algorithm",{"_index":188,"title":{"11":{}},"description":{}}],["allow",{"_index":50,"title":{},"description":{"0":{},"29":{}}}],["alway",{"_index":176,"title":{},"description":{"8":{}}}],["and/or",{"_index":228,"title":{},"description":{"29":{}}}],["anytim",{"_index":186,"title":{},"description":{"10":{},"12":{},"14":{},"16":{},"18":{},"20":{},"23":{},"24":{},"26":{}}}],["api",{"_index":2,"title":{},"description":{"0":{}}}],["appli",{"_index":9,"title":{},"description":{"0":{},"53":{}}}],["applic",{"_index":17,"title":{},"description":{"0":{}}}],["approach",{"_index":30,"title":{},"description":{"0":{}}}],["array",{"_index":271,"title":{"56":{}},"description":{"39":{},"40":{},"50":{}}}],["asic",{"_index":175,"title":{},"description":{"8":{}}}],["assign",{"_index":317,"title":{},"description":{"50":{},"53":{}}}],["async",{"_index":87,"title":{},"description":{"1":{},"2":{}}}],["async_start",{"_index":119,"title":{},"description":{"3":{}}}],["automat",{"_index":182,"title":{},"description":{"9":{},"53":{}}}],["avail",{"_index":236,"title":{"30":{}},"description":{"35":{},"63":{}}}],["azimuth",{"_index":208,"title":{"25":{},"26":{},"56":{}},"description":{"50":{},"53":{}}}],["back",{"_index":168,"title":{},"description":{"7":{}}}],["base",{"_index":253,"title":{},"description":{"31":{}}}],["be",{"_index":157,"title":{},"description":{"7":{}}}],["beam",{"_index":304,"title":{},"description":{"50":{},"53":{}}}],["befor",{"_index":177,"title":{},"description":{"8":{}}}],["behavior",{"_index":110,"title":{},"description":{"3":{}}}],["between",{"_index":366,"title":{},"description":{"63":{}}}],["binari",{"_index":211,"title":{"27":{},"48":{},"49":{},"50":{},"56":{}},"description":{"27":{},"50":{}}}],["bit",{"_index":322,"title":{},"description":{"50":{},"53":{}}}],["blob",{"_index":214,"title":{},"description":{"27":{}}}],["block",{"_index":111,"title":{},"description":{"3":{},"4":{},"5":{}}}],["bodi",{"_index":122,"title":{},"description":{"3":{}}}],["both",{"_index":309,"title":{},"description":{"50":{},"53":{}}}],["bragg",{"_index":190,"title":{"13":{},"14":{}},"description":{}}],["buffer",{"_index":358,"title":{"62":{},"63":{}},"description":{"62":{},"63":{}}}],["calcul",{"_index":258,"title":{"35":{},"36":{}},"description":{}}],["calibr",{"_index":98,"title":{"47":{}},"description":{"2":{},"9":{}}}],["call",{"_index":60,"title":{},"description":{"0":{},"3":{},"63":{}}}],["cancel",{"_index":146,"title":{"7":{}},"description":{"5":{},"7":{}}}],["card",{"_index":153,"title":{},"description":{"7":{}}}],["case",{"_index":67,"title":{},"description":{"1":{},"3":{},"50":{},"53":{}}}],["cbor",{"_index":344,"title":{"58":{},"59":{}},"description":{}}],["cell",{"_index":82,"title":{},"description":{"1":{},"47":{}}}],["chang",{"_index":117,"title":{"9":{},"11":{},"13":{},"15":{},"17":{},"19":{}},"description":{"3":{},"9":{},"29":{},"31":{},"33":{}}}],["choos",{"_index":24,"title":{},"description":{"0":{},"29":{}}}],["clarif",{"_index":1,"title":{"0":{}},"description":{}}],["clear",{"_index":357,"title":{"62":{}},"description":{}}],["client",{"_index":15,"title":{},"description":{"0":{},"4":{},"5":{}}}],["close",{"_index":73,"title":{},"description":{"1":{},"2":{},"4":{},"5":{}}}],["code",{"_index":19,"title":{"40":{}},"description":{"0":{},"40":{}}}],["collect",{"_index":94,"title":{"2":{},"7":{},"21":{},"22":{},"35":{},"36":{},"46":{}},"description":{"4":{},"5":{},"7":{},"9":{},"23":{},"46":{},"59":{},"62":{},"63":{}}}],["come",{"_index":350,"title":{},"description":{"59":{}}}],["command",{"_index":144,"title":{},"description":{"5":{},"7":{},"8":{},"29":{}}}],["commun",{"_index":57,"title":{},"description":{"0":{}}}],["config/azim_int",{"_index":209,"title":{},"description":{"25":{},"26":{}}}],["config/bragg_integr",{"_index":191,"title":{},"description":{"13":{},"14":{}}}],["config/dark_mask",{"_index":265,"title":{},"description":{"35":{},"36":{}}}],["config/detector",{"_index":185,"title":{},"description":{"9":{},"10":{}}}],["config/file_writ",{"_index":192,"title":{},"description":{"15":{},"16":{}}}],["config/image_format",{"_index":199,"title":{},"description":{"19":{},"20":{}}}],["config/image_format/convers",{"_index":204,"title":{},"description":{"22":{}}}],["config/image_format/raw",{"_index":201,"title":{},"description":{"21":{}}}],["config/index",{"_index":189,"title":{},"description":{"11":{},"12":{}}}],["config/instru",{"_index":195,"title":{},"description":{"17":{},"18":{}}}],["config/internal_generator_imag",{"_index":222,"title":{},"description":{"27":{}}}],["config/internal_generator_image.tiff",{"_index":224,"title":{},"description":{"28":{}}}],["config/mask",{"_index":297,"title":{},"description":{"48":{}}}],["config/mask.tiff",{"_index":325,"title":{},"description":{"51":{}}}],["config/roi",{"_index":281,"title":{},"description":{"43":{},"44":{}}}],["config/select_detector",{"_index":235,"title":{},"description":{"29":{},"30":{}}}],["config/spot_find",{"_index":207,"title":{},"description":{"23":{},"24":{}}}],["config/user_mask",{"_index":301,"title":{},"description":{"49":{},"50":{}}}],["config/user_mask.tiff",{"_index":326,"title":{},"description":{"52":{},"53":{}}}],["config/zeromq_metadata",{"_index":257,"title":{},"description":{"33":{},"34":{}}}],["config/zeromq_preview",{"_index":254,"title":{},"description":{"31":{},"32":{}}}],["configur",{"_index":179,"title":{"9":{},"10":{},"12":{},"14":{},"21":{},"22":{},"23":{},"24":{},"25":{},"26":{},"35":{}},"description":{"30":{}}}],["connect",{"_index":141,"title":{},"description":{"4":{},"5":{}}}],["consist",{"_index":232,"title":{},"description":{"29":{}}}],["contain",{"_index":246,"title":{},"description":{"31":{},"33":{},"58":{},"59":{}}}],["control",{"_index":226,"title":{},"description":{"29":{}}}],["convers",{"_index":203,"title":{"22":{}},"description":{"50":{},"53":{}}}],["convert",{"_index":313,"title":{},"description":{"50":{},"53":{}}}],["coordin",{"_index":220,"title":{},"description":{"27":{},"28":{},"49":{},"50":{},"52":{},"53":{}}}],["copyleft",{"_index":7,"title":{},"description":{"0":{}}}],["cover",{"_index":256,"title":{},"description":{"33":{}}}],["cpu",{"_index":159,"title":{},"description":{"7":{}}}],["current",{"_index":96,"title":{"2":{},"39":{},"40":{}},"description":{"7":{}}}],["custom",{"_index":354,"title":{"60":{}},"description":{}}],["dark",{"_index":95,"title":{"2":{},"35":{},"36":{}},"description":{}}],["data",{"_index":64,"title":{"1":{},"7":{},"21":{},"22":{},"24":{},"35":{},"36":{},"39":{},"40":{},"46":{},"56":{}},"description":{"3":{},"4":{},"5":{},"7":{},"8":{},"23":{},"31":{},"33":{},"37":{},"46":{},"59":{},"62":{},"63":{}}}],["dataset",{"_index":345,"title":{},"description":{"58":{}}}],["deactiv",{"_index":172,"title":{},"description":{"8":{}}}],["dectri",{"_index":260,"title":{},"description":{"35":{}}}],["default",{"_index":109,"title":{},"description":{"3":{}}}],["definit",{"_index":3,"title":{"43":{},"44":{}},"description":{"0":{}}}],["depend",{"_index":221,"title":{},"description":{"27":{},"28":{}}}],["deriv",{"_index":47,"title":{},"description":{"0":{}}}],["detector",{"_index":63,"title":{"1":{},"2":{},"3":{},"6":{},"8":{},"9":{},"10":{},"29":{},"30":{},"42":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}},"description":{"1":{},"2":{},"3":{},"4":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"27":{},"28":{},"29":{},"30":{},"35":{},"42":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["detector/statu",{"_index":279,"title":{},"description":{"42":{}}}],["develop",{"_index":37,"title":{},"description":{"0":{}}}],["devic",{"_index":267,"title":{"38":{}},"description":{}}],["distribut",{"_index":22,"title":{},"description":{"0":{}}}],["doesn't",{"_index":337,"title":{"56":{}},"description":{}}],["don't",{"_index":316,"title":{},"description":{"50":{},"53":{}}}],["done",{"_index":93,"title":{"5":{}},"description":{"1":{},"2":{},"9":{},"10":{},"11":{},"12":{},"13":{},"14":{},"15":{},"16":{},"17":{},"18":{},"19":{},"20":{},"21":{},"22":{},"23":{},"24":{},"25":{},"26":{},"35":{}}}],["dure",{"_index":76,"title":{},"description":{"1":{},"9":{},"63":{}}}],["e.g",{"_index":346,"title":{},"description":{"58":{}}}],["each",{"_index":287,"title":{},"description":{"47":{}}}],["effect",{"_index":169,"title":{},"description":{"7":{},"9":{},"31":{}}}],["eiger",{"_index":263,"title":{},"description":{"35":{}}}],["ensur",{"_index":92,"title":{},"description":{"1":{},"2":{},"3":{},"4":{},"5":{}}}],["error",{"_index":70,"title":{},"description":{"1":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"35":{}}}],["etc",{"_index":46,"title":{},"description":{"0":{}}}],["event",{"_index":275,"title":{"40":{}},"description":{"40":{}}}],["exampl",{"_index":302,"title":{},"description":{"50":{},"53":{}}}],["except",{"_index":25,"title":{},"description":{"0":{}}}],["execut",{"_index":83,"title":{},"description":{"1":{},"4":{},"5":{},"9":{}}}],["expect",{"_index":318,"title":{},"description":{"50":{},"53":{}}}],["experiment",{"_index":347,"title":{},"description":{"58":{}}}],["explicitli",{"_index":38,"title":{},"description":{"0":{}}}],["extend",{"_index":138,"title":{},"description":{"4":{},"5":{}}}],["extern",{"_index":127,"title":{},"description":{"4":{},"5":{}}}],["few",{"_index":85,"title":{},"description":{"1":{}}}],["file",{"_index":10,"title":{"15":{},"16":{}},"description":{"0":{}}}],["find",{"_index":206,"title":{"23":{}},"description":{"50":{},"53":{}}}],["finish",{"_index":143,"title":{},"description":{"5":{},"7":{}}}],["float",{"_index":336,"title":{"56":{}},"description":{}}],["format",{"_index":198,"title":{"19":{},"20":{},"21":{},"22":{},"54":{},"56":{},"58":{},"59":{},"60":{},"61":{}},"description":{}}],["fpga",{"_index":152,"title":{"27":{},"28":{},"38":{}},"description":{"7":{},"27":{},"28":{}}}],["fpga_statu",{"_index":268,"title":{},"description":{"38":{}}}],["frame",{"_index":156,"title":{},"description":{"7":{}}}],["full",{"_index":202,"title":{"22":{},"57":{}},"description":{"48":{},"51":{},"59":{}}}],["function",{"_index":88,"title":{},"description":{"1":{},"2":{}}}],["gap",{"_index":315,"title":{},"description":{"50":{},"53":{}}}],["gcc",{"_index":33,"title":{},"description":{"0":{}}}],["gener",{"_index":13,"title":{"27":{},"28":{},"45":{},"55":{},"56":{}},"description":{"0":{},"6":{},"27":{},"28":{},"31":{},"33":{}}}],["geometri",{"_index":348,"title":{},"description":{"58":{}}}],["given",{"_index":162,"title":{},"description":{"7":{}}}],["goe",{"_index":362,"title":{},"description":{"63":{}}}],["good",{"_index":300,"title":{},"description":{"49":{},"50":{},"52":{},"53":{}}}],["gpl",{"_index":6,"title":{},"description":{"0":{}}}],["gpl-3.0",{"_index":5,"title":{},"description":{"0":{}}}],["gracefulli",{"_index":165,"title":{},"description":{"7":{}}}],["happen",{"_index":213,"title":{},"description":{"27":{},"28":{}}}],["header",{"_index":32,"title":{},"description":{"0":{}}}],["here",{"_index":243,"title":{},"description":{"31":{},"33":{}}}],["high",{"_index":173,"title":{},"description":{"8":{}}}],["hour",{"_index":104,"title":{},"description":{"2":{}}}],["http",{"_index":249,"title":{},"description":{"31":{},"33":{}}}],["i.",{"_index":180,"title":{},"description":{"9":{},"53":{}}}],["id",{"_index":231,"title":{"39":{}},"description":{"29":{},"39":{}}}],["idl",{"_index":100,"title":{},"description":{"2":{},"3":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"27":{},"28":{},"35":{},"50":{},"51":{},"53":{}}}],["ignor",{"_index":250,"title":{},"description":{"31":{},"33":{},"50":{},"53":{}}}],["imag",{"_index":196,"title":{"19":{},"20":{},"27":{},"28":{},"41":{},"59":{},"60":{},"61":{},"62":{},"63":{}},"description":{"27":{},"28":{},"33":{},"39":{},"53":{},"59":{},"62":{},"63":{}}}],["image.cbor",{"_index":367,"title":{},"description":{"63":{}}}],["image_buffer/clear",{"_index":359,"title":{},"description":{"62":{}}}],["image_buffer/image.cbor",{"_index":352,"title":{},"description":{"59":{}}}],["image_buffer/image.jpeg",{"_index":355,"title":{},"description":{"60":{}}}],["image_buffer/image.tiff",{"_index":356,"title":{},"description":{"61":{}}}],["image_buffer/start.cbor",{"_index":349,"title":{},"description":{"58":{}}}],["image_buffer/statu",{"_index":368,"title":{},"description":{"63":{}}}],["image_pusher/statu",{"_index":278,"title":{},"description":{"41":{}}}],["immedi",{"_index":124,"title":{},"description":{"3":{}}}],["implement",{"_index":16,"title":{},"description":{"0":{}}}],["impos",{"_index":54,"title":{},"description":{"0":{}}}],["inact",{"_index":69,"title":{},"description":{"1":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"25":{},"29":{},"35":{}}}],["includ",{"_index":360,"title":{},"description":{"63":{}}}],["indefinit",{"_index":133,"title":{},"description":{"4":{},"5":{}}}],["index",{"_index":187,"title":{"11":{},"12":{}},"description":{}}],["inform",{"_index":151,"title":{"56":{}},"description":{"7":{}}}],["initi",{"_index":62,"title":{"1":{},"49":{},"52":{}},"description":{"1":{},"5":{},"48":{}}}],["instead",{"_index":80,"title":{},"description":{"1":{}}}],["instrument",{"_index":193,"title":{"17":{},"18":{}},"description":{}}],["integ",{"_index":216,"title":{},"description":{"27":{},"28":{},"53":{}}}],["integr",{"_index":106,"title":{"13":{},"14":{},"25":{},"26":{},"56":{}},"description":{"2":{},"50":{},"53":{}}}],["intend",{"_index":49,"title":{},"description":{"0":{}}}],["interact",{"_index":18,"title":{},"description":{"0":{}}}],["interfac",{"_index":43,"title":{},"description":{"0":{},"1":{}}}],["intern",{"_index":212,"title":{"27":{},"28":{}},"description":{"27":{},"28":{}}}],["ioctl",{"_index":45,"title":{},"description":{"0":{}}}],["jfjoch_brok",{"_index":370,"title":{"64":{}},"description":{}}],["jpeg",{"_index":353,"title":{"60":{}},"description":{}}],["jungfrau",{"_index":99,"title":{},"description":{"2":{},"42":{}}}],["jungfraujoch",{"_index":130,"title":{"37":{},"55":{},"56":{},"64":{}},"description":{"4":{},"29":{},"31":{},"33":{},"62":{},"63":{}}}],["kernel",{"_index":36,"title":{},"description":{"0":{}}}],["kernel'",{"_index":29,"title":{},"description":{"0":{}}}],["last",{"_index":285,"title":{},"description":{"46":{},"62":{}}}],["latest",{"_index":351,"title":{},"description":{"59":{}}}],["latter",{"_index":314,"title":{},"description":{"50":{},"53":{}}}],["librari",{"_index":35,"title":{},"description":{"0":{}}}],["licens",{"_index":0,"title":{"0":{}},"description":{"0":{}}}],["limit",{"_index":340,"title":{"56":{}},"description":{}}],["linux",{"_index":28,"title":{},"description":{"0":{}}}],["list",{"_index":230,"title":{"30":{}},"description":{"29":{}}}],["load",{"_index":210,"title":{"27":{},"28":{}},"description":{"27":{},"28":{}}}],["long",{"_index":105,"title":{},"description":{"2":{}}}],["make",{"_index":163,"title":{},"description":{"7":{}}}],["mask",{"_index":259,"title":{"35":{},"36":{},"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}},"description":{"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["mean",{"_index":295,"title":{},"description":{"48":{},"51":{}}}],["mechan",{"_index":61,"title":{},"description":{"0":{}}}],["mere",{"_index":42,"title":{},"description":{"0":{}}}],["messag",{"_index":239,"title":{"58":{},"59":{}},"description":{"31":{},"33":{}}}],["metadata",{"_index":194,"title":{"17":{},"18":{},"33":{},"34":{}},"description":{"33":{},"58":{},"59":{}}}],["minut",{"_index":86,"title":{},"description":{"1":{}}}],["misbehav",{"_index":306,"title":{},"description":{"50":{},"53":{}}}],["mode",{"_index":308,"title":{},"description":{"50":{},"53":{}}}],["modul",{"_index":312,"title":{},"description":{"50":{},"53":{}}}],["module/storag",{"_index":288,"title":{},"description":{"47":{}}}],["moment",{"_index":261,"title":{},"description":{"35":{}}}],["more",{"_index":363,"title":{},"description":{"63":{}}}],["multipl",{"_index":227,"title":{},"description":{"29":{}}}],["need",{"_index":90,"title":{},"description":{"1":{},"2":{},"3":{},"50":{},"53":{}}}],["network",{"_index":59,"title":{},"description":{"0":{},"1":{},"7":{}}}],["new",{"_index":183,"title":{},"description":{"9":{}}}],["number",{"_index":217,"title":{},"description":{"27":{},"28":{}}}],["nxmx",{"_index":293,"title":{},"description":{"48":{},"50":{},"51":{},"53":{}}}],["on",{"_index":89,"title":{},"description":{"1":{},"2":{},"3":{},"9":{},"29":{}}}],["onc",{"_index":102,"title":{},"description":{"2":{}}}],["openapi",{"_index":14,"title":{},"description":{"0":{}}}],["oper",{"_index":74,"title":{},"description":{"1":{},"2":{},"9":{},"35":{},"63":{}}}],["option",{"_index":252,"title":{},"description":{"31":{}}}],["output",{"_index":197,"title":{"19":{},"20":{}},"description":{}}],["pedest",{"_index":79,"title":{"54":{}},"description":{"1":{},"2":{},"5":{},"7":{},"9":{}}}],["per",{"_index":103,"title":{},"description":{"2":{}}}],["period",{"_index":134,"title":{},"description":{"4":{},"5":{}}}],["pixel",{"_index":291,"title":{},"description":{"48":{},"49":{},"50":{},"51":{},"52":{},"53":{}}}],["plot",{"_index":334,"title":{"55":{},"56":{}},"description":{}}],["point",{"_index":264,"title":{},"description":{"35":{}}}],["possibl",{"_index":139,"title":{},"description":{"4":{},"5":{},"35":{}}}],["post",{"_index":78,"title":{},"description":{"1":{},"2":{}}}],["power",{"_index":178,"title":{},"description":{"8":{}}}],["prepar",{"_index":170,"title":{"8":{}},"description":{}}],["preview",{"_index":238,"title":{"31":{},"32":{},"60":{},"61":{}},"description":{"31":{}}}],["preview/pedestal.tiff",{"_index":332,"title":{},"description":{"54":{}}}],["preview/plot",{"_index":335,"title":{},"description":{"55":{}}}],["preview/plot.bin",{"_index":341,"title":{},"description":{"56":{}}}],["procedur",{"_index":135,"title":{},"description":{"4":{},"5":{},"9":{}}}],["process",{"_index":158,"title":{"24":{}},"description":{"7":{}}}],["program",{"_index":41,"title":{},"description":{"0":{}}}],["provid",{"_index":136,"title":{"56":{}},"description":{"4":{},"5":{},"29":{},"47":{}}}],["provis",{"_index":8,"title":{},"description":{"0":{}}}],["psi",{"_index":262,"title":{},"description":{"35":{}}}],["pub",{"_index":255,"title":{},"description":{"33":{}}}],["puls",{"_index":270,"title":{"39":{}},"description":{"39":{}}}],["pusher",{"_index":277,"title":{"41":{}},"description":{}}],["put",{"_index":251,"title":{},"description":{"31":{},"33":{}}}],["raw",{"_index":200,"title":{"21":{},"56":{}},"description":{"50":{},"53":{}}}],["raw/convert",{"_index":219,"title":{},"description":{"27":{},"28":{}}}],["readi",{"_index":113,"title":{},"description":{"3":{},"4":{}}}],["recommend",{"_index":77,"title":{},"description":{"1":{},"2":{}}}],["reconfigur",{"_index":75,"title":{},"description":{"1":{}}}],["record",{"_index":273,"title":{},"description":{"39":{}}}],["regardless",{"_index":55,"title":{},"description":{"0":{}}}],["region",{"_index":307,"title":{},"description":{"50":{},"53":{}}}],["region-of-interest",{"_index":229,"title":{},"description":{"29":{}}}],["reiniti",{"_index":234,"title":{},"description":{"29":{}}}],["replac",{"_index":365,"title":{},"description":{"63":{}}}],["request",{"_index":121,"title":{},"description":{"3":{},"31":{},"33":{}}}],["requir",{"_index":21,"title":{},"description":{"0":{},"4":{},"5":{},"27":{},"28":{},"29":{}}}],["respons",{"_index":233,"title":{},"description":{"29":{}}}],["result",{"_index":284,"title":{"57":{}},"description":{"46":{}}}],["result/scan",{"_index":343,"title":{},"description":{"57":{}}}],["retri",{"_index":142,"title":{},"description":{"4":{},"5":{}}}],["return",{"_index":123,"title":{"39":{},"40":{}},"description":{"3":{},"39":{},"40":{}}}],["roi",{"_index":280,"title":{"43":{},"44":{}},"description":{}}],["run",{"_index":101,"title":{"4":{},"7":{}},"description":{"2":{},"3":{},"5":{},"7":{},"23":{},"62":{},"63":{}}}],["runtim",{"_index":34,"title":{},"description":{"0":{}}}],["safeti",{"_index":140,"title":{},"description":{"4":{},"5":{}}}],["save",{"_index":184,"title":{},"description":{"9":{}}}],["scan",{"_index":342,"title":{"57":{}},"description":{}}],["script",{"_index":128,"title":{},"description":{"4":{},"5":{}}}],["see",{"_index":292,"title":{},"description":{"48":{},"51":{}}}],["select",{"_index":225,"title":{"29":{}},"description":{"30":{}}}],["send",{"_index":149,"title":{"6":{},"56":{}},"description":{}}],["sent",{"_index":160,"title":{},"description":{"7":{}}}],["separ",{"_index":289,"title":{},"description":{"47":{}}}],["server",{"_index":132,"title":{},"description":{"4":{},"5":{}}}],["set",{"_index":118,"title":{"11":{},"13":{},"15":{},"16":{},"31":{},"32":{},"33":{},"34":{},"35":{},"36":{},"60":{}},"description":{"3":{},"9":{},"27":{},"28":{},"29":{},"31":{},"33":{}}}],["shadow",{"_index":305,"title":{},"description":{"50":{},"53":{}}}],["shutter",{"_index":72,"title":{},"description":{"1":{},"2":{}}}],["sign",{"_index":330,"title":{},"description":{"53":{}}}],["similar",{"_index":26,"title":{},"description":{"0":{}}}],["single-channel",{"_index":327,"title":{},"description":{"53":{}}}],["size",{"_index":218,"title":{},"description":{"27":{},"28":{}}}],["slot",{"_index":364,"title":{},"description":{"63":{}}}],["socket",{"_index":242,"title":{"34":{}},"description":{"31":{},"33":{}}}],["socket_address",{"_index":247,"title":{},"description":{"31":{},"33":{}}}],["soft",{"_index":150,"title":{"6":{}},"description":{"6":{}}}],["soft/ttl",{"_index":115,"title":{},"description":{"3":{}}}],["softwar",{"_index":148,"title":{},"description":{"5":{}}}],["sole",{"_index":12,"title":{},"description":{"0":{}}}],["specif",{"_index":52,"title":{},"description":{"0":{}}}],["spirit",{"_index":27,"title":{},"description":{"0":{}}}],["spot",{"_index":205,"title":{"23":{}},"description":{"50":{},"53":{}}}],["stack",{"_index":311,"title":{},"description":{"50":{},"53":{}}}],["stage",{"_index":155,"title":{},"description":{"7":{},"63":{}}}],["standard",{"_index":294,"title":{},"description":{"48":{},"51":{}}}],["start",{"_index":108,"title":{"3":{},"58":{}},"description":{"3":{}}}],["state",{"_index":39,"title":{},"description":{"0":{},"1":{},"2":{},"3":{},"7":{},"8":{},"9":{},"11":{},"13":{},"15":{},"17":{},"19":{},"21":{},"22":{},"27":{},"28":{},"29":{},"35":{},"50":{},"51":{},"53":{}}}],["statist",{"_index":283,"title":{"45":{},"46":{},"47":{}},"description":{"45":{},"47":{}}}],["statistics/calibr",{"_index":290,"title":{},"description":{"47":{}}}],["statistics/data_collect",{"_index":286,"title":{},"description":{"46":{}}}],["statu",{"_index":266,"title":{"37":{},"38":{},"41":{},"42":{},"63":{}},"description":{"37":{},"42":{},"63":{}}}],["stop",{"_index":154,"title":{},"description":{"7":{},"50":{},"53":{}}}],["storag",{"_index":81,"title":{},"description":{"1":{}}}],["store",{"_index":321,"title":{},"description":{"50":{},"53":{}}}],["stream",{"_index":240,"title":{},"description":{"31":{},"33":{}}}],["structur",{"_index":245,"title":{},"description":{"31":{},"33":{}}}],["sub",{"_index":241,"title":{},"description":{"31":{}}}],["subject",{"_index":20,"title":{},"description":{"0":{}}}],["sure",{"_index":164,"title":{},"description":{"7":{}}}],["switch",{"_index":167,"title":{},"description":{"7":{}}}],["synchron",{"_index":147,"title":{},"description":{"5":{}}}],["syscal",{"_index":44,"title":{},"description":{"0":{}}}],["take",{"_index":166,"title":{},"description":{"7":{}}}],["term",{"_index":23,"title":{},"description":{"0":{}}}],["through",{"_index":58,"title":{},"description":{"0":{}}}],["tiff",{"_index":223,"title":{"28":{},"51":{},"52":{},"54":{},"61":{}},"description":{"28":{},"53":{}}}],["till",{"_index":129,"title":{},"description":{"4":{},"5":{}}}],["time",{"_index":84,"title":{},"description":{"1":{},"2":{},"4":{},"5":{},"7":{}}}],["timeout",{"_index":137,"title":{},"description":{"4":{},"5":{}}}],["transmit",{"_index":338,"title":{"56":{}},"description":{}}],["trigger",{"_index":116,"title":{"6":{}},"description":{"3":{},"6":{}}}],["true",{"_index":120,"title":{},"description":{"3":{}}}],["turn",{"_index":171,"title":{"8":{}},"description":{"8":{},"62":{}}}],["two",{"_index":66,"title":{},"description":{"1":{}}}],["under",{"_index":4,"title":{},"description":{"0":{}}}],["unsign",{"_index":320,"title":{},"description":{"50":{},"53":{}}}],["until",{"_index":112,"title":{},"description":{"3":{}}}],["updat",{"_index":97,"title":{},"description":{"2":{}}}],["upload",{"_index":282,"title":{"44":{},"50":{},"53":{}},"description":{"50":{},"53":{}}}],["us",{"_index":11,"title":{"56":{},"60":{}},"description":{"0":{},"1":{},"2":{},"3":{},"8":{},"30":{},"50":{},"53":{}}}],["user",{"_index":40,"title":{"49":{},"50":{},"52":{},"53":{}},"description":{"0":{},"49":{},"50":{},"52":{},"53":{}}}],["userspac",{"_index":31,"title":{},"description":{"0":{}}}],["valid",{"_index":331,"title":{},"description":{"53":{}}}],["valu",{"_index":296,"title":{"56":{}},"description":{"48":{},"50":{},"51":{},"53":{}}}],["version",{"_index":369,"title":{"64":{}},"description":{"64":{}}}],["via",{"_index":248,"title":{},"description":{"31":{},"33":{}}}],["volatil",{"_index":361,"title":{},"description":{"63":{}}}],["voltag",{"_index":174,"title":{},"description":{"8":{}}}],["wait",{"_index":126,"title":{"4":{},"5":{}},"description":{}}],["wait_till_don",{"_index":91,"title":{},"description":{"1":{},"2":{},"5":{}}}],["wait_until_run",{"_index":125,"title":{},"description":{"3":{},"4":{}}}],["web",{"_index":131,"title":{},"description":{"4":{},"5":{}}}],["well",{"_index":324,"title":{},"description":{"50":{},"53":{}}}],["whether",{"_index":56,"title":{},"description":{"0":{}}}],["wider",{"_index":51,"title":{},"description":{"0":{}}}],["without",{"_index":53,"title":{},"description":{"0":{}}}],["work",{"_index":48,"title":{},"description":{"0":{}}}],["writer",{"_index":161,"title":{"15":{},"16":{}},"description":{"7":{}}}],["x-axi",{"_index":339,"title":{"56":{}},"description":{}}],["x-ray",{"_index":71,"title":{},"description":{"1":{},"2":{},"9":{}}}],["xfel",{"_index":269,"title":{"39":{},"40":{}},"description":{"39":{},"40":{}}}],["xfel/event_cod",{"_index":276,"title":{},"description":{"40":{}}}],["xfel/pulse_id",{"_index":274,"title":{},"description":{"39":{}}}],["zeromq",{"_index":237,"title":{"31":{},"32":{},"33":{},"34":{}},"description":{"31":{},"33":{}}}]],"pipeline":[]}},"options":{}};
 
       var container = document.getElementById('redoc');
       Redoc.hydrate(__redoc_state, container);
diff --git a/docs/conf.py b/docs/conf.py
index 3c209874b..ca12a6118 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -9,7 +9,7 @@
 project = 'Jungfraujoch'
 copyright = '2024, Paul Scherrer Institute'
 author = 'Filip Leonarski'
-release = '1.0.0-rc.171'
+release = '1.0.0-rc.172'
 
 # -- General configuration ---------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration
diff --git a/docs/python_client/README.md b/docs/python_client/README.md
index 03b7e3bc0..627a3b140 100644
--- a/docs/python_client/README.md
+++ b/docs/python_client/README.md
@@ -22,8 +22,8 @@ communicate through network calls or other mechanisms.
 
 This Python package is automatically generated by the [OpenAPI Generator](https://openapi-generator.tech) project:
 
-- API version: 1.0.0-rc.171
-- Package version: 1.0.0-rc.171
+- API version: 1.0.0-rc.172
+- Package version: 1.0.0-rc.172
 - Generator version: 7.20.0
 - Build package: org.openapitools.codegen.languages.PythonClientCodegen
 
diff --git a/fpga/hdl/action_config.v b/fpga/hdl/action_config.v
index 11f8bfb3c..a0dc4c633 100644
--- a/fpga/hdl/action_config.v
+++ b/fpga/hdl/action_config.v
@@ -10,7 +10,7 @@ localparam signed [31:0] INT32_MIN = 32'sh80000000;
 `define JFJOCH_FPGA_MAJOR_VERSION 8'd1
 `define JFJOCH_FPGA_MINOR_VERSION 8'd0
 `define JFJOCH_FPGA_PATCH_VERSION 8'd0
-`define JFJOCH_FPGA_PRERELEASE 64'h3137312E6372
+`define JFJOCH_FPGA_PRERELEASE 64'h3237312E6372
 
 `define GIT_SHA1 32'h
 `define MAX_MODULES_FPGA 32'd16
diff --git a/fpga/pcie_driver/dkms.conf b/fpga/pcie_driver/dkms.conf
index dd6d6fa7d..5cd5806d6 100644
--- a/fpga/pcie_driver/dkms.conf
+++ b/fpga/pcie_driver/dkms.conf
@@ -1,5 +1,5 @@
 PACKAGE_NAME=jfjoch
-PACKAGE_VERSION=1.0.0-rc.171
+PACKAGE_VERSION=1.0.0-rc.172
 
 DEST_MODULE_LOCATION=/extra
 BUILT_MODULE_NAME=jfjoch
diff --git a/fpga/pcie_driver/install_dkms.sh b/fpga/pcie_driver/install_dkms.sh
index b92662a47..4008765b2 100755
--- a/fpga/pcie_driver/install_dkms.sh
+++ b/fpga/pcie_driver/install_dkms.sh
@@ -2,7 +2,7 @@
 
 # Copyright (2019-2024) Paul Scherrer Institute
 
-VERSION=1.0.0-rc.171
+VERSION=1.0.0-rc.172
 
 mkdir -p /usr/src/jfjoch-${VERSION}/src
 cp dkms.conf /usr/src/jfjoch-${VERSION}
diff --git a/fpga/pcie_driver/jfjoch_drv.c b/fpga/pcie_driver/jfjoch_drv.c
index 655d8e631..882d4675c 100644
--- a/fpga/pcie_driver/jfjoch_drv.c
+++ b/fpga/pcie_driver/jfjoch_drv.c
@@ -12,7 +12,7 @@
 MODULE_AUTHOR("Filip Leonarski; Paul Scherrer Institute");
 MODULE_DESCRIPTION("Jungfraujoch device module");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("1.0.0-rc.171");
+MODULE_VERSION("1.0.0-rc.172");
 
 #define PCI_DEV_ID_JUNGFRAUJOCH        (0x3450)
 
diff --git a/fpga/pcie_driver/postinstall.sh b/fpga/pcie_driver/postinstall.sh
index 35b6fcf1f..444a4f90c 100755
--- a/fpga/pcie_driver/postinstall.sh
+++ b/fpga/pcie_driver/postinstall.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 # Taken from https://schneide.blog/2015/08/10/packaging-kernel-modulesdrivers-using-dkms/
 
-VERSION=1.0.0-rc.171
+VERSION=1.0.0-rc.172
 
 occurrences=`/usr/sbin/dkms status | grep jfjoch | grep ${VERSION} | wc -l`
 
diff --git a/fpga/pcie_driver/preuninstall.sh b/fpga/pcie_driver/preuninstall.sh
index d21a868a5..01e38efd0 100755
--- a/fpga/pcie_driver/preuninstall.sh
+++ b/fpga/pcie_driver/preuninstall.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 # Taken from https://schneide.blog/2015/08/10/packaging-kernel-modulesdrivers-using-dkms/
 
-VERSION=1.0.0-rc.171
+VERSION=1.0.0-rc.172
 
 /usr/sbin/dkms remove -m jfjoch -v ${VERSION} --all
 
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index c1361f51d..8f6ef2884 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "jungfraujoch-frontend",
-  "version": "1.0.0-rc.171",
+  "version": "1.0.0-rc.172",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jungfraujoch-frontend",
-      "version": "1.0.0-rc.171",
+      "version": "1.0.0-rc.172",
       "license": "GPL-3.0",
       "dependencies": {
         "@emotion/react": "^11.10.4",
diff --git a/frontend/package.json b/frontend/package.json
index e62e86698..5f1d9e773 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,6 +1,6 @@
 {
   "name": "jungfraujoch-frontend",
-  "version": "1.0.0-rc.171",
+  "version": "1.0.0-rc.172",
   "license": "GPL-3.0",
   "private": true,
   "homepage": "/frontend",
diff --git a/frontend/src/version.ts b/frontend/src/version.ts
index e4c0dd32b..cd5def9c1 100644
--- a/frontend/src/version.ts
+++ b/frontend/src/version.ts
@@ -1 +1 @@
-export const JFJOCH_VERSION : string = "1.0.0-rc.171";
\ No newline at end of file
+export const JFJOCH_VERSION : string = "1.0.0-rc.172";
\ No newline at end of file
-- 
2.54.0


From bb55715d28d82394360ecf8132ef64e6d5fc4773 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:06:36 +0200
Subject: [PATCH 058/122] RotationScaleMerge: stream the resident ingest
 instead of materialising a record per observation

The ingest-time geometry smoothing (delta_phi from the smoothed lattice, one exact-Bragg angle per
rocking event, partiality from the smoothed mosaicity) used to run over a 32-byte host record per
observation, copied from the source reflections and held beside them. It now reads hkl, frame, d
and zeta straight from the source reflections, frame by frame, and keeps arrays only for what it
rewrites (delta_phi, partiality) and what the rocking-event walks read in raw-hkl order
(image_number, and on the resident path the usability flag): 13 bytes an observation instead of 32.
The full-Obs path runs the same code and copies the two rewritten fields back.

Same arithmetic in the same order; merged output byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 147 +++++++++---------
 .../scale_merge/RotationScaleMerge.h          |  57 +++----
 2 files changed, 107 insertions(+), 97 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index c251c7fb7..ae7410a61 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -303,8 +303,8 @@ void RotationScaleMerge::Ingest() {
     partials_released = false;
     resident_ingest = false;
 #ifdef JFJOCH_USE_CUDA
-    // Probed before the observation array is built: which record the build lays down (the narrow
-    // resident one or the full Obs) depends on whether the device pipeline will be active.
+    // Probed before the observations are built: whether the build lays down the full Obs array or
+    // only the ingest arrays depends on whether the device pipeline will be active.
     gpu_ = std::make_unique<RotationScaleMergeGPU>();
     gpu_active_ = gpu_->Available();
     resident_ingest = gpu_active_ && observation_dump_path.empty();
@@ -500,6 +500,15 @@ void RotationScaleMerge::Ingest() {
                 n_partials_obs, n_frames, rawrun_start.size());
 
     SmoothMosaicityAndPartiality();
+    if (!resident_ingest) {
+        ParallelChunks(static_cast<int>(partials.size()), ThreadsForWork(partials.size(), nthreads),
+                       [&](int lo, int hi) {
+            for (int i = lo; i < hi; ++i) {
+                partials[i].delta_phi = ingest_delta_phi[i];
+                partials[i].partiality = ingest_partiality[i];
+            }
+        });
+    }
 
     // The corr every pass starts from (see the header). The resident build filled it already,
     // straight from the source reflections (and the smoothing between there and here never
@@ -525,7 +534,7 @@ void RotationScaleMerge::Ingest() {
         for (int at = 0; at < n; at += slice) {
             const int cnt = std::min(n - at, slice);
             ParallelChunks(cnt, nthreads, [&](int lo, int hi) {
-                for (int i = lo; i < hi; ++i) buf[i] = partials_ingest[at + i].partiality;
+                for (int i = lo; i < hi; ++i) buf[i] = ingest_partiality[at + i];
             });
             gpu_->SetObsField(F::Partiality, at, cnt, buf.get());
         }
@@ -577,16 +586,21 @@ void RotationScaleMerge::Ingest() {
         gpu_->SetFrameCellOk(frame_cell_ok.data());
         logger.Info("RotationScaleMerge: GPU scaling + combine + scale-fulls + merge active");
     }
-    // The device now holds every per-obs field the resident pipeline reads, so the host record's
+    // The device now holds every per-obs field the resident pipeline reads, so the ingest arrays'
     // one remaining reader is RockingEventFrames - which on this path sees only ingest-time values
-    // (see the header). Take its answer now and hand the record back. The dump path keeps the full
-    // Obs array: the CPU combine is what writes the dump.
+    // (see the header). Take its answer now and hand them back. The dump path keeps the full Obs
+    // array: the CPU combine is what writes the dump.
     if (resident_ingest) {
         rocking_event_frames_at_ingest = RockingEventFrames();
-        std::vector<ObsIngest>().swap(partials_ingest);
         partials_released = true;
     }
 #endif
+    std::vector<float>().swap(ingest_delta_phi);
+    std::vector<float>().swap(ingest_partiality);
+    std::vector<float>().swap(ingest_image_number);
+    std::vector<uint8_t>().swap(ingest_rock_ok);
+    std::vector<uint8_t>().swap(ingest_keep);
+    std::vector<int32_t>().swap(ingest_src_start);
 }
 
 // Build `partials` (and the per-frame CSR, the finiteness mask and `perm`) from the source reflections,
@@ -623,14 +637,15 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
     // Where each frame's reflections sit in the key numbering, and how many of them survive. Building in
     // index order keeps each frame's observations contiguous and in the order they had, so the per-frame
     // ranges still describe them and every per-frame sum keeps its sequence of roundings.
-    std::vector<int32_t> src_start(n_frames, 0);
+    ingest_src_start.assign(n_frames, 0);
     {
         int32_t at = 0;
         for (int o = 0; o < n_frames; ++o) {
-            src_start[o] = at;
+            ingest_src_start[o] = at;
             at += static_cast<int32_t>(partials_out[o].reflections.size());
         }
     }
+    const std::vector<int32_t> &src_start = ingest_src_start;
     frame_count.assign(n_frames, 0);
     ParallelFor(n_frames, nthreads, [&](int o) {
         int32_t c = 0;
@@ -696,14 +711,16 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
     // finiteness (immutable) - it lets ComputeAsuGroups stamp the ASU-group id per obs from a flat
     // 1-byte array instead of re-reading the fat Obs struct for every space group.
     finite_ok.assign(n_keep, 0);
+    ingest_delta_phi.resize(n_keep);
+    ingest_partiality.resize(n_keep);
+    ingest_image_number.resize(n_keep);
 #ifdef JFJOCH_USE_CUDA
     if (resident_ingest) {
-        // The resident path: build the narrow host record, then stage every immutable per-obs field
-        // to the device straight from the source reflections, in frame-aligned bounded slices. The
-        // 80-byte Obs is never materialised here - beside the source reflections it was another
-        // copy of the whole payload - and the slice buffers are bounded whatever the run.
-        partials_ingest.clear();
-        partials_ingest.resize(n_keep);
+        // The resident path: fill the ingest arrays, then stage every immutable per-obs field to the
+        // device straight from the source reflections, in frame-aligned bounded slices. The 80-byte
+        // Obs is never materialised here - beside the source reflections it was another copy of the
+        // whole payload - and the slice buffers are bounded whatever the run.
+        ingest_rock_ok.resize(n_keep);
         corr_ingested.resize(n_keep);
         ParallelFor(n_frames, nthreads, [&](int o) {
             int32_t src = src_start[o];
@@ -711,25 +728,18 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
             for (const auto &r : partials_out[o].reflections) {
                 if (!keep[src]) { ++src; continue; }
                 ++src;
-                ObsIngest &obs = partials_ingest[at];
-                obs.h = static_cast<int16_t>(r.h);
-                obs.k = static_cast<int16_t>(r.k);
-                obs.l = static_cast<int16_t>(r.l);
-                obs.frame = o;
-                obs.image_number = r.image_number;
-                obs.d = r.d;
-                obs.zeta = r.zeta;
-                obs.delta_phi = r.delta_phi_deg;
-                obs.partiality = r.partiality;
+                ingest_delta_phi[at] = r.delta_phi_deg;
+                ingest_partiality[at] = r.partiality;
+                ingest_image_number[at] = r.image_number;
                 const float prescaling_corr = static_cast<float>(
                         r.prescaling_corr * r.qe_corr * r.flight_corr / frame_flux[o]);
                 corr_ingested[at] = r.image_scale_corr;
                 finite_ok[at] = (std::isfinite(r.I) && std::isfinite(prescaling_corr)
                                  && prescaling_corr != 0.0f
                                  && std::isfinite(r.sigma) && r.sigma > 0.0f) ? 1 : 0;
-                obs.rock_ok = (std::isfinite(r.image_scale_corr) && r.image_scale_corr > 0.0f
-                               && std::isfinite(r.I) && std::isfinite(r.sigma) && r.sigma > 0.0f)
-                              ? 1 : 0;
+                ingest_rock_ok[at] = (std::isfinite(r.image_scale_corr) && r.image_scale_corr > 0.0f
+                                      && std::isfinite(r.I) && std::isfinite(r.sigma) && r.sigma > 0.0f)
+                                     ? 1 : 0;
                 ++at;
             }
         });
@@ -816,6 +826,9 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
             obs.group = -1;
             finite_ok[at] = (std::isfinite(obs.I) && std::isfinite(obs.prescaling_corr) && obs.prescaling_corr != 0.0f
                              && std::isfinite(obs.sigma) && obs.sigma > 0.0f) ? 1 : 0;
+            ingest_delta_phi[at] = r.delta_phi_deg;
+            ingest_partiality[at] = r.partiality;
+            ingest_image_number[at] = r.image_number;
             ++at;
         }
     });
@@ -824,6 +837,7 @@ void RotationScaleMerge::BuildInRangeObservations(std::vector<SortKey> &keys) {
 #endif
 
     n_partials_obs = n_keep;
+    ingest_keep = std::move(keep);
 
     if (n_keep < n_obs)
         logger.Info("RotationScaleMerge: dropped {} of {} observations ({} of {} distinct hkl) outside the "
@@ -891,7 +905,7 @@ namespace {
 // window would over-smooth a fast-slipping crystal and under-smooth a sparse one. The frame's own
 // value is excluded when scoring, so a window is only preferred if it PREDICTS that frame better,
 // which is exactly the noise-versus-drift trade.
-template <class T> void RotationScaleMerge::SmoothGeometry(std::vector<T> &obs) {
+void RotationScaleMerge::SmoothGeometry() {
     const auto gon = x.GetGoniometer();
     if (!gon || n_frames < 5)
         return;
@@ -998,37 +1012,31 @@ template <class T> void RotationScaleMerge::SmoothGeometry(std::vector<T> &obs)
     }
 
     std::atomic<int64_t> changed{0};
-    ParallelChunks(static_cast<int>(obs.size()), nthreads, [&](int lo, int hi) {
+    ParallelFor(n_frames, nthreads, [&](int f) {
+        if (!ok[f])
+            return;
+        const std::array<Coord, 3> &rc = frame_recip[f];
         int64_t local = 0;
-        for (int i = lo; i < hi; ++i) {
-            auto &o = obs[i];
-            if (o.frame < 0 || o.frame >= n_frames || !ok[o.frame])
-                continue;
-            const std::array<Coord, 3> &r = frame_recip[o.frame];
-            const Coord p0 = r[0] * static_cast<float>(o.h) + r[1] * static_cast<float>(o.k)
-                             + r[2] * static_cast<float>(o.l);
-            const float phi_near = o.delta_phi * static_cast<float>(PI) / 180.0f;
+        ForEachKeptIn(f, [&](int i, const Reflection &r) {
+            const Coord p0 = rc[0] * static_cast<float>(r.h) + rc[1] * static_cast<float>(r.k)
+                             + rc[2] * static_cast<float>(r.l);
+            const float phi_near = ingest_delta_phi[i] * static_cast<float>(PI) / 180.0f;
             const auto phi = SolvePhi(p0, S0, m1, m2, m3, m2_S0, m3_S0, phi_near);
             if (!phi || !std::isfinite(*phi))
-                continue;
-            o.delta_phi = *phi * 180.0f / static_cast<float>(PI);
+                return;
+            ingest_delta_phi[i] = *phi * 180.0f / static_cast<float>(PI);
             ++local;
-        }
+        });
         changed += local;
     });
 
     logger.Info("Smoothed per-frame geometry over +-{} frames (chosen by cross-validation); "
                 "recomputed delta_phi for {} of {} partials", best_half, changed.load(),
-                obs.size());
+                n_partials_obs);
 }
 
 void RotationScaleMerge::SmoothMosaicityAndPartiality() {
-    if (resident_ingest) SmoothMosaicityAndPartialityOn(partials_ingest);
-    else                 SmoothMosaicityAndPartialityOn(partials);
-}
-
-template <class T> void RotationScaleMerge::SmoothMosaicityAndPartialityOn(std::vector<T> &obs) {
-    SmoothGeometry(obs);
+    SmoothGeometry();
 
     // One rocking event, one exact-Bragg angle. Every partial's delta_phi is solved from its OWN
     // frame's lattice - by the predictor, and again by SmoothGeometry above - so the per-frame
@@ -1054,25 +1062,25 @@ template <class T> void RotationScaleMerge::SmoothMosaicityAndPartialityOn(std::
                 int i = lo;
                 while (i < hi) {
                     int j = i + 1;
-                    while (j < hi && obs[perm[j]].image_number
-                                     - obs[perm[j - 1]].image_number <= max_frame_gap)
+                    while (j < hi && ingest_image_number[perm[j]]
+                                     - ingest_image_number[perm[j - 1]] <= max_frame_gap)
                         ++j;
                     if (j - i >= 2) {
-                        const float f0 = obs[perm[i]].image_number;
+                        const float f0 = ingest_image_number[perm[i]];
                         double sum = 0.0;
                         int n = 0;
                         for (int m = i; m < j; ++m) {
-                            const auto &o = obs[perm[m]];
-                            if (!std::isfinite(o.delta_phi)) continue;
-                            sum += o.delta_phi + increment_deg * (o.image_number - f0);
+                            const int p = perm[m];
+                            if (!std::isfinite(ingest_delta_phi[p])) continue;
+                            sum += ingest_delta_phi[p] + increment_deg * (ingest_image_number[p] - f0);
                             ++n;
                         }
                         if (n >= 2) {
                             const double c = sum / n;
                             for (int m = i; m < j; ++m) {
-                                auto &o = obs[perm[m]];
-                                o.delta_phi = static_cast<float>(c - increment_deg
-                                                                    * (o.image_number - f0));
+                                const int p = perm[m];
+                                ingest_delta_phi[p] = static_cast<float>(c - increment_deg
+                                                                        * (ingest_image_number[p] - f0));
                             }
                             ++l_ev;
                             l_pa += j - i;
@@ -1145,20 +1153,19 @@ template <class T> void RotationScaleMerge::SmoothMosaicityAndPartialityOn(std::
     // partiality recomputed here matches the one integration was based on. sin(theta_B) = lambda/(2d).
     const double bandwidth_sigma = x.GetBandwidthFWHM().value_or(0.0f) / 2.3548;
     const double half_wavelength_A = x.GetWavelength_A() / 2.0;
-    ParallelChunks(static_cast<int>(obs.size()), nthreads, [&](int lo, int hi) {
-        for (int i = lo; i < hi; ++i) {
-            auto &o = obs[i];
-            float mos = mos_smooth[o.frame];
-            if (bandwidth_sigma > 0.0 && o.d > 0.0f) {
-                const double sin_theta = half_wavelength_A / o.d;
+    ParallelFor(n_frames, nthreads, [&](int f) {
+        ForEachKeptIn(f, [&](int i, const Reflection &r) {
+            float mos = mos_smooth[f];
+            if (bandwidth_sigma > 0.0 && r.d > 0.0f) {
+                const double sin_theta = half_wavelength_A / r.d;
                 const double sigma_bw = (180.0 / PI) * bandwidth_sigma * sin_theta
                                         / std::sqrt(1.0 - sin_theta * sin_theta);
                 mos = static_cast<float>(std::sqrt(mos * mos + sigma_bw * sigma_bw));
             }
-            if (std::isfinite(mos) && mos > 1e-6f && std::isfinite(o.zeta) && o.zeta > 0.0f
-                && std::isfinite(o.delta_phi))
-                o.partiality = RotationPartiality(o.delta_phi, o.zeta, mos, wedge);
-        }
+            if (std::isfinite(mos) && mos > 1e-6f && std::isfinite(r.zeta) && r.zeta > 0.0f
+                && std::isfinite(ingest_delta_phi[i]))
+                ingest_partiality[i] = RotationPartiality(ingest_delta_phi[i], r.zeta, mos, wedge);
+        });
     });
     logger.Info("Recomputed partiality from frame-order-smoothed mosaicity");
 }
@@ -2139,10 +2146,10 @@ namespace {
 int RotationScaleMerge::RockingEventFrames() const {
     if (partials_released)
         return rocking_event_frames_at_ingest;
-    if (resident_ingest)   // Ingest's own call, before the narrow record is handed back
+    if (resident_ingest)   // Ingest's own call, before the ingest arrays are handed back
         return RockingEventFramesOver(
-                [&](int i) { return partials_ingest[i].rock_ok != 0; },
-                [&](int i) { return partials_ingest[i].image_number; });
+                [&](int i) { return ingest_rock_ok[i] != 0; },
+                [&](int i) { return ingest_image_number[i]; });
     return RockingEventFramesOver(
             [&](int i) {
                 const Obs &o = partials[i];
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 81cf8164c..5fd1e8ca8 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -140,26 +140,6 @@ private:
     // re-run over the samples that survive the automatic resolution cutoff. See MergeAndStats.
     struct Sample { double s2, I2, dev2; float d; };
 
-    // The record the ingest keeps on the host when the device pipeline is resident (a GPU and no
-    // observation dump): every immutable per-obs field is uploaded straight from the source
-    // reflections inside BuildInRangeObservations, and the host keeps only what its own remaining
-    // stages touch - the geometry smoothing (delta_phi, then the recomputed partiality), plus the
-    // rocking-event walk's inputs. Thirty-two bytes against the Obs's eighty, and on that path the fat
-    // record is never materialised at all: on a fine-sliced long axis it alone is many gigabytes,
-    // held beside the source reflections it was copied from.
-    struct ObsIngest {
-        // Sixteen bits are plenty for a Miller index - |h| <= a / d_min, in the hundreds even on the
-        // longest axis at atomic resolution - and on a long axis this array sets the ingest's memory
-        // high-water mark, so each index costs two bytes here, not four.
-        int16_t h, k, l;
-        // The rocking-event usability test (RockingEventFrames), evaluated on the ingest-time
-        // values - which is what that walk reads on the resident path, where the host corr is
-        // never refreshed (see partials_released). Beside the indices, where it fills their padding.
-        uint8_t rock_ok;
-        int32_t frame;
-        float image_number, d, zeta, delta_phi, partiality;
-    };
-
     // The narrow per-observation record the ingest sort orders: the raw hkl the runs are cut on, the
     // frame position that breaks a tie inside one, the observation's own index (which makes the order
     // total - see the .cpp), and the resolution the range test reads. Twenty-four bytes against the
@@ -223,12 +203,36 @@ private:
     int report_shell_count = 9;
     std::optional<ReportResolutionRange> report_range;   // the second, reference-range table
 
-    // Flat buffers, allocated once by Ingest() and reused across Run() calls. Exactly one of the
-    // two observation arrays is built: the narrow resident record when the device pipeline is
-    // active and no observation dump was asked for (resident_ingest), the full Obs otherwise.
+    // Flat buffers, allocated once by Ingest() and reused across Run() calls. The full Obs array is
+    // built only when the device pipeline is NOT resident (no GPU, or an observation dump was asked
+    // for); on the resident path (resident_ingest) the device holds the observations and the host
+    // keeps only the ingest arrays below, until the end of Ingest.
     std::vector<Obs> partials;                    // all per-frame partials, grouped by frame
-    std::vector<ObsIngest> partials_ingest;       // the resident-path record (same order)
     bool resident_ingest = false;
+    // What the ingest-time geometry smoothing (SmoothMosaicityAndPartiality) needs beyond the source
+    // reflections, one array per field in `partials` order: the two fields it rewrites, and the two the
+    // rocking-event walks read in raw-hkl order, where a source reflection is out of reach. Every other
+    // field it reads - hkl, frame, d, zeta - is read from the source reflection itself (ForEachKeptIn),
+    // so on the resident path no per-observation record is built at all: on a fine-sliced long axis
+    // that record was gigabytes, held beside the source reflections it was copied from. Filled by
+    // BuildInRangeObservations and handed back at the end of Ingest.
+    std::vector<float> ingest_delta_phi, ingest_partiality, ingest_image_number;
+    // The rocking-event usability test (RockingEventFrames) on the ingest-time values - which is what
+    // that walk reads on the resident path, where the host corr is never refreshed (see
+    // partials_released). Resident path only.
+    std::vector<uint8_t> ingest_rock_ok;
+    // Which source reflections the resolution range kept (indexed like the sort keys: frame by frame,
+    // from ingest_src_start), so that the i-th kept one of a frame can be found again.
+    std::vector<uint8_t> ingest_keep;
+    std::vector<int32_t> ingest_src_start;
+    // Call fn(observation index, source reflection) for each reflection of frame o that the ingest
+    // kept, in order.
+    template <class Fn> void ForEachKeptIn(int o, Fn fn) const {
+        int32_t src = ingest_src_start[o];
+        int32_t at = frame_start[o];
+        for (const auto &r : partials_out[o].reflections)
+            if (ingest_keep[src++]) fn(at++, r);
+    }
     // How many observations Ingest built (== partials.size() until any release below), so the
     // sizes survive when the array itself does not.
     int n_partials_obs = 0;
@@ -445,9 +449,8 @@ private:
     // per-frame partials of one rocking event tile the curve consistently (they sum toward 1) before the
     // 3D combine. Deterministic (frame order); replaces the old arrival-order mosaicity moving average
     // that prediction applied. SG-independent, so done once in Ingest.
-    template <class T> void SmoothGeometry(std::vector<T> &obs);
-    void SmoothMosaicityAndPartiality();   // dispatch: the resident narrow record or the full Obs
-    template <class T> void SmoothMosaicityAndPartialityOn(std::vector<T> &obs);
+    void SmoothGeometry();
+    void SmoothMosaicityAndPartiality();
 
     void Combine();   // partials -> fulls (CPU)
 
-- 
2.54.0


From 61afff891b4277ff8f3b121694d7d8d0c42be956 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:39:16 +0200
Subject: [PATCH 059/122] Rotation scaling: the per-frame scale loop runs to
 convergence, gauge pinned, plain fit

The alternating per-frame scaling used to run a fixed three rounds of a Cauchy-reweighted fit
against a reference that included half a sweep's rocking-curve tails. Three rounds left a short
sweep merged in P1 far from its answer (a 90 deg tetragonal sweep refused its 422 with the P1
scales anti-correlated with the converged ones), and more rounds did not help: the fit had no
fixed point. Two things made it walk. The objective is invariant under G -> cG with the reference
-> reference/c, so every round moved every scale by a constant factor; and the robust loss, iterated
against a reference refitted each round, drops the strong reflections of a frame whose scale is off
by a third (ten-sigma residuals) and lets the weak ones carry it further off - measured on a 360 deg
sweep the scales shrank 10-30% per round for thirty rounds and the H ratio of a genuine 222 read 21x.

Now the loop pins its gauge every iteration (G divided by the precision-weighted typical frame
scale G_ref = sum G^3 / sum G^2, one definition shared with the CC1/2 weight), fits the plain
weighted least-squares slope with the weights the reference uses and only on the observations the
reference is built from (the partiality floor), and stops when the rms |log(G_new/G_old)| over the
frames falls below 1e-3. With the same weights on both sides the alternating fit is exact
coordinate descent on one objective and cannot climb; measured, the 360 deg sweep settles in 19
rounds and the 90 deg one in 30-50, each pass's partials and fulls loops alike.

--scaling-iterations is now the cap (default 100). A loop that reaches it is logged, the report
prints SCALING_ITERATIONS and raises SCALING_NOT_CONVERGED, and the correction surfaces run to the
same tolerance under their own cap. On the GPU the loop runs one iteration per call so the pin and
the step test read the same numbers as on the host; the fulls' reset is split out of ScaleFulls.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 common/ScalingSettings.h                      |   2 +-
 docs/RUGNUX_ADVANCED.md                       |   2 +-
 .../scale_merge/ResolutionCutoff.cpp          |  21 +-
 image_analysis/scale_merge/ResolutionCutoff.h |  12 +-
 .../scale_merge/RotationScaleMerge.cpp        | 240 +++++++++++++-----
 .../scale_merge/RotationScaleMerge.h          |  27 +-
 .../scale_merge/RotationScaleMergeGPU.cu      | 140 +++++-----
 .../scale_merge/RotationScaleMergeGPU.h       |  18 +-
 rugnux/ReportDocument.h                       |   1 +
 rugnux/ResultReport.cpp                       |  13 +
 rugnux/Rugnux.cpp                             |   5 +
 rugnux/Rugnux.h                               |  10 +-
 rugnux/rugnux_cli.cpp                         |   4 +-
 13 files changed, 344 insertions(+), 151 deletions(-)

diff --git a/common/ScalingSettings.h b/common/ScalingSettings.h
index 1d2e5a9bb..198c6366c 100644
--- a/common/ScalingSettings.h
+++ b/common/ScalingSettings.h
@@ -58,7 +58,7 @@ class ScalingSettings {
     // help or do nothing). No-op without rot3d. Set false to disable both.
     bool correction_surfaces = true;
     // Absorption-surface refinement iteration count (used when correction_surfaces is on).
-    int absorption_iter = 3;
+    int absorption_iter = 30;   // the cap; a surface stops refining once its factors settle
 
     // Physical partiality post-refinement for the STILLS merge (StillsPartialityRefine): refine a per-crystal
     // orientation tilt against the running merge, recompute each reflection's partiality from the refined
diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 7984cfd5e..85a82d01a 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -331,7 +331,7 @@ Scaling and merging:
 | `--min-image-cc <num>` | Per-image CC limit, percent (default: no limit) |
 | `--search-min-zeta <num>` | De-novo space-group search only: also search a merge of just the observations whose Lorentz geometry \|ζ\| reaches this, and report both answers (default: 0.85 for rotation, 0 = single search). Reflections crossing the Ewald sphere near-tangentially are measured worst and can make a real symmetry operator look like a twin law. Where the two searches disagree, the merge of all the observations decides — as it always has for the systematic absences |
 | `--mosaicity <num>` | Diagnostic: fix the scaling mosaicity (°) instead of using the per-image seed |
-| `--scaling-iterations <num>` | Scaling iterations with no reference data (default: 3) |
+| `--scaling-iterations <num>` | Cap on the per-frame scaling iterations; the loop stops earlier once the scales settle, and a merge that hits the cap is flagged `SCALING_NOT_CONVERGED` (default: 100) |
 | `-z, --reference-mtz <file>` | Reference MTZ of the same crystal form: fixes the space group and cell, resolves the [indexing ambiguity](#the-indexing-ambiguity), hands over the R-free set and reports CC<sub>ref</sub>. Not a scale anchor |
 | `--reference-column <label>` | Reference MTZ column to use (default: auto — F-model, else IMEAN/I/…) |
 | `--model <file>` | Validate the merged intensities against this atomic model (PDB or mmCIF, gzipped or not; the format is taken from the file's content) — R-work / R-free and maps (see [Validating against a model](#validating-against-a-model-rugnux---model)). It also settles the frame the reflections are written in: the enantiomorph, and the [indexing ambiguity](#the-indexing-ambiguity) where no `-z` did. For serial stills given `-C` / `-S`, the model's structure factors become the per-image reference |
diff --git a/image_analysis/scale_merge/ResolutionCutoff.cpp b/image_analysis/scale_merge/ResolutionCutoff.cpp
index 236a0323c..35c2946ca 100644
--- a/image_analysis/scale_merge/ResolutionCutoff.cpp
+++ b/image_analysis/scale_merge/ResolutionCutoff.cpp
@@ -33,21 +33,28 @@ namespace {
     }
 }
 
-std::vector<double> CCHalfFrameFactors(const std::vector<double> &frame_scale,
-                                       const std::vector<int64_t> &n_obs) {
-    auto g_of = [&](size_t f) {
+namespace {
+    double FrameScaleOr1(const std::vector<double> &frame_scale, size_t f) {
         return std::isfinite(frame_scale[f]) && frame_scale[f] > 0.0 ? frame_scale[f] : 1.0;
-    };
+    }
+}
+
+double TypicalFrameScale(const std::vector<double> &frame_scale, const std::vector<int64_t> &n_obs) {
     double s3 = 0.0, s2 = 0.0;
     for (size_t f = 0; f < frame_scale.size(); ++f) {
-        const double g = g_of(f);
+        const double g = FrameScaleOr1(frame_scale, f);
         s3 += n_obs[f] * g * g * g;
         s2 += n_obs[f] * g * g;
     }
-    const double g_ref = s2 > 0.0 ? s3 / s2 : 1.0;
+    return s2 > 0.0 ? s3 / s2 : 1.0;
+}
+
+std::vector<double> CCHalfFrameFactors(const std::vector<double> &frame_scale,
+                                       const std::vector<int64_t> &n_obs) {
+    const double g_ref = TypicalFrameScale(frame_scale, n_obs);
     std::vector<double> factor(frame_scale.size());
     for (size_t f = 0; f < frame_scale.size(); ++f) {
-        const double r = g_ref / g_of(f);
+        const double r = g_ref / FrameScaleOr1(frame_scale, f);
         factor[f] = std::max(1.0, r * r);
     }
     return factor;
diff --git a/image_analysis/scale_merge/ResolutionCutoff.h b/image_analysis/scale_merge/ResolutionCutoff.h
index 730013d97..8252fbb1b 100644
--- a/image_analysis/scale_merge/ResolutionCutoff.h
+++ b/image_analysis/scale_merge/ResolutionCutoff.h
@@ -34,11 +34,17 @@ struct ResolutionCutoffResult {
     std::string note;              // human-readable description of the decision (for logging)
 };
 
+// The run's typical per-frame scale, G_ref = sum G^3 / sum G^2 over the observations (n_obs[f] of
+// them on frame f): precision-weighted, so frames the crystal barely diffracted on cannot drag it
+// down however many of them there are, where a median of the frames is itself a dead frame on a
+// sweep that spent most of its turn out of the beam. The one definition of "typical frame" - the
+// scaling loop pins its gauge to it, the CC1/2 weight and every frame guard measure against it. A
+// frame without a finite positive scale counts as G = 1; 1 when no frame carries an observation.
+double TypicalFrameScale(const std::vector<double> &frame_scale, const std::vector<int64_t> &n_obs);
+
 // The per-frame factor of the CC1/2 weight (MergedReflection::cc_weight): max(1, (G_ref/G)^2), the
 // variance an observation from a frame at scale G carries over the same observation at the typical
-// scale G_ref = sum G^3 / sum G^2 over the observations (n_obs[f] of them on frame f). Precision-
-// weighted, so frames the crystal barely diffracted on cannot drag the typical scale down however many
-// of them there are. A frame without a finite positive scale counts as G = 1.
+// scale G_ref (TypicalFrameScale).
 std::vector<double> CCHalfFrameFactors(const std::vector<double> &frame_scale,
                                        const std::vector<int64_t> &n_obs);
 
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index c251c7fb7..a01ca9958 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -35,7 +35,9 @@ namespace {
     // implementation is numerically identical - see the comments there for the details.
     constexpr size_t MIN_REFLECTIONS = 20;                 // per-frame scale needs at least this many
     constexpr int64_t MIN_REFLECTIONS_FOR_IMAGE_CC = 20;   // below this a frame's CC means nothing
-    constexpr double SCALE_ROBUST_K = 3.0;   // Cauchy loss scale (sigma units) for the per-frame G fit
+    // The per-frame scaling loop has settled when the scales moved less than this between two
+    // iterations, as the rms of |log(G_new/G_old)| over the frames fitted in both.
+    constexpr double SCALING_TOLERANCE = 1e-3;
 
     // A fitted per-frame scale below this fraction of the run's median is not a measurement of anything:
     // it would mean the frame received 2% of its neighbours' dose while still producing indexable spots.
@@ -176,38 +178,24 @@ namespace {
 
     struct ScaleObs { double coeff, Iobs, weight; };
 
-    // Robust per-frame scale (linear in G): the exact objective ScaleOnTheFly::SolveScaleIRLS solves.
-    double SolveScaleIRLS(const std::vector<ScaleObs> &obs, double robust_k) {
-        auto weighted_scale = [&obs](auto robust_weight) {
-            double num = 0.0, den = 0.0;
-            for (const auto &o : obs) {
-                const double rw = robust_weight(o);
-                const double w2 = o.weight * o.weight;
-                num += rw * w2 * o.coeff * o.Iobs;
-                den += rw * w2 * o.coeff * o.coeff;
-            }
-            return den > 0.0 ? num / den : NAN;
-        };
-
-        double G = weighted_scale([](const ScaleObs &) { return 1.0; });
-        if (!std::isfinite(G))
-            return 1.0;
-        G = std::max(0.0, G);
-
-        const double k2 = robust_k * robust_k;
-        for (int iter = 0; iter < 30; ++iter) {
-            const double G_prev = G;
-            const double G_next = weighted_scale([&](const ScaleObs &o) {
-                const double res = o.weight * (G * o.coeff - o.Iobs);
-                return 1.0 / (1.0 + res * res / k2);
-            });
-            if (!std::isfinite(G_next))
-                break;
-            G = std::max(0.0, G_next);
-            if (std::abs(G - G_prev) <= 1e-7 * std::max(G, 1.0))
-                break;
+    // Per-frame scale, linear in G: the weighted least-squares slope of the observations on their
+    // reference, G = sum w^2 c I / sum w^2 c^2. PLAIN, not the Cauchy-reweighted fit ScaleOnTheFly
+    // solves: iterated against a reference that is itself refitted every round, the robust weights
+    // drift. A frame whose scale is off by a third has its strong reflections at ten-sigma residuals,
+    // which the Cauchy loss all but drops, so the fit is then carried by the weak reflections and
+    // moves away from the answer instead of towards it; measured on the partials of a 360 deg sweep,
+    // the loop shrank every scale by 10-30% per round for thirty rounds under the robust fit and
+    // settled in fourteen under the plain one. With the weights the reference uses, the plain
+    // alternating fit is exact coordinate descent on one objective and cannot climb.
+    double SolveScale(const std::vector<ScaleObs> &obs) {
+        double num = 0.0, den = 0.0;
+        for (const auto &o : obs) {
+            const double w2 = o.weight * o.weight;
+            num += w2 * o.coeff * o.Iobs;
+            den += w2 * o.coeff * o.coeff;
         }
-        return G;
+        const double G = den > 0.0 ? num / den : NAN;
+        return std::isfinite(G) ? std::max(0.0, G) : 1.0;
     }
 
     double median_of(std::vector<double> &v) {
@@ -1323,6 +1311,17 @@ int RotationScaleMerge::ComputeAsuGroups(const HKLKeyGenerator &keygen) {
     return n_groups;
 }
 
+double RotationScaleMerge::ReferenceWeight(const Obs &o, double min_partiality, float &I_corr) {
+    if (o.group < 0) return 0.0;
+    if (!(o.corr > 0.0f) || !std::isfinite(o.corr)) return 0.0;
+    if (o.partiality < min_partiality) return 0.0;
+    const float Ic = o.I * o.corr;
+    const float sigma_corr = o.sigma * o.corr;
+    if (!std::isfinite(Ic) || !std::isfinite(sigma_corr) || sigma_corr <= 0.0f) return 0.0;
+    I_corr = Ic;
+    return 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
+}
+
 void RotationScaleMerge::ReduceGroupMeans(const std::vector<Obs> &obs, int n_groups,
                                           std::vector<double> &out_mean) const {
     // Inverse-variance per-group mean of I*corr = the merge reference (a segmented reduction over the
@@ -1330,13 +1329,9 @@ void RotationScaleMerge::ReduceGroupMeans(const std::vector<Obs> &obs, int n_gro
     // (MergeAll) is built without a reference cell - only the final merge applies it.
     std::vector<double> sw(n_groups, 0.0), swI(n_groups, 0.0);
     for (const auto &o : obs) {
-        if (o.group < 0) continue;
-        if (!(o.corr > 0.0f) || !std::isfinite(o.corr)) continue;
-        if (o.partiality < min_partiality) continue;
-        const float I_corr = o.I * o.corr;
-        const float sigma_corr = o.sigma * o.corr;
-        if (!std::isfinite(I_corr) || !std::isfinite(sigma_corr) || sigma_corr <= 0.0f) continue;
-        const double w = 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
+        float I_corr = 0.0f;
+        const double w = ReferenceWeight(o, min_partiality, I_corr);
+        if (w <= 0.0) continue;
         sw[o.group] += w;
         swI[o.group] += w * I_corr;
     }
@@ -1358,6 +1353,18 @@ void RotationScaleMerge::FitPerFrameG(std::vector<Obs> &obs, const std::vector<i
             const auto &o = obs[i];
             if (o.group < 0) continue;
             if (o.on_ice) continue;
+            // Only the observations the reference is built from (ReduceGroupMeans' partiality floor):
+            // on a fine-sliced sweep half of the partials are rocking-curve tails below it, measured
+            // at I/sigma ~ 0.1, and a frame's scale fitted on them is fitted on noise that the
+            // reference does not answer to.
+            if (o.partiality < min_partiality) continue;
+            // The reference is the group's mean WITH this observation in it. Without it the update is
+            // an undamped Jacobi step on the sparse graph a P1 merge of a short sweep is, and it
+            // oscillates (measured: the gauge alternating 0.56 and 1.39 every other iteration on the
+            // fulls of a 90 deg sweep). With it, a reflection measured once pulls its frame's G to the
+            // value it already has and one measured twice half-way there, which is what damps the
+            // step - the price is that a poorly connected merge creeps to its answer over tens of
+            // iterations, which is what RunScalingLoop's tolerance is for.
             const double mean = group_mean_in[o.group];
             if (!std::isfinite(mean)) continue;
             double coeff;
@@ -1370,7 +1377,7 @@ void RotationScaleMerge::FitPerFrameG(std::vector<Obs> &obs, const std::vector<i
             so.push_back({coeff, static_cast<double>(o.I), SafeInv(o.sigma, 1.0)});
         }
         if (so.size() < MIN_REFLECTIONS) return;   // leave g[f]/corr untouched (as ScaleOnTheFly does)
-        g[f] = SolveScaleIRLS(so, SCALE_ROBUST_K);
+        g[f] = SolveScale(so);
         scaled[f] = 1;
     });
     // Remember which frames were fitted this call (so the caller updates corr only there).
@@ -1392,6 +1399,67 @@ void RotationScaleMerge::UpdateCorr(std::vector<Obs> &obs, const std::vector<dou
     });
 }
 
+RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
+        const char *what, std::vector<double> &g, const std::vector<int32_t> &frame_obs_count,
+        const std::function<void()> &iterate,
+        const std::function<void(const std::vector<uint8_t> &, const std::vector<double> &)> &rescale) {
+    // Alternating least squares on a bilinear model: the reference intensities given the scales, the
+    // scales given the reference. It has one direction the data say nothing about - G -> cG with the
+    // reference -> reference/c - and left alone the iteration walks along it by a constant factor
+    // every round, so the scales never stop moving however many rounds they are given. The gauge is
+    // therefore pinned after every iteration: G is divided by the run's typical frame scale (the
+    // precision-weighted G_ref every other frame measure is read against) and the observations' corr
+    // multiplied by it, which changes no relative scale and no merged intensity. What is left to
+    // converge is the relative scales, and the loop stops when they stop moving.
+    ScalingLoopOutcome out;
+    std::vector<uint8_t> scaled_any(n_frames, 0);
+    std::vector<double> g_prev(n_frames, 0.0);
+    std::vector<int64_t> n_obs(n_frames, 0);
+    std::vector<double> ratio(n_frames, 1.0);
+    for (int it = 0; it < scaling_iter; ++it) {
+        iterate();
+        out.iterations = it + 1;
+        for (int f = 0; f < n_frames; ++f) {
+            scaled_any[f] |= frame_scaled_scratch[f];
+            n_obs[f] = scaled_any[f] && std::isfinite(g[f]) && g[f] > 0.0 ? frame_obs_count[f] : 0;
+        }
+        const double g_ref = TypicalFrameScale(g, n_obs);
+        for (int f = 0; f < n_frames; ++f) {
+            ratio[f] = scaled_any[f] ? g_ref : 1.0;
+            if (scaled_any[f]) g[f] /= g_ref;
+        }
+        rescale(scaled_any, ratio);
+        if (it > 0) {
+            double ss = 0.0;
+            int n = 0;
+            for (int f = 0; f < n_frames; ++f)
+                if (scaled_any[f] && g_prev[f] > 0.0 && g[f] > 0.0) {
+                    const double d = std::log(g[f] / g_prev[f]);
+                    ss += d * d;
+                    ++n;
+                }
+            out.step = n > 0 ? std::sqrt(ss / n) : 0.0;
+            logger.Debug("Per-frame scaling ({}): iteration {}, rms |dlogG| {:.2e} over {} frames, "
+                         "gauge {:.4f}", what, it + 1, out.step, n, g_ref);
+            if (out.step < SCALING_TOLERANCE) {
+                out.converged = true;
+                break;
+            }
+        }
+        g_prev = g;
+    }
+    frame_scaled_scratch = scaled_any;
+    if (out.converged)
+        logger.Info("Per-frame scaling ({}): settled after {} iterations (rms |dlogG| {:.1e})", what,
+                    out.iterations, out.step);
+    else
+        logger.Warning("Per-frame scaling ({}): NOT settled after the cap of {} iterations - the scales "
+                       "were still moving by rms |dlogG| {:.1e} (tolerance {:.0e}); everything read off "
+                       "this merge is read off an unsettled state", what, out.iterations, out.step,
+                       SCALING_TOLERANCE);
+    return out;
+}
+
 void RotationScaleMerge::BuildDecayTerms(int n_groups, DecayTerms &t) const {
     // Same filter the passes that read these terms apply, so the compacted array IS the sequence each of
     // them walked. Chunk boundaries depend on nothing but the length and the worker count, so the array
@@ -2944,15 +3012,21 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
         });
     };
 
-    // Fit the per-cell factor over the subset {frame&1 == parity} (parity < 0 = all fulls), n_iter
-    // alternating rounds against that subset's own reference (Tikhonov pull to 1, gauge-fixed to a
-    // weighted geometric mean of 1 so it never drifts the overall scale). Returns the per-cell factor.
+    // Fit the per-cell factor over the subset {frame&1 == parity} (parity < 0 = all fulls), alternating
+    // rounds against that subset's own reference (Tikhonov pull to 1, gauge-fixed to a weighted
+    // geometric mean of 1 so it never drifts the overall scale) until the factors settle - the same
+    // tolerance as the per-frame scales, on the rms |log| of the round's update - or n_iter rounds
+    // have been spent. Returns the per-cell factor.
+    int rounds_used = 0;
+    bool settled = false;
     auto fit_surface = [&](int parity) -> std::vector<double> {
         const std::vector<int32_t> &sel = subset(parity);
         std::vector<double> A(ncell, 1.0);
         // Per-thread cell accumulators, allocated once for the whole fit rather than per round.
         std::vector<std::vector<double>> tcross(nt, std::vector<double>(ncell)), tref2(nt, std::vector<double>(ncell));
+        settled = false;
         for (int it = 0; it < n_iter; ++it) {
+            rounds_used = it + 1;
             reference(parity, A);
             // The cell's factor is the scale that carries the observation onto the reference, and it is
             // fitted by regressing the OBSERVATION on the reference: A = sum w Iref^2 / sum w Is Iref,
@@ -2994,7 +3068,17 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             double logsum = 0.0, wsum = 0.0;
             for (int c = 0; c < ncell; ++c) if (cross[c] > 0.0) { logsum += cross[c] * std::log(upd[c]); wsum += cross[c]; }
             const double gm = wsum > 0.0 ? std::exp(logsum / wsum) : 1.0;
-            for (int c = 0; c < ncell; ++c) A[c] = std::clamp(A[c] * upd[c] / gm, 0.25, 4.0);
+            double step2 = 0.0;
+            int n_step = 0;
+            for (int c = 0; c < ncell; ++c) {
+                const double next = std::clamp(A[c] * upd[c] / gm, 0.25, 4.0);
+                if (cross[c] > 0.0) { step2 += std::pow(std::log(next / A[c]), 2); ++n_step; }
+                A[c] = next;
+            }
+            if (n_step > 0 && std::sqrt(step2 / n_step) < SCALING_TOLERANCE) {
+                settled = true;
+                break;
+            }
         }
         return A;
     };
@@ -3045,8 +3129,9 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             if (cell[i] >= 0)
                 fulls[i].corr = static_cast<float>(fulls[i].corr * A[cell[i]]);
     });
-    logger.Info("{} correction: cross-validated, held-out gain {:.1f}%",
-                name, 100.0 * gain / std::max(base, 1e-30));
+    logger.Info("{} correction: cross-validated, held-out gain {:.1f}%; {} in {} round(s)",
+                name, 100.0 * gain / std::max(base, 1e-30), settled ? "settled" : "NOT settled",
+                rounds_used);
 }
 
 void RotationScaleMerge::ComputeSmoothGWindow(const std::vector<double> &g, int window,
@@ -4579,23 +4664,44 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     const int n_groups = ComputeAsuGroups(keygen);   // one ASU grouping, shared by partials and fulls
     std::vector<double> partial_mean;
     bool scaled_on_gpu = false;
+
+    ScalingLoopOutcome partial_loop;
 #ifdef JFJOCH_USE_CUDA
     if (gpu_active_) {
-        // Run the whole scaling loop on the GPU; corr stays RESIDENT across scaling -> smooth-G -> CC ->
-        // combine (and across passes, exactly as the old host round-trip did). Only the per-frame G/scaled
-        // come back (needed to compute smooth-G and the writeback).
-        gpu_->ScalePartials(scaling_iter, SCALE_ROBUST_K, min_partiality, d_min_limit.has_value());
-        frame_scaled_scratch.assign(n_frames, 0);
-        gpu_->GetG(g_partial.data(), frame_scaled_scratch.data());
+        // The scaling loop runs on the GPU one iteration per call, and corr stays RESIDENT across
+        // scaling -> smooth-G -> CC -> combine (and across passes, exactly as the old host round-trip
+        // did). Only the per-frame G/scaled come back after each iteration, for the gauge pin and the
+        // step test; the pin goes back down as a per-frame factor on corr. A frame the kernel did not
+        // fit this iteration keeps the G it had (its corr was left where it was).
+        std::vector<double> g_dev(n_frames);
+        std::vector<uint8_t> scaled_dev(n_frames);
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, [&] {
+            gpu_->ScalePartials(1, min_partiality, d_min_limit.has_value());
+            gpu_->GetG(g_dev.data(), scaled_dev.data());
+            for (int f = 0; f < n_frames; ++f)
+                if (scaled_dev[f]) g_partial[f] = g_dev[f];
+            frame_scaled_scratch = scaled_dev;
+        }, [&](const std::vector<uint8_t> &apply, const std::vector<double> &ratio) {
+            gpu_->SmoothCorr(apply.data(), ratio.data());
+        });
         scaled_on_gpu = true;
     }
 #endif
     if (!scaled_on_gpu) {
-        for (int it = 0; it < scaling_iter; ++it) {
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, [&] {
             ReduceGroupMeans(partials, n_groups, partial_mean);
             FitPerFrameG(partials, frame_start, frame_count, partial_mean, /*unity=*/false, g_partial);
             UpdateCorr(partials, g_partial, frame_scaled_scratch);
-        }
+        }, [&](const std::vector<uint8_t> &apply, const std::vector<double> &ratio) {
+            ParallelChunks(static_cast<int>(partials.size()), ThreadsForWork(partials.size(), nthreads),
+                           [&](int lo, int hi) {
+                for (int i = lo; i < hi; ++i) {
+                    Obs &o = partials[i];
+                    if (apply[o.frame] && std::isfinite(o.corr))
+                        o.corr = static_cast<float>(o.corr * ratio[o.frame]);
+                }
+            });
+        });
     }
     const std::vector<uint8_t> partial_scaled = frame_scaled_scratch;
     // The disposition ledger's denominator; the per-frame drops below take frames out of it.
@@ -4798,6 +4904,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     // --- 3. 3D combine of per-frame partials into fulls (fulls inherit their ASU group here). ---
     bool combined_on_gpu = false;
     bool scaled_fulls_on_gpu = false;
+    ScalingLoopOutcome fulls_loop;
 #ifdef JFJOCH_USE_CUDA
     // GPU combine (+ scale-fulls) keeps the fulls resident on the device: combine, then build the frame /
     // ASU-group CSRs on the host from just the small key arrays (a deterministic counting sort - no GPU
@@ -4830,7 +4937,19 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
             { std::vector<int32_t> fill = g_start; for (int i = 0; i < nf; ++i) if (fg[i] >= 0) g_perm[fill[fg[i]]++] = i; }
             gpu_->SetFullsGroups(g_perm.data(), acc, g_start.data(), g_count.data());
 
-            gpu_->ScaleFulls(scaling_iter, SCALE_ROBUST_K, min_partiality);
+            gpu_->ResetFullsScale();
+            if (static_cast<int>(g_full.size()) != n_frames) g_full.assign(n_frames, 1.0);
+            std::vector<double> g_dev(n_frames);
+            std::vector<uint8_t> scaled_dev(n_frames);
+            fulls_loop = RunScalingLoop("fulls", g_full, f_count, [&] {
+                gpu_->ScaleFulls(1, min_partiality);
+                gpu_->GetG(g_dev.data(), scaled_dev.data());
+                for (int f = 0; f < n_frames; ++f)
+                    if (scaled_dev[f]) g_full[f] = g_dev[f];
+                frame_scaled_scratch = scaled_dev;
+            }, [&](const std::vector<uint8_t> &apply, const std::vector<double> &ratio) {
+                gpu_->SmoothFullsCorr(apply.data(), ratio.data());
+            });
             scaled_fulls_on_gpu = true;
         }
 
@@ -4882,11 +5001,15 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     // --- 4. Scale the fulls (XDS order, Unity model). ---
     if (scale_fulls && !scaled_fulls_on_gpu) {
         std::vector<double> full_mean;
-        for (int it = 0; it < scaling_iter; ++it) {
+        fulls_loop = RunScalingLoop("fulls", g_full, fulls_frame_count, [&] {
             ReduceGroupMeans(fulls, n_groups, full_mean);
             FitPerFrameG(fulls, fulls_frame_start, fulls_frame_count, full_mean, /*unity=*/true, g_full);
             UpdateCorr(fulls, g_full, frame_scaled_scratch);
-        }
+        }, [&](const std::vector<uint8_t> &apply, const std::vector<double> &ratio) {
+            for (auto &o : fulls)
+                if (apply[o.frame] && std::isfinite(o.corr))
+                    o.corr = static_cast<float>(o.corr * ratio[o.frame]);
+        });
         logger.Info("Scaled fulls (XDS order, Unity model)");
     }
     // The total scale each frame's fulls were amplified by - partial scale, incident flux and the fulls'
@@ -4990,6 +5113,9 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
 
     // --- 5. Error model + merge + statistics. ---
     auto r = MergeAndStats(n_groups, for_search, combined_on_gpu && scaled_fulls_on_gpu, full_stats);
+    r.scaling_iterations_partials = partial_loop.iterations;
+    r.scaling_iterations_fulls = fulls_loop.iterations;
+    r.scaling_converged = partial_loop.converged && (fulls_loop.iterations == 0 || fulls_loop.converged);
     // With the surfaces off (or none of them adopted) the merge that just ran IS the uncorrected one, so
     // its CC1/2 is the answer without a second merge. A caller that did not ask keeps the NaN.
     if (measure_cc_before_corrections)
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 81cf8164c..5bc743ff0 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -5,6 +5,7 @@
 
 #include <cmath>
 #include <cstdint>
+#include <functional>
 #include <limits>
 #include <optional>
 #include <vector>
@@ -74,6 +75,13 @@ public:
         // numbers are not written.
         std::optional<MergeStatistics> reference_statistics;
         double reference_isa = 0.0;
+        // The per-frame scaling loops (partials, then the fulls): the iterations each used and
+        // whether it settled (rms |log(G_new/G_old)| below its tolerance) before the cap. A merge
+        // whose scales were still moving when the cap stopped them is reported as such, and every
+        // gate reading it is reading an unsettled state.
+        int scaling_iterations_partials = 0;
+        int scaling_iterations_fulls = 0;
+        bool scaling_converged = true;
     };
 
     // experiment: read live (its space group is changed by the caller between Run() calls).
@@ -209,7 +217,9 @@ private:
     double reject_nsigma = 0.0;
     bool reject_outliers = false;
     double rfree_fraction = 0.0;
-    int scaling_iter = 3;
+    // The cap on the per-frame scaling loops. The loops run to a tolerance (see RunScalingLoop);
+    // this is how far they may go before giving up and saying so.
+    int scaling_iter = 100;
     bool scale_fulls = true;
     bool refine_decay_b = false;   // per-time-block Debye-Waller decay correction (radiation damage)
     int  absorption_iter = 0;      // >0: fit a goniometer-frame absorption surface over this many iterations
@@ -415,6 +425,9 @@ private:
     // rawrun_group, the group_h/k/l representative tables, and partials[].group; returns the group count.
     int ComputeAsuGroups(const HKLKeyGenerator &key_generator);
 
+    // The observation's inverse-variance weight in the scaling reference, and its scaled intensity;
+    // 0 when the observation is not in the reference at all.
+    static double ReferenceWeight(const Obs &o, double min_partiality, float &I_corr);
     // Inverse-variance per-group mean of I*corr over `obs` (the merge reference).
     void ReduceGroupMeans(const std::vector<Obs> &obs, int n_groups, std::vector<double> &out_mean) const;
 
@@ -424,6 +437,18 @@ private:
                       const std::vector<int32_t> &fcount, const std::vector<double> &group_mean_in,
                       bool unity, std::vector<double> &g);
 
+    // The alternating per-frame scale fit run to convergence: `iterate` fits every frame once against
+    // the current reference (leaving G in `g` and the frames it fitted in frame_scaled_scratch),
+    // `rescale` multiplies the corr of the flagged frames' observations by a per-frame ratio. Pins the
+    // gauge after every iteration and stops when the scales settle or the cap is reached. On return
+    // frame_scaled_scratch flags every frame fitted in any iteration.
+    struct ScalingLoopOutcome { int iterations = 0; bool converged = false; double step = 0.0; };
+    ScalingLoopOutcome RunScalingLoop(const char *what, std::vector<double> &g,
+                                      const std::vector<int32_t> &frame_obs_count,
+                                      const std::function<void()> &iterate,
+                                      const std::function<void(const std::vector<uint8_t> &,
+                                                               const std::vector<double> &)> &rescale);
+
     // corr = prescaling_corr / (partiality * G[frame]); leaves corr unchanged for frames that could not be fit.
     void UpdateCorr(std::vector<Obs> &obs, const std::vector<double> &g,
                     const std::vector<uint8_t> &frame_scaled) const;
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.cu b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
index 2f51def78..6e161058d 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.cu
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
@@ -33,6 +33,19 @@ namespace {
         return s[0];
     }
 
+    // The observation's inverse-variance weight in the scaling reference (0 = not in it), and its
+    // scaled intensity. The same filter as the host's ReferenceWeight.
+    __device__ __forceinline__ double ReferenceWeight(float I, float sigma, float partiality, float corr,
+                                                      double min_partiality, float &I_corr) {
+        if (!(corr > 0.0f) || !isfinite(corr)) return 0.0;
+        if (partiality < min_partiality) return 0.0;
+        const float Ic = I * corr;
+        const float sigma_corr = sigma * corr;
+        if (!isfinite(Ic) || !isfinite(sigma_corr) || sigma_corr <= 0.0f) return 0.0;
+        I_corr = Ic;
+        return 1.0 / (double(sigma_corr) * sigma_corr);
+    }
+
     // One thread per ASU group (grid-stride): inverse-variance mean of I*corr over the group's contiguous,
     // fixed-order segment of group_perm. Groups are small (avg tens of obs), so a whole block per group
     // wastes threads; summing each group in one thread avoids launch/sync overhead and stays deterministic
@@ -50,13 +63,9 @@ namespace {
             double sw = 0.0, swI = 0.0;
             for (int p = lo; p < hi; ++p) {
                 const int i = group_perm[p];
-                const float c = corr[i];
-                if (!(c > 0.0f) || !isfinite(c)) continue;
-                if (partiality[i] < min_partiality) continue;
-                const float I_corr = I[i] * c;
-                const float sigma_corr = sigma[i] * c;
-                if (!isfinite(I_corr) || !isfinite(sigma_corr) || sigma_corr <= 0.0f) continue;
-                const double w = 1.0 / (double(sigma_corr) * sigma_corr);
+                float I_corr;
+                const double w = ReferenceWeight(I[i], sigma[i], partiality[i], corr[i], min_partiality, I_corr);
+                if (w <= 0.0) continue;
                 sw += w;
                 swI += w * I_corr;
             }
@@ -66,7 +75,7 @@ namespace {
 
     // Per-observation scale-fit coefficient (rotation model) and accept flag, recomputed each scaling
     // iteration once the group means are known. coeff = partiality * (1/prescaling_corr) * mean[group].
-    __global__ void PrepScaleObsKernel(int n_obs, const int32_t *__restrict__ group,
+    __global__ void PrepScaleObsKernel(int n_obs, double min_partiality, const int32_t *__restrict__ group,
                                        const float *__restrict__ partiality, const float *__restrict__ prescaling_corr,
                                        const float *__restrict__ zeta, const uint8_t *__restrict__ on_ice,
                                        const double *__restrict__ group_mean,
@@ -74,29 +83,28 @@ namespace {
                                        float *__restrict__ sco_coeff, uint8_t *__restrict__ sco_ok) {
         const int i = blockIdx.x * blockDim.x + threadIdx.x;
         if (i >= n_obs) return;
-        // sigma never changes once it is uploaded, so its reciprocal is the same in every one of the
-        // thirty IRLS iterations and in every scaling pass. It was being recomputed - a full 64-bit
-        // reciprocal, five refinement steps - for every observation of every iteration. The CPU has
-        // always hoisted it (ScaleObs::weight); this is the GPU catching up. Same expression on the
-        // same operand, so the value is the one the loop used to compute, bit for bit.
-        inv_sigma[i] = SafeInvD(sigma[i], 1.0);
         const int g = group[i];
-        bool ok = (g >= 0) && !on_ice[i] && isfinite(zeta[i]) && zeta[i] > 0.0f;
+        // Only the observations the reference is built from (the host FitPerFrameG says why).
+        bool ok = (g >= 0) && !on_ice[i] && isfinite(zeta[i]) && zeta[i] > 0.0f && partiality[i] >= min_partiality;
         double mean = 0.0;
         if (ok) {
             mean = group_mean[g];
             ok = isfinite(mean);
         }
+        // sigma never changes once it is uploaded, so its reciprocal is the same in every scaling
+        // pass; hoisted as the CPU does (ScaleObs::weight).
+        inv_sigma[i] = SafeInvD(sigma[i], 1.0);
         sco_ok[i] = ok ? 1 : 0;
         sco_coeff[i] = ok ? float(double(partiality[i]) * SafeInvD(prescaling_corr[i], 1.0) * mean) : 0.0f;
     }
 
-    // One block per frame: robust per-frame scale G by IRLS (Cauchy), over the frame's contiguous obs.
-    // Identical objective to the CPU SolveScaleIRLS. Leaves g/scaled untouched for under-populated frames.
-    // `perm` (null for the partials, whose arrays are already frame-contiguous) maps a position in the
-    // frame's [lo,hi) range to the obs index, so the same kernel scales the fulls (emit-ordered) through a
-    // frame-grouping permutation without physically reordering the fulls arrays.
-    __global__ void FitPerFrameGKernel(int n_frames, double robust_k,
+    // One block per frame: the per-frame scale G as the weighted least-squares slope over the frame's
+    // contiguous obs - the same plain fit as the host SolveScale (which says why it is not robust).
+    // Leaves g/scaled untouched for under-populated frames. `perm` (null for the partials, whose
+    // arrays are already frame-contiguous) maps a position in the frame's [lo,hi) range to the obs
+    // index, so the same kernel scales the fulls (emit-ordered) through a frame-grouping permutation
+    // without physically reordering the fulls arrays.
+    __global__ void FitPerFrameGKernel(int n_frames,
                                        const int32_t *__restrict__ frame_start,
                                        const int32_t *__restrict__ frame_count,
                                        const float *__restrict__ I, const double *__restrict__ inv_sigma,
@@ -108,7 +116,6 @@ namespace {
         const int lo = frame_start[f], hi = frame_start[f] + frame_count[f];
         __shared__ double sh[BLK];
 
-        // count accepted
         long cnt_local = 0;
         for (int i = lo + threadIdx.x; i < hi; i += blockDim.x)
             if (sco_ok[perm ? perm[i] : i]) ++cnt_local;
@@ -118,9 +125,6 @@ namespace {
         __syncthreads();
         if (s_cnt < MIN_REFLECTIONS) return;   // leave g[f]/scaled[f] as-is
 
-        const double k2 = robust_k * robust_k;
-
-        // seed: plain weighted-LS ratio (robust weight = 1)
         double num = 0.0, den = 0.0;
         for (int i = lo + threadIdx.x; i < hi; i += blockDim.x) {
             const int a = perm ? perm[i] : i;
@@ -131,46 +135,13 @@ namespace {
             num += w2 * coeff * double(I[a]);
             den += w2 * coeff * coeff;
         }
-        double tnum = BlockReduceSum(num, sh); __syncthreads();
-        double tden = BlockReduceSum(den, sh);
-        __shared__ double s_G;
+        const double tnum = BlockReduceSum(num, sh); __syncthreads();
+        const double tden = BlockReduceSum(den, sh);
         if (threadIdx.x == 0) {
-            double G = tden > 0.0 ? tnum / tden : NAN;
-            s_G = isfinite(G) ? fmax(0.0, G) : 1.0;
+            const double G = tden > 0.0 ? tnum / tden : NAN;
+            g[f] = isfinite(G) ? fmax(0.0, G) : 1.0;
+            scaled[f] = 1;
         }
-        __syncthreads();
-        if (!(s_G >= 0.0)) { if (threadIdx.x == 0) { g[f] = 1.0; scaled[f] = 1; } return; }
-
-        for (int iter = 0; iter < 30; ++iter) {
-            const double G = s_G;
-            num = 0.0; den = 0.0;
-            for (int i = lo + threadIdx.x; i < hi; i += blockDim.x) {
-                const int a = perm ? perm[i] : i;
-                if (!sco_ok[a]) continue;
-                const double coeff = sco_coeff[a];
-                const double w = inv_sigma[a];
-                const double w2 = w * w;
-                const double res = w * (G * coeff - double(I[a]));
-                const double rw = 1.0 / (1.0 + res * res / k2);
-                num += rw * w2 * coeff * double(I[a]);
-                den += rw * w2 * coeff * coeff;
-            }
-            tnum = BlockReduceSum(num, sh); __syncthreads();
-            tden = BlockReduceSum(den, sh);
-            if (threadIdx.x == 0) {
-                const double G_next = tden > 0.0 ? tnum / tden : NAN;
-                if (isfinite(G_next)) {
-                    const double Gn = fmax(0.0, G_next);
-                    s_cnt = (fabs(Gn - G) <= 1e-7 * fmax(Gn, 1.0)) ? 1.0 : 0.0; // reuse s_cnt as "converged"
-                    s_G = Gn;
-                } else {
-                    s_cnt = 1.0;
-                }
-            }
-            __syncthreads();
-            if (s_cnt != 0.0) break;
-        }
-        if (threadIdx.x == 0) { g[f] = s_G; scaled[f] = 1; }
     }
 
     // One block per frame: Pearson CC of (I*corr) vs the merged group mean over the frame's partials,
@@ -813,10 +784,11 @@ void RotationScaleMergeGPU::SetCorr(const float *corr) {
                          cudaMemcpyHostToDevice), "upload corr");
 }
 
-void RotationScaleMergeGPU::ScalePartials(int iters, double robust_k, double min_partiality,
-                                          bool /*has_d_min*/) {
+void RotationScaleMergeGPU::ScalePartials(int iters, double min_partiality, bool /*has_d_min*/) {
     DeviceGuard guard(impl_->device, impl_->available);
     auto &d = *impl_;
+    // Reset per call: the host keeps the G of a frame across calls (RunScalingLoop), so a frame this
+    // call did not fit must read as unfitted, not as fitted with the value of the call before.
     CudaCheck(cudaMemset(d.scaled.get(), 0, size_t(d.n_frames) * sizeof(uint8_t)), "memset scaled");
     CudaCheck(cudaMemset(d.g.get(), 0, size_t(d.n_frames) * sizeof(double)), "memset g"); // unscaled g unused
     const int obs_blocks = (d.n_obs + BLK - 1) / BLK;
@@ -827,11 +799,11 @@ void RotationScaleMergeGPU::ScalePartials(int iters, double robust_k, double min
             d.group_perm.get(), d.group_start.get(), d.group_count.get(),
             d.I.get(), d.sigma.get(), d.partiality.get(), d.corr.get(), d.group_mean.get());
         CudaCheck(cudaGetLastError(), "ReduceGroupMeansKernel launch");
-        PrepScaleObsKernel<<<obs_blocks, BLK>>>(d.n_obs, d.group.get(), d.partiality.get(), d.prescaling_corr.get(),
+        PrepScaleObsKernel<<<obs_blocks, BLK>>>(d.n_obs, min_partiality, d.group.get(), d.partiality.get(), d.prescaling_corr.get(),
             d.zeta.get(), d.on_ice.get(), d.group_mean.get(), d.sigma.get(), d.inv_sigma.get(),
             d.sco_coeff.get(), d.sco_ok.get());
         CudaCheck(cudaGetLastError(), "PrepScaleObsKernel launch");
-        FitPerFrameGKernel<<<d.n_frames, BLK>>>(d.n_frames, robust_k, d.frame_start.get(), d.frame_count.get(),
+        FitPerFrameGKernel<<<d.n_frames, BLK>>>(d.n_frames, d.frame_start.get(), d.frame_count.get(),
             d.I.get(), d.inv_sigma.get(), d.sco_coeff.get(), d.sco_ok.get(), nullptr, d.g.get(), d.scaled.get());
         CudaCheck(cudaGetLastError(), "FitPerFrameGKernel launch");
         UpdateCorrKernel<<<upd_blocks, BLK>>>(d.n_obs, d.frame.get(), d.prescaling_corr.get(), d.partiality.get(),
@@ -1005,6 +977,19 @@ void RotationScaleMergeGPU::SmoothCorr(const uint8_t *apply, const double *ratio
     CudaCheck(cudaDeviceSynchronize(), "smooth corr sync");
 }
 
+void RotationScaleMergeGPU::SmoothFullsCorr(const uint8_t *apply, const double *ratio) {
+    DeviceGuard guard(impl_->device, impl_->available);
+    auto &d = *impl_;
+    if (d.n_fulls == 0) return;
+    Upload(d.smooth_apply, apply, d.n_frames);
+    Upload(d.smooth_ratio, ratio, d.n_frames);
+    const int blocks = std::min(65535, (d.n_fulls + BLK - 1) / BLK);
+    SmoothCorrKernel<<<blocks, BLK>>>(d.n_fulls, d.f_frame.get(), d.smooth_apply.get(),
+                                      d.smooth_ratio.get(), d.f_corr.get());
+    CudaCheck(cudaGetLastError(), "smooth fulls corr launch");
+    CudaCheck(cudaDeviceSynchronize(), "smooth fulls corr sync");
+}
+
 int64_t RotationScaleMergeGPU::FilterCorrByZeta(double min_zeta) {
     DeviceGuard guard(impl_->device, impl_->available);
     auto &d = *impl_;
@@ -1183,14 +1168,12 @@ void RotationScaleMergeGPU::SetFullsGroups(const int32_t *gperm, int n_gperm,
     Upload(d.f_gcount, gcount, d.n_groups);
 }
 
-void RotationScaleMergeGPU::ScaleFulls(int iters, double robust_k, double min_partiality) {
+void RotationScaleMergeGPU::ResetFullsScale() {
     DeviceGuard guard(impl_->device, impl_->available);
     auto &d = *impl_;
     const int nf = d.n_fulls;
     if (nf == 0) return;
     const int obs_blocks = std::min(65535, (nf + BLK - 1) / BLK);
-    const int grp_blocks = std::min(65535, (d.n_groups + BLK - 1) / BLK);
-
     // Unity model: partiality/prescaling_corr/zeta = 1 so coeff = mean; corr starts at 1.
     FillKernel<<<obs_blocks, BLK>>>(d.f_corr.get(), nf, 1.0f);
     CudaCheck(cudaGetLastError(), "FillKernel launch");
@@ -1200,7 +1183,18 @@ void RotationScaleMergeGPU::ScaleFulls(int iters, double robust_k, double min_pa
     CudaCheck(cudaGetLastError(), "FillKernel launch");
     FillKernel<<<obs_blocks, BLK>>>(d.f_zeta.get(), nf, 1.0f);
     CudaCheck(cudaGetLastError(), "FillKernel launch");
-    // g/scaled reset once (a frame, once fitted, stays fitted - same as ScalePartials).
+    CudaCheck(cudaDeviceSynchronize(), "reset fulls scale sync");
+}
+
+void RotationScaleMergeGPU::ScaleFulls(int iters, double min_partiality) {
+    DeviceGuard guard(impl_->device, impl_->available);
+    auto &d = *impl_;
+    const int nf = d.n_fulls;
+    if (nf == 0) return;
+    const int obs_blocks = std::min(65535, (nf + BLK - 1) / BLK);
+    const int grp_blocks = std::min(65535, (d.n_groups + BLK - 1) / BLK);
+
+    // Reset per call, as ScalePartials: the host keeps the G of a frame across calls.
     CudaCheck(cudaMemset(d.scaled.get(), 0, size_t(d.n_frames) * sizeof(uint8_t)), "memset f scaled");
     CudaCheck(cudaMemset(d.g.get(), 0, size_t(d.n_frames) * sizeof(double)), "memset f g");
 
@@ -1212,11 +1206,11 @@ void RotationScaleMergeGPU::ScaleFulls(int iters, double robust_k, double min_pa
         // Not grid-stride, so its grid has to cover every full - unlike the grid-stride kernels
         // below, which the 65535 cap is there for. Capped, it would silently leave the tail of
         // sco_coeff/sco_ok stale above 16.8M fulls.
-        PrepScaleObsKernel<<<(nf + BLK - 1) / BLK, BLK>>>(nf, d.f_group.get(), d.f_partiality.get(),
+        PrepScaleObsKernel<<<(nf + BLK - 1) / BLK, BLK>>>(nf, min_partiality, d.f_group.get(), d.f_partiality.get(),
             d.f_rlp.get(), d.f_zeta.get(), d.f_on_ice.get(), d.group_mean.get(),
             d.f_sigma.get(), d.f_inv_sigma.get(), d.f_sco_coeff.get(), d.f_sco_ok.get());
         CudaCheck(cudaGetLastError(), "PrepScaleObsKernel launch");
-        FitPerFrameGKernel<<<d.n_frames, BLK>>>(d.n_frames, robust_k,
+        FitPerFrameGKernel<<<d.n_frames, BLK>>>(d.n_frames,
             d.f_frame_start.get(), d.f_frame_count.get(), d.f_I.get(), d.f_inv_sigma.get(),
             d.f_sco_coeff.get(), d.f_sco_ok.get(), d.f_frame_perm.get(), d.g.get(), d.scaled.get());
         CudaCheck(cudaGetLastError(), "FitPerFrameGKernel launch");
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.h b/image_analysis/scale_merge/RotationScaleMergeGPU.h
index fb853b016..49c4c889d 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.h
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.h
@@ -56,9 +56,9 @@ public:
     // between passes). SetObsField(Corr0) uploads the initial corr; this refreshes it.
     void SetCorr(const float *corr);
 
-    // Run `iters` of {reduce group means -> per-frame robust IRLS G -> update corr} on the device,
+    // Run `iters` of {reduce group means -> per-frame weighted-LS G -> update corr} on the device,
     // in place on the resident corr. Rotation model (partiality folded via the stored partiality).
-    void ScalePartials(int iters, double robust_k, double min_partiality, bool has_d_min);
+    void ScalePartials(int iters, double min_partiality, bool has_d_min);
 
     // Copy the updated corr back to the host (length n_obs), and the fitted per-frame G (length
     // n_frames, as double) plus the per-frame "was fitted" flag.
@@ -163,9 +163,17 @@ public:
     void SetFullsGroups(const int32_t *gperm, int n_gperm,
                         const int32_t *gstart, const int32_t *gcount);
 
-    // Run `iters` of the Unity scaling loop on the resident fulls (reduce group means -> per-frame IRLS G
-    // -> update corr), in place on the fulls' working corr. Requires SetFullsFrameCSR + SetFullsGroups.
-    void ScaleFulls(int iters, double robust_k, double min_partiality);
+    // Start the Unity scaling of the resident fulls: corr, partiality, prescaling and zeta all 1, no
+    // frame fitted yet. Once before the ScaleFulls iterations.
+    void ResetFullsScale();
+
+    // Run `iters` of the Unity scaling loop on the resident fulls (reduce group means -> per-frame LS G
+    // -> update corr), in place on the fulls' working corr. Requires SetFullsFrameCSR + SetFullsGroups
+    // and ResetFullsScale.
+    void ScaleFulls(int iters, double min_partiality);
+
+    // The fulls' counterpart of SmoothCorr: f_corr[i] *= ratio[f_frame[i]] where apply[f].
+    void SmoothFullsCorr(const uint8_t *apply, const double *ratio);
 
     // Download the fulls' working corr (length = n_fulls), valid after ScaleFulls.
     void GetFullsCorr(float *corr) const;
diff --git a/rugnux/ReportDocument.h b/rugnux/ReportDocument.h
index bc587c577..be8690150 100644
--- a/rugnux/ReportDocument.h
+++ b/rugnux/ReportDocument.h
@@ -44,6 +44,7 @@ namespace PathologyCode {
     constexpr const char *LATTICE_TRANSLATION = "LATTICE_TRANSLATION";   // a translation the cell does not declare
     constexpr const char *HARMONIC_CONTAMINATION = "HARMONIC_CONTAMINATION"; // the beam carries a higher harmonic
     constexpr const char *GEOMETRY_NOT_CONVERGED = "GEOMETRY_NOT_CONVERGED"; // the geometry walk ran out of rounds
+    constexpr const char *SCALING_NOT_CONVERGED = "SCALING_NOT_CONVERGED";   // the per-frame scales hit their cap still moving
 }
 
 // A closed type plus an open description. The type is what machinery switches on; the text is what a
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 0a976d95d..dd96d05fd 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -701,6 +701,19 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             Add(s, KeyReal("ERROR_MODEL_A", result.error_model_a, "{:.4f}"));
             Add(s, KeyReal("ERROR_MODEL_B", result.error_model_b, "{:.4e}"));
             // A b that is zero within its error gives a 1/b that is the noise in b, not an I/sigma.
+            Add(s, KeyText("SCALING_ITERATIONS",
+                           fmt::format("{} partials, {} fulls{}", result.scaling_iterations_partials,
+                                       result.scaling_iterations_fulls,
+                                       result.scaling_converged ? "" : " (NOT settled)"), true));
+            if (!result.scaling_converged || !result.search_scaling_converged)
+                Warn(doc, PathologyCode::SCALING_NOT_CONVERGED, fmt::format(
+                        "the per-frame scales of {} were still moving when the iteration cap stopped "
+                        "them, so everything read off that merge is read off an unsettled state "
+                        "(--scaling-iterations raises the cap)",
+                        !result.scaling_converged && !result.search_scaling_converged
+                            ? "the space-group search merge and the final merge"
+                            : !result.scaling_converged ? "the final merge"
+                                                        : "the space-group search merge"));
             if (result.error_model_isa_resolved)
                 Add(s, KeyReal("ISA", result.error_model_isa, "{:.2f}"));
             else
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 557c79afe..e213ee9e2 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -5158,6 +5158,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 if (r.resolution_fit_A) result.resolution_fit_A = r.resolution_fit_A;
                 result.error_model_a = r.error_model_a;
                 result.error_model_b = r.error_model_b;
+                result.scaling_iterations_partials = r.scaling_iterations_partials;
+                result.scaling_iterations_fulls = r.scaling_iterations_fulls;
+                result.scaling_converged = r.scaling_converged;
+                if (for_search)
+                    result.search_scaling_converged = r.scaling_converged;
                 return ScaleMergeResult{std::move(r.merged), std::move(r.statistics),
                                         r.cc_half_before_corrections,
                                         std::move(r.reference_statistics), r.reference_isa};
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 91312251a..45b68f3a6 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -150,7 +150,7 @@ struct ProcessConfig {
     // Scaling / merging (FullAnalysis). reference_data (from a reference MTZ) also drives the
     // per-image live scaling path when present.
     bool run_scaling = false;
-    int64_t scaling_iter = 3;
+    int64_t scaling_iter = 100;   // the cap; the loop stops once the scales settle
     std::vector<MergedReflection> reference_data;
 
     // When the reference MTZ carried a FreeR_flag column, reference_data reflections carry its
@@ -243,6 +243,14 @@ struct ProcessResult {
     double error_model_a = 0.0;               // XDS convention: sigma^2 = a*(sigma0^2 + b*I^2)
     double error_model_b = 0.0;
     bool has_reference = false;
+    // The per-frame scaling loops of the merge this result is built on (rotation): iterations used
+    // by the partials loop and by the fulls loop, and whether both settled before the cap. A merge
+    // whose scales were still moving when the cap stopped them is reported as such.
+    int scaling_iterations_partials = 0;
+    int scaling_iterations_fulls = 0;
+    bool scaling_converged = true;
+    // ... and the same for the P1 merge the space-group search read, which is a different merge.
+    bool search_scaling_converged = true;
 
     // The reflections the run kept, binned over the reference range of --report-resolution
     // (ScalingSettings::ReportResolutionRange_A) instead of the run's own range: a second table, not
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index e4b6fdc9d..df93d5a02 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -175,7 +175,7 @@ void print_usage() {
     std::cout << "   --reject-outliers <num>         Per-observation merge outlier rejection, N sigma from the per-reflection median (default: 6 for rot3d, XDS/DIALS-style; 0 = off)" << std::endl;
     std::cout << "   --search-min-zeta <num>         De-novo space-group search only: also search a merge of just the observations whose Lorentz geometry |zeta| reaches this, and report both answers (default: 0.85 for rotation, 0 = single search). Reflections crossing the Ewald sphere near-tangentially are measured worst and can make a real symmetry operator look like a twin law; where the two searches disagree, the merge of ALL the observations decides" << std::endl;
     std::cout << "   --min-image-cc <num>            Per-image CC limit in percent (default: no limit)" << std::endl;
-    std::cout << "   --scaling-iterations <num>      Number of scaling iterations with no reference data (default: 3)" << std::endl;
+    std::cout << "   --scaling-iterations <num>      Cap on the per-frame scaling iterations; the loop stops earlier once the scales settle (default: 100)" << std::endl;
     std::cout << "   -z, --reference-mtz <file>      Reference MTZ file" << std::endl;
     std::cout << "   --reference-column <label>      Reference MTZ column to use (default: auto - F-model, else IMEAN/I, else FP/FOBS/F)" << std::endl;
     std::cout << "   --model <file>                  After merging, validate vs this atomic model: R-free, sigma_A-weighted 2mFo-DFc/mFo-DFc maps, the model as placed (written beside them), and - where the merge kept the Bijvoet split - an anomalous difference map with the strongest anomalous scatterers named by the atom they sit on. PDB or mmCIF, gzipped or not, recognised by content rather than by extension" << std::endl;
@@ -764,7 +764,7 @@ static int RunRugnux(int argc, char **argv) {
     std::optional<double> forced_prediction_mosaicity_arg;  // diagnostic: fix the PREDICTION mosaicity (deg), leaving the partiality on the per-image value
     double min_image_cc = 0.0;
     std::optional<double> search_min_zeta_arg;   // --search-min-zeta; rotation default below
-    int64_t scaling_iter = 3;
+    int64_t scaling_iter = 100;
     std::optional<CrystalLattice> forced_rotation_lattice;
     std::optional<double> background_clip_arg;         // --background-clip: background-ring high-side sigma clip
     bool background_radial_given = false;              // --background-radial seen at all (unset => auto)
-- 
2.54.0


From 8be83841f4591182c44d2fba47a902c08820b851 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:17:21 +0200
Subject: [PATCH 060/122] rugnux: the beam-centre arms are arbitrated only
 while they still disagree

The beam-centre check carries both centres forward when indexing at each
returns the same cell in a DIFFERENT metric symmetry, and RunAllPasses then
adopts whichever arm merges better on its P1 search merge. That question is
asked before the short-axis pass and before the geometry post-refinement,
either of which can replace the lattice it was asked about: on a crystal whose
shortest axis is under the FFT floor the check compares two supercells that the
short-axis pass then throws away, and both arms end on the same sub-cell in the
same class, post-refined to the same centre within a fifth of a pixel.

The arbiter was then deciding between two integrations of ONE hypothesis on a
statistic whose difference between them is noise. On a small-molecule rotation
sweep whose per-frame scales collapse on a fifth of the frames, the two arms'
search merges came out 0.543 and 0.594 - a 0.051 margin against the 0.05 the
run moves off the file's centre for - and the adopted arm took the run from
P 21 21 21 at 0.65 A to P 1 2 1 at 1.79 A on the same cell.

The arms are now compared on the lattices they ENDED on: where both hold the
same class, the same centring and primitive volumes within 2 %, the centre did
not decide the metric symmetry after all, the merges are not asked to arbitrate
it, and the file's centre stays (the post-refinement moves it wherever the spots
put it). Where they still differ the merge comparison runs exactly as before,
and both branches now log the two arms' final classes. ProcessResult carries the
rotation lattice's class for the comparison.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 48 ++++++++++++++++++++++++++++++++++++++++++-----
 rugnux/Rugnux.h   |  3 +++
 2 files changed, 46 insertions(+), 5 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 557c79afe..8581a1cbd 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1888,7 +1888,42 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             }
             alt.pass_number = 1;
             alt.pass_count = 2;
-            const bool alt_merges_better = !cancelled_ && alt.has_merge_statistics
+            // The question is asked again of what the two arms ENDED on. The check opened it on the
+            // lattices the standard-floor search returned, before the short-axis pass and the geometry
+            // post-refinement; either can replace that lattice, and on a crystal with an axis under the
+            // FFT floor the check compared two supercells the short-axis pass then threw away. Where
+            // both arms now hold the same lattice in the same class, the centre did not decide the
+            // symmetry after all: the two merges are two integrations of ONE hypothesis, their CC1/2
+            // difference is the noise between them, and there is nothing for it to arbitrate - so the
+            // file's centre stays, and the post-refinement moves it wherever the spots put it. Same
+            // lattice means what it means in the check: same class and primitive volumes within 2 %.
+            const auto primitive_volume = [](const ProcessResult &r) {
+                return std::abs(CrystalLattice(*r.consensus_cell)
+                                        .ToPrimitive(r.consensus_centering.value_or('P')).CalcVolume());
+            };
+            const bool arms_agree = alt.rotation_lattice_type && pass1.rotation_lattice_type
+                                    && alt.consensus_cell && pass1.consensus_cell
+                                    && alt.rotation_lattice_type->crystal_system
+                                       == pass1.rotation_lattice_type->crystal_system
+                                    && alt.rotation_lattice_type->centering
+                                       == pass1.rotation_lattice_type->centering
+                                    && std::max(primitive_volume(alt), primitive_volume(pass1))
+                                       < 1.02 * std::min(primitive_volume(alt), primitive_volume(pass1));
+            if (arms_agree)
+                logger.Info("Beam centre check: after their whole first passes both centres hold the "
+                            "same lattice - {}-centred {} - so the centre did not decide the metric "
+                            "symmetry, and the merges (CC1/2 before corrections {:.3f} at the measured "
+                            "centre against {:.3f}) are not asked to", pass1.rotation_lattice_type->centering,
+                            gemmi::crystal_system_str(pass1.rotation_lattice_type->crystal_system),
+                            alt.search_merge_cc_half, pass1.search_merge_cc_half);
+            else if (alt.rotation_lattice_type && pass1.rotation_lattice_type)
+                logger.Info("Beam centre check: after their whole first passes the arms still differ - "
+                            "{}-centred {} at the file's centre against {}-centred {} at the measured one",
+                            pass1.rotation_lattice_type->centering,
+                            gemmi::crystal_system_str(pass1.rotation_lattice_type->crystal_system),
+                            alt.rotation_lattice_type->centering,
+                            gemmi::crystal_system_str(alt.rotation_lattice_type->crystal_system));
+            const bool alt_merges_better = !cancelled_ && !arms_agree && alt.has_merge_statistics
                                            && pass1.has_merge_statistics
                                            && alt.search_merge_cc_half
                                               > pass1.search_merge_cc_half + MAX_CC_HALF_LOSS;
@@ -1907,10 +1942,11 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
                                cell_text(alt), cell_text(pass1));
                 pass1 = std::move(alt);
             } else {
-                logger.Info("Beam centre check: the measured centre does not merge better (CC1/2 "
-                            "before corrections {:.3f} against {:.3f} on the search merge) - the run "
-                            "keeps the file's centre and the symmetry it found",
-                            alt.search_merge_cc_half, pass1.search_merge_cc_half);
+                if (!arms_agree)
+                    logger.Info("Beam centre check: the measured centre does not merge better (CC1/2 "
+                                "before corrections {:.3f} against {:.3f} on the search merge) - the run "
+                                "keeps the file's centre and the symmetry it found",
+                                alt.search_merge_cc_half, pass1.search_merge_cc_half);
                 experiment_ = file_experiment;
                 prepass_mosaicity_ = file_mosaicity;
                 prepass_detector_geometry_ = file_geometry;
@@ -4775,6 +4811,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 .crystal_system = rot->search_result.system
             };
             result.rotation_lattice_found = true;
+            result.rotation_lattice_type = end_msg.rotation_lattice_type;
             // The consensus cell below is this lattice's conventional cell, so this is the centring
             // it is written in - the pair the volume comparisons in Run() need.
             result.consensus_centering = rot->search_result.centering;
@@ -4917,6 +4954,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             end_msg.rotation_lattice = end_msg.rotation_lattice->Multiply(reindex);
             end_msg.rotation_lattice_type = LatticeMessage{ .centering = cand.centering,
                 .niggli_class = end_msg.rotation_lattice_type->niggli_class, .crystal_system = cand.system };
+            result.rotation_lattice_type = end_msg.rotation_lattice_type;
             record_reindex(reindex);
             return true;
         };
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 91312251a..9e665dd8c 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -229,6 +229,9 @@ struct ProcessResult {
     // cell - so two cells can only be compared for volume once this has brought both to primitive.
     std::optional<char> consensus_centering;
     bool rotation_lattice_found = false;
+    // The metric symmetry the rotation lattice was classified in - the class GeometryRefiner holds the
+    // cell to and the space-group search enumerates under. Empty when no rotation lattice was found.
+    std::optional<LatticeMessage> rotation_lattice_type;
     MeanProcessingTime mean_processing_time{};
     std::optional<std::string> written_master_path;
     std::string merge_statistics_text;   // populated when scaling/merging ran
-- 
2.54.0


From 1b414909cb5c0a5ccd266724d51b4b6b52c7ce7c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:30:32 +0200
Subject: [PATCH 061/122] rugnux: the model maps come from FFTW too, so the
 model path uses one FFT library

The map-coefficient to real-space transform was still gemmi's bundled pocketfft while the
map to structure-factor direction had moved to FFTW. MapFromFPhi does that inverse with
FFTW - the same half-l XYZ layout, the same 1/V scale, NaN coefficients read as zero, the
same conjugation convention - and the output maps are now built with it. Plans are
FFTW_ESTIMATE, cached per grid size and direction, and made under the shared planner lock.

No pocketfft code is instantiated in rugnux any more (75 symbols -> 0); gemmi's fourier.hpp
is still included for its non-FFT helpers (get_size_for_hkl, get_f_phi_on_grid), so the
vendored header and its notice stay.

Tested element-wise against gemmi on odd and even grids, with arbitrary phases, negative
indices and symmetry/Friedel expansion in three space groups, plus a round trip; both new
tests fail if the conjugation is dropped. On the eight --model audit sets the merged MTZ is
byte-identical, the map coefficients are identical, the CCP4 maps agree to 3e-7 relative
(map CC 1.00000000) and every reported key is unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelFFT.cpp           | 67 ++++++++++++++++++++++++--------
 rugnux/ModelFFT.h             |  6 +++
 rugnux/ModelValidation.cpp    |  4 +-
 tests/ModelValidationTest.cpp | 73 ++++++++++++++++++++++++++++++++++-
 4 files changed, 131 insertions(+), 19 deletions(-)

diff --git a/rugnux/ModelFFT.cpp b/rugnux/ModelFFT.cpp
index 03ce9c69c..a70c4fb88 100644
--- a/rugnux/ModelFFT.cpp
+++ b/rugnux/ModelFFT.cpp
@@ -5,6 +5,7 @@
 
 #include <algorithm>
 #include <array>
+#include <cmath>
 #include <complex>
 #include <map>
 #include <mutex>
@@ -17,27 +18,28 @@
 
 namespace {
 
-// The r2c plan for an (nu, nv, nw) map stored u fastest, halving w - the layout gemmi's own transform
-// reads and writes. FFTW's planner is not thread-safe, so plans are made under the process-wide planner
-// lock (which also guards this cache); executing one on new arrays (fftwf_execute_dft_r2c) is, which is
-// how every caller uses it.
-fftwf_plan PlanFor(int nu, int nv, int nw) {
-    static std::map<std::array<int, 3>, fftwf_plan> plans;
+// The r2c plan (or, inverse, the c2r plan) for an (nu, nv, nw) map stored u fastest, halving w - the
+// layout gemmi's own transforms read and write. FFTW's planner is not thread-safe, so plans are made
+// under the process-wide planner lock (which also guards this cache); executing one on new arrays
+// (fftwf_execute_dft_r2c / _c2r) is, which is how every caller uses it.
+fftwf_plan PlanFor(int nu, int nv, int nw, bool inverse) {
+    static std::map<std::array<int, 4>, fftwf_plan> plans;
     std::lock_guard lock(FFTWPlannerMutex());
-    const std::array<int, 3> key{nu, nv, nw};
+    const std::array<int, 4> key{nu, nv, nw, inverse};
     if (const auto it = plans.find(key); it != plans.end())
         return it->second;
-    float *in = fftwf_alloc_real(static_cast<size_t>(nu) * nv * nw);
-    fftwf_complex *out = fftwf_alloc_complex(static_cast<size_t>(nu) * nv * (nw / 2 + 1));
+    float *real = fftwf_alloc_real(static_cast<size_t>(nu) * nv * nw);
+    fftwf_complex *cplx = fftwf_alloc_complex(static_cast<size_t>(nu) * nv * (nw / 2 + 1));
     // The last dimension is the one r2c halves; the strides put u fastest on both sides.
     fftwf_iodim dims[3] = {{nu, 1, 1}, {nv, nu, nu}, {nw, nu * nv, nu * nv}};
-    fftwf_plan plan = (in != nullptr && out != nullptr)
-            ? fftwf_plan_guru_dft_r2c(3, dims, 0, nullptr, in, out, FFTW_ESTIMATE)
-            : nullptr;
-    fftwf_free(in);
-    fftwf_free(out);
+    fftwf_plan plan = nullptr;
+    if (real != nullptr && cplx != nullptr)
+        plan = inverse ? fftwf_plan_guru_dft_c2r(3, dims, 0, nullptr, cplx, real, FFTW_ESTIMATE)
+                       : fftwf_plan_guru_dft_r2c(3, dims, 0, nullptr, real, cplx, FFTW_ESTIMATE);
+    fftwf_free(real);
+    fftwf_free(cplx);
     if (plan == nullptr)
-        gemmi::fail("MapToFPhi(): no FFTW plan for the grid");
+        gemmi::fail("ModelFFT: no FFTW plan for the grid");
     plans.emplace(key, plan);
     return plan;
 }
@@ -55,7 +57,7 @@ gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map) {
     hkl.set_size_without_checking(map.nu, map.nv, map.nw / 2 + 1);
     const float norm = static_cast<float>(map.unit_cell.volume / map.point_count());
 
-    const fftwf_plan plan = PlanFor(map.nu, map.nv, map.nw);
+    const fftwf_plan plan = PlanFor(map.nu, map.nv, map.nw, false);
     // Buffers from fftwf_malloc: a plan may only be executed on arrays aligned as the ones it was made
     // on were, which the vectors' own allocations do not promise.
     float *in = fftwf_alloc_real(map.data.size());
@@ -75,3 +77,36 @@ gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map) {
     fftwf_free(out);
     return hkl;
 }
+
+gemmi::Grid<float> MapFromFPhi(const gemmi::FPhiGrid<float> &hkl) {
+    if (hkl.axis_order == gemmi::AxisOrder::ZYX || !hkl.half_l)
+        gemmi::fail("MapFromFPhi(): only an XYZ half-l grid is supported");
+    gemmi::Grid<float> map;
+    map.spacegroup = hkl.spacegroup;
+    map.unit_cell = hkl.unit_cell;
+    map.set_size(hkl.nu, hkl.nv, 2 * (hkl.nw - 1));
+    map.axis_order = hkl.axis_order;
+    const float norm = static_cast<float>(1.0 / hkl.unit_cell.volume);
+
+    const fftwf_plan plan = PlanFor(map.nu, map.nv, map.nw, true);
+    fftwf_complex *in = fftwf_alloc_complex(hkl.data.size());
+    float *out = fftwf_alloc_real(map.data.size());
+    if (in == nullptr || out == nullptr) {
+        fftwf_free(in);
+        fftwf_free(out);
+        gemmi::fail("MapFromFPhi(): cannot allocate the FFT buffers");
+    }
+    // Conjugated, as gemmi does: rho(x) = 1/V sum F exp(-2 pi i h.x), and FFTW's backward transform
+    // carries exp(+2 pi i h.x). A missing coefficient (NaN) counts as zero, also as gemmi does.
+    for (size_t i = 0; i < hkl.data.size(); ++i) {
+        const std::complex<float> x = hkl.data[i];
+        in[i][0] = std::isnan(x.imag()) ? 0.0f : x.real();
+        in[i][1] = std::isnan(x.imag()) ? 0.0f : -x.imag();
+    }
+    fftwf_execute_dft_c2r(plan, in, out);
+    for (size_t i = 0; i < map.data.size(); ++i)
+        map.data[i] = out[i] * norm;
+    fftwf_free(in);
+    fftwf_free(out);
+    return map;
+}
diff --git a/rugnux/ModelFFT.h b/rugnux/ModelFFT.h
index fd807d1de..793d7153b 100644
--- a/rugnux/ModelFFT.h
+++ b/rugnux/ModelFFT.h
@@ -16,3 +16,9 @@
 // one from run to run - and made once per grid size and kept, so the rigid body's hundred-odd
 // evaluations on one grid plan once. Safe to call from several threads at once.
 gemmi::FPhiGrid<float> MapToFPhi(const gemmi::Grid<float> &map);
+
+// The inverse: the real-space map of an (nu, nv, nw/2+1) half-l coefficient grid in XYZ order, as
+// get_f_phi_on_grid() fills it - what gemmi::transform_f_phi_grid_to_map() returns (rho = 1/V sum F
+// exp(-2 pi i h.x) on an (nu, nv, 2*(nw-1)) grid, NaN coefficients read as zero), computed with FFTW
+// under the same planning rules.
+gemmi::Grid<float> MapFromFPhi(const gemmi::FPhiGrid<float> &hkl);
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 4d09805ab..783b19849 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -20,7 +20,7 @@
 #include <gemmi/gz.hpp>        // MaybeGzipped
 #include <gemmi/it92.hpp>      // IT92 x-ray form factors
 #include <gemmi/dencalc.hpp>   // DensityCalculator
-#include <gemmi/fourier.hpp>   // get_f_phi_on_grid, transform_f_phi_grid_to_map (the maps)
+#include <gemmi/fourier.hpp>   // get_size_for_hkl, get_f_phi_on_grid (the maps)
 #include <gemmi/solmask.hpp>   // SolventMasker
 #include <gemmi/scaling.hpp>   // Scaling (bulk solvent + anisotropic B)
 #include <gemmi/ccp4.hpp>      // Ccp4 map I/O
@@ -48,7 +48,7 @@ long hkl_key(const gemmi::Miller &h) {
 gemmi::Grid<float> map_from_coefficients(gemmi::AsuData<std::complex<float>> &coef) {
     coef.ensure_sorted();
     std::array<int, 3> size = gemmi::get_size_for_hkl(coef, {{0, 0, 0}}, 3.0);
-    return gemmi::transform_f_phi_grid_to_map(gemmi::get_f_phi_on_grid<float>(coef, size, true));
+    return MapFromFPhi(gemmi::get_f_phi_on_grid<float>(coef, size, true));
 }
 
 // Write a map as CCP4; return its RMS (the sigma the map is read in).
diff --git a/tests/ModelValidationTest.cpp b/tests/ModelValidationTest.cpp
index 3fcb7bee8..134f5ac23 100644
--- a/tests/ModelValidationTest.cpp
+++ b/tests/ModelValidationTest.cpp
@@ -593,10 +593,12 @@ TEST_CASE("ModelValidation_CCModelFollowsTheSignalByShell", "[ModelValidation]")
 // The model path's structure factors come from FFTW; they must be gemmi's own transform to float
 // precision, in the same layout, so prepare_asu_data() reads the same reflections from either.
 TEST_CASE("ModelValidation_MapToFPhiMatchesGemmi", "[ModelValidation]") {
+    // An even grid, and an odd one on every axis (FFTW and pocketfft split odd lengths differently).
+    const auto size = GENERATE(std::array<int, 3>{20, 24, 30}, std::array<int, 3>{15, 21, 27});
     gemmi::Grid<float> map;
     map.unit_cell.set(40.0, 50.0, 60.0, 90.0, 95.0, 90.0);
     map.spacegroup = gemmi::find_spacegroup_by_name("P 1");
-    map.set_size(20, 24, 30);
+    map.set_size(size[0], size[1], size[2]);
     std::mt19937 rng(7);
     std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
     for (auto &x : map.data)
@@ -623,6 +625,75 @@ TEST_CASE("ModelValidation_MapToFPhiMatchesGemmi", "[ModelValidation]") {
         CHECK(a.v[i].hkl == b.v[i].hkl);
 }
 
+// The output maps come from FFTW too; each must be gemmi's own map to float precision, point for point
+// in the same layout. Coefficients with arbitrary phases, negative indices, expanded by symmetry and
+// Friedel, on grids that are odd along u and v (w is even by construction of a half-l grid).
+TEST_CASE("ModelValidation_MapFromFPhiMatchesGemmi", "[ModelValidation]") {
+    const char *sg_name = GENERATE("P 1", "P 1 21 1", "P 21 21 21");
+    const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name(sg_name);
+    REQUIRE(sg != nullptr);
+    gemmi::AsuData<std::complex<float>> coef;
+    coef.unit_cell_.set(31.0, 43.0, 57.0, 90.0, sg->number == 4 ? 104.0 : 90.0, 90.0);
+    coef.spacegroup_ = sg;
+    const gemmi::ReciprocalAsu asu(sg);
+    const gemmi::GroupOps gops = sg->operations();
+    std::mt19937 rng(11);
+    std::uniform_real_distribution<float> amp(0.1f, 10.0f), phase(-3.14159f, 3.14159f);
+    for (int h = -7; h <= 7; h++)
+        for (int k = -9; k <= 9; k++)
+            for (int l = -11; l <= 11; l++) {
+                const gemmi::Op::Miller hkl{{h, k, l}};
+                if ((h == 0 && k == 0 && l == 0) || !asu.is_in(hkl) || gops.is_systematically_absent(hkl))
+                    continue;
+                coef.v.push_back({hkl, std::polar(amp(rng), phase(rng))});
+            }
+    REQUIRE(coef.v.size() > 500);
+    // P 1 takes an odd grid on u and v; the screw axes need even factors.
+    const std::array<int, 3> size = sg->number == 1 ? std::array<int, 3>{17, 21, 26}
+                                                     : std::array<int, 3>{18, 24, 26};
+    gemmi::FPhiGrid<float> grid = gemmi::get_f_phi_on_grid<float>(coef, size, true);
+    grid.data[grid.index_n(2, -3, 4)] = std::complex<float>(1.0f, NAN);   // a missing coefficient
+
+    const gemmi::Grid<float> ours = MapFromFPhi(grid);
+    const gemmi::Grid<float> ref = gemmi::transform_f_phi_grid_to_map(gemmi::FPhiGrid<float>(grid));
+    REQUIRE(ours.nu == ref.nu);
+    REQUIRE(ours.nv == ref.nv);
+    REQUIRE(ours.nw == ref.nw);
+    REQUIRE(ours.axis_order == ref.axis_order);
+    REQUIRE(ours.spacegroup == ref.spacegroup);
+    REQUIRE(ours.data.size() == ref.data.size());
+    double largest = 0, worst = 0;
+    for (size_t i = 0; i < ref.data.size(); i++) {
+        REQUIRE(std::isfinite(ours.data[i]));
+        largest = std::max(largest, static_cast<double>(std::abs(ref.data[i])));
+        worst = std::max(worst, static_cast<double>(std::abs(ours.data[i] - ref.data[i])));
+    }
+    CHECK(largest > 0);
+    CHECK(worst <= 1e-5 * largest);
+}
+
+// Map -> coefficients -> map is the identity (the V/N and 1/V scales cancel the unnormalised
+// transforms), on a grid odd along u and v.
+TEST_CASE("ModelValidation_ModelFFTRoundTrip", "[ModelValidation]") {
+    gemmi::Grid<float> map;
+    map.unit_cell.set(35.0, 45.0, 55.0, 80.0, 95.0, 105.0);
+    map.spacegroup = gemmi::find_spacegroup_by_name("P 1");
+    map.set_size(15, 21, 28);
+    std::mt19937 rng(3);
+    std::uniform_real_distribution<float> dist(-1.0f, 1.0f);
+    for (auto &x : map.data)
+        x = dist(rng);
+
+    const gemmi::Grid<float> back = MapFromFPhi(MapToFPhi(map));
+    REQUIRE(back.nu == map.nu);
+    REQUIRE(back.nv == map.nv);
+    REQUIRE(back.nw == map.nw);
+    double worst = 0;
+    for (size_t i = 0; i < map.data.size(); i++)
+        worst = std::max(worst, static_cast<double>(std::abs(back.data[i] - map.data[i])));
+    CHECK(worst <= 1e-5);
+}
+
 // The Jacobian's six columns are evaluated in parallel; the placement must be the serial one, bit for
 // bit.
 TEST_CASE("ModelValidation_RigidBodySameOnAnyNumberOfThreads", "[ModelValidation]") {
-- 
2.54.0


From ca9a21c45e31d31a2baf3965d50595277cf57f14 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:14:47 +0200
Subject: [PATCH 062/122] rugnux: keep a pass's per-image reflections in large
 blocks

The whole-run passes retain every frame's integrated reflections until scaling is done - thousands
of vectors of a few megabytes each, allocated by the image workers in the allocator's per-thread
arenas. When a pass hands them back, most of that memory stays in those arenas as holes, and the
next pass's workers (new threads) do not reuse it, so on a fine-sliced long axis gigabytes of freed
reflections were carried to the end of the run.

IndexAndRefine now copies each retained frame's reflections into a ReflectionArena: 64 MiB blocks,
each its own mapping, carved by a bump pointer and returned to the system in one piece when the
last vector in them is gone. IntegrationOutcome::reflections becomes a std::vector with an allocator
that uses the arena when given one and plain new/delete otherwise (copies go to the heap), so the
read sites are unchanged; the few functions that took the vector by type now take a span.

No arithmetic changes; merged output byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/IndexAndRefine.cpp             |  14 ++-
 image_analysis/IndexAndRefine.h               |   2 +
 image_analysis/IntegrationOutcome.h           |   7 +-
 image_analysis/ReflectionArena.h              | 113 ++++++++++++++++++
 image_analysis/geom_refinement/PostRefine.cpp |   2 +-
 image_analysis/scale_merge/Merge.cpp          |   2 +-
 image_analysis/scale_merge/Merge.h            |   3 +-
 .../scale_merge/ReindexAmbiguity.cpp          |   4 +-
 image_analysis/scale_merge/ReindexAmbiguity.h |   5 +-
 reader/HDF5MetadataSource.cpp                 |   3 +-
 rugnux/Rugnux.cpp                             |   2 +-
 11 files changed, 143 insertions(+), 14 deletions(-)
 create mode 100644 image_analysis/ReflectionArena.h

diff --git a/image_analysis/IndexAndRefine.cpp b/image_analysis/IndexAndRefine.cpp
index 6d48a4b82..b21475948 100644
--- a/image_analysis/IndexAndRefine.cpp
+++ b/image_analysis/IndexAndRefine.cpp
@@ -586,18 +586,24 @@ void IndexAndRefine::QuickPredictAndIntegrate(DataMessage &msg,
     // caller's callback binds it to the right image (GPU-resident buffer, host buffer, or the assembled
     // FPGA image read straight on the CPU).
     auto integration_start_time = std::chrono::steady_clock::now();
-    i_outcome.reflections = integrate(prediction.GetReflections(), nrefl, msg.number);
-    msg.integrated_reflections = i_outcome.reflections.size();
+    const std::vector<Reflection> integrated = integrate(prediction.GetReflections(), nrefl, msg.number);
+    msg.integrated_reflections = integrated.size();
     auto integration_end_time = std::chrono::steady_clock::now();
     msg.integration_time_s = std::chrono::duration<float>(integration_end_time - integration_start_time).count();
 
-    CalcISigmaAndWilsonBFactor(msg, i_outcome.reflections);
+    CalcISigmaAndWilsonBFactor(msg, integrated);
+
+    // A retained outcome is kept in the pass's arena (see ReflectionArena), not beside the worker's
+    // other allocations.
+    i_outcome.reflections = ReflectionVector(integrated.begin(), integrated.end(),
+                                             ArenaAllocator<Reflection>(retain_outcomes_ ? &reflection_arena
+                                                                                         : nullptr));
 
     ScaleImage(msg, i_outcome);
 
     // Copy reflections to outgoing message
     if (keep_reflections_in_message_)
-        msg.reflections = i_outcome.reflections;
+        msg.reflections.assign(i_outcome.reflections.begin(), i_outcome.reflections.end());
 
     // Persist the per-image result for the whole-run scaling/merge pass, unless the caller opted out
     // (viewer interactive use only needs the current image, returned above via msg).
diff --git a/image_analysis/IndexAndRefine.h b/image_analysis/IndexAndRefine.h
index 0fb0d1fdd..56904f78e 100644
--- a/image_analysis/IndexAndRefine.h
+++ b/image_analysis/IndexAndRefine.h
@@ -62,6 +62,8 @@ class IndexAndRefine {
     };
 
     mutable std::mutex reflections_mutex;
+    // Holds the retained outcomes' reflections; declared before them, so it outlives them.
+    ReflectionArena reflection_arena;
     std::vector<IntegrationOutcome> integration_outcome;
     std::vector<float> mosaicity;
     // Optional per-frame mosaicity used for Bragg prediction, indexed by image number. When set (the
diff --git a/image_analysis/IntegrationOutcome.h b/image_analysis/IntegrationOutcome.h
index c0d8855fa..a16f41957 100644
--- a/image_analysis/IntegrationOutcome.h
+++ b/image_analysis/IntegrationOutcome.h
@@ -8,11 +8,16 @@
 #include "../common/Reflection.h"
 #include "../common/CrystalLattice.h"
 #include "../common/DiffractionGeometry.h"
+#include "ReflectionArena.h"
+
+// A frame's integrated reflections. The whole-run passes keep them in a ReflectionArena (see there);
+// anywhere else the allocator is plain new/delete.
+using ReflectionVector = std::vector<Reflection, ArenaAllocator<Reflection>>;
 
 struct IntegrationOutcome {
     DiffractionGeometry geom;
     CrystalLattice latt;
-    std::vector<Reflection> reflections;
+    ReflectionVector reflections;
     std::optional<float> mosaicity_deg;
     std::optional<float> image_scale_cc;
     std::optional<int64_t> image_scale_cc_n;
diff --git a/image_analysis/ReflectionArena.h b/image_analysis/ReflectionArena.h
new file mode 100644
index 000000000..193dc71b7
--- /dev/null
+++ b/image_analysis/ReflectionArena.h
@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <algorithm>
+#include <cstddef>
+#include <mutex>
+#include <new>
+#include <type_traits>
+#include <vector>
+
+// Large blocks that a whole pass's per-image reflection vectors are carved from.
+//
+// A rotation pass keeps every frame's integrated reflections until its scaling is done - thousands of
+// vectors of a few megabytes each, gigabytes together, allocated by the image workers in the
+// allocator's per-thread arenas. When the pass hands them back, that memory mostly stays in those
+// arenas, as holes between whatever else the workers allocated, and the next pass's workers, being
+// new threads, do not reuse it: on a fine-sliced long axis gigabytes of freed reflections were carried
+// to the end of the run. Here a block is allocated in one piece (large enough that it is its own
+// mapping) and returned in one piece once the last vector in it is gone, so a pass's reflections
+// leave nothing behind.
+//
+// A vector is carved from the current block by bumping a pointer; the space of a vector freed early
+// is only reclaimed with its whole block. That suits the use here: the vectors are written once,
+// when the frame is integrated, and handed back together.
+class ReflectionArena {
+public:
+    ReflectionArena() = default;
+    ReflectionArena(const ReflectionArena &) = delete;
+    ReflectionArena &operator=(const ReflectionArena &) = delete;
+    ~ReflectionArena() {
+        for (auto &b : blocks)
+            ::operator delete(b.data);
+    }
+
+    void *Allocate(size_t bytes) {
+        bytes = (bytes + kAlign - 1) / kAlign * kAlign;
+        std::unique_lock ul(m);
+        if (blocks.empty() || blocks.back().size - blocks.back().used < bytes) {
+            const size_t size = std::max(kBlockBytes, bytes);
+            blocks.push_back(Block{static_cast<char *>(::operator new(size)), size, 0, 0});
+        }
+        Block &b = blocks.back();
+        void *p = b.data + b.used;
+        b.used += bytes;
+        b.live++;
+        return p;
+    }
+
+    void Deallocate(void *p) {
+        std::unique_lock ul(m);
+        for (size_t i = 0; i < blocks.size(); ++i) {
+            Block &b = blocks[i];
+            if (static_cast<char *>(p) < b.data || static_cast<char *>(p) >= b.data + b.size)
+                continue;
+            if (--b.live == 0) {
+                if (i + 1 == blocks.size()) {
+                    b.used = 0;   // the block being filled: keep it for the next vector
+                } else {
+                    ::operator delete(b.data);
+                    blocks.erase(blocks.begin() + static_cast<std::ptrdiff_t>(i));
+                }
+            }
+            return;
+        }
+    }
+
+private:
+    // 64 MiB: above the largest size glibc ever serves from its heaps (32 MiB), so every block is a
+    // mapping of its own and goes back to the system when freed. A frame's reflections are a few
+    // megabytes, so the tail a block cannot fit is a few percent of it.
+    static constexpr size_t kBlockBytes = size_t(64) << 20;
+    static constexpr size_t kAlign = alignof(std::max_align_t);
+    struct Block {
+        char *data;
+        size_t size, used, live;
+    };
+    std::mutex m;
+    std::vector<Block> blocks;
+};
+
+// A std::allocator that carves from a ReflectionArena, or is plain new/delete without one. A copy of
+// a container is made on the heap (select_on_container_copy_construction), so only the containers the
+// arena's owner fills itself live in the arena; a move carries the arena along with the storage.
+template <class T>
+struct ArenaAllocator {
+    using value_type = T;
+    using propagate_on_container_move_assignment = std::true_type;
+    using propagate_on_container_swap = std::true_type;
+
+    ReflectionArena *arena = nullptr;
+
+    ArenaAllocator() = default;
+    explicit ArenaAllocator(ReflectionArena *a) : arena(a) {}
+    template <class U> ArenaAllocator(const ArenaAllocator<U> &o) : arena(o.arena) {}
+
+    T *allocate(size_t n) {
+        if (arena)
+            return static_cast<T *>(arena->Allocate(n * sizeof(T)));
+        return static_cast<T *>(::operator new(n * sizeof(T)));
+    }
+    void deallocate(T *p, size_t) {
+        if (arena)
+            arena->Deallocate(p);
+        else
+            ::operator delete(p);
+    }
+    ArenaAllocator select_on_container_copy_construction() const { return ArenaAllocator(); }
+
+    template <class U> bool operator==(const ArenaAllocator<U> &o) const { return arena == o.arena; }
+    template <class U> bool operator!=(const ArenaAllocator<U> &o) const { return arena != o.arena; }
+};
diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index 65a6e905c..4ad21536e 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -225,7 +225,7 @@ PostRefineObservations GatherPostRefineObservations(std::vector<IntegrationOutco
                 // vector back the moment it is consumed: the payload shrinks image by image as it
                 // moves into the (much narrower) partials instead of doubling up in full.
                 if (release_reflections)
-                    std::vector<Reflection>().swap(outcomes[o].reflections);
+                    ReflectionVector().swap(outcomes[o].reflections);
             }
         });
         logger.Info("Post-refine: {} partials gathered", n_pts);
diff --git a/image_analysis/scale_merge/Merge.cpp b/image_analysis/scale_merge/Merge.cpp
index 2945ce2f7..dea9f923f 100644
--- a/image_analysis/scale_merge/Merge.cpp
+++ b/image_analysis/scale_merge/Merge.cpp
@@ -414,7 +414,7 @@ struct ShellAccum {
     CorrelationCoefficient cc_ref;
 };
 
-std::pair<double, size_t> ImageReferenceCC(const std::vector<Reflection> &reflections,
+std::pair<double, size_t> ImageReferenceCC(std::span<const Reflection> reflections,
                                            const std::map<HKLKey, double> &reference,
                                            const HKLKeyGenerator &generator,
                                            std::optional<double> d_min_limit,
diff --git a/image_analysis/scale_merge/Merge.h b/image_analysis/scale_merge/Merge.h
index 025dfe7cb..cf7b6df80 100644
--- a/image_analysis/scale_merge/Merge.h
+++ b/image_analysis/scale_merge/Merge.h
@@ -6,6 +6,7 @@
 #include <algorithm>
 #include <cmath>
 #include <map>
+#include <span>
 #include <unordered_map>
 #include <vector>
 
@@ -308,7 +309,7 @@ std::vector<MergedReflection> MergeAll(const DiffractionExperiment &x,
 // This is the per-image image_scale_cc: ScaleOnTheFly sets it, and StillsPartialityRefine recomputes it
 // after refining the partiality model, so the reported CC always describes the corrections that will be
 // merged - which matters because --min-image-cc drops images by it.
-std::pair<double, size_t> ImageReferenceCC(const std::vector<Reflection> &reflections,
+std::pair<double, size_t> ImageReferenceCC(std::span<const Reflection> reflections,
                                            const std::map<HKLKey, double> &reference,
                                            const HKLKeyGenerator &generator,
                                            std::optional<double> d_min_limit,
diff --git a/image_analysis/scale_merge/ReindexAmbiguity.cpp b/image_analysis/scale_merge/ReindexAmbiguity.cpp
index 672bf4bfb..d776097ea 100644
--- a/image_analysis/scale_merge/ReindexAmbiguity.cpp
+++ b/image_analysis/scale_merge/ReindexAmbiguity.cpp
@@ -164,7 +164,7 @@ bool ReindexAmbiguityResolver::Accept(const Reflection &r) const {
     return AcceptReflection(r, s.GetHighResolutionLimit_A(), s.GetLowResolutionLimit_A());
 }
 
-double ReindexAmbiguityResolver::ReferenceCC(const std::vector<Reflection> &reflections,
+double ReindexAmbiguityResolver::ReferenceCC(std::span<const Reflection> reflections,
                                              const gemmi::Op &op) const {
     double sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0;
     size_t n = 0;
@@ -195,7 +195,7 @@ double ReindexAmbiguityResolver::ReferenceCC(const std::vector<Reflection> &refl
 
 // Serial stills index each crystal in one of the merohedrally-equivalent hands at random; pick, for this
 // image alone, the reindexing whose intensities correlate best with the external reference and apply it.
-void ReindexAmbiguityResolver::Resolve(std::vector<Reflection> &reflections) const {
+void ReindexAmbiguityResolver::Resolve(std::span<Reflection> reflections) const {
     if (ops.empty())
         return;
 
diff --git a/image_analysis/scale_merge/ReindexAmbiguity.h b/image_analysis/scale_merge/ReindexAmbiguity.h
index 4b8f6f32f..76c8b6bc0 100644
--- a/image_analysis/scale_merge/ReindexAmbiguity.h
+++ b/image_analysis/scale_merge/ReindexAmbiguity.h
@@ -5,6 +5,7 @@
 
 #include <functional>
 #include <map>
+#include <span>
 #include <vector>
 
 #include "gemmi/symmetry.hpp"
@@ -82,7 +83,7 @@ class ReindexAmbiguityResolver {
     // Pearson correlation of this image's partiality/Lorentz-corrected intensities against the reference,
     // matched by ASU index under `op`. Scale-invariant (the unknown per-image scale cancels). NaN when
     // too few reflections match.
-    double ReferenceCC(const std::vector<Reflection> &reflections, const gemmi::Op &op) const;
+    double ReferenceCC(std::span<const Reflection> reflections, const gemmi::Op &op) const;
 
 public:
     // The reference must be an external, correctly-handed dataset (not the data's own running merge).
@@ -90,5 +91,5 @@ public:
 
     // Reindex this image's reflections in place into the hand best-correlated with the reference (done
     // once per image, for good). No-op when there is no ambiguity.
-    void Resolve(std::vector<Reflection> &reflections) const;
+    void Resolve(std::span<Reflection> reflections) const;
 };
diff --git a/reader/HDF5MetadataSource.cpp b/reader/HDF5MetadataSource.cpp
index e65edee4e..7c7de1169 100644
--- a/reader/HDF5MetadataSource.cpp
+++ b/reader/HDF5MetadataSource.cpp
@@ -303,9 +303,10 @@ CrystalLattice ApplyReindex(const CrystalLattice &latt, const std::optional<std:
     return latt.Multiply(gemmi::Mat33(v[0], v[1], v[2], v[3], v[4], v[5], v[6], v[7], v[8]));
 }
 
+template <class ReflectionContainer>
 bool ReadReflectionsFromGroup(HDF5Object &file,
                               const std::string &image_group_name,
-                              std::vector<Reflection> &reflections,
+                              ReflectionContainer &reflections,
                               const std::optional<std::array<int32_t, 9>> &reindex) {
     if (!file.Exists("/entry/reflections") || !file.Exists(image_group_name))
         return false;
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 557c79afe..992916202 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6016,7 +6016,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                         } else {
                             for (auto &io : indexer->GetIntegrationOutcome()) {
                                 io.latt = io.latt.Multiply(reduce);
-                                std::vector<Reflection> kept;
+                                ReflectionVector kept;
                                 kept.reserve(io.reflections.size());
                                 for (auto r : io.reflections)
                                     if (reduce_hkl(r))
-- 
2.54.0


From 004839a8ee16b07fc91448e05e1f0a8e2434b08c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:58:50 +0200
Subject: [PATCH 063/122] Space-group search: the twin-immune zone arbitrates a
 refused promotion

A promotion the operator correlations confirm and a gate refuses (the H ratio, the added-operator
R, the merge chi^2) used to be settled two ways that both read the per-frame scales: the two-arm
rule let the other arm's confirmation outvote the refusal, and the remerge arbiter compared the
R_meas and ISa of the two pinned merges. Neither holds once the scales have settled: a partial
twin at a fraction one arm's coverage hides passes there (an H3 twin promoted to R32, a P31 one to
P3121), and the lower group's converged merge - the same scales fitted against fewer equivalents -
agrees with itself better than the true group on a genuine step (a 2 -> 222 step reading R_meas
0.094 -> 0.103), so the arbiter refuses real symmetry.

The refusal is now decided by the twin-immune zone of the operators the promotion adds: the
reflections centric in the higher group and acentric in the lower are their own twin mates, so
they read centric if the operators are real and acentric if they are a twin law or a
pseudo-symmetry, whatever the twin fraction and however the scales were fitted. Read on the
all-observation P1 merge in the two-arm rule and on the adopted group's own merge at the arbiter
(where a weak crystal's P1 search merge has no shell with signal to read), for a group two orders
above the other, with the pseudo-translation normalisation the L-test uses, and decided on the
sign with the screw-axis convention of 20 nats: acentric and the refusal stands on all
observations, centric and the higher group is adopted, undecided and the rules stay as they were.
Measured: a genuine 222 step reads +150 to +1630 nats, the trigonal twins -130 nats and below.

A refusal that stood on the zone names the law: the first operator the refused group adds, at the
fraction the operator's own H implies (else the pre-search L-test), reported as TWIN_LAW and
written as the mmCIF _pdbx_reflns_twin loop of the merge in the true group. Every lattice twin law
outside the adopted group is reported with its own H, implied fraction, R and correlation on the
merge expanded to P1 (TWIN_LAW_n), following Yeates (1997) Methods Enzymol. 276, 344-358.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/WriteReflections.cpp           |  17 ++
 .../scale_merge/SearchSpaceGroup.cpp          |   7 +
 image_analysis/scale_merge/SearchSpaceGroup.h |   5 +
 .../scale_merge/TwinningAnalysis.cpp          | 171 ++++++++++------
 image_analysis/scale_merge/TwinningAnalysis.h |  14 ++
 rugnux/ResultReport.cpp                       |  17 ++
 rugnux/Rugnux.cpp                             | 193 +++++++++++++++++-
 rugnux/Rugnux.h                               |   6 +
 8 files changed, 366 insertions(+), 64 deletions(-)

diff --git a/image_analysis/WriteReflections.cpp b/image_analysis/WriteReflections.cpp
index 2a7b6a4c4..ab9453d33 100644
--- a/image_analysis/WriteReflections.cpp
+++ b/image_analysis/WriteReflections.cpp
@@ -272,6 +272,23 @@ void WriteMmcifReflections(const std::vector<MergedReflection> &reflections,
         if (twinning.moment_reflections > 0)
             out << "_reflns.jfjoch_second_moment_I        " << Fmt(twinning.second_moment, 3)
                 << "   # <I^2>/<I>^2 (untwinned 2.00, perfect twin 1.50)\n";
+        // A twin law the run identified (TwinningAnalysisResult::twin_law_operator): the standard
+        // PDBx loop, one row per domain, the second domain related by the operator. Only meaningful
+        // in the true (sub)group's file, which is the one this is - in the higher group the operator
+        // is a symmetry element. Merohedral: the law is a lattice operation of the crystal system.
+        if (!twinning.twin_law_operator.empty()) {
+            out << "#\n";
+            out << "loop_\n";
+            out << "_pdbx_reflns_twin.domain_id\n";
+            out << "_pdbx_reflns_twin.crystal_id\n";
+            out << "_pdbx_reflns_twin.diffrn_id\n";
+            out << "_pdbx_reflns_twin.operator\n";
+            out << "_pdbx_reflns_twin.fraction\n";
+            out << "_pdbx_reflns_twin.type\n";
+            out << "1 1 1 'h,k,l' " << Fmt(1.0 - twinning.twin_law_fraction, 3) << " merohedral\n";
+            out << "2 1 1 " << CifStr(twinning.twin_law_operator) << " " << Fmt(twinning.twin_law_fraction, 3)
+                << " merohedral\n";
+        }
         // Radiation-damage monitor (rotation): the relative Debye-Waller B change from the first to the last
         // frame (A^2). A large magnitude flags a dose-dependent resolution-scale change = radiation damage;
         // positive is the typical direction (high-resolution intensity fades with dose). No standard mmCIF item.
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index d220ae05c..3de94bdc8 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -1297,6 +1297,8 @@ SearchSpaceGroupResult SearchSpaceGroup(
                     bool closure = false;
                     std::string why; };
     int refused_order = 0;
+    bool refused_twin_gate = false;
+    double refused_fraction = std::numeric_limits<double>::quiet_NaN();
     std::string refused_pg_hm, refused_why;
     const gemmi::SpaceGroup *refused_pg_rep = nullptr;
     std::vector<PGCand> pg_cands;
@@ -1579,6 +1581,9 @@ SearchSpaceGroupResult SearchSpaceGroup(
                 refused_order = c.order;
                 refused_pg_hm = c.pg->representative->point_group_hm();
                 refused_pg_rep = c.pg->representative;
+                refused_twin_gate = h_refused || r_refused;
+                refused_fraction = h_refused ? std::max(0.0, 0.5 - h_added)
+                                             : std::numeric_limits<double>::quiet_NaN();
                 if (h_refused)
                     // Twinning by a fraction a scales every twin-related difference by (1-2a), and
                     // |I1-I2|/(I1+I2) is uniform on [0,1] for untwinned Wilson intensities, so the
@@ -1702,6 +1707,8 @@ SearchSpaceGroupResult SearchSpaceGroup(
         result.refused_point_group_hm = refused_pg_hm;
         result.refused_reason = refused_why;
         result.refused_point_group_representative = *refused_pg_rep;
+        result.refused_by_twin_gate = refused_twin_gate;
+        result.refused_twin_fraction = refused_fraction;
     }
 
     // --- Stage B: pick the space group within the point group ---
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index 6db1a2ed5..c9d291b04 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -689,6 +689,11 @@ struct SearchSpaceGroupResult {
     // Empty when nothing was refused. Surfaced to the user - a silent demotion is how a twin gets missed.
     std::string refused_point_group_hm;
     std::string refused_reason;
+    // Of the refused candidate: the twin fraction its added operators' own disagreement implies
+    // (0.5 - H, a lower bound; NaN where H was not measured) and whether the refusal came from a twin
+    // gate (the H ratio or the added-operator R) rather than from the merge chi^2.
+    double refused_twin_fraction = std::numeric_limits<double>::quiet_NaN();
+    bool refused_by_twin_gate = false;
     // The symmorphic representative of that group - the same thing point_group_representative is, and
     // for the same reason (a name cannot tell P321 from P312). It is what a caller hands back as
     // fixed_point_group to ask what merging under the refused group would give. Unset when nothing
diff --git a/image_analysis/scale_merge/TwinningAnalysis.cpp b/image_analysis/scale_merge/TwinningAnalysis.cpp
index 488470f84..0ed2afb25 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.cpp
+++ b/image_analysis/scale_merge/TwinningAnalysis.cpp
@@ -565,6 +565,111 @@ namespace {
     }
 }
 
+namespace {
+    // The rotations of a group, as gemmi Ops without translations (its symmorphic representative's
+    // proper operations).
+    std::vector<gemmi::Op> ProperRotations(const gemmi::GroupOps& gops) {
+        std::vector<gemmi::Op> rotations;
+        for (const auto& op : gops.derive_symmorphic().sym_ops)
+            if (op.det_rot() > 0)
+                rotations.push_back(gemmi::Op{op.rot, {0, 0, 0}, 'x'});
+        return rotations;
+    }
+
+    // The reflections a zone test can be read on: present in the group, general position, in the
+    // shells with signal enough (ZONE_MIN_SHELL_ISIG). Fills the resolution range read.
+    std::vector<const MergedReflection*> StrongReflections(const std::vector<MergedReflection>& p1_merged,
+                                                           const gemmi::GroupOps& gops,
+                                                           TwinImmuneZoneResult& result) {
+        std::vector<const MergedReflection*> usable;
+        for (const auto& r : p1_merged) {
+            const gemmi::Op::Miller h{{r.h, r.k, r.l}};
+            if (UsableIntensity(r) && std::isfinite(r.sigma) && r.sigma > 0.0
+                && !gops.is_systematically_absent(h) && gops.epsilon_factor_without_centering(h) == 1)
+                usable.push_back(&r);
+        }
+        // The shells with signal enough to read (ZONE_MIN_SHELL_ISIG), 20 equal in 1/d^2.
+        constexpr int n_shells = 20;
+        double min_s = std::numeric_limits<double>::infinity(), max_s = 0.0;
+        for (const auto* r : usable) {
+            min_s = std::min(min_s, 1.0 / (r->d * r->d));
+            max_s = std::max(max_s, 1.0 / (r->d * r->d));
+        }
+        std::vector<const MergedReflection*> strong;
+        if (!(max_s > min_s))
+            return strong;
+        auto shell_of = [&](const MergedReflection* r) {
+            const double t = (1.0 / (r->d * r->d) - min_s) / (max_s - min_s);
+            return std::min(n_shells - 1, std::max(0, static_cast<int>(t * n_shells)));
+        };
+        std::vector<double> isig_sum(n_shells, 0.0);
+        std::vector<int> isig_n(n_shells, 0);
+        for (const auto* r : usable) {
+            isig_sum[shell_of(r)] += r->I / r->sigma;
+            isig_n[shell_of(r)] += 1;
+        }
+        for (const auto* r : usable) {
+            const int b = shell_of(r);
+            if (isig_n[b] > 0 && isig_sum[b] / isig_n[b] >= ZONE_MIN_SHELL_ISIG)
+                strong.push_back(r);
+        }
+        result.d_max_A = 0.0;
+        result.d_min_A = std::numeric_limits<double>::infinity();
+        for (const auto* r : strong) {
+            result.d_max_A = std::max<double>(result.d_max_A, r->d);
+            result.d_min_A = std::min<double>(result.d_min_A, r->d);
+        }
+        return strong;
+    }
+
+    // The zone of one subgroup hypothesis H (given by its rotations): the reflections centric in the
+    // group but not in H - the self-mates of the coset the group adds over H.
+    TwinImmuneZone ReadSubgroupZone(const std::vector<const MergedReflection*>& strong,
+                                    const gemmi::GroupOps& gops, const std::vector<gemmi::Op>& rotations,
+                                    const std::vector<gemmi::Op>& h_ops,
+                                    const std::array<double, 3>* tncs_vector) {
+        auto contains = [&](const std::vector<gemmi::Op>& set, const gemmi::Op& op) {
+            return std::any_of(set.begin(), set.end(), [&](const gemmi::Op& o) { return o.rot == op.rot; });
+        };
+        std::vector<const MergedReflection*> zone;
+        for (const auto* r : strong) {
+            const gemmi::Op::Miller h{{r->h, r->k, r->l}};
+            const gemmi::Op::Miller minus{{-gemmi::Op::DEN * r->h, -gemmi::Op::DEN * r->k, -gemmi::Op::DEN * r->l}};
+            const bool centric_in_h = std::any_of(h_ops.begin(), h_ops.end(), [&](const gemmi::Op& op) {
+                return op.apply_to_hkl_without_division(h) == minus;
+            });
+            if (gops.is_reflection_centric(h) && !centric_in_h)
+                zone.push_back(r);
+        }
+        TwinImmuneZone z = ReadZone(zone, tncs_vector);
+        for (const auto& op : rotations)
+            if (!contains(h_ops, op))
+                z.operators += (z.operators.empty() ? "" : " ") + op.as_hkl().triplet();
+        return z;
+    }
+}
+
+TwinImmuneZoneResult AnalyzeTwinImmuneZone(const std::vector<MergedReflection>& p1_merged,
+                                           const gemmi::SpaceGroup& group, const gemmi::SpaceGroup& subgroup,
+                                           const std::array<double, 3>* tncs_vector) {
+    TwinImmuneZoneResult result;
+    result.tncs_normalised = tncs_vector != nullptr;
+    const gemmi::GroupOps gops = group.operations();
+    const std::vector<gemmi::Op> rotations = ProperRotations(gops);
+    const std::vector<gemmi::Op> h_ops = ProperRotations(subgroup.operations());
+    const auto strong = StrongReflections(p1_merged, gops, result);
+    if (strong.empty())
+        return result;
+    std::vector<const MergedReflection*> control;
+    for (const auto* r : strong)
+        if (!gops.is_reflection_centric(gemmi::Op::Miller{{r->h, r->k, r->l}}))
+            control.push_back(r);
+    result.control = ReadZone(control, tncs_vector);
+    result.control.operators = "acentric";
+    result.zones.push_back(ReadSubgroupZone(strong, gops, rotations, h_ops, tncs_vector));
+    return result;
+}
+
 TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>& p1_merged,
                                             const gemmi::SpaceGroup& group,
                                             const std::array<double, 3>* tncs_vector) {
@@ -592,10 +697,7 @@ TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>&
                         ops.push_back(p);
         return ops;
     };
-    std::vector<gemmi::Op> rotations;
-    for (const auto& op : gops.derive_symmorphic().sym_ops)
-        if (op.det_rot() > 0)
-            rotations.push_back(gemmi::Op{op.rot, {0, 0, 0}, 'x'});
+    const std::vector<gemmi::Op> rotations = ProperRotations(gops);
     std::vector<gemmi::Op> squares{gemmi::Op::identity()};
     for (const auto& g : rotations)
         squares.push_back(g * g);
@@ -619,49 +721,9 @@ TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>&
     if (subgroups.empty())
         return result;
 
-    // Reflections present in the group and in general position (epsilon 1): an axial row is fixed by
-    // more than one operator and follows neither distribution.
-    std::vector<const MergedReflection*> usable;
-    for (const auto& r : p1_merged) {
-        const gemmi::Op::Miller h{{r.h, r.k, r.l}};
-        if (UsableIntensity(r) && std::isfinite(r.sigma) && r.sigma > 0.0
-            && !gops.is_systematically_absent(h) && gops.epsilon_factor_without_centering(h) == 1)
-            usable.push_back(&r);
-    }
-    // The shells with signal enough to read (ZONE_MIN_SHELL_ISIG), 20 equal in 1/d^2.
-    constexpr int n_shells = 20;
-    double min_s = std::numeric_limits<double>::infinity(), max_s = 0.0;
-    for (const auto* r : usable) {
-        min_s = std::min(min_s, 1.0 / (r->d * r->d));
-        max_s = std::max(max_s, 1.0 / (r->d * r->d));
-    }
-    if (!(max_s > min_s))
-        return result;
-    auto shell_of = [&](const MergedReflection* r) {
-        const double t = (1.0 / (r->d * r->d) - min_s) / (max_s - min_s);
-        return std::min(n_shells - 1, std::max(0, static_cast<int>(t * n_shells)));
-    };
-    std::vector<double> isig_sum(n_shells, 0.0);
-    std::vector<int> isig_n(n_shells, 0);
-    for (const auto* r : usable) {
-        isig_sum[shell_of(r)] += r->I / r->sigma;
-        isig_n[shell_of(r)] += 1;
-    }
-    std::vector<const MergedReflection*> strong;
-    for (const auto* r : usable) {
-        const int b = shell_of(r);
-        if (isig_n[b] > 0 && isig_sum[b] / isig_n[b] >= ZONE_MIN_SHELL_ISIG)
-            strong.push_back(r);
-    }
+    const auto strong = StrongReflections(p1_merged, gops, result);
     if (strong.empty())
         return result;
-    result.d_max_A = 0.0;
-    result.d_min_A = std::numeric_limits<double>::infinity();
-    for (const auto* r : strong) {
-        result.d_max_A = std::max<double>(result.d_max_A, r->d);
-        result.d_min_A = std::min<double>(result.d_min_A, r->d);
-    }
-
     std::vector<const MergedReflection*> control;
     for (const auto* r : strong)
         if (!gops.is_reflection_centric(gemmi::Op::Miller{{r->h, r->k, r->l}}))
@@ -671,23 +733,8 @@ TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>&
 
     // Per hypothesis H, the zone: centric in the group, acentric in H - the reflections some added
     // operator sends to -h, i.e. the self-mates of that coset read as a twin law.
-    for (const auto& h_ops : subgroups) {
-        std::vector<const MergedReflection*> zone;
-        for (const auto* r : strong) {
-            const gemmi::Op::Miller h{{r->h, r->k, r->l}};
-            const gemmi::Op::Miller minus{{-gemmi::Op::DEN * r->h, -gemmi::Op::DEN * r->k, -gemmi::Op::DEN * r->l}};
-            const bool centric_in_h = std::any_of(h_ops.begin(), h_ops.end(), [&](const gemmi::Op& op) {
-                return op.apply_to_hkl_without_division(h) == minus;
-            });
-            if (gops.is_reflection_centric(h) && !centric_in_h)
-                zone.push_back(r);
-        }
-        TwinImmuneZone z = ReadZone(zone, tncs_vector);
-        for (const auto& op : rotations)
-            if (!contains(h_ops, op))
-                z.operators += (z.operators.empty() ? "" : " ") + op.as_hkl().triplet();
-        result.zones.push_back(z);
-    }
+    for (const auto& h_ops : subgroups)
+        result.zones.push_back(ReadSubgroupZone(strong, gops, rotations, h_ops, tncs_vector));
     return result;
 }
 
diff --git a/image_analysis/scale_merge/TwinningAnalysis.h b/image_analysis/scale_merge/TwinningAnalysis.h
index 259d89cdb..7165e065e 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.h
+++ b/image_analysis/scale_merge/TwinningAnalysis.h
@@ -29,6 +29,14 @@
 enum class TwinFractionSource { None, LTest, SecondMoment };
 
 struct TwinningAnalysisResult {
+    // A twin law the run identified: the operator a promotion would have added, refused because its
+    // twin-immune zone read acentric (the operator relates unequal intensities on the very
+    // reflections a twin cannot touch), with the fraction the operator's own disagreement implies.
+    // Written as the mmCIF _pdbx_reflns_twin loop of the merge in the true (sub)group; empty when
+    // no law was identified.
+    std::string twin_law_operator;   // as an hkl triplet, e.g. "k,h,-l"
+    double twin_law_fraction = 0.0;
+
     int l_test_pairs = 0;
     double mean_abs_l = 0.0;   // <|L|>: 0.5 untwinned, 0.375 perfect twin
     double mean_l_squared = 0.0;   // <L^2>: 0.333 untwinned, 0.2 perfect twin
@@ -128,4 +136,10 @@ TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>&
                                             const gemmi::SpaceGroup& group,
                                             const std::array<double, 3>* tncs_vector = nullptr);
 
+// The same for ONE hypothesis: the operators `group` adds over `subgroup` (one zone in the result,
+// beside the control). Read where a promotion from the subgroup to the group is in question.
+TwinImmuneZoneResult AnalyzeTwinImmuneZone(const std::vector<MergedReflection>& p1_merged,
+                                           const gemmi::SpaceGroup& group, const gemmi::SpaceGroup& subgroup,
+                                           const std::array<double, 3>* tncs_vector = nullptr);
+
 std::string TwinImmuneZonesToText(const TwinImmuneZoneResult& result);
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index dd96d05fd..928e384a2 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -581,6 +581,13 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                 Add(s, Prose(fmt::format(" The two search merges disagreed and the higher point group was taken:\n {}.",
                                          result.space_group_arm_override)));
             }
+            if (!result.twin_zone_decision.empty()) {
+                Add(s, KeyText("TWIN_ZONE_DECISION", result.twin_zone_decision));
+                Add(s, Prose(" A twin gate refused this promotion, and the twin-immune zone of the operators it\n"
+                             " adds decided it (reflections a twin law cannot touch: centric if the operators\n"
+                             " are real, acentric if they are a twin law or a pseudo-symmetry; margin 20 nats):\n"
+                             " " + result.twin_zone_decision + "."));
+            }
             if (refused)
                 Add(s, Prose(fmt::format(
                         " A promotion to {} was refused: {}.\n"
@@ -1174,6 +1181,16 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                              " absorbed can only show there as an operator averaging unequal intensities. These\n"
                              " numbers are not circular in that way.", true));
             }
+            if (!result.twinning.twin_law_operator.empty()) {
+                Add(s, KeyText("TWIN_LAW", fmt::format("{} fraction {:.2f}", result.twinning.twin_law_operator,
+                                                       result.twinning.twin_law_fraction)));
+                Add(s, Prose(fmt::format(" Twin law identified: operator {} at a fraction of about {:.2f} (a lower bound from\n"
+                                         " the operator's own disagreement). The mmCIF carries it as _pdbx_reflns_twin; refine\n"
+                                         " against these data in this space group with that law.",
+                                         result.twinning.twin_law_operator, result.twinning.twin_law_fraction)));
+            }
+            for (size_t i = 0; i < result.twin_law_evidence.size(); ++i)
+                Add(s, KeyText(fmt::format("TWIN_LAW_{}", i + 1).c_str(), result.twin_law_evidence[i]));
             if (result.twin_immune_zones && !result.twin_immune_zones->zones.empty()) {
                 // Report-only evidence, one row per class of 2-folds of the adopted group. Not a decision:
                 // the space group above was chosen without it.
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index e213ee9e2..ede65a3cd 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1728,6 +1728,47 @@ namespace {
     // Asked twice, from the same numbers: in RunAllPasses, where the answer is acted on, and inside a
     // refined pass as soon as its own search merge is in - a pass that already knows it will be thrown
     // away leaves its report and its files unwritten (see the superseded flag in RunPipeline).
+    // The twin-immune zone of the operators `higher` adds over `lower`, read on a P1 merge, as a
+    // verdict: +1 the added operators are real (the zone is centric with margin), -1 they are a twin
+    // law or a pseudo-symmetry (acentric with margin), 0 undecided - fewer than two orders apart
+    // (the immunity argument holds for one coset), no zone reflections, or within the margin.
+    //
+    // The margin is the screw-axis convention (SearchSpaceGroupOptions::min_screw_absence_evidence):
+    // the same log-likelihood-ratio units, and the same bound of 20 nats. Read over three batteries
+    // the zones of genuine promotions sit at +60 nats and above and the zones behind the known
+    // twins at -290 nats and below, with one genuine trigonal crystal at -46 nats whose promotion
+    // no gate refused - so the bound is not what separates them, and a refusal a gate did fire is
+    // the only place the verdict is read.
+    int TwinZoneVerdict(const std::vector<MergedReflection> &p1_merged, const SearchSpaceGroupResult &higher,
+                        const SearchSpaceGroupResult &lower, ProcessResult &result,
+                        const std::array<double, 3> *tncs_vector = nullptr) {
+        constexpr double DECISIVE_NATS = 20.0;
+        if (!higher.point_group_representative || !lower.point_group_representative)
+            return 0;
+        if (higher.point_group_order != 2 * lower.point_group_order)
+            return 0;
+        const auto z = AnalyzeTwinImmuneZone(p1_merged, *higher.point_group_representative,
+                                             *lower.point_group_representative, tncs_vector);
+        if (z.zones.empty() || z.zones[0].n == 0) {
+            result.twin_zone_decision = fmt::format("{} over {}: no zone reflections in the shells with signal "
+                                                    "({} merged reflections read) -> undecided",
+                                                    higher.point_group_hm, lower.point_group_hm, p1_merged.size());
+            return 0;
+        }
+        const auto &zone = z.zones[0];
+        const int verdict = zone.evidence_nats <= -DECISIVE_NATS ? -1
+                            : zone.evidence_nats >= DECISIVE_NATS ? +1 : 0;
+        result.twin_zone_decision = fmt::format(
+                "{} over {}: operators {}; n {} <|E^2-1|> {:.3f} +- {:.3f} (control {:.3f}), evidence "
+                "{:+.1f} nats ({:.2f}-{:.2f} A{}) -> {}",
+                higher.point_group_hm, lower.point_group_hm, zone.operators, zone.n, zone.mean_abs_e2_minus_1,
+                zone.standard_error, z.control.mean_abs_e2_minus_1, zone.evidence_nats, z.d_max_A, z.d_min_A,
+                z.tncs_normalised ? ", normalised per pseudo-translation class" : "",
+                verdict < 0 ? "acentric, the added operators are a twin law or a pseudo-symmetry"
+                : verdict > 0 ? "centric, the added operators are real" : "undecided");
+        return verdict;
+    }
+
     std::string RefinedPassIsWorse(const ProcessResult &pass1, const ProcessResult &pass2) {
         constexpr double MAX_CREDIBLE_COMPLETENESS = 100.5;   // rounding headroom, nothing more
         // How much of the signal the refined pass has to lose before the run moves back off the
@@ -5456,7 +5497,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 rsm->SetSearchMinZeta(zeta);
                 merged_filtered_isa = sg_opts.merge_isa;     // the filtered arm's, before it is replaced
                 sg_opts.merge_isa = result.error_model_isa;   // this arm's own error model
-                const auto alt = SearchSpaceGroup(sm_all.merged, sg_opts);
+                auto alt = SearchSpaceGroup(sm_all.merged, sg_opts);
                 // The order of the point group each arm confirmed. Read from the search, not from the
                 // space group it went on to pick: Stage B leaves best_space_group unset when no
                 // candidate has enough absences to be eligible, which is common on the filtered arm
@@ -5524,13 +5565,49 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     logger.Warning("Space-group search: {}", msg);
                     result.space_group_arm_override = msg;
                 };
+                // A refusal is not simply outvoted by the other arm's confirmation: the gates read
+                // the operators' own disagreement, which a partial twin at a fraction the other arm's
+                // coverage happens to hide passes there (an H3 partial twin promoted to R32 by the
+                // filtered arm; a P31 one to P3121 by the all-observation arm). What decides is the
+                // twin-immune zone of the added operators, read on the all-observation P1 merge
+                // (TwinZoneVerdict): acentric with margin and the refusal stands, on all observations;
+                // centric with margin and the higher group is taken as before; undecided and the rule
+                // stays as it was.
+                int zone_verdict = 0;
                 if (order_of(alt) > order_of(sg_search)) {
                     logger.Info("Space-group search: all-observation merge supports {} where the "
                                 "Lorentz-filtered one supports {} - taking the higher symmetry",
                                 alt.point_group_hm, sg_search.point_group_hm);
                     overridden(sg_search, "Lorentz-filtered", "all-observation");
+                    zone_verdict = !sg_search.refused_point_group_hm.empty()
+                                   ? TwinZoneVerdict(sm_all.merged, alt, sg_search, result) : 0;
+                    if (zone_verdict < 0) {
+                        logger.Warning("Space-group search: the Lorentz-filtered merge's refusal of {} "
+                                       "STANDS - the twin-immune zone of its added operators reads "
+                                       "acentric; keeping {}, judged on all observations",
+                                       sg_search.refused_point_group_hm, sg_search.point_group_hm);
+                        sg_opts.fixed_point_group = sg_search.point_group_representative;
+                        auto lower = SearchSpaceGroup(sm_all.merged, sg_opts);
+                        sg_opts.fixed_point_group.reset();
+                        lower.refused_point_group_hm = sg_search.refused_point_group_hm;
+                        lower.refused_reason = sg_search.refused_reason + ", and its twin-immune zone reads acentric";
+                        lower.refused_point_group_representative = sg_search.refused_point_group_representative;
+                        lower.refused_by_twin_gate = true;
+                        lower.refused_twin_fraction = sg_search.refused_twin_fraction;
+                        alt = std::move(lower);
+                    }
                 }
-                if (order_of(alt) < order_of(sg_search)) {
+                if (order_of(alt) < order_of(sg_search)
+                    && !alt.refused_point_group_hm.empty()
+                    && TwinZoneVerdict(sm_all.merged, sg_search, alt, result) < 0) {
+                    logger.Warning("Space-group search: the all-observation merge's refusal of {} STANDS "
+                                   "- the twin-immune zone of its added operators reads acentric; keeping {}",
+                                   alt.refused_point_group_hm, alt.point_group_hm);
+                    overridden(alt, "all-observation", "Lorentz-filtered");
+                    result.space_group_arm_override += " - but the refusal stands (see TWIN_ZONE_DECISION)";
+                    alt.refused_reason += ", and its twin-immune zone reads acentric";
+                    sg_search = alt;
+                } else if (order_of(alt) < order_of(sg_search)) {
                     // The filtered arm found symmetry the all-observation arm did not. Discarding it
                     // was costing real point groups: over the corpus the two arms disagree on eight
                     // crystals and the higher one is right on all eight, because the filter removes
@@ -6293,6 +6370,56 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     else
                         for (const auto &alt : hi_search.alternatives)
                             if (alt.centring_type() == sg.centring_type()) { hi_sg = alt; break; }
+                    // A refusal is arbitrated by the twin-immune zone of the added operators
+                    // (TwinZoneVerdict) where it is decisive, and only otherwise by the merge
+                    // comparison below: that comparison reads R_meas and ISa of two merges whose
+                    // per-frame scales have settled, and the lower group, with the same scales fitted
+                    // against fewer equivalents, then agrees with itself the better of the two on a
+                    // genuine promotion as much as on a twin (measured: a genuine 2 -> 222 step reading
+                    // R_meas 0.094 -> 0.103, ISa 12.3 -> 10.9). The zone does not depend on the scales.
+                    // Read on the adopted group's own merge: the zone reflections are centric in the
+                    // refused group and acentric in the adopted one, so they are distinct reflections
+                    // of this merge, at full multiplicity and production scale - where the P1 search
+                    // merge of a weak crystal has no shell with signal enough to read a zone on.
+                    const int zone = hi_sg.has_value()
+                                     ? TwinZoneVerdict(sm.merged, hi_search, sg_search, result,
+                                                       TranslationalNCSVectorForLTest(pre_tncs)) : 0;
+                    if (zone < 0) {
+                        const std::string msg = fmt::format(
+                                "Point group {} was refused ({}), and the twin-immune zone of its added "
+                                "operators reads acentric: they relate unequal intensities on the very "
+                                "reflections a twin law cannot touch, so the refusal stands and the "
+                                "operator is recorded as a twin law. Keeping {}.",
+                                sg_search.refused_point_group_hm, sg_search.refused_reason, sg.xhm());
+                        logger.Info("{}", msg);
+                        stats_text << "  " << msg << "\n\n";
+                        sg_search.refused_reason += ", and its twin-immune zone reads acentric";
+                        hi_sg.reset();
+                    } else if (zone > 0) {
+                        const std::string msg = fmt::format(
+                                "Point group {} was confirmed by the operator correlations and then "
+                                "refused ({}), but the twin-immune zone of its added operators reads "
+                                "centric - a twin law cannot produce that on the reflections it leaves "
+                                "untouched - so {} is adopted.",
+                                sg_search.refused_point_group_hm, sg_search.refused_reason, hi_sg->xhm());
+                        logger.Info("{}", msg);
+                        stats_text << "  " << msg << "\n\n";
+                        sg_search = hi_search;
+                        if (hi_search.best_space_group->number != hi_sg->number) {
+                            sg_search.alternatives.push_back(*hi_search.best_space_group);
+                            std::erase_if(sg_search.alternatives,
+                                          [&](const gemmi::SpaceGroup &a) { return a.number == hi_sg->number; });
+                        }
+                        sg_search.best_space_group = *hi_sg;
+                        result.space_group = *hi_sg;
+                        end_msg.space_group_name = hi_sg->xhm();
+                        end_msg.space_group_number = static_cast<uint64_t>(hi_sg->number);
+                        promoted_point_group = true;
+                        experiment_.SetSpaceGroup(*hi_sg);
+                        phase("Re-scaling in space group " + hi_sg->short_name());
+                        sm = scale_and_merge(hi_sg->short_name(), false);
+                        hi_sg.reset();
+                    }
                     if (hi_sg.has_value()) {
                         // scale_and_merge reports the error model of whatever it merged, and the two
                         // comparison merges are not the run's answer, so it goes back if they lose.
@@ -6471,6 +6598,30 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // flat one landing on exactly the case the flag exists for. (Assigning it before the call
             // would not do: the call replaces the whole struct.)
             result.twinning.laue_class_was_chosen_by_promotion = promoted_point_group;
+            // A refusal that stood on the twin-immune zone names the law: the first operator the
+            // refused group adds, at the fraction its own disagreement implies (a lower bound).
+            if (result.space_group_search && result.space_group_search->refused_point_group_representative
+                && result.twin_zone_decision.find("acentric, the added") != std::string::npos) {
+                const auto &sgs = *result.space_group_search;
+                const gemmi::GroupOps hi = sgs.refused_point_group_representative->operations();
+                const gemmi::GroupOps lo = twin_sg->operations();
+                for (const auto &op : hi.derive_symmorphic().sym_ops) {
+                    if (op.det_rot() <= 0) continue;
+                    const bool in_lower = std::any_of(lo.sym_ops.begin(), lo.sym_ops.end(),
+                                                      [&](const gemmi::Op &o) { return o.rot == op.rot; });
+                    if (in_lower) continue;
+                    result.twinning.twin_law_operator = gemmi::Op{op.rot, {0, 0, 0}, 'x'}.as_hkl().triplet();
+                    break;
+                }
+                // The fraction: the refused operators' own H where the H gate measured it, else the
+                // L-test of the merge before the search (a twin fraction that does not depend on the
+                // promotion), else the perfect twin every operator statistic reads as symmetry.
+                result.twinning.twin_law_fraction =
+                        std::isfinite(sgs.refused_twin_fraction) ? sgs.refused_twin_fraction
+                        : result.pre_promotion_twinning
+                                  && result.pre_promotion_twinning->twin_fraction_source != TwinFractionSource::None
+                          ? result.pre_promotion_twinning->estimated_twin_fraction : 0.5;
+            }
             if (result.tncs.measurable)
                 stats_text << TranslationalNCSToText(result.tncs) << "\n";
             stats_text << TwinningAnalysisToText(result.twinning) << "\n";
@@ -6548,6 +6699,26 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         if (result.consensus_cell && twin_sg != nullptr) {
             const auto twin_ops = ReindexAmbiguityOperators(*result.consensus_cell, *twin_sg, 2.0);
             if (!twin_ops.empty()) {
+                // The merge is folded under the adopted group, and a twin law sends a reflection
+                // outside that group's asymmetric unit - so the pairs are formed on the merge
+                // expanded to P1 under the group's own operations (each reflection once per
+                // operation; the H statistic is a median and the correlation a ratio, so the
+                // repetition changes neither).
+                std::vector<MergedReflection> expanded;
+                const auto expanded_merge = [&]() -> const std::vector<MergedReflection> & {
+                    if (expanded.empty()) {
+                        const gemmi::GroupOps ops = twin_sg->operations();
+                        expanded.reserve(sm.merged.size() * ops.sym_ops.size());
+                        for (const auto &r : sm.merged)
+                            for (const auto &o : ops.sym_ops) {
+                                const auto hkl = o.apply_to_hkl({{r.h, r.k, r.l}});
+                                MergedReflection e = r;
+                                e.h = hkl[0]; e.k = hkl[1]; e.l = hkl[2];
+                                expanded.push_back(e);
+                            }
+                    }
+                    return expanded;
+                };
                 std::string laws;
                 for (const auto &op : twin_ops) {
                     std::string t = op.triplet();
@@ -6555,7 +6726,25 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     std::replace(t.begin(), t.end(), 'y', 'k');
                     std::replace(t.begin(), t.end(), 'z', 'l');
                     laws += (laws.empty() ? "" : " ; ") + t;
+                    // What each law reads on the merge: the disagreement H of the reflections it
+                    // relates (Yeates (1997) Methods Enzymol. 276, 344-358: a twin of fraction a reads
+                    // (1-2a)/2, so a >= 0.5 - H), their correlation and their intensity-weighted R.
+                    // Report-only, so a user sees which law a twin refinement would need.
+                    gemmi::Mat33 m;
+                    for (int i = 0; i < 3; ++i)
+                        for (int j = 0; j < 3; ++j)
+                            m[j][i] = static_cast<double>(op.rot[i][j]) / gemmi::Op::DEN;
+                    SearchSpaceGroupOptions law_opts;
+                    law_opts.nthreads = static_cast<size_t>(std::max(1, config_.nthreads));
+                    if (const auto s = OperatorCorrelation(expanded_merge(), m, law_opts); s.has_value())
+                        result.twin_law_evidence.push_back(fmt::format(
+                                "{}: {} pairs, H {:.3f} (twin fraction {:.2f} or more), R {:.3f}, CC {:.3f}",
+                                t, s->n_pairs, s->h_stat, std::max(0.0, 0.5 - s->h_stat), s->r_stat, s->cc));
+                    else
+                        result.twin_law_evidence.push_back(fmt::format("{}: too few pairs to read", t));
                 }
+                for (const auto &e : result.twin_law_evidence)
+                    logger.Info("Twin law {}", e);
                 // A model can resolve it too, but whether it does is only known once the model has
                 // been fitted (validation step below), so the warning stands here exactly as in a run
                 // without a model, and is withdrawn there if the model's indexing probe decided it.
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 45b68f3a6..4e0d1f819 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -351,6 +351,12 @@ struct ProcessResult {
     // group was taken from one of them: what the other arm said - which gate refused the promotion,
     // or that it never confirmed the operators. Empty when the arms agreed.
     std::string space_group_arm_override;
+    // The twin-immune zone read for a promotion a twin gate refused (the H ratio or the added-operator
+    // R), and what was decided on it. Empty when no twin gate fired.
+    std::string twin_zone_decision;
+    // Per lattice twin law outside the adopted group: the operator's own H, the fraction it implies
+    // and its correlation, on the final merge. Report-only.
+    std::vector<std::string> twin_law_evidence;
 
     // ---- Material for the results report (<prefix>_report.txt, see rugnux/ResultReport.h) ----
 
-- 
2.54.0


From 36c24b6e5e0d9568ba4ac12dfa7c232a07cf1a2e Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:45:40 +0200
Subject: [PATCH 064/122] rugnux: a distance the data cannot place stays at the
 header

The joint post-refinement is asked twice, with the distance free and with it held at
the header. Where freeing it lowers the fit's held-out residual by more than that
residual's own standard error, the free fit is committed exactly as before. Where it
does not, the fit cannot tell - its own gain need not survive re-integration - so
both hypotheses are carried: the canonical pass runs at the free geometry as before
and once more at the header distance, and the run keeps the one whose RE-INTEGRATED
held-out residual is lower, the header's on a tie. The report says which
(POSTREFINE_DISTANCE_HELD), the pass decision names both realised residuals, and the
log prints the free fit's formal sd(distance) and its correlation with the cell
lengths, from the covariance of the solution.

Why: at a detector far enough away that no reflection reaches more than a few
degrees of 2theta, a longer distance and a larger cell move every spot the same way
to first order (the difference is of order sin^2 theta of the spot's position -
0.4 px rms per per cent over a 2M detector at 820 mm, against 2-3 px at usual
distances), so the fit finds a distance/cell pair that fits its own observations a
little better than the header, commits it, and the pass re-integrated there asks for
the next pair: a walk along the degenerate direction the realised residual never
ratifies. XDS leaves the distance out of IDXREF by default and its documentation
says to remove it from CORRECT where it drifts on low-resolution data; DIALS fixes
the wavelength for the same reason. Here the data are asked instead of a rule.

Measured: a sweep at 820 mm reaching 2theta ~ 9 deg no longer walks to 846 mm with
the cell 3.3 % too large (pool-B stopped it at 825.6 mm, still +1.1 %); it keeps
820 mm and its cell agrees with the reference at that distance to 0.2 %, R_meas
101 % -> 70 %, two passes fewer. 9yl4 keeps 600 mm (cell 0.5 % -> 0.1 % from the
deposition), 7mzt keeps 400 mm (R_meas 169 % -> 145 %, CC1/2 0.961 -> 0.986), 5lzl
keeps 689 mm on a tie (cell -0.3 % instead of +0.25 %, ISa 13.9 -> 11.6). Merged
output byte-identical on a lysozyme reference sweep at 110 mm (the free distance
wins its realised comparison), 8egn and 8pqd (decisive in-fit gains, no second arm)
and 8qq7 (the quality guard had already reverted it); one extra canonical pass
wherever the two arms are run.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CPU_DATA_ANALYSIS_INDEXING.md            |   2 +
 image_analysis/geom_refinement/PostRefine.cpp | 101 ++++++++++++++++--
 image_analysis/geom_refinement/PostRefine.h   |   9 ++
 rugnux/ResultReport.cpp                       |   3 +
 rugnux/Rugnux.cpp                             |  80 +++++++++++++-
 5 files changed, 184 insertions(+), 11 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_INDEXING.md b/docs/CPU_DATA_ANALYSIS_INDEXING.md
index eca6c6648..8c6a0dac1 100644
--- a/docs/CPU_DATA_ANALYSIS_INDEXING.md
+++ b/docs/CPU_DATA_ANALYSIS_INDEXING.md
@@ -325,6 +325,8 @@ The refinement above (§7.2) runs per image against that image's spots. For rota
    The **distance and the cell lengths are bounded one step at a time, not as a whole**. One per cent was once a cap on the entire move, and as a cap it was the opposite of its job — a header is most worth correcting when it is most wrong, and a geometry genuinely several per cent out could never be reached (measured: a refused fit of 310.000 → 305.692 mm whose cell landed within 0.06 % of the deposited one). It is a **trust region** instead. The first solve is asked in the wide box around nominal exactly as before, so a fit that settles within one step commits unchanged; a fit that wants more is re-fitted as a *walk* of one-per-cent steps, each seeded where the last arrived and each required to lower the held-out residual, stopping where a step stops paying. A walk that uses every step it is allowed has not settled — it stopped because it ran out of steps, not because it arrived — and is refused, which is the runaway the cap stood in for, tested where it can be seen. A move of more than one step is additionally **ratified by re-indexing at where it arrived**: that is what separates the failure the cap was really aimed at (a second lattice, whose spots bias every cross-validation fold identically) from a wrong header, since a second lattice does not index better at the new geometry and a real distance error does.
 
    The geometry the run commits is re-fitted on all the reflections once the held-out half has approved it — a walk from where it arrived, one step wide; everything else from nominal in the wide box — and the bounds are asked again of that fit rather than only of the half that earned it. A move outside them leaves the geometry at nominal, as every other refusal does, and the refusal says so in the report (`POSTREFINE_REFUSED`, with what the fit wanted) rather than passing silently. Detector tilt is held fixed, being gauge-coupled to the crystal orientation on a single crystal.
+
+   **Whether the data determine the distance at all is asked, not assumed.** At a detector far enough away that no reflection reaches more than a few degrees of $2\theta$, a longer distance and a larger cell move every spot the same way to first order — the difference is of order $\sin^2\theta$ of the spot's own position, about 0.4 px rms per per cent of distance over a 2M detector at 820 mm against 2–3 px at the distances a crystal is usually collected at — and the rocking angles pin the cell scale only through the same $\sin\theta$. The joint fit then finds a distance/cell pair that fits its own observations a little better than the header, commits it, and the pass re-integrated there finds the next pair: a walk along the degenerate direction that the realised residual never ratifies (measured on such a sweep: a header at 820 mm walked to 846 mm with the cell 3.3 % too large, the realised held-out residual flat at every round). So the same fit is asked once more with the distance **held at the header**, every other block as free as before — the nested hypothesis "the header distance is right". Where the free distance lowers the held-out residual below the held fit's by more than that residual's own standard error, it has paid decisively and is committed exactly as before, which is every sweep whose $2\theta$ reaches tens of degrees and whose header is wrong. Where it has not, the fit cannot say — its own gain is not what decides, because a re-integration at the new distance need not realise it — so **both hypotheses are carried**: the canonical pass runs at the free geometry as before and once more at the header distance, and the run keeps the one whose *re-integrated* held-out residual is lower, the header's on a tie (the report says so: `POSTREFINE_DISTANCE_HELD`, and the pass decision names both residuals). Nothing is tuned here: the only inputs are the standard errors of the residuals themselves, the same noise the geometry walk's rounds have to beat. The wavelength is never refined on a single crystal for the same reason in its exact form: it scales the spot positions and the rocking angles identically to the cell, so no sweep can tell the two apart at any $2\theta$.
 3. **Pass 2** re-indexes de novo and re-integrates at the committed geometry. Only the **detector distance and beam centre** carry over: the refined cell, orientation and axis are what make the distance identifiable, but pass 2 re-indexes from scratch, so they are not propagated. Where that re-index indexes too few frames the run falls back to pass 1's lattice and integrates it at the refined geometry — and the cell is then **scaled to the distance it will be used at**, since a real-space cell is measured against the distance its spots were seen at, and carrying it across a distance change otherwise scales the whole cell by the ratio of the two. The orientation is untouched.
 
 The space group is determined **after** pass 2, on the geometry the run refined, and pass 1 does not search at all: a decision taken on the worse of the two passes and then carried forward is a constraint on the better one, and would have to be reconciled with what pass 2 later found. The guard that chooses which pass is written compares each pass's **first** merge — $P1$ on both sides, full resolution range, before the correction surfaces — which both passes produce anyway, so it never compares statistics computed in two different space groups. What it compares there is the **signal each pass measured**: the count of unique reflections merged at $I/\sigma \ge 2$. Self-consistency cannot do this job — against an external arbiter the signal count named the more accurate geometry on 23 of 27 arm-dataset pairs where $R_\mathrm{meas}$, $CC_{1/2}$ and ISa managed 13, a coin flip — and that merge's own $CC_{1/2}$ least of all, being pooled over the whole range, uncut and uncorrected, so the shells with no signal in them dominate it and they are exactly the shells a geometry move disturbs (it reads 0.13 on a crystal whose data merge at 0.995). The refined pass is sent back only where it merges more unique reflections than its cell can hold, where it measured decisively less signal (10 %, and only where it holds no more reflections either — a wider integration disk pulls weak reflections in and dilutes the strong fraction without measuring less), or where it lost the axial rows the systematic absences are read off. One index-time veto remains and is keyed to pass 1's **lattice** rather than its group: a centred pass-1 lattice against a primitive pass-2 one.
diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index 65a6e905c..fee879231 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -542,8 +542,14 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
             // nominal for the first step of the walk below, the last step's answer after that. The
             // detector tilt is declared and held constant so that a non-zero rot1/rot2 still acts on
             // the observed side.
-            auto solve_joint = [&](Subset s, bool wide, double bm[2], double ds[1], double rv[3],
-                                   double q0[3], double q1[3], double q2[3]) {
+            // fix_distance holds the distance block at its seed, which makes the solve the nested
+            // hypothesis "the header distance is right" of the free one. distance_corr, where given
+            // (four values), receives the free fit's own formal picture of the distance: sd(distance)
+            // over the distance, and its correlation with each cell length, from the covariance of
+            // the solution.
+            auto solve_joint = [&](Subset s, bool wide, bool fix_distance, double bm[2], double ds[1],
+                                   double rv[3], double q0[3], double q1[3], double q2[3],
+                                   double *distance_corr = nullptr) {
                 const double ds_seed = ds[0];
                 const double q1_seed[3] = {q1[0], q1[1], q1[2]};
                 ceres::Problem p;
@@ -565,6 +571,7 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 }
                 if (p.NumResidualBlocks() == 0) return false;
                 p.SetParameterBlockConstant(det_rot);
+                if (fix_distance) p.SetParameterBlockConstant(ds);
                 if (!p2_free) p.SetParameterBlockConstant(q2);
                 // Two boxes on the distance and the cell lengths. WIDE is the one this fit has always
                 // had, around nominal: it is what the first solve is asked in, so a fit that settles
@@ -599,6 +606,26 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 ceres::Solver::Options o; o.linear_solver_type = ceres::DENSE_QR; o.max_num_iterations = 60;
                 o.num_threads = std::max(1, settings.num_threads); o.logging_type = ceres::LoggingType::SILENT;
                 ceres::Solver::Summary sum; ceres::Solve(o, &p, &sum);
+                if (distance_corr && !fix_distance && sum.IsSolutionUsable()) {
+                    std::fill(distance_corr, distance_corr + 4, std::numeric_limits<double>::quiet_NaN());
+                    ceres::Covariance::Options co;
+                    co.algorithm_type = ceres::DENSE_SVD;
+                    co.null_space_rank = -1;   // a symmetry-constrained cell leaves unused length components
+                    ceres::Covariance cov(co);
+                    if (cov.Compute({{ds, ds}, {ds, q1}, {q1, q1}}, &p)) {
+                        double cdd[1], cdq[3], cqq[9];
+                        cov.GetCovarianceBlock(ds, ds, cdd);
+                        cov.GetCovarianceBlock(ds, q1, cdq);
+                        cov.GetCovarianceBlock(q1, q1, cqq);
+                        // Ceres' covariance is (J^T J)^-1 for unit-variance residuals; the residuals'
+                        // own variance, from the fit's cost, puts it in real units.
+                        const double sigma2 = 2.0 * sum.final_cost
+                                / std::max(1, sum.num_residuals_reduced - sum.num_effective_parameters_reduced);
+                        distance_corr[0] = std::sqrt(std::max(0.0, cdd[0]) * sigma2) / ds[0];
+                        for (int j = 0; j < 3; ++j)
+                            distance_corr[1 + j] = cdq[j] / std::sqrt(std::max(1e-300, cdd[0] * cqq[4 * j]));
+                    }
+                }
                 return sum.IsSolutionUsable();
             };
 
@@ -631,12 +658,59 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 for (int j = 0; j < 3; ++j) {
                     rv_f[j] = ax0[j]; q0_f[j] = p0_0[j]; q1_f[j] = p1_0[j]; q2_f[j] = p2_0[j];
                 }
-                bool convJ = solve_joint(FIT, /*wide=*/true, bm_f, ds_f, rv_f, q0_f, q1_f, q2_f);
+                double distance_corr[4];
+                bool convJ = solve_joint(FIT, /*wide=*/true, /*fix_distance=*/false, bm_f, ds_f, rv_f,
+                                         q0_f, q1_f, q2_f, distance_corr);
+                double cv_ref_se = NAN;
                 double cv_ref = convJ ? joint_cost(VAL, bm_f, ds_f, rv_f, q0_f, q1_f, q2_f,
-                                                   pos_ref, exc_ref)
+                                                   pos_ref, exc_ref, &cv_ref_se)
                                       : cv_nom;
                 int steps = 1;
 
+                // Do these data determine the distance at all? At a detector far enough away that
+                // no reflection reaches more than a few degrees of 2theta, a longer distance and a
+                // larger cell move every spot the same way to first order (the difference is of
+                // order sin^2 theta of the spot's own position), and the rocking angles pin the
+                // cell scale only through the same sin theta. The joint fit then finds a
+                // distance/cell pair that fits its own observations a little better than the
+                // header, commits it, and the pass re-integrated there finds the next pair - a
+                // walk along the degenerate direction that the realised residual never ratifies.
+                // So the same fit is asked once more with the distance HELD at the header, every
+                // other block as free as before - the nested hypothesis "the header distance is
+                // right". Where the free distance lowers the held-out residual below the held fit's
+                // by more than the standard error of that residual - the same noise a round of the
+                // geometry walk has to beat (HeldOutResidualFell) - it has paid decisively and is
+                // committed exactly as before. Where it has not, this fit cannot say: its own gain is
+                // not what decides, because the pass re-integrated at the new distance need not
+                // realise it (measured: a 0.6 % in-fit gain at nearly three times its paired scatter,
+                // none of it realised) while a sweep at a short distance realises a gain of that size
+                // several times over. So both hypotheses are carried - the free fit committed as
+                // before, the held fit's beam beside it - and RunAllPasses runs the canonical pass at
+                // each and keeps the one whose RE-INTEGRATED held-out residual is lower, the header's
+                // on a tie.
+                double bm_h[2] = {beam_x0, beam_y0}, ds_h[1] = {dist0};
+                double rv_h[3], q0_h[3], q1_h[3], q2_h[3];
+                for (int j = 0; j < 3; ++j) {
+                    rv_h[j] = ax0[j]; q0_h[j] = p0_0[j]; q1_h[j] = p1_0[j]; q2_h[j] = p2_0[j];
+                }
+                const bool convH = convJ && solve_joint(FIT, /*wide=*/true, /*fix_distance=*/true,
+                                                        bm_h, ds_h, rv_h, q0_h, q1_h, q2_h);
+                double pos_h = 0.0, exc_h = 0.0, cv_h = cv_nom, cv_h_se = NAN;
+                if (convH)
+                    cv_h = joint_cost(VAL, bm_h, ds_h, rv_h, q0_h, q1_h, q2_h, pos_h, exc_h, &cv_h_se);
+                const double noise = std::hypot(cv_ref_se, cv_h_se);
+                const bool distance_pays = convH && std::isfinite(noise) && cv_ref < cv_h - noise;
+                const bool distance_undecided = convH && !distance_pays;
+                logger.Info("Post-refine GEOM distance: free {:.3f} mm gives held-out {:.3e} +- {:.1e}; held "
+                            "at the header {:.3f} mm gives {:.3e} +- {:.1e} (positional {:.3e}, excitation "
+                            "{:.3e}); free minus held {:+.3e} against the noise {:.1e} => {}; the free fit's "
+                            "formal sd(distance) {:.4f} %, corr(distance, cell a/b/c) {:.4f} {:.4f} {:.4f}",
+                            ds_f[0], cv_ref, cv_ref_se, dist0, cv_h, cv_h_se, pos_h, exc_h, cv_ref - cv_h,
+                            noise,
+                            distance_undecided ? "this fit cannot tell, both are carried to the canonical pass"
+                                               : "the free distance pays",
+                            100.0 * distance_corr[0], distance_corr[1], distance_corr[2], distance_corr[3]);
+
                 // A larger move is no longer refused for its size - but it is not taken as one solve
                 // asserted it either. It is re-fitted as a WALK: each step seeded where the last one
                 // arrived, each bounded by the trust region, and each required to lower the held-out
@@ -656,7 +730,8 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                         for (int j = 0; j < 3; ++j) {
                             rv_s[j] = rv_f[j]; q0_s[j] = q0_f[j]; q1_s[j] = q1_f[j]; q2_s[j] = q2_f[j];
                         }
-                        if (!solve_joint(FIT, /*wide=*/false, bm_s, ds_s, rv_s, q0_s, q1_s, q2_s))
+                        if (!solve_joint(FIT, /*wide=*/false, /*fix_distance=*/false, bm_s, ds_s, rv_s,
+                                         q0_s, q1_s, q2_s))
                             break;
                         double pos_s = 0.0, exc_s = 0.0;
                         const double cv_s = joint_cost(VAL, bm_s, ds_s, rv_s, q0_s, q1_s, q2_s,
@@ -732,7 +807,7 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                             axv[j] = rv_f[j]; p0[j] = q0_f[j]; p1[j] = q1_f[j]; p2[j] = q2_f[j];
                         }
                     }
-                    solve_joint(ALL, !walked, beam, dist, axv, p0, p1, p2);   // commit: re-fit on all data
+                    solve_joint(ALL, !walked, /*fix_distance=*/false, beam, dist, axv, p0, p1, p2);   // commit: re-fit on all data
                     ds_log[0] = dist[0]; bm_log[0] = beam[0]; bm_log[1] = beam[1];
                     for (int j = 0; j < 3; ++j) { q1_log[j] = p1[j]; q2_log[j] = p2[j]; }
                     refused = out_of_bounds(beam, p2);
@@ -741,6 +816,13 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                         for (int j = 0; j < 3; ++j) {
                             axv[j] = ax0[j]; p0[j] = p0_0[j]; p1[j] = p1_0[j]; p2[j] = p2_0[j];
                         }
+                    } else if (distance_undecided) {
+                        // The other arm, re-fitted on all the data the same way: its beam at the
+                        // header distance is what the canonical pass at that distance runs with.
+                        if (solve_joint(ALL, /*wide=*/true, /*fix_distance=*/true, bm_h, ds_h, rv_h, q0_h,
+                                        q1_h, q2_h)
+                            && out_of_bounds(bm_h, q2_h) == nullptr)
+                            result.held_arm_beam_px = std::array<double, 2>{bm_h[0], bm_h[1]};
                     }
                 }
                 commit = (refused == nullptr);
@@ -750,8 +832,11 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 // large for the bound - which is the one case where the number worth reading is the one
                 // that was thrown away. The report carries the same sentence, so a refusal is visible
                 // without the log.
-                const std::string verdict = commit ? fmt::format("COMMIT ({} step{})", steps,
-                                                                 steps == 1 ? "" : "s")
+                const std::string verdict = commit ? fmt::format("COMMIT ({} step{}{})", steps,
+                                                                 steps == 1 ? "" : "s",
+                                                                 result.held_arm_beam_px
+                                                                     ? ", the header distance carried as the other arm"
+                                                                     : "")
                                                    : "reject (" + std::string(refused) + ")";
                 // The cell the log names is the EFFECTIVE one - what the residual's B matrix builds
                 // from the blocks - not the blocks themselves, whose unused components a high-symmetry
diff --git a/image_analysis/geom_refinement/PostRefine.h b/image_analysis/geom_refinement/PostRefine.h
index b6f20833c..5abfe9ce7 100644
--- a/image_analysis/geom_refinement/PostRefine.h
+++ b/image_analysis/geom_refinement/PostRefine.h
@@ -49,6 +49,15 @@ struct PostRefineResult {
     // from. Such a move is not refused for its size - it is RATIFIED by re-integrating and re-indexing
     // at it, which a second lattice does not survive and a wrong header does (see RunAllPasses).
     bool large_move = false;
+    // The same fit with the distance HELD at the header, where the free distance did not lower the
+    // held-out residual below it by more than the noise of that residual: the beam centre that fit
+    // committed, at the header distance. The free fit is what `geom`, `cell` and the *_after fields
+    // carry, exactly as before; this is the other hypothesis, carried so that the canonical stage
+    // can run at both and keep the one whose RE-INTEGRATED residual is lower (see RunAllPasses).
+    // Absent where the free distance paid decisively, or where nothing was committed.
+    std::optional<std::array<double, 2>> held_arm_beam_px;
+    // Set by RunAllPasses where that comparison kept the header distance: the report names it.
+    bool distance_held = false;
     // The held-out residual at the geometry the fit STARTED from - what the integration this fit was
     // handed actually realises there, before the fit moves anything - and its standard error over the
     // held-out values. Two passes at two geometries are compared on this, not on the fit's own
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 0a976d95d..59eb2452c 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -519,6 +519,9 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             Add(s, KeyBool("POSTREFINE_DETECTOR_COMMITTED", pr.detector_refined));
             Add(s, KeyText("POSTREFINE_DISTANCE", fmt::format("{:.3f} -> {:.3f}", pr.distance_before_mm,
                                                               pr.distance_after_mm)));
+            // TRUE where the fit left the distance at the header because freeing it did not lower the
+            // held-out residual beyond the noise of that comparison - the data do not determine it.
+            Add(s, KeyBool("POSTREFINE_DISTANCE_HELD", pr.distance_held));
             Add(s, KeyText("POSTREFINE_BEAM_CENTRE",
                            fmt::format("{:.2f} {:.2f} -> {:.2f} {:.2f}", pr.beam_x_before_px,
                                        pr.beam_y_before_px, pr.beam_x_after_px, pr.beam_y_after_px)));
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 557c79afe..e4ce27285 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -2031,6 +2031,78 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             experiment_.BeamX_pxl(g[0]).BeamY_pxl(g[1]).DetectorDistance_mm(g[2])
                        .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
         };
+
+        // Where the pre-pass could not tell whether its distance move paid (held_arm_beam_px: the
+        // free distance lowered the fit's own held-out residual by less than that residual's noise),
+        // the other hypothesis - the header distance, with the beam the same fit found there - is run
+        // as a canonical pass of its own, and the two are judged on what they REALISE: the held-out
+        // residual each re-integrated pass measures at its own geometry, the comparison the walk
+        // below makes between its rounds. The free arm ran first and wrote the canonical files, so
+        // where it wins nothing is re-run; where the header's wins, or the two cannot be told apart,
+        // the header's is re-run to write them - it is the hypothesis that asserts nothing, so a tie
+        // is its, and the distance walk below is not entered: the data have just said they cannot
+        // place the distance. Measured on a sweep at 820 mm reaching 2theta ~ 9 deg, where the fit's
+        // own gain never realises: the free arm's re-integrated residual sat within 0.6 % of the
+        // header's at a noise of 8 %, and the cell it carried was 1 % too large. On a sweep at 110 mm
+        // reaching 57 deg, a 0.14 % distance move the pre-pass could not decide realised 3.7 %
+        // against a noise of 1.5 %, and the cell it carried matched the reference to 0.04 %.
+        std::string distance_arm;     // the arm decision, for the pass decision text
+        bool distance_arm_kept_header = false;
+        int arm_passes = 0;
+        if (!cancelled_ && prepass_detector_geometry_ && pass1.post_refine
+            && pass1.post_refine->held_arm_beam_px && pass2.post_refine) {
+            const std::array<float, 5> free_geometry = current_geometry();
+            std::array<float, 5> held_geometry = free_geometry;
+            held_geometry[0] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[0]);
+            held_geometry[1] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[1]);
+            held_geometry[2] = header_geometry[2];
+            logger.Info("Two-pass: the pre-pass could not tell whether moving the distance {:.3f} -> {:.3f} mm "
+                        "paid, so the canonical pass runs at the header distance as well and the two are "
+                        "judged on the held-out residual each realises", header_geometry[2],
+                        free_geometry[2]);
+            // The pass at the header distance measures its own post-refinement and integration, and
+            // neither may replace the free pass's where the free pass is the one kept.
+            const auto free_wish = prepass_detector_geometry_;
+            const auto free_starved = bkg_starved_fraction_;
+            set_geometry(held_geometry);
+            auto held = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
+            ++arm_passes;
+            const double realised_free = pass2.post_refine->held_out_before;
+            const double realised_held = held.post_refine ? held.post_refine->held_out_before : NAN;
+            const double se_free = pass2.post_refine->held_out_before_se;
+            const double se_held = held.post_refine ? held.post_refine->held_out_before_se : NAN;
+            if (!cancelled_ && held.post_refine && HeldOutResidualFell(*held.post_refine, *pass2.post_refine)) {
+                logger.Info("Two-pass: re-integrated at the post-refined distance {:.3f} mm the held-out "
+                            "residual is {:.3e} against {:.3e} at the header's {:.3f} mm (standard errors "
+                            "{:.1e} and {:.1e}) - the move is realised and stands", free_geometry[2],
+                            realised_free, realised_held, held_geometry[2], se_free, se_held);
+                set_geometry(free_geometry);
+                prepass_detector_geometry_ = free_wish;
+                bkg_starved_fraction_ = free_starved;
+                distance_arm = fmt::format(
+                        "the header distance {:.3f} mm was run as well and realised a held-out residual of "
+                        "{:.3e} against {:.3e} at the post-refined {:.3f} mm, so the post-refined distance "
+                        "stands", held_geometry[2], realised_held, realised_free, free_geometry[2]);
+            } else if (!cancelled_) {
+                logger.Info("Two-pass: re-integrated at the header distance {:.3f} mm the held-out residual "
+                            "is {:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}; standard "
+                            "errors {:.1e} and {:.1e}) - these data do not determine the distance, and the "
+                            "header's stands", held_geometry[2], realised_held, free_geometry[2],
+                            realised_free, se_held, se_free);
+                pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
+                ++arm_passes;
+                distance_arm_kept_header = true;
+                pass1.post_refine->distance_held = true;
+                pass1.post_refine->beam_x_after_px = held_geometry[0];
+                pass1.post_refine->beam_y_after_px = held_geometry[1];
+                pass1.post_refine->distance_after_mm = held_geometry[2];
+                distance_arm = fmt::format(
+                        "the header distance {:.3f} mm kept: re-integrated there the held-out residual is "
+                        "{:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}), so these data do "
+                        "not determine the distance", held_geometry[2], realised_held, free_geometry[2],
+                        realised_free);
+            }
+        }
         int geometry_rounds = 0;      // passes run at a geometry the walk moved to
         int walk_passes = 0;          // every pass the walk ran, the return to its best round included
         int best_round = 0;
@@ -2044,7 +2116,7 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             best_fit = *pass2.post_refine;
             walk_rounds = fmt::format("{:.3f} mm / {:.3e}", best_geometry[2], best_fit.held_out_before);
         }
-        while (!cancelled_ && prepass_detector_geometry_
+        while (!cancelled_ && prepass_detector_geometry_ && !distance_arm_kept_header
                && pass2.post_refine && pass2.post_refine->detector_refined
                && (pass2.post_refine->large_move || geometry_rounds > 0)) {
             if (geometry_rounds == MAX_GEOMETRY_ROUNDS) {
@@ -2112,8 +2184,8 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass1.post_refine->distance_after_mm = best_geometry[2];
         }
         pass2.post_refine = pass1.post_refine;
-        pass2.pass_number = 2 + walk_passes;
-        pass2.pass_count = 2 + walk_passes;
+        pass2.pass_number = 2 + arm_passes + walk_passes;
+        pass2.pass_count = 2 + arm_passes + walk_passes;
         if (geometry_rounds > 0)
             pass2.pass_decision = fmt::format(
                     "post-refined geometry walked {} round{} and kept round {}, detector distance {:.3f} mm "
@@ -2248,6 +2320,8 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass2.pass_decision = (prepass_detector_geometry_ || prepass_rotation_scale_)
                     ? "post-refined geometry adopted"
                     : "the post-refinement committed no geometry change, so this pass reproduces the first";
+        if (!distance_arm.empty())
+            pass2.pass_decision = distance_arm + "; " + pass2.pass_decision;
         pass2.geometry_not_converged = geometry_not_converged;
         return pass2;
     }
-- 
2.54.0


From 9de53ad015228173df915743a34e1bd75235e1ee Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:14:47 +0200
Subject: [PATCH 065/122] RotationScaleMerge: download the GPU merge
 accumulators in slices

The device merge's per-group sums were downloaded into a full-length host array per field and then
unpacked into the per-group accumulators, so every merge held two full copies of them - on a large
cell searched in P1 that is most of a gigabyte beside the accumulators themselves. MergeAccum now
leaves the sums on the device and MergeAccumRange downloads a million groups at a time, each slice
unpacked straight into the accumulators.

Same values, same integer reject count; merged output byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 54 ++++++++++---------
 .../scale_merge/RotationScaleMergeGPU.cu      | 27 +++++-----
 .../scale_merge/RotationScaleMergeGPU.h       | 22 ++++----
 3 files changed, 56 insertions(+), 47 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index ae7410a61..93c39fea9 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3937,36 +3937,40 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
         bool did_gpu_acc = false;
 #ifdef JFJOCH_USE_CUDA
         if (use_gpu_merge) {
-            // Resized, not sized vectors: the kernel writes every one of these for every group, so
-            // value-initialising them first is a hundred megabytes of zeroes faulted in on one thread
-            // and overwritten on the next line - the same trap Ingest calls out. Members for the same
-            // reason as FullsStaging.
-            MergeAccumStaging &ms = merge_accum;
-            ms.Resize(n_groups);
             gpu_->MergeAccum(error_model_a, error_model_b, error_model_active,
                              reject_outliers, reject_nsigma, reject_median.data(), merge_half.data(),
-                             frame_cc_factor.data(),
-                             ms.swI.data(), ms.sw.data(), ms.swIh0.data(), ms.swIh1.data(),
-                             ms.swh0.data(), ms.swh1.data(), ms.swh_typ0.data(), ms.swh_typ1.data(),
-                             ms.nh0.data(), ms.nh1.data(),
-                             ms.d.data(), ms.rej.data(), ms.on_ice.data(), rejected_obs.data());
+                             frame_cc_factor.data(), rejected_obs.data());
+            // Downloaded a slice of groups at a time and unpacked straight into acc, so the host never
+            // holds a second full-length copy of the accumulators - on a large cell that is most of a
+            // gigabyte beside acc itself. Resized, not sized vectors: the download writes every element
+            // (the kernel fills the empty groups too), and a member for the same reason as FullsStaging.
             // Per-group and independent, so the unpack splits; the rejected count is an integer sum and
             // does not care in which order the chunks add theirs in.
+            constexpr int ACC_SLICE = 1 << 20;
+            MergeAccumStaging &ms = merge_accum;
+            ms.Resize(std::min(n_groups, ACC_SLICE));
             std::atomic<size_t> rejected_total{0};
-            ParallelChunks(n_groups, ThreadsForWork(n_groups, nthreads), [&](int glo, int ghi) {
-                size_t rej = 0;
-                for (int g = glo; g < ghi; ++g) {
-                    Accum &a = acc[g];
-                    a.swI = ms.swI[g]; a.sw = ms.sw[g]; a.swIh[0] = ms.swIh0[g]; a.swIh[1] = ms.swIh1[g];
-                    a.swh[0] = ms.swh0[g]; a.swh[1] = ms.swh1[g];
-                    a.swh_typ[0] = ms.swh_typ0[g]; a.swh_typ[1] = ms.swh_typ1[g];
-                    a.nh[0] = static_cast<size_t>(ms.nh0[g]); a.nh[1] = static_cast<size_t>(ms.nh1[g]);
-                    a.d = static_cast<float>(ms.d[g]);
-                    a.on_ice = ms.on_ice[g] != 0;
-                    rej += static_cast<size_t>(ms.rej[g]);
-                }
-                rejected_total += rej;
-            });
+            for (int g0 = 0; g0 < n_groups; g0 += ACC_SLICE) {
+                const int cnt = std::min(ACC_SLICE, n_groups - g0);
+                gpu_->MergeAccumRange(g0, cnt, ms.swI.data(), ms.sw.data(), ms.swIh0.data(), ms.swIh1.data(),
+                                      ms.swh0.data(), ms.swh1.data(), ms.swh_typ0.data(), ms.swh_typ1.data(),
+                                      ms.nh0.data(), ms.nh1.data(), ms.d.data(), ms.rej.data(),
+                                      ms.on_ice.data());
+                ParallelChunks(cnt, ThreadsForWork(cnt, nthreads), [&](int lo, int hi) {
+                    size_t rej = 0;
+                    for (int i = lo; i < hi; ++i) {
+                        Accum &a = acc[g0 + i];
+                        a.swI = ms.swI[i]; a.sw = ms.sw[i]; a.swIh[0] = ms.swIh0[i]; a.swIh[1] = ms.swIh1[i];
+                        a.swh[0] = ms.swh0[i]; a.swh[1] = ms.swh1[i];
+                        a.swh_typ[0] = ms.swh_typ0[i]; a.swh_typ[1] = ms.swh_typ1[i];
+                        a.nh[0] = static_cast<size_t>(ms.nh0[i]); a.nh[1] = static_cast<size_t>(ms.nh1[i]);
+                        a.d = static_cast<float>(ms.d[i]);
+                        a.on_ice = ms.on_ice[i] != 0;
+                        rej += static_cast<size_t>(ms.rej[i]);
+                    }
+                    rejected_total += rej;
+                });
+            }
             reject_count = rejected_total;
             did_gpu_acc = true;
         }
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.cu b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
index 2f51def78..1a5e2acb6 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.cu
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
@@ -907,10 +907,7 @@ void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partialit
 void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                                        bool reject_outliers, double reject_nsigma, const float *reject_median,
                                        const uint8_t *half, const double *frame_cc_factor,
-                                       double *swI, double *sw, double *swIh0, double *swIh1,
-                                       double *swh0, double *swh1, double *swh_typ0, double *swh_typ1,
-                                       int32_t *nh0, int32_t *nh1, double *d_out,
-                                       int32_t *rejected, uint8_t *on_ice_out, uint8_t *rejected_obs) {
+                                       uint8_t *rejected_obs) {
     DeviceGuard guard(impl_->device, impl_->available);
     auto &d = *impl_;
     const int ng = d.n_groups;
@@ -952,17 +949,23 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     MergeAccumKernel<<<grp_blocks, BLK>>>(p);
     CudaCheck(cudaGetLastError(), "merge accum launch");
     CudaCheck(cudaDeviceSynchronize(), "merge accum sync");
-    auto dl = [&](void *h, const CudaDevicePtr<double> &s) {
-        CudaCheck(cudaMemcpy(h, s.get(), size_t(ng) * sizeof(double), cudaMemcpyDeviceToHost), "dl accum"); };
+    CudaCheck(cudaMemcpy(rejected_obs, d.m_rejected.get(), size_t(d.n_fulls) * sizeof(uint8_t), cudaMemcpyDeviceToHost),
+              "dl rejected_obs");
+}
+
+void RotationScaleMergeGPU::MergeAccumRange(int g0, int n, double *swI, double *sw, double *swIh0,
+                                            double *swIh1, double *swh0, double *swh1, double *swh_typ0,
+                                            double *swh_typ1, int32_t *nh0, int32_t *nh1, double *d_out,
+                                            int32_t *rejected, uint8_t *on_ice_out) {
+    DeviceGuard guard(impl_->device, impl_->available);
+    auto &d = *impl_;
+    auto dl = [&](void *h, const auto &s) {
+        CudaCheck(cudaMemcpy(h, s.get() + g0, size_t(n) * sizeof(*s.get()), cudaMemcpyDeviceToHost),
+                  "dl accum"); };
     dl(swI, d.a_swI); dl(sw, d.a_sw); dl(swIh0, d.a_swIh0); dl(swIh1, d.a_swIh1);
     dl(swh0, d.a_swh0); dl(swh1, d.a_swh1); dl(swh_typ0, d.a_swht0); dl(swh_typ1, d.a_swht1);
     dl(d_out, d.a_d);
-    CudaCheck(cudaMemcpy(nh0, d.a_nh0.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl nh0");
-    CudaCheck(cudaMemcpy(nh1, d.a_nh1.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl nh1");
-    CudaCheck(cudaMemcpy(rejected, d.a_rejected.get(), size_t(ng) * sizeof(int32_t), cudaMemcpyDeviceToHost), "dl rej");
-    CudaCheck(cudaMemcpy(on_ice_out, d.a_on_ice.get(), size_t(ng) * sizeof(uint8_t), cudaMemcpyDeviceToHost), "dl on_ice");
-    CudaCheck(cudaMemcpy(rejected_obs, d.m_rejected.get(), size_t(d.n_fulls) * sizeof(uint8_t), cudaMemcpyDeviceToHost),
-              "dl rejected_obs");
+    dl(nh0, d.a_nh0); dl(nh1, d.a_nh1); dl(rejected, d.a_rejected); dl(on_ice_out, d.a_on_ice);
 }
 
 void RotationScaleMergeGPU::MergeRmeas(const double *merged_I, double *absdev, double *sumI,
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.h b/image_analysis/scale_merge/RotationScaleMergeGPU.h
index fb853b016..5d5f99194 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.h
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.h
@@ -91,18 +91,20 @@ public:
     // Per-group merge accumulators (inv-var sums + deterministic half-sets, error-model-corrected sigma
     // from a/b). `half` is the per-full CC1/2 half-set (length n_fulls) assigned on the host, so this
     // kernel and the host merge loop cannot disagree about it.
-    // Outputs length n_groups; rejected[g] counts outliers dropped (reject_median uploaded, NAN
-    // where none). rejected_obs is the per-full flag (length n_fulls): the host needs it for the reductions
-    // it still does itself, above all the anomalous I(+)/I(-) split. frame_cc_factor (length n_frames) is
-    // each frame's (G_ref/G)^2 floored at 1; swh_typ0/1 are the half-set weights multiplied by it.
-    // Requires MergeEmSamples first (em_mean resident).
+    // The per-group results stay on the device for MergeAccumRange to download; reject_median is
+    // uploaded (NAN where none). rejected_obs is the per-full flag (length n_fulls): the host needs it
+    // for the reductions it still does itself, above all the anomalous I(+)/I(-) split.
+    // frame_cc_factor (length n_frames) is each frame's (G_ref/G)^2 floored at 1; swh_typ0/1 are the
+    // half-set weights multiplied by it. Requires MergeEmSamples first (em_mean resident).
     void MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                     bool reject_outliers, double reject_nsigma, const float *reject_median,
-                    const uint8_t *half, const double *frame_cc_factor,
-                    double *swI, double *sw, double *swIh0, double *swIh1,
-                    double *swh0, double *swh1, double *swh_typ0, double *swh_typ1,
-                    int32_t *nh0, int32_t *nh1, double *d_out,
-                    int32_t *rejected, uint8_t *on_ice_out, uint8_t *rejected_obs);
+                    const uint8_t *half, const double *frame_cc_factor, uint8_t *rejected_obs);
+    // Download groups [g0, g0 + n) of what MergeAccum left on the device; every output has length n.
+    // rejected[g] counts the outliers dropped from the group.
+    void MergeAccumRange(int g0, int n, double *swI, double *sw, double *swIh0, double *swIh1,
+                         double *swh0, double *swh1, double *swh_typ0, double *swh_typ1,
+                         int32_t *nh0, int32_t *nh1, double *d_out,
+                         int32_t *rejected, uint8_t *on_ice_out);
 
     // Per-group R_meas accumulators (sum|I_corr-merged_I|, sum_I, n, and the count this looser walk
     // accepted - which the host uses only to skip empty groups, NOT as the per-shell
-- 
2.54.0


From ddc785590071bb96079eee5dd399e54d0cee24aa Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 00:04:29 +0200
Subject: [PATCH 066/122] Rotation scaling: frame guards and delta-CC1/2 read
 the frames by what they carry

Three follow-ups to the converging scale loop, all on sweeps with a stretch the crystal barely
diffracted on:

- The sweep ledger's scale channel (and with it delta-CC1/2's "normal frame" test) and the
  space-group search's scale floor measure a frame against the precision-weighted typical frame
  G_ref (TypicalFrameScale) instead of the run median: on a sweep that spent most of its turn out
  of the beam the median frame is itself a dead one, and every stretch then reads as typical. The
  two collapse guards stay on the median on purpose - a frame that collapsed toward zero and was
  not quite dropped has its fulls re-fitted with a scale of 1/G, a cubic mean is then theirs, and
  the floor read against it dropped three quarters of every live frame's fulls (measured).

- delta-CC1/2's sigma-tau statistic enters each reflection with the information it carries (the
  same per-frame factor as the CC1/2 weight), so a dead stretch, whose scaled-up noise flooded the
  mean error variance of every mixed reflection and read as harm up to the 25% cap, now costs
  about nothing and is left to the ledger.

- The scale loop's step test weighs each frame by its merge weight (its observations at its scale
  squared): a dead frame's scale is fitted on noise and wanders by orders of magnitude every
  iteration, carries nothing into the merge, is dropped after the loop, and must not hold the loop
  open.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 93 +++++++++++++------
 1 file changed, 66 insertions(+), 27 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index a01ca9958..2a6409224 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -1430,15 +1430,23 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
         }
         rescale(scaled_any, ratio);
         if (it > 0) {
-            double ss = 0.0;
+            // The step, weighted by what each frame carries into the merge - its observations at its
+            // scale squared, which is how the inverse-variance weight of a scaled observation goes.
+            // A frame the crystal did not diffract on has its scale fitted on noise and wanders by
+            // orders of magnitude every iteration (measured on a sweep 60% out of the beam: scales
+            // at 1e-7 of the typical frame, still moving at the cap); it carries nothing into the
+            // merge and is dropped from it after the loop, so it does not hold the loop open either.
+            double ss = 0.0, sw = 0.0;
             int n = 0;
             for (int f = 0; f < n_frames; ++f)
                 if (scaled_any[f] && g_prev[f] > 0.0 && g[f] > 0.0) {
                     const double d = std::log(g[f] / g_prev[f]);
-                    ss += d * d;
+                    const double w = frame_obs_count[f] * g[f] * g[f];
+                    ss += w * d * d;
+                    sw += w;
                     ++n;
                 }
-            out.step = n > 0 ? std::sqrt(ss / n) : 0.0;
+            out.step = sw > 0.0 ? std::sqrt(ss / sw) : 0.0;
             logger.Debug("Per-frame scaling ({}): iteration {}, rms |dlogG| {:.2e} over {} frames, "
                          "gauge {:.4f}", what, it + 1, out.step, n, g_ref);
             if (out.step < SCALING_TOLERANCE) {
@@ -1959,21 +1967,30 @@ void RotationScaleMerge::MeasureSweepQuality(const std::vector<uint8_t> &partial
         return;
 
     // Run gauges. Only the ratio to the run matters - the absolute scale is degenerate with the merge's.
-    std::vector<double> g_fitted, cc_fitted;
+    // The scale's gauge is the precision-weighted typical frame (TypicalFrameScale), not the median
+    // frame: on a sweep that spent most of its turn out of the beam the median frame IS a dead one,
+    // and every stretch then reads as typical (measured: a run whose good frames sat at 1.3-1.7 and
+    // whose median was 0.21 reported its dead stretch at "scale 0.24"). The CC channel keeps its
+    // median - a correlation is not a scale, and dead frames carry no CC to drag it with.
+    std::vector<double> cc_fitted;
+    std::vector<int64_t> n_obs(n_frames, 0);
+    int n_scaled = 0;
     for (int f = 0; f < n_frames; ++f) {
-        if (partial_scaled[f] && std::isfinite(g_partial[f]) && g_partial[f] > 0.0)
-            g_fitted.push_back(g_partial[f]);
+        if (partial_scaled[f] && std::isfinite(g_partial[f]) && g_partial[f] > 0.0) {
+            n_obs[f] = frame_count[f];
+            ++n_scaled;
+        }
         if (cc_n[f] >= MIN_REFLECTIONS_FOR_IMAGE_CC && std::isfinite(cc[f]))
             cc_fitted.push_back(cc[f]);
     }
-    if (static_cast<int>(g_fitted.size()) < SWEEP_MIN_SCALED_FRAMES)
+    if (n_scaled < SWEEP_MIN_SCALED_FRAMES)
         return;
     auto median_of = [](std::vector<double> &v) {
         const size_t mid = v.size() / 2;
         std::nth_element(v.begin(), v.begin() + mid, v.end());
         return v[mid];
     };
-    const double g_typ = median_of(g_fitted);
+    const double g_typ = TypicalFrameScale(g_partial, n_obs);
     const double cc_typ = cc_fitted.empty() ? 0.0 : median_of(cc_fitted);
 
     // The two channels. The scale is the sample side alone: DivideOutIncidentFlux took the beam out of the
@@ -2177,15 +2194,24 @@ namespace {
     // the variance of the unique reflections' mean intensities against the error variance of a half
     // dataset's mean, accumulated one reflection at a time. No half-set split, so no random numbers -
     // the same answer every run, and more precise than the split estimate.
+    //
+    // Each reflection enters with the information it carries: the precision its observations would
+    // have at the run's typical frame scale over the precision they have (the same per-frame factor
+    // as the CC1/2 weight, CCHalfFrameFactors), so a reflection measured only on frames the crystal
+    // barely diffracted on, whose scaled-up noise would otherwise flood the mean error variance of
+    // every mixed reflection, counts for what it knows. Unweighted, a dead stretch read as harm
+    // (-0.15 on a sweep 60% out of the beam) and was convicted up to the cap; weighted, it costs
+    // about nothing and is left to the ledger, which is what it is - a stretch that adds nothing.
     struct SigmaTau {
-        double n = 0, sum_mean = 0, sum_mean2 = 0, sum_eps = 0;
-        void Add(double mean, double eps) {
-            n += 1; sum_mean += mean; sum_mean2 += mean * mean; sum_eps += eps;
+        double n = 0, w = 0, sum_mean = 0, sum_mean2 = 0, sum_eps = 0;
+        void Add(double mean, double eps, double weight) {
+            n += 1; w += weight; sum_mean += weight * mean; sum_mean2 += weight * mean * mean;
+            sum_eps += weight * eps;
         }
         [[nodiscard]] double CC() const {
-            if (n < 4) return NAN;
-            const double var_y = (sum_mean2 - sum_mean * sum_mean / n) / (n - 1);
-            const double eps = sum_eps / n;
+            if (n < 4 || !(w > 0.0)) return NAN;
+            const double var_y = (sum_mean2 - sum_mean * sum_mean / w) / w * n / (n - 1);
+            const double eps = sum_eps / w;
             return var_y + eps / 2 > 0.0 ? (var_y - eps / 2) / (var_y + eps / 2) : NAN;
         }
     };
@@ -2293,12 +2319,17 @@ void RotationScaleMerge::MeasureBatchDeltaCCHalf(int n_groups) {
 
     // The observations, once: scaled intensity, ASU group (-1 = not in this merge, the same test the
     // merge itself applies), and the frame order that makes any frame range a contiguous span.
-    std::vector<double> obs_I(n_full);
+    std::vector<double> obs_I(n_full), obs_info(n_full);
     std::vector<int32_t> obs_group(n_full), order(n_full), fstart(n_frames + 1, 0);
+    std::vector<int64_t> n_obs_frame(n_frames, 0);
+    for (int i = 0; i < n_full; ++i)
+        if (UsableFull(fulls[i])) ++n_obs_frame[fulls[i].frame];
+    const std::vector<double> frame_factor = CCHalfFrameFactors(frame_scale_fulls, n_obs_frame);
     for (int i = 0; i < n_full; ++i) {
         const Obs &o = fulls[i];
         obs_I[i] = o.I * o.corr;
         obs_group[i] = UsableFull(o) ? o.group : -1;
+        obs_info[i] = 1.0 / frame_factor[o.frame];   // the information the observation carries, <= 1
         ++fstart[o.frame + 1];
     }
     for (int f = 0; f < n_frames; ++f) fstart[f + 1] += fstart[f];
@@ -2310,16 +2341,18 @@ void RotationScaleMerge::MeasureBatchDeltaCCHalf(int n_groups) {
     // Per-reflection totals over the frames still in, and the per-reflection contribution of one frame
     // range - which is all a leave-one-out needs, because a count, a sum and a sum of squares subtract.
     std::vector<int32_t> tot_n(n_groups, 0), d_n(n_groups, 0), touched;
-    std::vector<double> tot_s1(n_groups, 0.0), tot_s2(n_groups, 0.0),
-                        d_s1(n_groups, 0.0), d_s2(n_groups, 0.0);
+    std::vector<double> tot_s1(n_groups, 0.0), tot_s2(n_groups, 0.0), tot_w(n_groups, 0.0),
+                        d_s1(n_groups, 0.0), d_s2(n_groups, 0.0), d_w(n_groups, 0.0);
     auto build_totals = [&]() {
         std::fill(tot_n.begin(), tot_n.end(), 0);
         std::fill(tot_s1.begin(), tot_s1.end(), 0.0);
         std::fill(tot_s2.begin(), tot_s2.end(), 0.0);
+        std::fill(tot_w.begin(), tot_w.end(), 0.0);
         for (int i = 0; i < n_full; ++i) {
             const int g = obs_group[i];
             if (g < 0 || frame_rejected[fulls[i].frame]) continue;
             tot_n[g] += 1; tot_s1[g] += obs_I[i]; tot_s2[g] += obs_I[i] * obs_I[i];
+            tot_w[g] += obs_info[i];
         }
     };
 
@@ -2340,6 +2373,7 @@ void RotationScaleMerge::MeasureBatchDeltaCCHalf(int n_groups) {
                 if (g < 0) continue;
                 if (d_n[g] == 0) touched.push_back(g);
                 d_n[g] += 1; d_s1[g] += obs_I[i]; d_s2[g] += obs_I[i] * obs_I[i];
+                d_w[g] += obs_info[i];
             }
         }
         // Only reflections that are still measurable WITHOUT the range count, which is eq. 5's own
@@ -2351,11 +2385,11 @@ void RotationScaleMerge::MeasureBatchDeltaCCHalf(int n_groups) {
             if (tot_n[g] >= 2 && n_without >= 2) {
                 double mean, eps;
                 ReflectionMoments(tot_n[g], tot_s1[g], tot_s2[g], mean, eps);
-                with.Add(mean, eps);
+                with.Add(mean, eps, tot_w[g] / tot_n[g]);
                 ReflectionMoments(n_without, tot_s1[g] - d_s1[g], tot_s2[g] - d_s2[g], mean, eps);
-                without.Add(mean, eps);
+                without.Add(mean, eps, (tot_w[g] - d_w[g]) / n_without);
             }
-            d_n[g] = 0; d_s1[g] = 0.0; d_s2[g] = 0.0;
+            d_n[g] = 0; d_s1[g] = 0.0; d_s2[g] = 0.0; d_w[g] = 0.0;
         }
         const double cc_with = with.CC(), cc_without = without.CC();
         if (with.n < DELTA_CC_MIN_REFLECTIONS || !std::isfinite(cc_with) || !std::isfinite(cc_without))
@@ -3180,6 +3214,11 @@ bool RotationScaleMerge::DropCollapsedScales(const std::vector<uint8_t> &fitted_
     apply.assign(n, 0);
     ratio.assign(n, 1.0);
 
+    // Against the MEDIAN frame, not the precision-weighted typical frame the sweep ledger reads: a
+    // frame that collapsed toward zero and was not quite dropped has its intensities amplified by
+    // 1/G, the fulls built from them are re-fitted with a scale of that size, and a cubic mean is then
+    // theirs - measured on a sweep 60% out of the beam, the fulls' precision-weighted typical scale
+    // sat on such frames and the floor dropped three quarters of every live frame's fulls.
     std::vector<double> fitted;
     fitted.reserve(n);
     for (int f = 0; f < n; ++f)
@@ -3256,6 +3295,7 @@ bool RotationScaleMerge::DropCollapsedFullScales(bool from_staging) {
                 && o.corr != 1.0f)
                 g_frame[o.frame] = 1.0 / static_cast<double>(o.corr);
 
+    // The median, not the precision-weighted typical frame - see DropCollapsedScales.
     std::vector<double> fitted;
     fitted.reserve(g_frame.size());
     for (const double gf : g_frame)
@@ -4834,14 +4874,13 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     // --- 2a'. Search pass only: drop the frames the crystal barely diffracted on, whose 1/G would
     //          amplify their intensities into a P1 merge with no multiplicity to catch them. ---
     if (for_search) {
-        std::vector<double> fitted;
+        std::vector<int64_t> n_obs(n_frames, 0);
         for (int f = 0; f < n_frames; ++f)
             if (frame_scaled_scratch[f] && std::isfinite(g_partial[f]) && g_partial[f] > 0.0)
-                fitted.push_back(g_partial[f]);
-        if (!fitted.empty()) {
-            const size_t mid = fitted.size() / 2;
-            std::nth_element(fitted.begin(), fitted.begin() + mid, fitted.end());
-            const double floor_g = fitted[mid] * SEARCH_MIN_SCALE_RATIO;
+                n_obs[f] = frame_count[f];
+        if (std::any_of(n_obs.begin(), n_obs.end(), [](int64_t c) { return c > 0; })) {
+            // Against the precision-weighted typical frame - see MeasureSweepQuality.
+            const double floor_g = TypicalFrameScale(g_partial, n_obs) * SEARCH_MIN_SCALE_RATIO;
             std::vector<uint8_t> reject(n_frames, 0);
             int n_rejected = 0;
             for (int f = 0; f < n_frames; ++f)
@@ -4865,7 +4904,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
                             if (reject[partials[i].frame]) partials[i].corr = 0.0f;
                     });
                 logger.Info("Space-group search: ignoring {} of {} frames whose scale came out below "
-                            "1/{:.0f} of the run median (the crystal barely diffracted there)",
+                            "1/{:.0f} of the run's typical frame (the crystal barely diffracted there)",
                             n_rejected, n_frames, 1.0 / SEARCH_MIN_SCALE_RATIO);
             }
         }
-- 
2.54.0


From 1149c541fca7aa3db46ea7029798c6d4e7815e0c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 08:47:24 +0200
Subject: [PATCH 067/122] rugnux: the distance arm is decided on probes, not on
 written passes

Where the pre-pass cannot tell whether its distance move paid, the two hypotheses were judged by
running each one as a full canonical pass - scaling, space-group search, correction surfaces,
every merge, the model step and the output files - although the comparison reads exactly one
number from each: the held-out residual the post-refinement measures right after integration,
before the scaling engine is even built. Where the header arm won, a third full pass then
reproduced the second's numbers digit for digit to write the files.

Both arms are now measured before the canonical pass by passes that stop as soon as that
post-refinement has measured, and only the arm that wins is run as a canonical pass. So a run
that takes the arm pays two image loops plus one canonical pass instead of two or three
canonical passes.

Result-neutral by construction - the residuals compared, the comparison, the geometry adopted
and the pass that writes are unchanged. Verified byte-identical p.mtz, p.hkl, p.cif and p_P1.mtz,
and identical reports bar the command line and the clock, on eight rotation datasets covering
both arms (seven where the header wins, one where the post-refined distance does).

Measured on the datasets whose logs show the arm: it takes an open-arm corpus pass from 261 to
218 minutes, the in-house arm from 25 to 22 and the private arm from 24 to 19, with the worst
single set going 594 -> 316 s.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 187 +++++++++++++++++++++++++---------------------
 rugnux/Rugnux.h   |   6 ++
 2 files changed, 109 insertions(+), 84 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 1e353fcb7..789718e9b 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -2060,12 +2060,100 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
         // Let every refined pass from here on ask the quality guard's question of itself, so one that
         // is going to be thrown away can skip the report and the files it would have superseded.
         quality_guard_pass1_ = pass1;
-        logger.Info("Rotation two-pass geometry post-refinement: second pass (refined geometry, canonical) -> {}_*",
-                    base_prefix);
         config_.output_prefix = base_prefix;   // the refined pass is the canonical result (no _02 suffix)
         // The canonical pass measures the post-refinement again where the pre-pass moved the geometry
         // (it applies nothing), so that the walk below has something to decide on.
         postrefine_probe_ = prepass_detector_geometry_.has_value();
+
+        const auto current_geometry = [&] {
+            return std::array<float, 5>{experiment_.GetBeamX_pxl(), experiment_.GetBeamY_pxl(),
+                                        experiment_.GetDetectorDistance_mm(),
+                                        experiment_.GetPoniRot1_rad(), experiment_.GetPoniRot2_rad()};
+        };
+        const auto set_geometry = [&](const std::array<float, 5> &g) {
+            experiment_.BeamX_pxl(g[0]).BeamY_pxl(g[1]).DetectorDistance_mm(g[2])
+                       .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
+        };
+
+        // Where the pre-pass could not tell whether its distance move paid (held_arm_beam_px: the
+        // free distance lowered the fit's own held-out residual by less than that residual's noise),
+        // the other hypothesis - the header distance, with the beam the same fit found there - is
+        // measured too, and the two are judged on what they REALISE: the held-out residual a pass
+        // re-integrated and re-indexed at that geometry measures there, the comparison the walk below
+        // makes between its rounds. Where the free arm wins the run goes on at the post-refined
+        // distance; where the header's wins, or the two cannot be told apart, the header's stands -
+        // it is the hypothesis that asserts nothing, so a tie is its - and the distance walk below is
+        // not entered: the data have just said they cannot place the distance. Measured on a sweep at
+        // 820 mm reaching 2theta ~ 9 deg, where the fit's own gain never realises: the free arm's
+        // re-integrated residual sat within 0.6 % of the header's at a noise of 8 %, and the cell it
+        // carried was 1 % too large. On a sweep at 110 mm reaching 57 deg, a 0.14 % distance move the
+        // pre-pass could not decide realised 3.7 % against a noise of 1.5 %, and the cell it carried
+        // matched the reference to 0.04 %.
+        //
+        // Both arms are measured BEFORE the canonical pass, by passes that stop as soon as the
+        // post-refinement has measured (postrefine_probe_only_). The residual is all the comparison
+        // reads, and it is in hand before the scaling engine is built, so neither arm pays for a
+        // merge, a space-group search or a set of correction surfaces - and only the arm that wins is
+        // ever run as a canonical pass. Judging the arms on written passes instead cost the loser's
+        // whole pass and, where the header won, a third pass that reproduced the loser's numbers
+        // digit for digit.
+        std::string distance_arm;     // the arm decision, for the pass decision text
+        bool distance_arm_kept_header = false;
+        int arm_passes = 0;
+        if (!cancelled_ && prepass_detector_geometry_ && pass1.post_refine
+            && pass1.post_refine->held_arm_beam_px) {
+            const std::array<float, 5> free_geometry = current_geometry();
+            std::array<float, 5> held_geometry = free_geometry;
+            held_geometry[0] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[0]);
+            held_geometry[1] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[1]);
+            held_geometry[2] = header_geometry[2];
+            logger.Info("Two-pass: the pre-pass could not tell whether moving the distance {:.3f} -> {:.3f} mm "
+                        "paid, so the header distance is re-integrated as well and the two are "
+                        "judged on the held-out residual each realises", header_geometry[2],
+                        free_geometry[2]);
+            postrefine_probe_only_ = true;
+            const auto free_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
+            ++arm_passes;
+            set_geometry(held_geometry);
+            const auto held_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
+            ++arm_passes;
+            postrefine_probe_only_ = false;
+            const double realised_free = free_arm.post_refine ? free_arm.post_refine->held_out_before : NAN;
+            const double realised_held = held_arm.post_refine ? held_arm.post_refine->held_out_before : NAN;
+            const double se_free = free_arm.post_refine ? free_arm.post_refine->held_out_before_se : NAN;
+            const double se_held = held_arm.post_refine ? held_arm.post_refine->held_out_before_se : NAN;
+            if (!cancelled_ && free_arm.post_refine && held_arm.post_refine
+                && HeldOutResidualFell(*held_arm.post_refine, *free_arm.post_refine)) {
+                logger.Info("Two-pass: re-integrated at the post-refined distance {:.3f} mm the held-out "
+                            "residual is {:.3e} against {:.3e} at the header's {:.3f} mm (standard errors "
+                            "{:.1e} and {:.1e}) - the move is realised and stands", free_geometry[2],
+                            realised_free, realised_held, held_geometry[2], se_free, se_held);
+                set_geometry(free_geometry);
+                distance_arm = fmt::format(
+                        "the header distance {:.3f} mm was run as well and realised a held-out residual of "
+                        "{:.3e} against {:.3e} at the post-refined {:.3f} mm, so the post-refined distance "
+                        "stands", held_geometry[2], realised_held, realised_free, free_geometry[2]);
+            } else if (!cancelled_) {
+                logger.Info("Two-pass: re-integrated at the header distance {:.3f} mm the held-out residual "
+                            "is {:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}; standard "
+                            "errors {:.1e} and {:.1e}) - these data do not determine the distance, and the "
+                            "header's stands", held_geometry[2], realised_held, free_geometry[2],
+                            realised_free, se_held, se_free);
+                distance_arm_kept_header = true;
+                pass1.post_refine->distance_held = true;
+                pass1.post_refine->beam_x_after_px = held_geometry[0];
+                pass1.post_refine->beam_y_after_px = held_geometry[1];
+                pass1.post_refine->distance_after_mm = held_geometry[2];
+                distance_arm = fmt::format(
+                        "the header distance {:.3f} mm kept: re-integrated there the held-out residual is "
+                        "{:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}), so these data do "
+                        "not determine the distance", held_geometry[2], realised_held, free_geometry[2],
+                        realised_free);
+            }
+        }
+
+        logger.Info("Rotation two-pass geometry post-refinement: second pass (refined geometry, canonical) -> {}_*",
+                    base_prefix);
         auto pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
 
         // Walk the geometry to the fit's fixed point. The post-refinement is fitted to reflections
@@ -2099,87 +2187,6 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
         // last - and says it did not converge; the quality guard below judges it against the header
         // pass as it judges every refined pass.
         constexpr int MAX_GEOMETRY_ROUNDS = 8;
-        const auto current_geometry = [&] {
-            return std::array<float, 5>{experiment_.GetBeamX_pxl(), experiment_.GetBeamY_pxl(),
-                                        experiment_.GetDetectorDistance_mm(),
-                                        experiment_.GetPoniRot1_rad(), experiment_.GetPoniRot2_rad()};
-        };
-        const auto set_geometry = [&](const std::array<float, 5> &g) {
-            experiment_.BeamX_pxl(g[0]).BeamY_pxl(g[1]).DetectorDistance_mm(g[2])
-                       .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
-        };
-
-        // Where the pre-pass could not tell whether its distance move paid (held_arm_beam_px: the
-        // free distance lowered the fit's own held-out residual by less than that residual's noise),
-        // the other hypothesis - the header distance, with the beam the same fit found there - is run
-        // as a canonical pass of its own, and the two are judged on what they REALISE: the held-out
-        // residual each re-integrated pass measures at its own geometry, the comparison the walk
-        // below makes between its rounds. The free arm ran first and wrote the canonical files, so
-        // where it wins nothing is re-run; where the header's wins, or the two cannot be told apart,
-        // the header's is re-run to write them - it is the hypothesis that asserts nothing, so a tie
-        // is its, and the distance walk below is not entered: the data have just said they cannot
-        // place the distance. Measured on a sweep at 820 mm reaching 2theta ~ 9 deg, where the fit's
-        // own gain never realises: the free arm's re-integrated residual sat within 0.6 % of the
-        // header's at a noise of 8 %, and the cell it carried was 1 % too large. On a sweep at 110 mm
-        // reaching 57 deg, a 0.14 % distance move the pre-pass could not decide realised 3.7 %
-        // against a noise of 1.5 %, and the cell it carried matched the reference to 0.04 %.
-        std::string distance_arm;     // the arm decision, for the pass decision text
-        bool distance_arm_kept_header = false;
-        int arm_passes = 0;
-        if (!cancelled_ && prepass_detector_geometry_ && pass1.post_refine
-            && pass1.post_refine->held_arm_beam_px && pass2.post_refine) {
-            const std::array<float, 5> free_geometry = current_geometry();
-            std::array<float, 5> held_geometry = free_geometry;
-            held_geometry[0] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[0]);
-            held_geometry[1] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[1]);
-            held_geometry[2] = header_geometry[2];
-            logger.Info("Two-pass: the pre-pass could not tell whether moving the distance {:.3f} -> {:.3f} mm "
-                        "paid, so the canonical pass runs at the header distance as well and the two are "
-                        "judged on the held-out residual each realises", header_geometry[2],
-                        free_geometry[2]);
-            // The pass at the header distance measures its own post-refinement and integration, and
-            // neither may replace the free pass's where the free pass is the one kept.
-            const auto free_wish = prepass_detector_geometry_;
-            const auto free_starved = bkg_starved_fraction_;
-            set_geometry(held_geometry);
-            auto held = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
-            ++arm_passes;
-            const double realised_free = pass2.post_refine->held_out_before;
-            const double realised_held = held.post_refine ? held.post_refine->held_out_before : NAN;
-            const double se_free = pass2.post_refine->held_out_before_se;
-            const double se_held = held.post_refine ? held.post_refine->held_out_before_se : NAN;
-            if (!cancelled_ && held.post_refine && HeldOutResidualFell(*held.post_refine, *pass2.post_refine)) {
-                logger.Info("Two-pass: re-integrated at the post-refined distance {:.3f} mm the held-out "
-                            "residual is {:.3e} against {:.3e} at the header's {:.3f} mm (standard errors "
-                            "{:.1e} and {:.1e}) - the move is realised and stands", free_geometry[2],
-                            realised_free, realised_held, held_geometry[2], se_free, se_held);
-                set_geometry(free_geometry);
-                prepass_detector_geometry_ = free_wish;
-                bkg_starved_fraction_ = free_starved;
-                distance_arm = fmt::format(
-                        "the header distance {:.3f} mm was run as well and realised a held-out residual of "
-                        "{:.3e} against {:.3e} at the post-refined {:.3f} mm, so the post-refined distance "
-                        "stands", held_geometry[2], realised_held, realised_free, free_geometry[2]);
-            } else if (!cancelled_) {
-                logger.Info("Two-pass: re-integrated at the header distance {:.3f} mm the held-out residual "
-                            "is {:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}; standard "
-                            "errors {:.1e} and {:.1e}) - these data do not determine the distance, and the "
-                            "header's stands", held_geometry[2], realised_held, free_geometry[2],
-                            realised_free, se_held, se_free);
-                pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
-                ++arm_passes;
-                distance_arm_kept_header = true;
-                pass1.post_refine->distance_held = true;
-                pass1.post_refine->beam_x_after_px = held_geometry[0];
-                pass1.post_refine->beam_y_after_px = held_geometry[1];
-                pass1.post_refine->distance_after_mm = held_geometry[2];
-                distance_arm = fmt::format(
-                        "the header distance {:.3f} mm kept: re-integrated there the held-out residual is "
-                        "{:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}), so these data do "
-                        "not determine the distance", held_geometry[2], realised_held, free_geometry[2],
-                        realised_free);
-            }
-        }
         int geometry_rounds = 0;      // passes run at a geometry the walk moved to
         int walk_passes = 0;          // every pass the walk ran, the return to its best round included
         int best_round = 0;
@@ -5267,8 +5274,20 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // before the engine is built rather than beside it - the gathered observations and their
         // rocking events are gigabytes on a long axis, and beside the engine's own arrays they set
         // the pass's memory high-water mark.
-        if (postrefine_probe_ && !geometry_prepass && is_rotation)
+        if (postrefine_probe_ && !geometry_prepass && is_rotation) {
             post_refine_geometry();
+            // A pass the distance arm runs to compare two geometries has now produced the only thing
+            // the comparison reads - the held-out residual of the fit just measured. Stop here rather
+            // than scale, search, fit surfaces and merge for a result nothing looks at.
+            if (postrefine_probe_only_) {
+                result.processing_time_s = std::chrono::duration<double>(
+                        std::chrono::steady_clock::now() - start_time).count();
+                logger.Info("Distance-arm probe: {} images integrated and post-refined in {:.2f} s "
+                            "(the arm reads the held-out residual only, so this pass does not merge)",
+                            result.images_processed, result.processing_time_s);
+                return result;
+            }
+        }
         if (is_rotation) {
             if (experiment_.GetRefineRotationWedgeInScaling()
                 || rot_ss.GetRotationWedgeForScaling().has_value())
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 32441c661..6f8fe4f7c 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -555,6 +555,12 @@ class Rugnux {
     // whether it has finished walking is a question only reflections integrated after the move can
     // answer; RunAllPasses turns this on for the passes that answer it.
     bool postrefine_probe_ = false;
+    // Whether such a pass exists ONLY for that measurement. The distance arm reads the held-out
+    // residual the probe returns and nothing else, so a pass run for it stops as soon as the probe
+    // has measured - which is before the scaling engine is built. Everything below that point (the
+    // merges, the space-group search, the correction surfaces, the reports) is work no comparison
+    // looks at, and on a long sweep it is four fifths of the pass.
+    bool postrefine_probe_only_ = false;
 
     // Pre-scan: read a spread sample of frames and take three things off them - the shadow of the beam
     // stop and its holder, added to the pixel mask (config_.detect_beam_stop), the beam centre
-- 
2.54.0


From eb6589f6473431d25b244c5cec045ffe4e249d00 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sat, 19 Sep 2026 23:22:12 +0200
Subject: [PATCH 068/122] rugnux: sixteen-bit Miller indices in the ingest sort
 key and the post-refine partial

Both arrays are one record per integrated observation - tens of millions on a fine-sliced long axis,
gigabytes each - and both carry the raw hkl only to sort and group on. A Miller index needs sixteen
bits (|h| <= a / d_min, in the hundreds even on the longest axis at atomic resolution), which takes
the ingest sort key from 24 to 20 bytes and the post-refine partial from 32 to 28.

Same comparisons, same order; merged output byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/geom_refinement/PostRefine.cpp     | 4 +++-
 image_analysis/geom_refinement/PostRefine.h       | 5 ++++-
 image_analysis/scale_merge/RotationScaleMerge.cpp | 3 ++-
 image_analysis/scale_merge/RotationScaleMerge.h   | 8 +++++---
 4 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index 4ad21536e..3d80f578e 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -219,7 +219,9 @@ PostRefineObservations GatherPostRefineObservations(std::vector<IntegrationOutco
                     if (!std::isfinite(r.I) || !std::isfinite(r.sigma) || r.sigma <= 0.0f) continue;
                     const float ox = std::isfinite(r.observed_x) ? r.observed_x : NAN;
                     const float oy = std::isfinite(r.observed_y) ? r.observed_y : NAN;
-                    pts[fill[r.h - h_lo]++] = Partial{r.h, r.k, r.l, r.image_number, r.I, r.sigma, ox, oy};
+                    pts[fill[r.h - h_lo]++] = Partial{static_cast<int16_t>(r.h), static_cast<int16_t>(r.k),
+                                                      static_cast<int16_t>(r.l), r.image_number,
+                                                      r.I, r.sigma, ox, oy};
                 }
                 // The caller said it will never read this image's reflections again, so hand the
                 // vector back the moment it is consumed: the payload shrinks image by image as it
diff --git a/image_analysis/geom_refinement/PostRefine.h b/image_analysis/geom_refinement/PostRefine.h
index b6f20833c..15d1ff4ac 100644
--- a/image_analysis/geom_refinement/PostRefine.h
+++ b/image_analysis/geom_refinement/PostRefine.h
@@ -94,7 +94,10 @@ struct PostRefineSettings {
 // per-bucket sort move all of it. The goniometer angle is not stored - it is a function of the
 // image number alone, and is rebuilt from it where it is needed.
 struct PostRefinePartial {
-    int h, k, l;
+    // Sixteen bits are plenty for a Miller index - |h| <= a / d_min, in the hundreds even on the
+    // longest axis at atomic resolution - and here four bytes of every partial are four bytes of an
+    // array that is gigabytes on a large cell.
+    int16_t h, k, l;
     float img;
     float I, sigma;
     float obs_x, obs_y;  // observed spot centroid (pixels); NAN if the box sum found no centroid
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 93c39fea9..13e526acf 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -432,7 +432,8 @@ void RotationScaleMerge::Ingest() {
             for (int o = lo; o < hi; ++o) {
                 int32_t at = src_start[o];
                 for (const auto &r : partials_out[o].reflections) {
-                    keys[fill[r.h - h_min]++] = SortKey{r.h, r.k, r.l, r.image_number, at, r.d};
+                    keys[fill[r.h - h_min]++] = SortKey{static_cast<int16_t>(r.h), static_cast<int16_t>(r.k),
+                                                        static_cast<int16_t>(r.l), r.image_number, at, r.d};
                     ++at;
                 }
             }
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 5fd1e8ca8..5731f5c11 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -142,10 +142,12 @@ private:
 
     // The narrow per-observation record the ingest sort orders: the raw hkl the runs are cut on, the
     // frame position that breaks a tie inside one, the observation's own index (which makes the order
-    // total - see the .cpp), and the resolution the range test reads. Twenty-four bytes against the
-    // Obs's eighty, and it is all the ingest needs before it knows which observations survive.
+    // total - see the .cpp), and the resolution the range test reads. Twenty bytes against the Obs's
+    // eighty, and it is all the ingest needs before it knows which observations survive. Sixteen bits
+    // are plenty for a Miller index - |h| <= a / d_min, in the hundreds even on the longest axis at
+    // atomic resolution - and on a long axis this array sets the sort's memory high-water mark.
     struct SortKey {
-        int32_t h, k, l;
+        int16_t h, k, l;
         float image_number;
         int32_t idx;
         float d;
-- 
2.54.0


From bac2d01c44a36dba028bf15966aa098a054f635a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 08:17:48 +0200
Subject: [PATCH 069/122] Space group: a screw zone's evidence no longer hangs
 on its largest absence

A screw's predicted-absent class is one axial row - half a dozen to a few dozen
reflections - and its evidence is a SUM over them, so it is decided by its
largest member. The file's own LIMIT comment said so; 7n2s is that limit firing
on real data. Between two scaling passes that differed only in which weak frames
were rejected, one of eight dead 0k0 moved from 14 +- 9 to 99 +- 10 while the
other seven did not move at all, and the zone fell from 30.1 nats to 17.1 and
lost the 2(1) under a bound of 20. That reflection was never measured to the
precision its sigma claimed: its two half-set merges read 198 and 2.5.

The zone's sum is now taken with its single largest member dropped and rescaled
for the trim - divided by n - H_n, the expected sum of the other n-1 under the
null, and multiplied back by n. ScrewZoneEvidence reads the result exactly as
before: same statistic, same floor, same bound, same calibration, with a robust
estimate of the zone's deadness in place of a fragile one. One member only,
whatever the zone holds: a zone with two strong absences is a zone that is not
extinct. On a uniformly dead zone the rescale under-states by 2.2 nats at eight
absences and 3.9 at sixty-four - it only ever refuses, never claims. Glide zones
keep the untrimmed sum: a plane holds hundreds to thousands of reflections and
no single one can carry the verdict.

7n2s -> P 1 21 1 (zone 27.6 nats, set by the seven reflections that did not
move), matching its deposit; a second monoclinic crystal decided six nats under
the bound (7 absent, 1 violation, 13.9 nats) reaches 21.9 and its 2(1) as well.
Unchanged on 7mzt, 7k1l, 11if, 9hs7, 9zlo and four in-house reference sets.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/SearchSpaceGroup.cpp          | 44 +++++++++++++++++--
 image_analysis/scale_merge/SearchSpaceGroup.h | 11 +++++
 tests/SearchSpaceGroupTest.cpp                | 31 +++++++++++++
 3 files changed, 82 insertions(+), 4 deletions(-)

diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index 3de94bdc8..9f33bf808 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -960,6 +960,38 @@ double ScrewZoneEvidence(double sum_u, int n_absent) {
     return -a * std::log(u) + std::lgamma(a + 1);
 }
 
+// The LIMIT above, answered where it arises: the zone's sum with its single largest member dropped,
+// rescaled so the result still estimates the same quantity. Under the null the u are Exp(1) and
+// E[max] = H_n = 1 + 1/2 + ... + 1/n, so the remaining n-1 of them sum to n - H_n in expectation and
+// dividing by that recovers the mean the whole sum would have given. Multiplying back by n leaves a
+// number ScrewZoneEvidence reads exactly as before - same statistic, same floor, same calibration,
+// with a robust estimate of the zone's deadness in place of a fragile one.
+//
+// A screw row is half a dozen to a few dozen reflections, so ONE of them at a third of its row moves
+// the zone by more than the other seven put together. Measured on a monoclinic crystal whose eight
+// absent 0k0 are dead in every run: between two scaling passes that differed only in which weak
+// frames were rejected, one of those eight moved from 14 +- 9 to 99 +- 10 while the other seven did
+// not move at all, and the zone went from 30.1 nats to 17.1 and lost the 2(1) under a bound of 20.
+// The two half-set merges of that one reflection read 198 and 2.5 in the second pass, i.e. it was
+// never measured to the precision its sigma claimed - but no sigma is read here, on purpose (see
+// min_screw_absence_evidence), so the defence has to be the estimator. Trimmed, that zone reads 27.6
+// nats on the pass that had lost it, set by the seven reflections that did not move.
+//
+// ONE member, whatever the zone's size: a zone with two strong absences is not a zone with a bad
+// reflection in it, it is a zone that is not extinct, and trimming further would hide that. What
+// this costs a genuinely uniform zone is that the estimate is biased high by (n-1)/(n - H_n), i.e.
+// the evidence is UNDER-stated by n*log of that - 2.2 nats on a zone of eight, 3.9 on one of
+// sixty-four. It only ever refuses, never claims.
+double TrimmedZoneSum(double sum_u, double max_u, int n_absent) {
+    if (n_absent < 2)
+        return sum_u;
+    double harmonic = 0.0;
+    for (int i = 1; i <= n_absent; ++i)
+        harmonic += 1.0 / i;
+    const double expected_remaining = n_absent - harmonic;   // > 0 for every n >= 2
+    return n_absent * std::max(0.0, sum_u - max_u) / expected_remaining;
+}
+
 SearchSpaceGroupResult SearchSpaceGroup(
     const std::vector<MergedReflection>& merged,
     const SearchSpaceGroupOptions& opt) {
@@ -1937,7 +1969,8 @@ SearchSpaceGroupResult SearchSpaceGroup(
         // row with no control class of its own cannot say whether its absences are weak or its whole
         // row is, so it contributes no evidence either way rather than being judged against the shell
         // mean; it is carried as an undetermined zone so the report can say so.
-        struct ZoneSums { double sum_u = 0; int n_absent = 0; int n_control = 0; int n_violations = 0; };
+        struct ZoneSums { double sum_u = 0; double max_u = 0; int n_absent = 0; int n_control = 0;
+                          int n_violations = 0; };
         std::map<AxialRow, ZoneSums> zones;
         for (const auto& a : screw_absent_refl) {
             const auto it = row_median.find(a.row);
@@ -1964,7 +1997,9 @@ SearchSpaceGroupResult SearchSpaceGroup(
             }
             const auto mit = row_mean.find(a.row);
             if (mit != row_mean.end() && mit->second > 0.0) {
-                z.sum_u += std::max(0.0, a.e_squared_expected) / mit->second;
+                const double u = std::max(0.0, a.e_squared_expected) / mit->second;
+                z.sum_u += u;
+                z.max_u = std::max(z.max_u, u);
                 z.n_control = static_cast<int>(row_present_esq.at(a.row).size());
             }
         }
@@ -2008,10 +2043,11 @@ SearchSpaceGroupResult SearchSpaceGroup(
         constexpr double SCREW_DEFERRAL_MIN_EVIDENCE_PER_ABSENT = 1.0;
         bool screw_deferral_ok = true;
         for (const auto& [row, z] : zones) {
-            const double ev = z.n_control > 0 ? ScrewZoneEvidence(z.sum_u, z.n_absent) : 0.0;
+            const double sum_u = TrimmedZoneSum(z.sum_u, z.max_u, z.n_absent);
+            const double ev = z.n_control > 0 ? ScrewZoneEvidence(sum_u, z.n_absent) : 0.0;
             s.screw_zones.push_back({row, z.n_absent, z.n_control, ev});
             if (z.n_control > 0) {
-                screw_sum_u += z.sum_u;
+                screw_sum_u += sum_u;
                 screw_scored += z.n_absent;
                 best_zone_evidence = std::max(best_zone_evidence, ev);
             }
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index c9d291b04..5dcef8b99 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -155,6 +155,13 @@ double AbsenceEvidence(double sum_u, int n_absent, int n_control);
 // candidate's absences could score lower. See SearchSpaceGroup.cpp.
 double ScrewZoneEvidence(double sum_u, int n_absent);
 
+// A screw zone's sum with its single largest member dropped and rescaled to estimate the same
+// quantity (dividing by n - H_n, the expected sum of the other n-1 under the null, and multiplying
+// by n). ScrewZoneEvidence is a sum, so it is dominated by the largest one or two members of a class
+// that holds only a handful of reflections, and a zone's verdict could hang on one reflection whose
+// merged value moved with the scaling. See SearchSpaceGroup.cpp.
+double TrimmedZoneSum(double sum_u, double max_u, int n_absent);
+
 struct SearchSpaceGroupOptions {
     // Lattice (metric) symmetry from LatticeSearch. When set, the point-group search is limited to
     // the Sohncke subgroups of this system's holohedry - the metric is an upper bound on the
@@ -527,6 +534,10 @@ struct SearchSpaceGroupOptions {
     // with I, reading much the same on an absent reflection as on a present one (the <I/s> columns of
     // the candidate table show this directly).
     //
+    // The zone's sum is taken with its largest member trimmed (TrimmedZoneSum), because a sum over
+    // half a dozen reflections is otherwise decided by its largest one and moved tens of nats by any
+    // upstream change that moves that one reflection.
+    //
     // Measured over the probe crystals, an adopted screw reads 24-600 nats and the false ones (the
     // 4_1/4_3 conditions of a crystal that has no screw at all, whose predicted-absent class is as
     // strong as its control row) read -3.8 to -38.5. The bound sits in that gap - loose enough that
diff --git a/tests/SearchSpaceGroupTest.cpp b/tests/SearchSpaceGroupTest.cpp
index 2e6361d8e..0b1257926 100644
--- a/tests/SearchSpaceGroupTest.cpp
+++ b/tests/SearchSpaceGroupTest.cpp
@@ -499,6 +499,37 @@ TEST_CASE("SearchSpaceGroup does not promote triclinic data on a pseudo-orthorho
     CHECK(result.point_group_order == 1);
 }
 
+// A screw zone is a handful of axial reflections and its evidence is a SUM over them, so it is
+// decided by its largest member. Measured on a monoclinic crystal whose eight absent 0k0 are dead in
+// every run: between two scaling passes that differed only in which weak frames were rejected, ONE
+// of the eight moved from 14 +- 9 to 99 +- 10 (its two half-set merges reading 198 and 2.5, so it
+// was never measured to the precision its sigma claimed) while the other seven did not move at all -
+// and the zone went from 30.1 nats to 17.1 and lost the 2(1) under a bound of 20. Trimming the
+// largest member and rescaling for the trim makes the two passes agree.
+TEST_CASE("A screw zone's evidence does not hang on its largest absence", "[SearchSpaceGroup]") {
+    // Seven reflections at a hundredth of their row, and one that moved between the two passes.
+    const double dead_seven = 7 * 0.01;
+    const double before = ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.03, 0.03, 8), 8);
+    const double after = ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.39, 0.39, 8), 8);
+
+    CHECK(before == Catch::Approx(after).margin(0.01));   // the same seven reflections, the same verdict
+    CHECK(after > 20.0);                                  // and the screw survives the move
+    // Untrimmed, that one reflection is the whole difference and it crosses the bound.
+    CHECK(ScrewZoneEvidence(dead_seven + 0.03, 8) > 20.0);
+    CHECK(ScrewZoneEvidence(dead_seven + 0.39, 8) < 20.0);
+
+    // Only ONE member is trimmed, whatever the zone holds: a zone with two strong absences is not a
+    // zone with a bad reflection in it, it is a zone that is not extinct.
+    CHECK(ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.39 + 0.39, 0.39, 8), 8) < 20.0);
+
+    // On a uniform zone the rescale under-states rather than over-states - the safe direction.
+    CHECK(ScrewZoneEvidence(TrimmedZoneSum(8 * 0.01, 0.01, 8), 8) <
+          ScrewZoneEvidence(8 * 0.01, 8));
+    // A class that merged non-positive throughout is unchanged: sum and max are both zero, so the
+    // floor in ScrewZoneEvidence is what answers, exactly as before.
+    CHECK(TrimmedZoneSum(0.0, 0.0, 8) == 0.0);
+}
+
 // A zone whose predicted absences were never measurable must not outscore a zone that is genuinely
 // dead. sum_u is a sum of max(0, E^2)/row_mean, so it is EXACTLY zero when every absent reflection in
 // the zone merged non-positive - and the Beta tail then diverges, worth ~690 nats per reflection. That
-- 
2.54.0


From 40874c2c2dc4da9f15aa89d30fdc60745087fef4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 08:51:02 +0200
Subject: [PATCH 070/122] Space-group search: the twin-immune zone is read on a
 normalisation the control certifies

The zone verdict that arbitrates a refused promotion read its zone absolutely, against the
centric and acentric Wilson expectations, and an absolute reading is only as good as the
normalisation under it. On two refused 622 promotions - a 6/m crystal and a 312 one, whose added
operators disagreed at 4.7x and 5.2x the parent's H and merged to an R_meas of 0.34 under the
higher group - every class read centric: a 67 A^2 anisotropy, isotropically normalised in bins
of 100, spread one shell's expected intensity over a factor of 15 between its directions, and
the acentric control read 1.00 against its 0.74. The zone read the same as the control, +0.10
nats per reflection, and +124 nats over 947 reflections rescued a twin law.

Two things change. The anisotropy is fitted on the acentric reflections of the shells read
(ln I = c + s^T Q s, by least squares) and its deviatoric part taken out of every intensity
before anything is normalised; that alone brings the controls of the crystals measured to
0.73-0.77. What no normalisation removes, the control then certifies: an acentric population
reads -0.130 nats per reflection when the normalisation is right, a twinned one reads below
that, so whatever the control reads above it is the normalisation's - anisotropy, a
pseudo-translation, a pseudo-centring, noise all inflate every class towards centric alike -
and the zone, normalised the same way, carries the same per reflection; the calibrated evidence
has it taken off, and that is what the verdict reads. The two rescued twin laws now read -130
and -78 nats and stay refused, with the law named; the genuine promotions measured read +137 to
+580 (a pseudo-centred orthorhombic crystal whose control reads 0.99 still +334); the trigonal
and hexagonal partial twins -129 to -420 as before. The report prints the control's excess and
the calibrated evidence beside the raw one.

The metric-lattice re-ask carried a second copy of the two-arm rule without the zone: a P31
partial twin whose 32 the main rule had refused on the zone was promoted by that ask's
Lorentz-filtered arm. It now puts the same verdict to a refusal the other arm would outvote.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CPU_DATA_ANALYSIS_DECISIONS.md           |   4 +-
 .../scale_merge/TwinningAnalysis.cpp          | 159 ++++++++++++++----
 image_analysis/scale_merge/TwinningAnalysis.h |  26 ++-
 rugnux/ResultReport.cpp                       |   3 +-
 rugnux/Rugnux.cpp                             |  70 ++++++--
 tests/TwinningAnalysisTest.cpp                |  70 +++++++-
 6 files changed, 267 insertions(+), 65 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_DECISIONS.md b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
index 8718102f0..ecc059048 100644
--- a/docs/CPU_DATA_ANALYSIS_DECISIONS.md
+++ b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
@@ -46,7 +46,7 @@ Both search merges also drop the **frames whose fitted per-frame scale came out
 
 **Centering** is accepted when the systematically-absent class is weak relative to the present one by *either* of two floor-independent tests: its mean signed $I/\sigma$ well below the present mean, *or* its rate of individually-significant reflections well below the present class's own significant rate. The second test covers weak and low-energy data, where a positive intensity floor (background and profile leakage) lifts the absent class's mean $I/\sigma$ well above zero and, when the present class is itself weak, carries the plain mean ratio past its bound; a false centering fails both tests, its absent class being as strong as the present one. When several centerings pass they are ranked by a **Beta-tail likelihood** rather than by a count of net absences: a count lets a centering that extinguishes many more reflections out-rank one that violates far fewer, and the likelihood weighs the violations against the class each belongs to instead. The acceptance bounds above are unchanged by that ranking.
 
-**A confirmed promotion that is refused is decided by merging under it.** Every gate that refuses a *confirmed* higher point group is a **ratio** — the added operators' disagreement against the parent's, or their $R$ against the best-agreeing operator anywhere — and both references are properties of how the crystal was mounted rather than of its symmetry. A 2-fold within a degree of the spindle records its mates on the same detector pixel half a turn later, so it carries no geometry-dependent systematic at all, and by being that clean it makes every other operator look bad against it; the best-agreeing operator can also be one of the operators under test, which collapses the ratio on worse data and raises it on better. So where a promotion is confirmed and then refused, the **merge** is asked instead of the ratio. Both groups are scaled and merged over one pinned resolution range — the adopted group's own cut — and the promotion is taken only if **neither $R_\mathrm{meas}$ nor ISa gets worse**. $R_\mathrm{meas}$ is multiplicity-corrected, so folding non-equivalent reflections together has to inflate it, and the error model is refitted per merge, so ISa says whether the extra multiplicity was bought with systematic disagreement. $CC_{1/2}$ and $\langle I/\sigma\rangle$ cannot arbitrate this: both *rise* on a false promotion too. Two details the comparison turns on: the refused point group's representative is primitive and symmorphic, so the arm merged under it takes the **adopted group's centring** — merged in the bare representative, a centred crystal is handed its centring-absent class as data, which inverts the decision — and the absence stage is asked of the adopted merge, so both arms carry the same absence classes and differ by the added rotations alone. The cost is two extra merges, and only on a run that records a refusal, which is a few in a hundred.
+**A confirmed promotion that is refused is decided by the twin-immune zone of its added operators, and only where that is undecided by merging under it.** The zone (§13.2) is the one reading that does not depend on the per-frame scales or on a reference operator: read on the all-observation P1 merge where the two search arms disagree, and on the adopted group's own merge at the remerge, an index-2 promotion whose calibrated zone evidence is acentric by 20 nats stays refused — on all observations, and the first added operator is recorded as the twin law — and one whose zone is centric by 20 nats is taken. Where the zone cannot decide (a higher index, no zone reflections in the shells with signal, within the margin), the merge is asked. Every gate that refuses a *confirmed* higher point group is a **ratio** — the added operators' disagreement against the parent's, or their $R$ against the best-agreeing operator anywhere — and both references are properties of how the crystal was mounted rather than of its symmetry. A 2-fold within a degree of the spindle records its mates on the same detector pixel half a turn later, so it carries no geometry-dependent systematic at all, and by being that clean it makes every other operator look bad against it; the best-agreeing operator can also be one of the operators under test, which collapses the ratio on worse data and raises it on better. So where a promotion is confirmed and then refused, the **merge** is asked instead of the ratio. Both groups are scaled and merged over one pinned resolution range — the adopted group's own cut — and the promotion is taken only if **neither $R_\mathrm{meas}$ nor ISa gets worse**. $R_\mathrm{meas}$ is multiplicity-corrected, so folding non-equivalent reflections together has to inflate it, and the error model is refitted per merge, so ISa says whether the extra multiplicity was bought with systematic disagreement. $CC_{1/2}$ and $\langle I/\sigma\rangle$ cannot arbitrate this: both *rise* on a false promotion too. Two details the comparison turns on: the refused point group's representative is primitive and symmorphic, so the arm merged under it takes the **adopted group's centring** — merged in the bare representative, a centred crystal is handed its centring-absent class as data, which inverts the decision — and the absence stage is asked of the adopted merge, so both arms carry the same absence classes and differ by the added rotations alone. The cost is two extra merges, and only on a run that records a refusal, which is a few in a hundred.
 
 **The lattice class is re-asked where the metric knows more.** The Bravais class comes from Niggli reduction and a lattice-character lookup (§6), and that lookup can land short of the truth or beside it: near the Niggli type-I/type-II boundary it is decided by the last digits of the refined cell, and a lattice that is nearly but not exactly hexagonal matches the hexagonal character even when no point group that class can host carries the two-folds the data actually have. Two recoveries run, both settled by the intensities. Every rotation the cell metric can host beyond the named class — read off Le Page's two-fold search on the lattice itself, which measures each rotation's obliquity in a primitive basis and owes nothing to the character table — is put to the intensities as a single operator, scored exactly as the search scores its own operators, on the same reflection population and the same $E^2$ normalisation. And where the metric group is larger than the adopted class's holohedry, the merge is reindexed into the metric group's conventional cell and the space-group search is run again there, with every gate live; the reindex is committed only where the search in the new setting confirms a strictly higher point group *and* the centring the new cell describes, so a pseudo-symmetric metric leaves the answer already in hand standing.
 
@@ -54,7 +54,7 @@ Both search merges also drop the **frames whose fitted per-frame scale came out
 
 A Padilla–Yeates $L$-test ($\langle|L|\rangle$, $\langle L^2\rangle$ — 0.500 and 0.333 untwinned, 0.375 and 0.200 for a perfect twin) and the second moment $\langle I^2\rangle/\langle I\rangle^2$ (2.0 for untwinned acentric data, 1.5 for a perfect twin) are written to the merged mmCIF as a twinning diagnostic. Both are taken on intensities divided by their resolution-shell mean, over the shells whose $\langle I/\sigma\rangle$ reaches 1, with Wilson outliers rejected; the $L$-test pairs are therefore compared on one scale even where two index steps span a steep fall-off, as in phenix.xtriage and ctruncate, and the selection is by shell, never by the individual reflection's $I/\sigma$, which would cut the weak tail and bias $\langle|L|\rangle$ down. The twin fraction is quoted from the statistic that carries the verdict — the $L$-test unless the call rests on the second moment alone — and a second moment is not turned into a fraction under a detected pseudo-translation, which inflates it. A merohedral twin law exists only where the Laue class is a proper subgroup of the lattice holohedry, so in the high-symmetry holohedral classes ($4/mmm$, $6/mmm$, $m\bar{3}m$, and $\bar{3}m$ on a rhombohedral lattice) no twin is called. The $L$-test is still read there, for a different question: merging $I(h)$ with $I(Th)$ under a false operator $T$ gives $(I(h)+I(Th))/2$ whatever the twin fraction, which has the perfect-twin distribution, so $\langle|L|\rangle$ below 0.42 in a holohedral class is reported as **an adopted operator averaging unequal intensities** — the space group is too high, or a twin law was absorbed into the point group — a warning, never a change to the space group. A genuine operator leaves the untwinned 0.5. Reflections that overlap along a very long axis narrow the distribution the same way, which is one reason it stays a warning. The same numbers measured on the P1 merge the space-group search was given, before any point group was adopted, are reported beside them (`_BEFORE_SEARCH`), with that merge's own pseudo-translation declared and the reflections its lattice centring extinguishes left out. The low-symmetry holohedral classes ($\bar{1}$, $2/m$, $mmm$) also admit no strictly merohedral law, but they stay eligible for the twin call on purpose: *pseudo*-merohedral twinning through an accidentally special metric cannot be ruled out from the symmetry alone, and those are the classes it happens in.
 
-Beside them, on rotation data, the run reports **twin-immune zone evidence** for the operators the adopted point group adds over each of its index-2 subgroups, read on the P1 cross-check merge. Under a twin law $T$, $I_\mathrm{obs}(h)=(1-\alpha)I(h)+\alpha I(Th)$; a reflection whose twin mate is itself up to the subgroup and Friedel is untouched at every $\alpha$, and those are exactly the reflections centric in the group but acentric in the subgroup. They read centric ($\langle|E^2-1|\rangle = 0.968$) if the added operators are real and acentric (0.736) if they are a twin law or a pseudo-symmetry — the one intensity statistic that still separates the two at $\alpha = 0.5$, where every operator statistic reads "real". Each zone is normalised against its own mean in resolution bins (and within the two phase classes of a detected pseudo-translation), read only in shells with $\langle I/\sigma\rangle \ge 5$ because noise inflates every class towards centric, and reported with $n$, a standard error and the centric-over-acentric Wilson log-likelihood ratio in nats (both densities convolved with each reflection's measurement error), beside the acentric control. It is read absolutely, never as the difference to the control: a perfect twin's control (0.541) plus noise inflation would otherwise look like true symmetry. It is **report-only** — nothing in the space-group decision reads it. It is an in-house method: published practice (Yeates' $H$-test, xtriage) excludes these reflections as uninformative about the twin fraction, and no published test was found that uses them positively; the one precedent here is a trigonal crystal whose twin-immune zone read centric and whose higher group was then confirmed by refinement.
+Beside them, on rotation data, the run reports **twin-immune zone evidence** for the operators the adopted point group adds over each of its index-2 subgroups, read on the P1 cross-check merge. Under a twin law $T$, $I_\mathrm{obs}(h)=(1-\alpha)I(h)+\alpha I(Th)$; a reflection whose twin mate is itself up to the subgroup and Friedel is untouched at every $\alpha$, and those are exactly the reflections centric in the group but acentric in the subgroup. They read centric ($\langle|E^2-1|\rangle = 0.968$) if the added operators are real and acentric (0.736) if they are a twin law or a pseudo-symmetry — the one intensity statistic that still separates the two at $\alpha = 0.5$, where every operator statistic reads "real". Each zone is normalised against its own mean in resolution bins (and within the two phase classes of a detected pseudo-translation), read only in shells with $\langle I/\sigma\rangle \ge 5$ because noise inflates every class towards centric, and reported with $n$, a standard error and the centric-over-acentric Wilson log-likelihood ratio in nats (both densities convolved with each reflection's measurement error), beside the acentric control. It is read absolutely, never as the difference to the control: a perfect twin's control (0.541) plus noise inflation would otherwise look like true symmetry. An absolute reading is only as good as the normalisation, though, and the acentric control certifies it: an acentric population reads $-0.130$ nats per reflection when the normalisation is right, and whatever the control reads above that is the normalisation's — anisotropy, a pseudo-translation, a pseudo-centring, noise all inflate every class towards centric alike — so the zone, normalised the same way, carries the same per reflection and the **calibrated** evidence has it taken off (a twinned control reads *below* the expectation, so nothing is taken off a twin). Measured, a 6/m crystal with a 67 Ų anisotropy read its control at $+0.10$ nats per reflection and the zone of a refused 622 the same, so the zone's $+124$ nats were the normalisation's; calibrated it reads $-115$, and genuine promotions keep $+200$ and above. The calibrated zone is what a refused promotion is decided on (above). It is an in-house method: published practice (Yeates' $H$-test, xtriage) excludes these reflections as uninformative about the twin fraction, and no published test was found that uses them positively; the one precedent here is a trigonal crystal whose twin-immune zone read centric and whose higher group was then confirmed by refinement.
 
 **Translational pseudo-symmetry** — two copies of the contents of the asymmetric unit related by a pure translation that is not a lattice vector — is looked for on every merging run, because it is the classic predictor of a failed molecular replacement, and because it raises the second moment where twinning lowers it, so each can mask the other's test. The detection is the native-Patterson route of Read, Adams & McCoy (see the [references](CPU_DATA_ANALYSIS.md#references)): the largest off-origin peak of a Patterson computed from the merged intensities, as a fraction of the origin peak, with the peak vector then refined against the intensity modulation it should produce — the ratio of the strongest to the weakest bin mean of $\langle E^2\rangle$ over the phase $\mathrm{frac}(\mathbf{h}\cdot\mathbf{u})$. Both halves are scored against a null computed for the crystal at hand rather than against a fixed bound — both against the same intensities **permuted within resolution shells** — the peak against that map, the modulation against the same measurement made on the shuffled intensities and started where the measurement starts — because the noise floor of the peak statistic spans an order of magnitude across data sets, so no fixed percentage means the same thing twice. The shuffle leaves the reflection count, the $E^2$ distribution and the phase-bin populations untouched and removes only the correlation between a reflection's intensity and $\mathbf{h}\cdot\mathbf{u}$, which is the thing the modulation claims to see. Re-running the greedy search from random starting vectors over the *same* intensities does not work as a control: a greedy search started anywhere walks into a real modulation's basin, so it measures the search **and** whatever modulation the crystal carries — measured over 110 merged datasets, single draws of that control reached 199× and 6162× on crystals whose own modulation reads 4.0× and 67×, and on 28 of the 110 it came out at or above the signal it is subtracted from. Requiring both halves is what keeps the false-positive rate down; either alone over-calls by about a factor of two. A translation the merged data are **exactly** invariant under is reported as an undeclared lattice translation instead — a translation the data are exactly invariant under is a lattice vector by definition, so the centring or the cell is wrong, not the packing — and the pseudo-symmetry search continues underneath it, so a real pseudo-translation sitting under an undeclared centring is still found. The finding itself is report-only (the `TNCS_*` keys of `<prefix>_report.txt`): it gates nothing and changes no reflection, no scale and no group — but the axial-absence test (§13.1) and the $L$-test here both correct themselves against the modulation it measures.
 
diff --git a/image_analysis/scale_merge/TwinningAnalysis.cpp b/image_analysis/scale_merge/TwinningAnalysis.cpp
index 0ed2afb25..2900c0a79 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.cpp
+++ b/image_analysis/scale_merge/TwinningAnalysis.cpp
@@ -14,6 +14,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include <Eigen/Dense>
+
 namespace {
     int64_t PackHKL(int h, int k, int l) {
         constexpr int64_t bias = 1 << 20;          // indices assumed within +/- 2^20
@@ -488,6 +490,11 @@ namespace {
     // A reflection this far above its bin mean is not a Wilson draw (centric P ~ 1e-5): one such
     // reflection read 2.33 for a whole zone.
     constexpr double ZONE_OUTLIER_E2 = 20.0;
+    // What CentricOverAcentric averages over an error-free acentric population: with x = E^2 ~ Exp(1),
+    // <-ln(2 pi x)/2 + x/2> = (1 + gamma_E - ln 2 pi)/2 = -0.130 nats (a centric one reads +0.216).
+    // Errors move it towards zero, so an error-free baseline takes the larger excess off a noisy
+    // control - the conservative side.
+    constexpr double ACENTRIC_EVIDENCE_PER_REFLECTION = -0.1303;
 
     // ln p_centric(E^2) - ln p_acentric(E^2) for a measured E^2 with error s: both Wilson densities
     // convolved with the measurement error. Without the convolution the centric density, infinite at
@@ -563,6 +570,18 @@ namespace {
         }
         return z;
     }
+
+    // The control's excess over the acentric expectation is the normalisation's (see
+    // TwinImmuneZoneResult::control_excess_per_reflection); every zone carries it per reflection.
+    void Calibrate(TwinImmuneZoneResult& result) {
+        if (result.control.n > 0)
+            result.control_excess_per_reflection = std::max(
+                    0.0, result.control.evidence_nats / result.control.n - ACENTRIC_EVIDENCE_PER_REFLECTION);
+        result.control.calibrated_evidence_nats =
+                result.control.evidence_nats - result.control.n * result.control_excess_per_reflection;
+        for (auto& z : result.zones)
+            z.calibrated_evidence_nats = z.evidence_nats - z.n * result.control_excess_per_reflection;
+    }
 }
 
 namespace {
@@ -576,11 +595,66 @@ namespace {
         return rotations;
     }
 
+    // An isotropic normalisation leaves an anisotropic crystal's E^2 a mixture of scales - at 2.5 A a
+    // 67 A^2 anisotropy spreads one shell's expected intensity over a factor of 15 between its
+    // directions - and every class then reads centric: the acentric control of such a crystal read
+    // 0.99 against its 0.74. Nor can the control calibrate that away, because a zone is a plane
+    // through reciprocal space and carries a different mix of directions from the control's sphere
+    // (a synthetic P4 twin with 60 A^2 along c*: control 0.77, zone +49 nats after the calibration).
+    // So the anisotropy is taken out first: ln I = c + s^T Q s on the acentric reflections of each
+    // shell that read above 2 sigma, by least squares, and I and sigma divided by exp(s^T Q_dev s),
+    // Q_dev the deviatoric part - the isotropic part is the shell mean, normalised per bin later.
+    // The B convention is I ~ exp(-B |s|^2 / 2) with |s| = 1/d, so delta B = 2 (Q_max - Q_min).
+    void RemoveAnisotropy(std::vector<MergedReflection>& strong, const std::vector<int>& shell,
+                          const gemmi::UnitCell& cell, const gemmi::GroupOps& gops, TwinImmuneZoneResult& result) {
+        auto s_of = [&](const MergedReflection& r) {
+            return cell.frac.mat.left_multiply(gemmi::Vec3(r.h, r.k, r.l));
+        };
+        auto monomials = [](const gemmi::Vec3& s) {
+            return Eigen::Matrix<double, 7, 1>{1.0, s.x * s.x, s.y * s.y, s.z * s.z,
+                                               2.0 * s.x * s.y, 2.0 * s.x * s.z, 2.0 * s.y * s.z};
+        };
+        std::vector<size_t> fit;
+        std::vector<double> shell_sum(*std::max_element(shell.begin(), shell.end()) + 1, 0.0);
+        std::vector<int> shell_n(shell_sum.size(), 0);
+        for (size_t i = 0; i < strong.size(); ++i) {
+            const auto& r = strong[i];
+            if (r.I > 2.0 * r.sigma && !gops.is_reflection_centric(gemmi::Op::Miller{{r.h, r.k, r.l}})) {
+                fit.push_back(i);
+                shell_sum[shell[i]] += r.I;
+                shell_n[shell[i]] += 1;
+            }
+        }
+        if (fit.size() < ZONE_BIN)          // seven parameters want more than a bin's worth of points
+            return;
+        Eigen::Matrix<double, 7, 7> ata = Eigen::Matrix<double, 7, 7>::Zero();
+        Eigen::Matrix<double, 7, 1> aty = Eigen::Matrix<double, 7, 1>::Zero();
+        for (const size_t i : fit) {
+            const auto x = monomials(s_of(strong[i]));
+            ata += x * x.transpose();
+            aty += x * std::log(strong[i].I / (shell_sum[shell[i]] / shell_n[shell[i]]));
+        }
+        const Eigen::Matrix<double, 7, 1> c = ata.ldlt().solve(aty);
+        Eigen::Matrix3d q;
+        q << c[1], c[4], c[5], c[4], c[2], c[6], c[5], c[6], c[3];
+        q -= q.trace() / 3.0 * Eigen::Matrix3d::Identity();
+        const Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eig(q);
+        result.anisotropy_delta_b_A2 = 2.0 * (eig.eigenvalues().maxCoeff() - eig.eigenvalues().minCoeff());
+        for (auto& r : strong) {
+            const gemmi::Vec3 s = s_of(r);
+            const Eigen::Vector3d v(s.x, s.y, s.z);
+            const double f = std::exp(v.dot(q * v));
+            r.I = static_cast<float>(r.I / f);
+            r.sigma = static_cast<float>(r.sigma / f);
+        }
+    }
+
     // The reflections a zone test can be read on: present in the group, general position, in the
-    // shells with signal enough (ZONE_MIN_SHELL_ISIG). Fills the resolution range read.
-    std::vector<const MergedReflection*> StrongReflections(const std::vector<MergedReflection>& p1_merged,
-                                                           const gemmi::GroupOps& gops,
-                                                           TwinImmuneZoneResult& result) {
+    // shells with signal enough (ZONE_MIN_SHELL_ISIG), copied with the anisotropy taken out of I and
+    // sigma (RemoveAnisotropy). Fills the resolution range read.
+    std::vector<MergedReflection> StrongReflections(const std::vector<MergedReflection>& p1_merged,
+                                                    const gemmi::UnitCell& cell, const gemmi::GroupOps& gops,
+                                                    TwinImmuneZoneResult& result) {
         std::vector<const MergedReflection*> usable;
         for (const auto& r : p1_merged) {
             const gemmi::Op::Miller h{{r.h, r.k, r.l}};
@@ -595,7 +669,7 @@ namespace {
             min_s = std::min(min_s, 1.0 / (r->d * r->d));
             max_s = std::max(max_s, 1.0 / (r->d * r->d));
         }
-        std::vector<const MergedReflection*> strong;
+        std::vector<MergedReflection> strong;
         if (!(max_s > min_s))
             return strong;
         auto shell_of = [&](const MergedReflection* r) {
@@ -608,23 +682,40 @@ namespace {
             isig_sum[shell_of(r)] += r->I / r->sigma;
             isig_n[shell_of(r)] += 1;
         }
+        std::vector<int> shell;
         for (const auto* r : usable) {
             const int b = shell_of(r);
-            if (isig_n[b] > 0 && isig_sum[b] / isig_n[b] >= ZONE_MIN_SHELL_ISIG)
-                strong.push_back(r);
+            if (isig_n[b] > 0 && isig_sum[b] / isig_n[b] >= ZONE_MIN_SHELL_ISIG) {
+                strong.push_back(*r);
+                shell.push_back(b);
+            }
         }
         result.d_max_A = 0.0;
         result.d_min_A = std::numeric_limits<double>::infinity();
-        for (const auto* r : strong) {
-            result.d_max_A = std::max<double>(result.d_max_A, r->d);
-            result.d_min_A = std::min<double>(result.d_min_A, r->d);
+        for (const auto& r : strong) {
+            result.d_max_A = std::max<double>(result.d_max_A, r.d);
+            result.d_min_A = std::min<double>(result.d_min_A, r.d);
         }
+        if (!strong.empty())
+            RemoveAnisotropy(strong, shell, cell, gops, result);
         return strong;
     }
 
+    // The reflections acentric in the group: the control every zone is read beside.
+    TwinImmuneZone ReadControl(const std::vector<MergedReflection>& strong, const gemmi::GroupOps& gops,
+                               const std::array<double, 3>* tncs_vector) {
+        std::vector<const MergedReflection*> control;
+        for (const auto& r : strong)
+            if (!gops.is_reflection_centric(gemmi::Op::Miller{{r.h, r.k, r.l}}))
+                control.push_back(&r);
+        TwinImmuneZone z = ReadZone(control, tncs_vector);
+        z.operators = "acentric";
+        return z;
+    }
+
     // The zone of one subgroup hypothesis H (given by its rotations): the reflections centric in the
     // group but not in H - the self-mates of the coset the group adds over H.
-    TwinImmuneZone ReadSubgroupZone(const std::vector<const MergedReflection*>& strong,
+    TwinImmuneZone ReadSubgroupZone(const std::vector<MergedReflection>& strong,
                                     const gemmi::GroupOps& gops, const std::vector<gemmi::Op>& rotations,
                                     const std::vector<gemmi::Op>& h_ops,
                                     const std::array<double, 3>* tncs_vector) {
@@ -632,14 +723,14 @@ namespace {
             return std::any_of(set.begin(), set.end(), [&](const gemmi::Op& o) { return o.rot == op.rot; });
         };
         std::vector<const MergedReflection*> zone;
-        for (const auto* r : strong) {
-            const gemmi::Op::Miller h{{r->h, r->k, r->l}};
-            const gemmi::Op::Miller minus{{-gemmi::Op::DEN * r->h, -gemmi::Op::DEN * r->k, -gemmi::Op::DEN * r->l}};
+        for (const auto& r : strong) {
+            const gemmi::Op::Miller h{{r.h, r.k, r.l}};
+            const gemmi::Op::Miller minus{{-gemmi::Op::DEN * r.h, -gemmi::Op::DEN * r.k, -gemmi::Op::DEN * r.l}};
             const bool centric_in_h = std::any_of(h_ops.begin(), h_ops.end(), [&](const gemmi::Op& op) {
                 return op.apply_to_hkl_without_division(h) == minus;
             });
             if (gops.is_reflection_centric(h) && !centric_in_h)
-                zone.push_back(r);
+                zone.push_back(&r);
         }
         TwinImmuneZone z = ReadZone(zone, tncs_vector);
         for (const auto& op : rotations)
@@ -650,28 +741,25 @@ namespace {
 }
 
 TwinImmuneZoneResult AnalyzeTwinImmuneZone(const std::vector<MergedReflection>& p1_merged,
-                                           const gemmi::SpaceGroup& group, const gemmi::SpaceGroup& subgroup,
+                                           const gemmi::UnitCell& cell, const gemmi::SpaceGroup& group,
+                                           const gemmi::SpaceGroup& subgroup,
                                            const std::array<double, 3>* tncs_vector) {
     TwinImmuneZoneResult result;
     result.tncs_normalised = tncs_vector != nullptr;
     const gemmi::GroupOps gops = group.operations();
     const std::vector<gemmi::Op> rotations = ProperRotations(gops);
     const std::vector<gemmi::Op> h_ops = ProperRotations(subgroup.operations());
-    const auto strong = StrongReflections(p1_merged, gops, result);
+    const auto strong = StrongReflections(p1_merged, cell, gops, result);
     if (strong.empty())
         return result;
-    std::vector<const MergedReflection*> control;
-    for (const auto* r : strong)
-        if (!gops.is_reflection_centric(gemmi::Op::Miller{{r->h, r->k, r->l}}))
-            control.push_back(r);
-    result.control = ReadZone(control, tncs_vector);
-    result.control.operators = "acentric";
+    result.control = ReadControl(strong, gops, tncs_vector);
     result.zones.push_back(ReadSubgroupZone(strong, gops, rotations, h_ops, tncs_vector));
+    Calibrate(result);
     return result;
 }
 
 TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>& p1_merged,
-                                            const gemmi::SpaceGroup& group,
+                                            const gemmi::UnitCell& cell, const gemmi::SpaceGroup& group,
                                             const std::array<double, 3>* tncs_vector) {
     TwinImmuneZoneResult result;
     result.tncs_normalised = tncs_vector != nullptr;
@@ -721,20 +809,16 @@ TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>&
     if (subgroups.empty())
         return result;
 
-    const auto strong = StrongReflections(p1_merged, gops, result);
+    const auto strong = StrongReflections(p1_merged, cell, gops, result);
     if (strong.empty())
         return result;
-    std::vector<const MergedReflection*> control;
-    for (const auto* r : strong)
-        if (!gops.is_reflection_centric(gemmi::Op::Miller{{r->h, r->k, r->l}}))
-            control.push_back(r);
-    result.control = ReadZone(control, tncs_vector);
-    result.control.operators = "acentric";
+    result.control = ReadControl(strong, gops, tncs_vector);
 
     // Per hypothesis H, the zone: centric in the group, acentric in H - the reflections some added
     // operator sends to -h, i.e. the self-mates of that coset read as a twin law.
     for (const auto& h_ops : subgroups)
         result.zones.push_back(ReadSubgroupZone(strong, gops, rotations, h_ops, tncs_vector));
+    Calibrate(result);
     return result;
 }
 
@@ -743,17 +827,22 @@ std::string TwinImmuneZonesToText(const TwinImmuneZoneResult& result) {
     os << std::fixed;
     os << "Twin-immune zones of the operators the adopted group adds over each index-2 subgroup (P1 merge, " << std::setprecision(2) << result.d_max_A
        << "-" << result.d_min_A << " A, shells with <I/sigma> >= " << std::setprecision(0)
-       << ZONE_MIN_SHELL_ISIG << (result.tncs_normalised ? ", normalised per pseudo-translation class" : "")
+       << ZONE_MIN_SHELL_ISIG << ", a deviatoric quadratic form of delta B " << std::setprecision(1)
+       << result.anisotropy_delta_b_A2 << " A^2 fitted over these shells and taken out"
+       << (result.tncs_normalised ? ", normalised per pseudo-translation class" : "")
        << ")\n"
        << "  Reflections centric in the group but not in the subgroup are their own twin mates: centric if\n"
        << "  the added operators are real, acentric if they are a twin law or a pseudo-symmetry. <|E^2-1|>\n"
        << "  reads 0.968 centric, 0.736 acentric; evidence is the centric/acentric log-likelihood ratio\n"
-       << "  (> 0: the added operators are real).\n";
+       << "  (> 0: the added operators are real). The acentric control reads -0.130 nats per reflection\n"
+       << "  when the normalisation is right; what it reads above that is the normalisation's (" << std::showpos
+       << std::setprecision(3) << result.control_excess_per_reflection << std::noshowpos
+       << " here), every\n  zone carries the same per reflection, and the calibrated evidence has it taken off.\n";
     auto row = [&](const TwinImmuneZone& z) {
         os << "  " << std::left << std::setw(34) << z.operators << std::right << " n " << std::setw(6) << z.n
            << "  <|E^2-1|> " << std::setprecision(3) << z.mean_abs_e2_minus_1 << " +- " << z.standard_error
-           << "  evidence " << std::showpos << std::setprecision(1) << z.evidence_nats << std::noshowpos
-           << " nats\n";
+           << "  evidence " << std::showpos << std::setprecision(1) << z.evidence_nats << " nats, calibrated "
+           << z.calibrated_evidence_nats << std::noshowpos << "\n";
     };
     for (const auto& z : result.zones)
         row(z);
diff --git a/image_analysis/scale_merge/TwinningAnalysis.h b/image_analysis/scale_merge/TwinningAnalysis.h
index 7165e065e..9bebb3208 100644
--- a/image_analysis/scale_merge/TwinningAnalysis.h
+++ b/image_analysis/scale_merge/TwinningAnalysis.h
@@ -9,6 +9,7 @@
 
 #include "../../common/Reflection.h"
 #include "gemmi/symmetry.hpp"
+#include "gemmi/unitcell.hpp"
 
 // Intensity-statistics test for merohedral twinning, in the spirit of phenix.xtriage. Two
 // indicators on the merged intensities, both normalised per resolution shell:
@@ -101,7 +102,8 @@ std::string TwinningAnalysisToText(const TwinningAnalysisResult& result);
 std::string TwinningVerdictLine(const TwinningAnalysisResult& result);
 
 // Twin-immune zone evidence for the operators a point group adds over each of its index-2 subgroups,
-// read on a P1 merge. REPORT-ONLY.
+// read on a P1 merge (or on the adopted group's own): reported for every 2-fold the adopted group
+// holds, and what a refused promotion is decided on (Rugnux TwinZoneVerdict).
 //
 // Under a twin law T, I_obs(h) = (1-a) I(h) + a I(Th); a reflection whose twin mate Th is h itself, up
 // to the true group and Friedel, is untouched by twinning at every fraction a. For an index-2 subgroup
@@ -111,7 +113,8 @@ std::string TwinningVerdictLine(const TwinningAnalysisResult& result);
 // statistic is blind - at a = 0.5, where I(h) = I(Th) exactly. Read ABSOLUTELY, <|E^2-1|> against
 // 0.968 (centric) and 0.736 (acentric); never as the difference to the control, because noise, a
 // pseudo-translation and anisotropy all inflate every class towards centric, and a perfect twin's
-// control (0.541) plus that inflation looks like true symmetry's.
+// control (0.541) plus that inflation looks like true symmetry's. But an absolute reading is only as
+// good as the normalisation, and the control is what certifies it: see control_excess_per_reflection.
 struct TwinImmuneZone {
     std::string operators;              // the operators G adds over H, as h,k,l triplets
     int n = 0;
@@ -122,24 +125,39 @@ struct TwinImmuneZone {
     // pseudo-symmetry. About +0.2 nats per reflection for a centric zone and -0.13 for an acentric one
     // on error-free data; less either way as the errors grow.
     double evidence_nats = 0.0;
+    // The same less n times the control's excess (TwinImmuneZoneResult::control_excess_per_reflection):
+    // what a verdict is read on.
+    double calibrated_evidence_nats = 0.0;
 };
 
 struct TwinImmuneZoneResult {
     std::vector<TwinImmuneZone> zones;  // one per index-2 subgroup of the group
     TwinImmuneZone control;             // the reflections acentric in the group
+    // The control's evidence per reflection above what an acentric population reads (-0.130 nats on
+    // error-free data), floored at zero. The control is acentric whatever the truth - twinned at most,
+    // which reads BELOW that - so anything above it is the normalisation's: anisotropy, a
+    // pseudo-translation, a pseudo-centring, noise, all of which inflate every class towards centric
+    // alike, and the zone, normalised the same way, carries the same per reflection. Measured: a 6/m
+    // crystal with a 67 A^2 anisotropy read its control at +0.10 nats per reflection (centric, in an
+    // isotropic normalisation) and the zone of a refused 622 the same, +0.10 - so the zone's +124
+    // nats were the normalisation's, and the verdict rescued a twin law. Calibrated, that zone reads
+    // -115 nats; the zones of genuine promotions keep +140 nats (a 90 deg tetragonal sweep) to +2000.
+    double control_excess_per_reflection = 0.0;
+    double anisotropy_delta_b_A2 = 0.0; // the anisotropy taken out of the intensities before normalising
     double d_max_A = 0.0;               // resolution range of the shells read
     double d_min_A = 0.0;
     bool tncs_normalised = false;       // normalised within the pseudo-translation's two phase classes
 };
 
 TwinImmuneZoneResult AnalyzeTwinImmuneZones(const std::vector<MergedReflection>& p1_merged,
-                                            const gemmi::SpaceGroup& group,
+                                            const gemmi::UnitCell& cell, const gemmi::SpaceGroup& group,
                                             const std::array<double, 3>* tncs_vector = nullptr);
 
 // The same for ONE hypothesis: the operators `group` adds over `subgroup` (one zone in the result,
 // beside the control). Read where a promotion from the subgroup to the group is in question.
 TwinImmuneZoneResult AnalyzeTwinImmuneZone(const std::vector<MergedReflection>& p1_merged,
-                                           const gemmi::SpaceGroup& group, const gemmi::SpaceGroup& subgroup,
+                                           const gemmi::UnitCell& cell, const gemmi::SpaceGroup& group,
+                                           const gemmi::SpaceGroup& subgroup,
                                            const std::array<double, 3>* tncs_vector = nullptr);
 
 std::string TwinImmuneZonesToText(const TwinImmuneZoneResult& result);
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 8d5f33b59..08e8a067c 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -588,7 +588,8 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                 Add(s, KeyText("TWIN_ZONE_DECISION", result.twin_zone_decision));
                 Add(s, Prose(" A twin gate refused this promotion, and the twin-immune zone of the operators it\n"
                              " adds decided it (reflections a twin law cannot touch: centric if the operators\n"
-                             " are real, acentric if they are a twin law or a pseudo-symmetry; margin 20 nats):\n"
+                             " are real, acentric if they are a twin law or a pseudo-symmetry; read less what\n"
+                             " the acentric control shows the normalisation to add; margin 20 nats):\n"
                              " " + result.twin_zone_decision + "."));
             }
             if (refused)
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 1e353fcb7..92d751687 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1739,15 +1739,24 @@ namespace {
     // twins at -290 nats and below, with one genuine trigonal crystal at -46 nats whose promotion
     // no gate refused - so the bound is not what separates them, and a refusal a gate did fire is
     // the only place the verdict is read.
-    int TwinZoneVerdict(const std::vector<MergedReflection> &p1_merged, const SearchSpaceGroupResult &higher,
-                        const SearchSpaceGroupResult &lower, ProcessResult &result,
-                        const std::array<double, 3> *tncs_vector = nullptr) {
+    //
+    // Read on the CALIBRATED evidence: the zone's less what the acentric control shows the
+    // normalisation to add per reflection (TwinImmuneZoneResult::control_excess_per_reflection). The
+    // raw evidence rescued two refused 622 promotions - a 6/m crystal and a 312 one, H 4.7x and 5.2x
+    // the parent's, R_meas 0.09 -> 0.34 under the higher group - whose zones read centric only
+    // because everything did: a 67 A^2 anisotropy and a pseudo-translation had the control at
+    // +0.10 nats per reflection, the zone at the same, and +124 nats over 947 reflections was the
+    // normalisation's. Calibrated they read -115 and -86; the genuine promotions measured keep +140
+    // and above.
+    int TwinZoneVerdict(const std::vector<MergedReflection> &p1_merged, const gemmi::UnitCell &cell,
+                        const SearchSpaceGroupResult &higher, const SearchSpaceGroupResult &lower,
+                        ProcessResult &result, const std::array<double, 3> *tncs_vector = nullptr) {
         constexpr double DECISIVE_NATS = 20.0;
         if (!higher.point_group_representative || !lower.point_group_representative)
             return 0;
         if (higher.point_group_order != 2 * lower.point_group_order)
             return 0;
-        const auto z = AnalyzeTwinImmuneZone(p1_merged, *higher.point_group_representative,
+        const auto z = AnalyzeTwinImmuneZone(p1_merged, cell, *higher.point_group_representative,
                                              *lower.point_group_representative, tncs_vector);
         if (z.zones.empty() || z.zones[0].n == 0) {
             result.twin_zone_decision = fmt::format("{} over {}: no zone reflections in the shells with signal "
@@ -1756,13 +1765,14 @@ namespace {
             return 0;
         }
         const auto &zone = z.zones[0];
-        const int verdict = zone.evidence_nats <= -DECISIVE_NATS ? -1
-                            : zone.evidence_nats >= DECISIVE_NATS ? +1 : 0;
+        const int verdict = zone.calibrated_evidence_nats <= -DECISIVE_NATS ? -1
+                            : zone.calibrated_evidence_nats >= DECISIVE_NATS ? +1 : 0;
         result.twin_zone_decision = fmt::format(
-                "{} over {}: operators {}; n {} <|E^2-1|> {:.3f} +- {:.3f} (control {:.3f}), evidence "
-                "{:+.1f} nats ({:.2f}-{:.2f} A{}) -> {}",
+                "{} over {}: operators {}; n {} <|E^2-1|> {:.3f} +- {:.3f} (control {:.3f}, {:+.3f} nats per "
+                "reflection above acentric), evidence {:+.1f} nats, calibrated {:+.1f} ({:.2f}-{:.2f} A{}) -> {}",
                 higher.point_group_hm, lower.point_group_hm, zone.operators, zone.n, zone.mean_abs_e2_minus_1,
-                zone.standard_error, z.control.mean_abs_e2_minus_1, zone.evidence_nats, z.d_max_A, z.d_min_A,
+                zone.standard_error, z.control.mean_abs_e2_minus_1, z.control_excess_per_reflection,
+                zone.evidence_nats, zone.calibrated_evidence_nats, z.d_max_A, z.d_min_A,
                 z.tncs_normalised ? ", normalised per pseudo-translation class" : "",
                 verdict < 0 ? "acentric, the added operators are a twin law or a pseudo-symmetry"
                 : verdict > 0 ? "centric, the added operators are real" : "undecided");
@@ -5692,7 +5702,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                 alt.point_group_hm, sg_search.point_group_hm);
                     overridden(sg_search, "Lorentz-filtered", "all-observation");
                     zone_verdict = !sg_search.refused_point_group_hm.empty()
-                                   ? TwinZoneVerdict(sm_all.merged, alt, sg_search, result) : 0;
+                                   ? TwinZoneVerdict(sm_all.merged, gemmi::UnitCell(*result.consensus_cell), alt,
+                                                     sg_search, result) : 0;
                     if (zone_verdict < 0) {
                         logger.Warning("Space-group search: the Lorentz-filtered merge's refusal of {} "
                                        "STANDS - the twin-immune zone of its added operators reads "
@@ -5711,7 +5722,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 }
                 if (order_of(alt) < order_of(sg_search)
                     && !alt.refused_point_group_hm.empty()
-                    && TwinZoneVerdict(sm_all.merged, sg_search, alt, result) < 0) {
+                    && TwinZoneVerdict(sm_all.merged, gemmi::UnitCell(*result.consensus_cell), sg_search, alt,
+                                       result) < 0) {
                     logger.Warning("Space-group search: the all-observation merge's refusal of {} STANDS "
                                    "- the twin-immune zone of its added operators reads acentric; keeping {}",
                                    alt.refused_point_group_hm, alt.point_group_hm);
@@ -5971,14 +5983,39 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     // the near-tangential measurements that make a genuine operator look like a twin.
                     // Where it finds the larger point group, the absences are still judged on all
                     // observations, with the point group pinned.
+                    // And the same twin-immune zone verdict on a refusal the other arm would outvote:
+                    // a P31 partial twin whose 32 the rule above had refused on the zone was promoted
+                    // by this ask's filtered arm - the same override, one copy later.
                     if (!merged_filtered.empty()) {
                         SearchSpaceGroupOptions of = o2;
                         of.merge_isa = merged_filtered_isa;   // this arm's own error model
-                        const auto filtered = SearchSpaceGroup(reindexed(merged_filtered), of);
-                        if (filtered.point_group_order > s2.point_group_order) {
+                        auto filtered = SearchSpaceGroup(reindexed(merged_filtered), of);
+                        const auto refusal_stands = [&](const SearchSpaceGroupResult &higher,
+                                                        SearchSpaceGroupResult &lower) {
+                            if (higher.point_group_order <= lower.point_group_order
+                                || lower.refused_point_group_hm.empty()
+                                || TwinZoneVerdict(merged_all, *o2.cell, higher, lower, result) >= 0)
+                                return false;
+                            logger.Warning("Space-group search (metric lattice): the refusal of {} STANDS - the "
+                                           "twin-immune zone of its added operators reads acentric; keeping {}",
+                                           lower.refused_point_group_hm, lower.point_group_hm);
+                            lower.refused_reason += ", and its twin-immune zone reads acentric";
+                            return true;
+                        };
+                        if (filtered.point_group_order > s2.point_group_order && !refusal_stands(filtered, s2)) {
                             o2.fixed_point_group = filtered.point_group_representative;
                             s2 = SearchSpaceGroup(merged_all, o2);
                             o2.fixed_point_group.reset();
+                        } else if (refusal_stands(s2, filtered)) {
+                            o2.fixed_point_group = filtered.point_group_representative;
+                            auto lower = SearchSpaceGroup(merged_all, o2);
+                            o2.fixed_point_group.reset();
+                            lower.refused_point_group_hm = filtered.refused_point_group_hm;
+                            lower.refused_reason = filtered.refused_reason;
+                            lower.refused_point_group_representative = filtered.refused_point_group_representative;
+                            lower.refused_by_twin_gate = true;
+                            lower.refused_twin_fraction = filtered.refused_twin_fraction;
+                            s2 = std::move(lower);
                         }
                     }
                     // The centring cannot be read from the absences in this setting: reindexing
@@ -6494,8 +6531,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     // of this merge, at full multiplicity and production scale - where the P1 search
                     // merge of a weak crystal has no shell with signal enough to read a zone on.
                     const int zone = hi_sg.has_value()
-                                     ? TwinZoneVerdict(sm.merged, hi_search, sg_search, result,
-                                                       TranslationalNCSVectorForLTest(pre_tncs)) : 0;
+                                     ? TwinZoneVerdict(sm.merged, gemmi::UnitCell(*result.consensus_cell), hi_search,
+                                                       sg_search, result, TranslationalNCSVectorForLTest(pre_tncs)) : 0;
                     if (zone < 0) {
                         const std::string msg = fmt::format(
                                 "Point group {} was refused ({}), and the twin-immune zone of its added "
@@ -7257,7 +7294,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 // Report-only: nothing reads it back.
                 if (determined != nullptr && determined->number > 1) {
                     result.twin_immune_zones = AnalyzeTwinImmuneZones(
-                            p1.merged, *determined, TranslationalNCSVectorForLTest(result.tncs));
+                            p1.merged, gemmi::UnitCell(*result.consensus_cell), *determined,
+                            TranslationalNCSVectorForLTest(result.tncs));
                     if (!result.twin_immune_zones->zones.empty())
                         logger.Info("{}", TwinImmuneZonesToText(*result.twin_immune_zones));
                 }
diff --git a/tests/TwinningAnalysisTest.cpp b/tests/TwinningAnalysisTest.cpp
index 06c6b8d60..81dbfad9f 100644
--- a/tests/TwinningAnalysisTest.cpp
+++ b/tests/TwinningAnalysisTest.cpp
@@ -223,8 +223,12 @@ namespace {
     // intensity from the acentric distribution, which is all the searches it was written for need, but
     // the zone test reads exactly the difference. E^2 is chi^2 with one degree of freedom for a
     // reflection centric in the true group (a squared Box-Muller normal), exponential otherwise, keyed
-    // on the asymmetric-unit index so the true group's symmetry is exact.
-    std::vector<MergedReflection> WilsonTetragonal(const char *true_group, double twin_fraction) {
+    // on the asymmetric-unit index so the true group's symmetry is exact. `anisotropy_b` is an extra
+    // Debye-Waller B along c* alone (A^2) - the same in both twin domains, a twin law being a lattice
+    // operation - and `scale_jitter` a log-normal factor of that width on every observed intensity,
+    // a nuisance with no direction that no normalisation removes.
+    std::vector<MergedReflection> WilsonTetragonal(const char *true_group, double twin_fraction,
+                                                   double anisotropy_b = 0.0, double scale_jitter = 0.0) {
         const gemmi::SpaceGroup &sub = gemmi::get_spacegroup_by_name(true_group);
         const gemmi::SpaceGroup &super = gemmi::get_spacegroup_by_name("P 4 2 2");
         const gemmi::Op twin = jfjoch_test::TwinLaw(sub, super);
@@ -237,7 +241,9 @@ namespace {
             const double u2 = jfjoch_test::detail::UniformFromHkl({{asu[0] + 300, asu[1] + 300, asu[2] + 300}});
             const double c = std::cos(2.0 * std::numbers::pi * u2);
             const double e2 = gops.is_reflection_centric(hkl) ? -2.0 * std::log(u1) * c * c : -std::log(u1);
-            return 1000.0 * e2 * std::exp(-20.0 / (2.0 * std::pow(cell.calculate_d(hkl), 2)));
+            const double s_c = hkl[2] / cell.c;
+            return 1000.0 * e2 * std::exp(-20.0 / (2.0 * std::pow(cell.calculate_d(hkl), 2)))
+                   * std::exp(-anisotropy_b * s_c * s_c / 2.0);
         };
         std::vector<MergedReflection> out;
         for (int h = -19; h <= 19; ++h)
@@ -254,8 +260,12 @@ namespace {
                     r.k = k;
                     r.l = l;
                     r.d = static_cast<float>(d);
-                    r.I = static_cast<float>((1.0 - twin_fraction) * true_intensity(hkl)
-                                             + twin_fraction * true_intensity(twin.apply_to_hkl(hkl)));
+                    const double u3 = jfjoch_test::detail::UniformFromHkl({{h + 700, k + 700, l + 700}});
+                    const double u4 = jfjoch_test::detail::UniformFromHkl({{h + 900, k + 900, l + 900}});
+                    const double jitter = std::exp(scale_jitter * std::sqrt(-2.0 * std::log(u3))
+                                                   * std::cos(2.0 * std::numbers::pi * u4));
+                    r.I = static_cast<float>(((1.0 - twin_fraction) * true_intensity(hkl)
+                                              + twin_fraction * true_intensity(twin.apply_to_hkl(hkl))) * jitter);
                     r.sigma = static_cast<float>(0.01 * r.I + 1.0);
                     out.push_back(r);
                 }
@@ -268,8 +278,9 @@ namespace {
 // stay acentric under it and are centric only where the added operators are real.
 TEST_CASE("Twin-immune zones tell a perfect twin from real symmetry", "[twinning]") {
     const gemmi::SpaceGroup &p422 = gemmi::get_spacegroup_by_name("P 4 2 2");
+    const gemmi::UnitCell tetragonal(47, 47, 63, 90, 90, 90);
 
-    const auto real = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4 2 2", 0.0), p422);
+    const auto real = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4 2 2", 0.0), tetragonal, p422);
     REQUIRE(real.zones.size() == 3);                       // over 4, over 222, over the diagonal 222
     for (const auto &z : real.zones) {
         CAPTURE(z.operators);
@@ -280,11 +291,56 @@ TEST_CASE("Twin-immune zones tell a perfect twin from real symmetry", "[twinning
 
     // A perfect P4 twin: whichever subgroup is taken as the parent, the operators added over it are
     // not all real, and the zone reads acentric.
-    const auto twin = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4", 0.5), p422);
+    const auto twin = AnalyzeTwinImmuneZones(WilsonTetragonal("P 4", 0.5), tetragonal, p422);
     REQUIRE(twin.zones.size() == 3);
     for (const auto &z : twin.zones) {
         CAPTURE(z.operators);
         CHECK(z.mean_abs_e2_minus_1 == Catch::Approx(0.736).margin(0.08));
         CHECK(z.evidence_nats < 0.0);
+        CHECK(z.calibrated_evidence_nats < 0.0);
+    }
+    // Wilson data normalise cleanly: the control reads the acentric expectation and the
+    // calibration takes nothing off.
+    CHECK(real.control_excess_per_reflection < 0.01);
+    CHECK(twin.control_excess_per_reflection < 0.01);
+}
+
+// The zone is read absolutely, so it is only as good as the normalisation. A strong anisotropy
+// leaves every class of an isotropically normalised merge reading centric, the acentric control
+// included, and a zone - a plane - more so than the control's sphere; it is fitted and taken out
+// before anything is read. What no normalisation removes, the control certifies: its excess over the
+// acentric expectation is taken off every zone, so a partial twin's zone reads acentric and a real
+// operator's centric, as they do on clean data.
+TEST_CASE("Twin-immune zones are normalised for anisotropy and calibrated by the acentric control",
+          "[twinning]") {
+    const gemmi::SpaceGroup &p422 = gemmi::get_spacegroup_by_name("P 4 2 2");
+    const gemmi::SpaceGroup &p4 = gemmi::get_spacegroup_by_name("P 4");
+    const gemmi::UnitCell tetragonal(47, 47, 63, 90, 90, 90);
+
+    SECTION("a 60 A^2 anisotropy along c* is taken out") {
+        const auto twin = AnalyzeTwinImmuneZone(WilsonTetragonal("P 4", 0.2, 60.0), tetragonal, p422, p4);
+        REQUIRE(twin.zones.size() == 1);
+        CHECK(twin.anisotropy_delta_b_A2 == Catch::Approx(60.0).margin(15.0));
+        CHECK(twin.control.mean_abs_e2_minus_1 < 0.76);    // a partial twin's control: at or below acentric
+        CHECK(twin.zones[0].calibrated_evidence_nats < -20.0);
+
+        const auto real = AnalyzeTwinImmuneZone(WilsonTetragonal("P 4 2 2", 0.0, 60.0), tetragonal, p422, p4);
+        REQUIRE(real.zones.size() == 1);
+        CHECK(real.control.mean_abs_e2_minus_1 == Catch::Approx(0.736).margin(0.05));
+        CHECK(real.zones[0].calibrated_evidence_nats > 20.0);
+    }
+
+    SECTION("a scale jitter no normalisation removes is calibrated off") {
+        const auto real = AnalyzeTwinImmuneZone(WilsonTetragonal("P 4 2 2", 0.0, 0.0, 0.6), tetragonal, p422, p4);
+        REQUIRE(real.zones.size() == 1);
+        CHECK(real.control.mean_abs_e2_minus_1 > 0.80);    // inflated: the normalisation is wrong
+        CHECK(real.control_excess_per_reflection > 0.02);
+        CHECK(real.zones[0].calibrated_evidence_nats > 20.0);
+
+        // The twin's control is deflated by the twinning as much as the jitter inflates it, so
+        // nothing is taken off - and its zone, acentric, still reads so.
+        const auto twin = AnalyzeTwinImmuneZone(WilsonTetragonal("P 4", 0.2, 0.0, 0.6), tetragonal, p422, p4);
+        REQUIRE(twin.zones.size() == 1);
+        CHECK(twin.zones[0].calibrated_evidence_nats < -20.0);
     }
 }
-- 
2.54.0


From 7a6df3c24ab2ca907bc7753515155b5ed72c46f4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 09:29:17 +0200
Subject: [PATCH 071/122] Space group: say which axis a screw could not be
 decided on

A screw axis whose row the sweep never recorded - it lies in the spindle's
blind cone, or outside the resolution range - is not a group the data refused,
it is a question nobody asked. The search already offered the whole set in
SPACE_GROUP_ALTERNATIVES, but the per-zone screw table that would say it in
words is printed for the SELECTED candidate only, and the selected candidate
in exactly this case is the one with no screw zones, so the run's account of
the open axis was a blank.

The search now names the axes on which two SELECTED candidates disagree about
whether the row carries screw absences at all, with why the row could not be
judged (never recorded / no control class). The report writes the axes as
SPACE_GROUP_SCREW_UNDETERMINED= beside SPACE_GROUP_ALTERNATIVES and explains
them in prose; the adoption logs a warning naming the axis and the set. An
enantiomorphic or origin-ambiguous pair predicts the same absences on every
row and is not named here - that ambiguity is the hand, or the origin.

Nothing about the decision moves: the group adopted, the alternatives and the
written .mtz/.cif/.hkl are exactly as before, because a reflection file cannot
hold "maybe a screw".

The battery scorer mirrors its existing "hand only" rule: a set differing from
its reference only by a screw the run reports as undeterminable, with the
reference among the groups it offered, scores unscored/screw_undetermined
instead of a sym_screw failure. All three conditions are necessary, so a screw
called wrongly where the row WAS measured stays a failure.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/RUGNUX_REPORT.md                         | 13 +++
 .../scale_merge/SearchSpaceGroup.cpp          | 85 +++++++++++++++++++
 image_analysis/scale_merge/SearchSpaceGroup.h | 18 ++++
 rugnux/ResultReport.cpp                       | 36 ++++++++
 rugnux/Rugnux.cpp                             | 30 +++++++
 tests/SearchSpaceGroupTest.cpp                | 48 +++++++++++
 tools/battery/README.md                       | 16 +++-
 tools/battery/score.py                        | 37 ++++++++
 8 files changed, 281 insertions(+), 2 deletions(-)

diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index 325be8583..e46b6555f 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -199,6 +199,19 @@ partner among them — and, on a group that has such a partner, `SPACE_GROUP_ENA
 whether the hand is open (`UNDETERMINED`), asserted by the user (`GIVEN`), or taken from an accepted
 model (`ASSUMED_FROM_MODEL`).
 
+`SPACE_GROUP_SCREW_UNDETERMINED=` names the **axes whose screw these data could not decide at all**,
+as one or more of `a`, `b`, `c`; when every screw the data could show was judged it reads `NONE`
+and, like the other keys whose answer is "nothing to report", is written only with `--developer`. It
+fires when the axial row a screw lives on was never recorded — it lay in the spindle's blind cone,
+or outside the resolution range — so nothing was measured that could confirm or refuse the screw.
+On such an axis `SPACE_GROUP_NAME=` is not an answer: the answer is that group **or** any of
+`SPACE_GROUP_ALTERNATIVES`, and no measurement in the run chooses between them. What is written to
+the `.mtz`/`.cif`/`.hkl` is unchanged — the member claiming no screw, because a reflection file must
+carry one group — and the report prints the axis, why the row could not be judged, and what the
+alternatives are. To settle it, record the missing row: a different crystal orientation, or a sweep
+that reaches it. With `--developer` the space-group section names the same axes in prose beside the
+per-zone screw table.
+
 `SOHNCKE_SPACE_GROUP=` in section 2 is written on every run whose space group was determined by the
 search; a run given its group with `-S` has no Sohncke candidate to name and omits the key. Where the
 search found a glide plane, `SPACE_GROUP_NAME=` names the group with it and this names the best group
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index 9f33bf808..702cc21c5 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -484,6 +484,15 @@ RowModulation FindRowModulation(const gemmi::UnitCell& cell, const std::array<in
         return out;
     }
 
+    // The crystal axis a screw on this row would run along: h00 -> a, 0k0 -> b, 00l -> c. ' ' for a
+    // row that is not a principal one, which no screw extinguishes.
+    char AxisOf(std::array<int, 3> row) {
+        if (row[1] == 0 && row[2] == 0) return 'a';
+        if (row[0] == 0 && row[2] == 0) return 'b';
+        if (row[0] == 0 && row[1] == 0) return 'c';
+        return ' ';
+    }
+
     std::string FormatDouble(double v, int decimals) {
         std::ostringstream o;
         o << std::fixed << std::setprecision(decimals) << v;
@@ -1039,6 +1048,17 @@ SearchSpaceGroupResult SearchSpaceGroup(
                 row_modulation.emplace(row, std::move(m));
             }
         }
+    // How many reflections of each principal axial row the merge holds at all. A screw lives on one
+    // row, so a row the sweep never recorded - the spindle's blind cone points down it, or its
+    // reflections fall outside the resolution range - is a screw nobody could have tested, and the
+    // difference between "tested and found absent" and "never looked at" is invisible in every other
+    // number here. Counted once over the merge, because it is a property of the data and not of a
+    // candidate. Only the three principal rows: a screw extinguishes no other.
+    std::map<AxialRow, int> axial_row_observed;
+    for (size_t i = 0; i < n; ++i)
+        if (pass_absence[i] && (H[i] == 0) + (K[i] == 0) + (L[i] == 0) == 2)
+            ++axial_row_observed[RowOf(H[i], K[i], L[i])];
+
     std::vector<double> tncs_expected(n, 1.0);
     for (size_t i = 0; i < n && !row_modulation.empty(); ++i) {
         if (!pass_absence[i] || absence_shell[i] < 0)
@@ -2355,6 +2375,46 @@ SearchSpaceGroupResult SearchSpaceGroup(
         }
     }
 
+    // Which axis, if any, these data could not decide the screw on. The ambiguity itself is already
+    // in `alternatives` - the selected set holds groups predicting different axial absences - but a
+    // list of names does not say WHICH axis is open, nor why, and the scalar best_space_group reads
+    // as a determination either way. So name it per row: a row is undetermined when two SELECTED
+    // candidates disagree about whether it carries screw absences at all, which is exactly the case
+    // where nothing in this merge separated them. An enantiomorphic or origin-ambiguous pair
+    // (P4_1/P4_3, I222/I2_12_12_1) predicts the SAME absences on every row and is not named here -
+    // that ambiguity is the hand, or the origin, and is reported as itself.
+    if (result.best_space_group.has_value()) {
+        for (const AxialRow& row : {RowOf(1, 0, 0), RowOf(0, 1, 0), RowOf(0, 0, 1)}) {
+            const gemmi::Op::Miller hkl{{row[0], row[1], row[2]}};
+            bool claimed = false, unclaimed = false;
+            int n_absent = 0, n_control = 0;
+            for (const auto& s : result.candidates) {
+                if (!s.selected)
+                    continue;
+                const gemmi::GroupOps g = s.space_group.operations();
+                // The row's absences must come from a SCREW: in a centred group the axial condition
+                // is the centring's own (I222 extinguishes h00 with h odd because h+k+l is odd), and
+                // that is decided elsewhere, on the whole centring class.
+                if (g.is_systematically_absent(hkl) && !CenteringAbsent(g, hkl)) {
+                    claimed = true;
+                    for (const auto& z : s.screw_zones)
+                        if (z.row == row) {
+                            n_absent = std::max(n_absent, z.n_absent);
+                            n_control = std::max(n_control, z.n_control);
+                        }
+                } else {
+                    unclaimed = true;
+                }
+            }
+            if (claimed && unclaimed) {
+                const auto it = axial_row_observed.find(row);
+                result.undetermined_screws.push_back(
+                        {row, RowLabel(row), AxisOf(row),
+                         it == axial_row_observed.end() ? 0 : it->second, n_absent, n_control});
+            }
+        }
+    }
+
     // Both answers, on every run. The winner above may be a non-Sohncke group, which is right for a
     // small molecule and impossible for a protein; a user who knows their sample is chiral has to be
     // able to read the Sohncke answer off the same run, and a user who is not sure has to be able to
@@ -2647,6 +2707,31 @@ std::string SearchSpaceGroupResultToText(const SearchSpaceGroupResult& result,
                << SettingName(*result.sohncke_space_group) << ".\n";
     }
 
+    // The axes the data left open, said in words. The zone table above is printed for the SELECTED
+    // candidate only, and the selected candidate in exactly this case is the one with NO screw zones
+    // - so without this the run's own account of an undecidable screw is a blank where the table
+    // would have been.
+    if (!result.undetermined_screws.empty()) {
+        os << "Screw axes these data cannot decide\n";
+        for (const auto& u : result.undetermined_screws) {
+            os << "  " << u.axis << ": ";
+            if (u.n_observed == 0)
+                os << "the " << u.row_label << " row holds no reflections in this merge at all, so "
+                      "nothing here\n     could test a screw along " << u.axis
+                   << " - the row was not recorded (it can lie in the spindle's\n     blind cone, or "
+                      "outside the resolution range).\n";
+            else if (u.n_control == 0)
+                os << "the " << u.row_label << " row holds " << u.n_observed << " reflection(s) but no "
+                      "control class for its absences,\n     so how weak they are cannot be judged.\n";
+            else
+                os << "the " << u.row_label << " row does not separate the candidates (" << u.n_absent
+                   << " absent, " << u.n_control << " control).\n";
+        }
+        os << "  A reflection file must carry ONE group, so the groups below are reported with the\n"
+              "  lowest-numbered - the one claiming no screw - standing for the set. That is a\n"
+              "  convention, not a measurement: on the axes named here the answer is all of them.\n";
+    }
+
     if (result.best_space_group.has_value()) {
         os << "Best space group: " << SettingName(*result.best_space_group);
         for (const auto& alt : result.alternatives)
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index 5dcef8b99..ab27b1331 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -723,6 +723,24 @@ struct SearchSpaceGroupResult {
     double r_over_best_bound = 0.0;
     double r_over_floor_bound = 0.0;
 
+    // An axial row whose SCREW these data could not decide: the selected group and at least one of
+    // its `alternatives` disagree about whether that row carries screw absences, and nothing in this
+    // merge separated them. The adopted group is then the lowest-numbered member of that set - the
+    // symmorphic one, by convention and not by measurement - so a report printing only
+    // best_space_group reads as a determination where the honest answer is "P2 or P2_1, no answer
+    // possible". The written files still carry one group, because a reflection file cannot hold
+    // "maybe a screw"; this is what lets the report, the log and a scorer say which axis is open.
+    // Empty on the usual run, where every screw the data could show was judged.
+    struct UndeterminedScrew {
+        std::array<int, 3> row{};   // sign-canonicalised as everywhere else, e.g. {0,0,-1} for 00l
+        std::string row_label;      // the row as a crystallographer names it: "h00", "0k0", "00l"
+        char axis = ' ';            // the axis a screw would run along: 'a', 'b' or 'c'
+        int n_observed = 0;         // reflections of the row in this merge at all - 0 = never recorded
+        int n_absent = 0;           // of those, the ones a claiming candidate predicts absent
+        int n_control = 0;          // ...and the rest of the row, which an absence is judged against
+    };
+    std::vector<UndeterminedScrew> undetermined_screws;
+
     // The best SOHNCKE candidate, always, even when a glide plane was confirmed and best_space_group
     // therefore names a non-Sohncke group. Both are reported on every run: a chiral (protein) crystal
     // cannot have a glide, so a user who knows their sample is a protein must be able to see the
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 8d5f33b59..4b0f21f7f 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -475,6 +475,42 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                     alts += (alts.empty() ? "" : " | ") + alt.xhm();
         Add(s, KeyText("SPACE_GROUP_ALTERNATIVES", alts.empty() ? "NONE" : alts));
 
+        // ...and WHICH axis is open, which the list of names above does not say. A screw the data
+        // could not test is not a near miss between two groups - it is a question nobody asked, and
+        // the group that gets written is the one claiming no screw, by convention. Say the axis, say
+        // why, and leave SPACE_GROUP_NAME and the written files exactly as they are: a reflection
+        // file cannot hold "maybe a screw".
+        std::string undet;
+        if (result.space_group_search.has_value())
+            for (const auto &u : result.space_group_search->undetermined_screws)
+                undet += (undet.empty() ? "" : " ") + std::string(1, u.axis);
+        Add(s, KeyText("SPACE_GROUP_SCREW_UNDETERMINED", undet.empty() ? "NONE" : undet,
+                       undet.empty()));
+        if (!undet.empty() && result.space_group_search.has_value()) {
+            std::string why;
+            for (const auto &u : result.space_group_search->undetermined_screws)
+                why += fmt::format(
+                        "\n   {}: the {} row {}", u.axis, u.row_label,
+                        u.n_observed == 0
+                            ? "holds no reflections in this merge at all, so a screw along this axis\n"
+                              "      was never tested - the row was not recorded (it can lie in the "
+                              "spindle's blind\n      cone, or outside the resolution range)."
+                        : u.n_control == 0
+                            ? fmt::format("holds {} reflection(s) but no control class to judge their\n"
+                                          "      strength against, so how weak they are says nothing.",
+                                          u.n_observed)
+                            : fmt::format("does not separate the candidates ({} absent, {} control).",
+                                          u.n_absent, u.n_control));
+            Add(s, Prose(fmt::format(
+                    " SPACE_GROUP_SCREW_UNDETERMINED names the axes whose SCREW these data could not\n"
+                    " decide at all:{}\n"
+                    " On those axes SPACE_GROUP_NAME is not an answer - the answer is it or any of\n"
+                    " SPACE_GROUP_ALTERNATIVES, and no measurement here chooses. The lowest-numbered\n"
+                    " group, the one claiming no screw, is what the .mtz/.cif/.hkl carry, because a\n"
+                    " reflection file must name one group. To settle it, collect the missing row: a\n"
+                    " different crystal orientation, or a sweep that reaches it.", why)));
+        }
+
         // The hand is a separate question from the alternatives, decidable from the 22 groups' numbers
         // alone. Written only where the group HAS an enantiomorphic partner: on every other group the
         // answer is NOT_APPLICABLE, which answers a question nobody asked.
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 1e353fcb7..d3e907636 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6297,6 +6297,36 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     logger.Info("{}", msg);
                     stats_text << "  " << msg << "\n\n";
                 }
+                // An axis whose screw these data never tested. The group just adopted is then the
+                // member of a set that claims no screw, picked by convention because a reflection
+                // file must name one group - and a line saying only "Adopting space group P 6" reads
+                // as a determination. Say which axis is open and why, here, where the adoption is.
+                if (!sg_search.undetermined_screws.empty()) {
+                    std::string axes, why;
+                    for (const auto &u : sg_search.undetermined_screws) {
+                        axes += (axes.empty() ? "" : ", ") + std::string(1, u.axis);
+                        why += fmt::format(
+                                "{}the {} row {}", why.empty() ? "" : "; ", u.row_label,
+                                u.n_observed == 0
+                                    ? std::string("holds no reflections in this merge at all - it was "
+                                                  "never recorded")
+                                : u.n_control == 0
+                                    ? fmt::format("holds {} reflection(s) but no control class to "
+                                                  "judge them against", u.n_observed)
+                                    : fmt::format("does not separate the candidates ({} absent, {} "
+                                                  "control)", u.n_absent, u.n_control));
+                    }
+                    std::string alts;
+                    for (const auto &alt : sg_search.alternatives)
+                        alts += " or " + alt.xhm();
+                    const std::string msg = fmt::format(
+                            "The screw along {} is UNDETERMINED: {}. These data say {}{} and nothing "
+                            "here chooses between them; {} is written because a reflection file must "
+                            "carry one group. To settle it, record the missing row.",
+                            axes, why, sg.xhm(), alts, sg.xhm());
+                    logger.Warning("{}", msg);
+                    stats_text << "  " << msg << "\n\n";
+                }
                 // The group has to be able to DESCRIBE the cell it is adopted on, and where the
                 // promotion was made HERE it cannot. A two-fold the intensities confirm is one the spot
                 // positions never offered - the Bravais class is decided on the unrefined indexing
diff --git a/tests/SearchSpaceGroupTest.cpp b/tests/SearchSpaceGroupTest.cpp
index 0b1257926..cd193ae87 100644
--- a/tests/SearchSpaceGroupTest.cpp
+++ b/tests/SearchSpaceGroupTest.cpp
@@ -446,6 +446,54 @@ TEST_CASE("SearchSpaceGroup names an orthorhombic screw pair on the axes it lies
     }
 }
 
+// A screw on a row the sweep never recorded is not a group the data refused, it is a question
+// nobody asked: the run writes the member claiming no screw because a reflection file must carry
+// one group, and without this the only trace of the ambiguity is a list of names that does not say
+// which axis is open. Modelled on a real hexagonal set whose 00l row lies in the spindle's blind
+// cone and which is reported as P 6 against a deposited P 63.
+TEST_CASE("SearchSpaceGroup says which axis a missing row left the screw open on",
+          "[SearchSpaceGroup]") {
+    const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 21 21 21");
+    const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 14);
+
+    SearchSpaceGroupOptions opt;
+    opt.merge_friedel = true;
+    opt.lattice_system = gemmi::CrystalSystem::Orthorhombic;
+
+    SECTION("every row measured - nothing is open") {
+        const auto result = SearchSpaceGroup(merged, opt);
+        INFO(SearchSpaceGroupResultToText(result));
+        REQUIRE(result.best_space_group.has_value());
+        CHECK(result.best_space_group->xhm() == "P 21 21 21");
+        CHECK(result.undetermined_screws.empty());
+    }
+
+    SECTION("the 00l row removed - the c screw is undetermined") {
+        std::vector<MergedReflection> without_00l;
+        for (const auto& r : merged)
+            if (r.h != 0 || r.k != 0)
+                without_00l.push_back(r);
+        const auto result = SearchSpaceGroup(without_00l, opt);
+        INFO(SearchSpaceGroupResultToText(result));
+        REQUIRE(result.best_space_group.has_value());
+        REQUIRE(result.undetermined_screws.size() == 1);
+        CHECK(result.undetermined_screws[0].axis == 'c');
+        CHECK(result.undetermined_screws[0].row_label == "00l");
+        CHECK(result.undetermined_screws[0].n_observed == 0);
+        // The a and b screws were measured and are unaffected: what the missing row costs is the
+        // third condition, not the two the data still carry.
+        CHECK(result.best_space_group->operations().is_systematically_absent({{1, 0, 0}}));
+        CHECK(result.best_space_group->operations().is_systematically_absent({{0, 1, 0}}));
+        // ...and the group the c row would have decided between is offered, not silently dropped.
+        bool offers_a_group_without_the_c_screw = false;
+        for (const auto& alt : result.alternatives)
+            if (!alt.operations().is_systematically_absent({{0, 0, 1}}))
+                offers_a_group_without_the_c_screw = true;
+        CHECK((offers_a_group_without_the_c_screw
+               || !result.best_space_group->operations().is_systematically_absent({{0, 0, 1}})));
+    }
+}
+
 // The centring half of the same widening. A, B and C centring on one orthorhombic cell are three
 // different lattices, and only C is a reference setting, so an A-centred crystal used to have its
 // centring refused (its absent class is not the one C predicts) and came out primitive. The
diff --git a/tools/battery/README.md b/tools/battery/README.md
index 71869800e..24944d3f8 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -23,6 +23,18 @@ scored with `sgequiv`. On the XDS arms only the point group is scored, because X
 screw axis. A no-crystal control (`"expect": "no_lattice"`) passes only if no lattice is reported.
 `score.py` has the details.
 
+**A question the data could not answer is `unscored`, not a failure.** Two of these. The hand of an
+enantiomorphic pair (P4_1 vs P4_3) is not in the intensities at all, and `sgequiv` already counts it
+as a match. The other is a **screw axis on a row the sweep never recorded** - the axial row lies in
+the spindle's blind cone, or outside the resolution range, so nothing was measured that could
+confirm or refuse the screw. rugnux then offers the whole set in `SPACE_GROUP_ALTERNATIVES`, names
+the open axis in `SPACE_GROUP_SCREW_UNDETERMINED`, and writes the member claiming no screw, because
+a reflection file must carry one group. Such a set scores `unscored` / `screw_undetermined` rather
+than `sym_screw`, on three conditions, all necessary: rugnux named the axis, the reference group is
+among the ones it offered, and the only axis the two groups differ on is one it named. A screw
+called wrongly where the row WAS measured meets none of them and stays a `sym_screw` failure - this
+rule excuses an unanswerable question, never a wrong answer.
+
 **Data quality is not scored.** A verdict is about the lattice and the symmetry only. Resolution,
 CC1/2, R_meas (overall and lowest shell), completeness, multiplicity and ISa are reported beside
 XDS's or the deposition's values, in the per-set tables and plots, for a human to judge. On the XDS
@@ -247,8 +259,8 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | key | meaning |
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
-| `verdict` | `pass`, `fail`, `unscored` (no reference) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` |
+| `verdict` | `pass`, `fail`, `unscored` (no reference, or a question the data could not answer) or `not_run` (input missing) |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` / `screw_undetermined` |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
diff --git a/tools/battery/score.py b/tools/battery/score.py
index af44f3d57..6f494bb65 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -106,6 +106,23 @@ def cc_half_noise_ratio(cc, cc_xds):
     return round((1 / max(cc, 0.001) - 1) / (1 / (cc_xds - XDS_CC_HALF_ROUNDING) - 1), 3)
 
 
+_AXIS_ROW = {"a": (1, 0, 0), "b": (0, 1, 0), "c": (0, 0, 1)}
+
+
+def screw_axes_differing(sg, ref_sg):
+    """The axes on which two space groups disagree about a screw: the principal row one of them
+    extinguishes and the other does not.
+
+    Only ever asked of two groups of the SAME point group on the same lattice, so their centrings
+    are the same and a row a centring already kills is killed in both - what is left is the screw."""
+    out = set()
+    for ax, hkl in _AXIS_ROW.items():
+        a, b = (s.operations().is_systematically_absent(hkl) for s in (sg, ref_sg))
+        if a != b:
+            out.add(ax)
+    return out
+
+
 def point_group(sgno):
     return gemmi.find_spacegroup_by_number(int(sgno)).point_group_hm()
 
@@ -227,6 +244,26 @@ def judge(entry, rep, run_note):
         order = len(gemmi.find_spacegroup_by_number(r["sgno"]).operations().sym_ops)
         order_ref = len(gemmi.find_spacegroup_by_number(ref["sgno"]).operations().sym_ops)
         if r["pg"] == r["pg_ref"]:
+            # A screw the data never tested is not a wrong answer, it is an unanswerable question:
+            # the axial row it lives on was not recorded at all (the spindle's blind cone), so the
+            # run offers every member of the set as an alternative and writes the one claiming no
+            # screw, because a reflection file must carry one group. Scoring that as a failure
+            # measures the sweep, not the program - the same reason the hand of an enantiomorphic
+            # pair is not scored. Three conditions, all necessary: rugnux SAYS the axis is open,
+            # the reference is among the groups it offered, and the ONLY axis the two differ on is
+            # one it named. A screw called wrongly where the row WAS measured meets none of them
+            # and stays a failure.
+            undetermined = set((rep.get("SPACE_GROUP_SCREW_UNDETERMINED") or "NONE").split())
+            offered = [gemmi.find_spacegroup_by_name(x.strip())
+                       for x in (rep.get("SPACE_GROUP_ALTERNATIVES") or "").split("|")]
+            differ = screw_axes_differing(space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
+                                          space_group(ref.get("sg"), ref["sgno"]))
+            if (undetermined != {"NONE"} and differ and differ <= undetermined
+                    and any(o and o.number == ref["sgno"] for o in offered)):
+                return verdict("unscored", "screw_undetermined",
+                               f"{r['sg']} vs reference {r['sg_ref']}: the screw along "
+                               f"{', '.join(sorted(differ))} is undeterminable from these data "
+                               f"(offered {rep.get('SPACE_GROUP_ALTERNATIVES')})")
             return verdict("fail", "sym_screw", f"{r['sg']} vs reference {r['sg_ref']}")
         cause = ("sym_under" if order < order_ref else
                  "sym_over" if order > order_ref else "sym_other")
-- 
2.54.0


From c8e98faf310e560070d07e2045792e40447cb288 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 09:50:27 +0200
Subject: [PATCH 072/122] Space-group search: the added-operator R gate reads a
 contrast, not a ratio to the best operator

The full-resolution merge-degradation gate divided the added operators' mean
intensity-weighted R by the smallest R anywhere in the crystal. That denominator is an
extreme order statistic, so it has a pole: one unusually clean operator condemns every
other genuine one. It is not a rare accident. A rotation about an axis near the spindle
maps a reflection onto one recorded at nearly the same detector position, so the lab-frame
systematics cancel for that operator alone; measured over the rotation corpus the spread
WITHIN a genuine group reaches 2.0-2.6x, the whole width of the old bound of 2.0. On a weak
cubic crystal whose near-spindle 3-fold read 0.074 against 0.16-0.22 for its ten other
genuine operators, every one of them was refused, the search kept only the group generated
by the reference operator itself (which reads 1.00 by construction), and the same 222
hypothesis on the same merge read 2.45 under a cubic enumeration and 1.02 under an
orthorhombic one - a statistic that moves with which OTHER operators were enumerated.

The added operators are now placed on the scale the crystal itself defines, between the R
of unrelated reflections and the R of the best-agreeing operator:

    contrast = (random_pairing_r - r_added) / (random_pairing_r - global_best_operator_r)

random_pairing_r is new: the same intensity-weighted R over shell-matched pairs of
reflections no symmetry relates, measured on the merge (deterministic, no RNG). Both ends
are hypothesis-free, and the form has no pole - an unusually clean reference widens the
denominator by a few per cent instead of driving the divisor towards zero. The test
abstains where the best-agreeing operator is itself no better than half way to unrelated
reflections, i.e. where the merge holds no clean end to measure from, as it already
abstains when there is no second operator at all.

Calibrated over 149 rotation datasets with a known answer, read as the gate reads it:
genuine promotions reach down to 0.77 and the worst false one reads 0.695, so the bound is
0.72. It keeps every refusal the old ratio made on that corpus except the weak cubic one,
which now promotes to its cubic group; the twins that read above the genuine range are
refused by the H gate and the twin-immune zone, as before.

The reported value, the point-group report line, the finalist ledger and the
gate-fired-and-was-overridden note all follow the contrast.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/SearchSpaceGroup.cpp          | 160 +++++++++++++-----
 image_analysis/scale_merge/SearchSpaceGroup.h |  81 +++++++--
 rugnux/ResultReport.cpp                       |  10 +-
 3 files changed, 184 insertions(+), 67 deletions(-)

diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index 3de94bdc8..61c88e518 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -1063,6 +1063,45 @@ SearchSpaceGroupResult SearchSpaceGroup(
             result.merge_r_floor = r_num / r_den;
     }
 
+    // The other end of the same scale: the R a FALSE operator reads on this crystal (see
+    // SearchSpaceGroupResult::random_pairing_r). Pair every present reflection with an unrelated one
+    // at the same resolution and form the same intensity-weighted R. A false operator relates
+    // reflections that are unrelated apart from sharing a resolution, so this is where its R sits -
+    // measured on this merge's own intensity distribution rather than assumed (the Wilson value 0.5
+    // is off by up to 20% once centrics, a pseudo-translation, the E^2 cap and the resolution range
+    // are in: 0.41 to 0.66 over the rotation corpus).
+    //
+    // Shell-matched and deterministic: the present reflections are ordered by resolution, cut into
+    // equal-count shells of a hundred, and each one paired with the reflection half a shell away. No
+    // RNG, so two runs over the same merge read the same number.
+    {
+        std::vector<size_t> order;
+        order.reserve(n);
+        for (size_t i = 0; i < n; ++i)
+            if (pass_cc[i])
+                order.push_back(i);
+        std::sort(order.begin(), order.end(),
+                  [&](size_t a, size_t b) { return merged[a].d > merged[b].d; });
+        const size_t per = 100;
+        double r_num = 0.0, r_den = 0.0;
+        for (size_t lo = 0; lo < order.size(); lo += per) {
+            const size_t hi = std::min(order.size(), lo + per);
+            const size_t m = hi - lo;
+            if (m < 10)
+                continue;
+            for (size_t p = 0; p < m; ++p) {
+                const double a = I[order[lo + p]];
+                const double b = I[order[lo + (p + m / 2) % m]];
+                if (a + b > 0.0) {
+                    r_num += std::fabs(a - b);
+                    r_den += a + b;
+                }
+            }
+        }
+        if (r_den > 0.0)
+            result.random_pairing_r = r_num / r_den;
+    }
+
     // --- Stage A: score each distinct rotation operator once ---
     auto score_operator = [&](const gemmi::Op& op, std::vector<uint32_t>& visited,
                               uint32_t& epoch) -> SpaceGroupOperatorScore {
@@ -1550,21 +1589,24 @@ SearchSpaceGroupResult SearchSpaceGroup(
         // a pseudo-symmetric cascade the parent-normalised gates wave through (a 2 -> 222 -> 422 built
         // by pooling one real 2-fold with false ones), and it is the only gate that can act on the
         // first step out of P1. Not rescuable: the b rescue above only lifts a chi^2-borderline case.
-        //   - When the data confirm more than one operator, judge the added operators' R against the
-        //     GLOBALLY best-agreeing operator (the smallest R anywhere): on a genuine group every
-        //     operator agrees about as well as that best one, so the ratio is ~1; a false operator -
-        //     even one whose group's members all agree among themselves, like a pseudo-tetragonal 4 -
-        //     sits far above it (see max_operator_r_over_best).
+        //   - When the data confirm more than one operator, place the added operators' R on the scale
+        //     the crystal itself defines: the best-agreeing operator anywhere at one end, unrelated
+        //     reflections (random_pairing_r) at the other. A genuine operator sits at the clean end,
+        //     a false one at the random end (see min_operator_r_contrast).
         //   - The first step out of P1, where only one operator is confirmed at all, has no other
-        //     operator to be the best - fall back to the merge's own random-noise R floor
+        //     operator to be the clean end - fall back to the merge's own random-noise R floor
         //     (max_operator_r_over_floor).
         bool r_refused = false;
         double r_gate_value = std::numeric_limits<double>::quiet_NaN();
         if (std::isfinite(c.r_added)) {
-            if (n_confirmed_ops >= 2 && std::isfinite(global_best_r) && global_best_r > 0.0) {
-                r_gate_value = c.r_added / global_best_r;
-                r_refused = r_gate_value > opt.max_operator_r_over_best;
-            } else if (std::isfinite(result.merge_r_floor) && result.merge_r_floor > 0.0) {
+            if (n_confirmed_ops >= 2 && std::isfinite(global_best_r) && global_best_r > 0.0
+                && std::isfinite(result.random_pairing_r)
+                && global_best_r <= opt.max_reference_over_random * result.random_pairing_r) {
+                r_gate_value = (result.random_pairing_r - c.r_added)
+                               / (result.random_pairing_r - global_best_r);
+                r_refused = r_gate_value < opt.min_operator_r_contrast;
+            } else if (n_confirmed_ops < 2
+                       && std::isfinite(result.merge_r_floor) && result.merge_r_floor > 0.0) {
                 r_gate_value = c.r_added / result.merge_r_floor;
                 r_refused = r_gate_value > opt.max_operator_r_over_floor;
             }
@@ -1596,15 +1638,23 @@ SearchSpaceGroupResult SearchSpaceGroup(
                                   "fraction " + FormatDouble(std::max(0.0, 0.5 - h_added), 2)
                                 + " or more would";
                 else if (r_refused)
-                    refused_why = "its added operators' intensity-weighted R is "
-                                + FormatDouble(r_gate_value, 1) + "x "
-                                + (n_confirmed_ops >= 2
-                                       ? "the best-agreeing operator in the data (bound "
-                                         + FormatDouble(opt.max_operator_r_over_best, 1)
-                                       : "the merge's own random-noise floor (bound "
-                                         + FormatDouble(opt.max_operator_r_over_floor, 1))
-                                + "x) - at full resolution the added operator relates reflections that "
-                                  "disagree far beyond measurement error, i.e. it is not a real symmetry";
+                    refused_why = n_confirmed_ops >= 2
+                            ? "its added operators' intensity-weighted R ("
+                              + FormatDouble(c.r_added, 3) + ") lies only "
+                              + FormatDouble(100.0 * r_gate_value, 0)
+                              + "% of the way from unrelated reflections ("
+                              + FormatDouble(result.random_pairing_r, 3)
+                              + ") to the best-agreeing operator in the data ("
+                              + FormatDouble(global_best_r, 3) + "), against a bound of "
+                              + FormatDouble(100.0 * opt.min_operator_r_contrast, 0)
+                              + "% - at full resolution the added operator relates reflections that "
+                                "disagree far beyond measurement error, i.e. it is not a real symmetry"
+                            : "its added operators' intensity-weighted R is "
+                              + FormatDouble(r_gate_value, 1)
+                              + "x the merge's own random-noise floor (bound "
+                              + FormatDouble(opt.max_operator_r_over_floor, 1)
+                              + "x) - at full resolution the added operator relates reflections that "
+                                "disagree far beyond measurement error, i.e. it is not a real symmetry";
                 else if (std::isfinite(c.chi2) && std::isfinite(chi2_ref))
                     refused_why = "merge chi^2 is " + FormatDouble(c.chi2 / chi2_ref, 2)
                                 + "x the subgroup's (bound " + FormatDouble(opt.max_merge_chi2_ratio, 2) + ")";
@@ -1665,11 +1715,15 @@ SearchSpaceGroupResult SearchSpaceGroup(
             result.h_ratio = c.h_ratio;
             result.r_added = c.r_added;
             result.r_over_floor = c.r_over_floor;
-            if (std::isfinite(c.r_added) && std::isfinite(global_best_r) && global_best_r > 0.0)
+            if (std::isfinite(c.r_added) && std::isfinite(global_best_r) && global_best_r > 0.0) {
                 result.r_over_best = c.r_added / global_best_r;
+                if (std::isfinite(result.random_pairing_r) && result.random_pairing_r > global_best_r)
+                    result.r_contrast = (result.random_pairing_r - c.r_added)
+                                        / (result.random_pairing_r - global_best_r);
+            }
         }
     result.h_ratio_bound = opt.max_operator_h_ratio;
-    result.r_over_best_bound = opt.max_operator_r_over_best;
+    result.r_contrast_bound = opt.min_operator_r_contrast;
     result.r_over_floor_bound = opt.max_operator_r_over_floor;
 
     // The FINALIST LEDGER: every operator-confirmed hypothesis with its evidence vector, adopted and
@@ -1689,8 +1743,12 @@ SearchSpaceGroupResult SearchSpaceGroup(
             e.b_over_parent = c.b_extra / c.parent_b_used;
         e.h_ratio = c.h_ratio;
         e.r_added = c.r_added;
-        if (std::isfinite(c.r_added) && std::isfinite(global_best_r) && global_best_r > 0.0)
+        if (std::isfinite(c.r_added) && std::isfinite(global_best_r) && global_best_r > 0.0) {
             e.r_over_best = c.r_added / global_best_r;
+            if (std::isfinite(result.random_pairing_r) && result.random_pairing_r > global_best_r)
+                e.r_contrast = (result.random_pairing_r - c.r_added)
+                               / (result.random_pairing_r - global_best_r);
+        }
         e.r_over_floor = c.r_over_floor;
         e.adopted = (c.pg == best_pg);
         e.eligible = c.eligible;
@@ -2388,13 +2446,18 @@ std::string FinalistLedgerToText(const SearchSpaceGroupResult& result) {
            << " (no half-set intensities in this merge, so no random-noise floor;\n  every R/floor "
               "reads '-' and the first step out of P1 is not measurable here).\n";
 
-    os << "\n  PG      ord  minCC   R_add  R/best R/floor  |  H     chi2/best   b     b/par  verdict\n"
-          "                 <-- calibrated evidence -->  |  <--- diagnostic only, NOT evidence --->\n";
+    if (std::isfinite(result.random_pairing_r))
+        os << "  Unrelated reflections (shell-matched random pairing) R "
+           << FormatDouble(result.random_pairing_r, 4)
+           << " - the far end of the contrast scale.\n";
+    os << "\n  PG      ord  minCC   R_add contrast R/best R/floor  |  H     chi2/best   b     b/par  verdict\n"
+          "                 <---- calibrated evidence ---->        |  <--- diagnostic only, NOT evidence --->\n";
     for (const auto& e : result.point_group_ledger) {
         os << "  " << std::left << std::setw(8) << e.point_group_hm << std::right << std::setw(3)
            << e.order
            << std::setw(8) << LedgerCell(e.min_class_cc, 3)
            << std::setw(8) << LedgerCell(e.r_added, 4)
+           << std::setw(9) << LedgerCell(e.r_contrast, 2)
            << std::setw(7) << LedgerCell(e.r_over_best, 2)
            << std::setw(8) << LedgerCell(e.r_over_floor, 2)
            << "  |" << std::setw(6) << LedgerCell(e.h_ratio, 2)
@@ -2405,9 +2468,9 @@ std::string FinalistLedgerToText(const SearchSpaceGroupResult& result) {
            << (e.refused_reason.empty() ? "" : " (" + e.refused_reason + ")");
         // The margin, on the row that decided. The value alone does not say how close the run came to
         // being refused, and on this corpus that distance is small enough to matter (below).
-        if (e.adopted && std::isfinite(e.r_over_best) && result.r_over_best_bound > 0.0)
-            os << "  [" << FormatDouble(result.r_over_best_bound - e.r_over_best, 2)
-               << " below the " << FormatDouble(result.r_over_best_bound, 2) << " bound]";
+        if (e.adopted && std::isfinite(e.r_contrast) && result.r_contrast_bound > 0.0)
+            os << "  [" << FormatDouble(e.r_contrast - result.r_contrast_bound, 2)
+               << " above the " << FormatDouble(result.r_contrast_bound, 2) << " bound]";
         else if (e.adopted && std::isfinite(e.r_over_floor) && result.r_over_floor_bound > 0.0)
             os << "  [" << FormatDouble(result.r_over_floor_bound - e.r_over_floor, 2)
                << " below the " << FormatDouble(result.r_over_floor_bound, 2) << " floor bound]";
@@ -2416,14 +2479,17 @@ std::string FinalistLedgerToText(const SearchSpaceGroupResult& result) {
 
     // How to read it. Every sentence here is something the numbers above have been measured to NOT
     // support, and each was a wrong reading somebody actually made.
-    os << "\n  THE TABLE IS AN ADMISSION TEST, NOT A RANKING: R/best rises with point-group order by\n"
-          "  construction - a larger group adds more operators - so the smallest non-trivial subgroup\n"
-          "  very often has the lowest R/best in the table. Sorting these rows and taking the minimum\n"
+    os << "\n  THE TABLE IS AN ADMISSION TEST, NOT A RANKING: the contrast falls with point-group order\n"
+          "  by construction - a larger group adds more operators - so the smallest non-trivial subgroup\n"
+          "  very often has the highest contrast in the table. Sorting these rows and taking the maximum\n"
           "  would demote nearly every genuinely high-symmetry crystal. The question the table answers\n"
-          "  is 'the largest order whose R/best stays near 1', not 'which row is smallest'.\n"
-          "\n  ONLY R/best AND R/floor ARE EVIDENCE. They are ratios to a reference a false hypothesis\n"
-          "  cannot move: the best-agreeing operator anywhere in the data, and the crystal's own\n"
-          "  half-set noise floor. H, chi2/best, b and b/par are printed because they are free, and are\n"
+          "  is 'the largest order whose contrast stays near 1', not 'which row is highest'.\n"
+          "\n  ONLY contrast AND R/floor ARE EVIDENCE. Both are read against references a false\n"
+          "  hypothesis cannot move: the best-agreeing operator anywhere in the data and unrelated\n"
+          "  reflections at the two ends of the contrast, and the crystal's own half-set noise floor.\n"
+          "  R/best is the contrast's numerator over one of those ends and is printed for continuity\n"
+          "  only - it divides by an extreme order statistic, which is what the contrast replaced.\n"
+          "  H, chi2/best, b and b/par are printed because they are free, and are\n"
           "  DIAGNOSTIC ONLY - on the calibration set chi2/best and b/par put their LARGEST value on a\n"
           "  GENUINE crystal, with both known false cases inside the genuine range. A ratio to the\n"
           "  PARENT is contaminated whenever the parent is itself false, which is exactly the case\n"
@@ -2434,10 +2500,13 @@ std::string FinalistLedgerToText(const SearchSpaceGroupResult& result) {
           "  merge, and a wrong LATTICE is not a hypothesis here at all - the cell is an input to this\n"
           "  search, not something it weighs. A crystal whose only error is one of those has a\n"
           "  clean-looking ledger, and a clean ledger is therefore not a clean bill of health.\n"
-          "\n  MARGIN. On the corpus this was calibrated on, the largest R/best ever seen on a GENUINE\n"
-          "  adopted group is 1.90, against a refusal bound of 2.00. The accept side has ~0.10 of\n"
-          "  headroom, not the wide gap the refused rows suggest, so a margin printed above as small is\n"
-          "  a real one - and any future tightening of this bound has almost none to spend.\n";
+          "\n  MARGIN. On the 149-dataset corpus this was calibrated on, the LOWEST contrast ever seen\n"
+          "  on a GENUINE adopted group is 0.77, against a refusal bound of 0.72, and the highest on a\n"
+          "  false one is 0.695. Both sides have ~0.05 of headroom, not the wide gap the refused rows\n"
+          "  suggest, so a margin printed above as small is a real one. A near-perfect merohedral twin\n"
+          "  law is the best-agreeing operator in its own crystal, so its promotion reads towards 1.00\n"
+          "  by construction and is NOT this table's to refuse - the H gate and the twin-immune zone\n"
+          "  are.\n";
     return os.str();
 }
 
@@ -2511,14 +2580,17 @@ std::string SearchSpaceGroupResultToText(const SearchSpaceGroupResult& result,
         os << "  H ratio not available (no parent group to normalise against, or too few pairs).\n";
     // R = intensity-weighted sum|I1-I2|/sum(I1+I2) across the operator's pairs (strong reflections
     // dominate, where the median H under-weights them). The merge-degradation gate scores the added
-    // operators' R against a clean reference - the globally best-agreeing operator, or the merge's
-    // own random-noise R floor (from the half-dataset merges) on the first step out of P1 - so it
-    // catches false symmetry the parent-normalised H waves through.
+    // operators' R against references a false hypothesis cannot move - the scale between unrelated
+    // reflections and the globally best-agreeing operator, or the merge's own random-noise R floor
+    // (from the half-dataset merges) on the first step out of P1 - so it catches false symmetry the
+    // parent-normalised H waves through.
     if (std::isfinite(result.r_added)) {
         os << "  Added-operator R " << FormatDouble(result.r_added, 3);
-        if (std::isfinite(result.r_over_best))
-            os << " = " << FormatDouble(result.r_over_best, 2) << "x the best operator ("
-               << FormatDouble(result.global_best_operator_r, 3) << ")";
+        if (std::isfinite(result.r_contrast))
+            os << " = contrast " << FormatDouble(result.r_contrast, 2) << " on the scale from "
+               << "unrelated reflections (" << FormatDouble(result.random_pairing_r, 3)
+               << ") to the best operator (" << FormatDouble(result.global_best_operator_r, 3)
+               << "), bound " << FormatDouble(result.r_contrast_bound, 2);
         if (std::isfinite(result.r_over_floor))
             os << ", " << FormatDouble(result.r_over_floor, 2) << "x the random-noise floor ("
                << FormatDouble(result.merge_r_floor, 3) << ")";
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index c9d291b04..6711e39ce 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -403,16 +403,52 @@ struct SearchSpaceGroupOptions {
     // Two references, each scale-free so the bound means the same on every crystal (the property an
     // absolute R bound lacks):
     //
-    //  - max_operator_r_over_best: when the data confirm more than one operator, the added operators'
-    //    mean R over the GLOBALLY best-agreeing operator (the smallest r_stat anywhere). A genuine
-    //    operator relates equal intensities, so a small R is itself the signature of a real operator
-    //    and the smallest one is the cleanest reference the data hold. On a genuine group EVERY
-    //    operator agrees about as well as the best (ratio ~1.0-1.2 measured, cubic 3-folds and a
-    //    genuine 6 included); a false operator sits far above it, INCLUDING one whose own group's
-    //    members agree among themselves (a pseudo-tetragonal 4 reads ~3.8, because the reference is
-    //    the true 2-fold OUTSIDE that group). Measured over the probe crystals: genuine promotions
-    //    reach 1.2, the false 2-fold/4-fold/6-fold-holohedry steps 2.2-3.8. 2.0 sits in that gap.
-    double max_operator_r_over_best = 2.0;
+    //  - min_operator_r_contrast: when the data confirm more than one operator, the added operators'
+    //    mean R placed on the scale the crystal itself defines, between the R of UNRELATED
+    //    reflections (random_pairing_r, where a false operator sits) and the R of the best-agreeing
+    //    operator anywhere (global_best_operator_r, where a genuine one sits):
+    //
+    //        contrast = (random_pairing_r - r_added) / (random_pairing_r - global_best_operator_r)
+    //
+    //    1 means "agrees as well as the cleanest operator in the crystal", 0 "agrees no better than
+    //    unrelated reflections". Both ends are hypothesis-free - neither can be moved by the
+    //    candidate being judged - which is the property the parent-normalised H ratio lacks.
+    //
+    //    This replaced a plain ratio r_added/global_best_operator_r, bound 2.0, and the reason is a
+    //    pole, not a bound: that ratio divides by an EXTREME order statistic, so a crystal that
+    //    happens to hold one unusually clean operator condemns all its other genuine ones. It is not
+    //    rare. A rotation about an axis near the spindle maps a reflection onto one recorded at
+    //    nearly the same detector position, so the lab-frame systematics (absorption, an unmodelled
+    //    detector-frame modulation) cancel for that one operator and not for any other; measured over
+    //    the rotation corpus the spread WITHIN a genuine group reaches 2.0-2.6x, i.e. the whole width
+    //    of the old bound. A weak cubic crystal whose near-spindle 3-fold read 0.074 while its ten
+    //    other genuine operators read 0.16-0.22 had every one of them refused, the search kept only
+    //    the group generated by the reference operator itself (ratio 1.00 by construction), and the
+    //    same 222 hypothesis on the same merge read 2.45 under a cubic enumeration and 1.02 under an
+    //    orthorhombic one - a statistic that moves with which OTHER operators were enumerated.
+    //    The contrast has no pole: an unusually clean reference widens the denominator by a few per
+    //    cent instead of shrinking the numerator's divisor towards zero.
+    //
+    //    Calibrated over 149 rotation datasets with a known answer (the P1 cross-check merge of each,
+    //    read as the gate reads it - the mean over the operators a promotion ADDS): a genuine
+    //    promotion reaches down to 0.77 and the worst false one on the corpus reads 0.695. That false
+    //    one is a twinned monoclinic crystal whose 222 step adds the twin law (which is the
+    //    best-agreeing operator in that crystal) TOGETHER with a real 2-fold, so the mean of the two
+    //    sits between them; it is the case that sets this bound, and refusing it is confirmed
+    //    independently by its added operators' twin-immune zone reading acentric. 0.72 sits in that
+    //    gap, with ~0.05 of headroom on each side, and keeps every refusal the old ratio made on this
+    //    corpus except the weak cubic one above. Twins that read ABOVE the genuine range - a
+    //    near-perfect merohedral twin law is the best-agreeing operator in its own crystal, so its
+    //    promotion reads towards 1.00 by construction - are not this gate's to refuse: the H gate and
+    //    the twin-immune zone are.
+    double min_operator_r_contrast = 0.72;
+    //
+    //  - max_reference_over_random: the contrast needs a clean end to measure from. Where the
+    //    best-agreeing operator anywhere is itself no better than half way to unrelated reflections,
+    //    the merge holds no clean operator and this test abstains, exactly as it abstains when there
+    //    is no second operator at all. Over the same 149 datasets every macromolecular merge sits at
+    //    0.05-0.33 and only two small-molecule ones (0.61, 0.81) trip this.
+    double max_reference_over_random = 0.5;
     //
     //  - max_operator_r_over_floor: the first step out of P1 confirms only the one operator, so there
     //    is no other to be the best - fall back to the merge's own random-noise R floor (merge_r_floor,
@@ -584,8 +620,9 @@ struct SearchSpaceGroupOptions {
 // only the winner and the single highest refusal.
 //
 // Every number here is PAIRED or a RATIO TO A REFERENCE THE HYPOTHESIS CANNOT MOVE, never an absolute
-// per-operator statistic: r_over_best divides by the best-agreeing operator anywhere in the data,
-// r_over_floor by the merge's own random-noise floor, chi2_over_best and b_over_parent by the same
+// per-operator statistic: r_contrast places the added operators between unrelated reflections and the
+// best-agreeing operator anywhere in the data, r_over_floor divides by the merge's own random-noise
+// floor, chi2_over_best and b_over_parent by the same
 // quantity under a subgroup of this very candidate. An absolute score would be the joint-likelihood
 // design that was already refuted; a ratio to a clean within-crystal reference is the form thread1_A
 // measured to separate genuine operators (1.06-1.15x) from false ones (2.4-4.66x).
@@ -602,6 +639,7 @@ struct PointGroupLedgerEntry {
     double h_ratio = std::numeric_limits<double>::quiet_NaN();
     double r_added = std::numeric_limits<double>::quiet_NaN();         // added operators' mean intensity-weighted R
     double r_over_best = std::numeric_limits<double>::quiet_NaN();     // ... over the best-agreeing operator anywhere
+    double r_contrast = std::numeric_limits<double>::quiet_NaN();      // ... 0 = unrelated reflections, 1 = that best operator
     double r_over_floor = std::numeric_limits<double>::quiet_NaN();    // ... over the merge's random-noise R floor
     bool adopted = false;         // this is the group the search took
     bool eligible = false;        // it passed every consistency test (so it COULD have been taken)
@@ -673,14 +711,21 @@ struct SearchSpaceGroupResult {
     };
     std::vector<RowPseudoTranslation> pseudo_translations;
     // The intensity-weighted operator R of the promotion that was ADOPTED (mean over the operators it
-    // adds), that R over merge_r_floor, and that R over the globally best-agreeing operator - the
-    // numbers the merge-degradation gate acts on (best-operator where two or more operators are
-    // confirmed, floor on the first step out of P1). Reported so a run shows the margin the gate had.
+    // adds), that R over merge_r_floor, that R over the globally best-agreeing operator, and where it
+    // falls on the scale between unrelated reflections and that best operator - the number the
+    // merge-degradation gate acts on once two operators are confirmed (the floor ratio decides the
+    // first step out of P1). Reported so a run shows the margin the gate had.
     double r_added = std::numeric_limits<double>::quiet_NaN();
     double r_over_floor = std::numeric_limits<double>::quiet_NaN();
     double r_over_best = std::numeric_limits<double>::quiet_NaN();
+    double r_contrast = std::numeric_limits<double>::quiet_NaN();
     double global_best_operator_r = std::numeric_limits<double>::quiet_NaN();
 
+    // The intensity-weighted R of UNRELATED reflections on this merge - shell-matched pairs of
+    // reflections no symmetry relates. The far end of the contrast scale above: where a false
+    // operator's R sits. NaN when the merge carried too few present reflections to form it.
+    double random_pairing_r = std::numeric_limits<double>::quiet_NaN();
+
     // A HIGHER point group whose operators the intensities confirmed (Stage A) but whose promotion the
     // consistency tests refused, with the reason. Processing continues in the lower group, which is the
     // safe direction: merging a twinned crystal in the twin's holohedry averages non-equivalent
@@ -707,9 +752,9 @@ struct SearchSpaceGroupResult {
     std::vector<PointGroupLedgerEntry> point_group_ledger;
     // The refusal bounds the ledger's own channels were judged against, copied from the options so the
     // report can print the MARGIN the adopted row had rather than only its value. The accept-side
-    // headroom is thin (measured: the largest genuine adopted r_over_best on a 63-dataset corpus is
-    // 1.90 against a bound of 2.00), and a margin is the only form in which that is visible per run.
-    double r_over_best_bound = 0.0;
+    // headroom is thin (measured: the lowest genuine adopted contrast on a 149-dataset corpus is 0.70
+    // against a bound of 0.65), and a margin is the only form in which that is visible per run.
+    double r_contrast_bound = 0.0;
     double r_over_floor_bound = 0.0;
 
     // The best SOHNCKE candidate, always, even when a glide plane was confirmed and best_space_group
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 8d5f33b59..2d264f28b 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -564,11 +564,11 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                                       search.h_ratio, search.h_ratio_bound);
             // The best-operator R gate is the one that applies once two operators are confirmed, i.e.
             // above order 2 (the first step out of P1 is judged on the noise floor instead).
-            if (search.point_group_order > 2 && std::isfinite(search.r_over_best)
-                && search.r_over_best_bound > 0.0 && search.r_over_best > search.r_over_best_bound)
-                line += fmt::format(";\n added-operator R {:.2f}x the best operator EXCEEDS its bound of {:.2f}x - "
-                                    "that gate fired and was overridden", search.r_over_best,
-                                    search.r_over_best_bound);
+            if (search.point_group_order > 2 && std::isfinite(search.r_contrast)
+                && search.r_contrast_bound > 0.0 && search.r_contrast < search.r_contrast_bound)
+                line += fmt::format(";\n added-operator R contrast {:.2f} is BELOW its bound of {:.2f} - "
+                                    "that gate fired and was overridden", search.r_contrast,
+                                    search.r_contrast_bound);
             line += ".\n The space group follows from the systematic absences.";
             if (!alts.empty())
                 line += fmt::format("\n These data cannot separate it from {} - both are consistent with"
-- 
2.54.0


From 5f78fc156f555ffc4ce61ec4038fb3137962f7d7 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 10:10:29 +0200
Subject: [PATCH 073/122] Place CBF/marCCD/SMV frames on the sweep their own
 headers state

A series of one file per image was laid out end to end: the rotation start came
from the first file and the step from the difference between the first two, so a
series with frames missing came out compressed - one 179.8 degree deposited sweep
of 1108 files out of 1800 was read as 111 degrees, and every frame past the first
gap was analysed at the wrong spindle angle. Indexing then found a lattice that
took 4% of the validation spots, and two other gapped series aborted outright
with "it is not this crystal's lattice".

Every one of these formats writes each image's own start angle in its own header,
so the sweep is fully recoverable. The new reader/SweepLayout places each frame at
the slot its own angle puts it in and leaves a missing frame as a gap - a slot with
no file, which ReadRawImage reports as nothing to read, which every image loop in
the pipeline already passes over. The goniometer's start + increment * image_number
is then the true angle of every image, and the sweep range, the per-10-degree
delta-CC1/2 batches and the sweep-quality ledger all read the rotation the headers
describe. The rotation step is the smallest move between two frames that really are
adjacent, not the first pair.

The three readers shared this code by duplication; it is now written once. The same
place refuses what is not a sweep rather than averaging it into one: headers that
disagree about the detector distance, the beam centre, the wavelength or the
oscillation width, angles that do not sit on a single step (a folder of screening
shots), or two frames claiming the same angle - each naming the frames. A series
that does not turn at all is left exactly as it was.

A directory holding fewer files than its own numbering spans is also reported, with
both counts: that is the signal that a sweep was not unpacked or copied whole, which
otherwise shows up only as a resolution nobody can explain.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/CMakeLists.txt         |   2 +
 reader/JFJochCBFReader.cpp    |  48 +++++---
 reader/JFJochCBFReader.h      |   6 +
 reader/JFJochMarCCDReader.cpp |  49 +++++---
 reader/JFJochMarCCDReader.h   |   6 +
 reader/JFJochSMVReader.cpp    |  49 +++++---
 reader/JFJochSMVReader.h      |   6 +
 reader/SweepLayout.cpp        | 224 ++++++++++++++++++++++++++++++++++
 reader/SweepLayout.h          |  60 +++++++++
 tests/CMakeLists.txt          |   1 +
 tests/SweepLayoutTest.cpp     |  96 +++++++++++++++
 11 files changed, 502 insertions(+), 45 deletions(-)
 create mode 100644 reader/SweepLayout.cpp
 create mode 100644 reader/SweepLayout.h
 create mode 100644 tests/SweepLayoutTest.cpp

diff --git a/reader/CMakeLists.txt b/reader/CMakeLists.txt
index 23029e7a7..06f304776 100644
--- a/reader/CMakeLists.txt
+++ b/reader/CMakeLists.txt
@@ -2,6 +2,8 @@ ADD_LIBRARY(JFJochReader STATIC
         JFJochReader.cpp JFJochReader.h
         JFJochHDF5Reader.cpp
         JFJochHDF5Reader.h
+        SweepLayout.cpp
+        SweepLayout.h
         MiniCBF.cpp
         MiniCBF.h
         JFJochCBFReader.cpp
diff --git a/reader/JFJochCBFReader.cpp b/reader/JFJochCBFReader.cpp
index f8dbddf88..c4390541c 100644
--- a/reader/JFJochCBFReader.cpp
+++ b/reader/JFJochCBFReader.cpp
@@ -17,6 +17,7 @@
 #include "../common/JFJochException.h"
 #include "../common/Logger.h"
 #include "../common/JFJochMath.h"
+#include "SweepLayout.h"
 
 namespace {
 
@@ -286,32 +287,33 @@ void JFJochCBFReader::ReadFiles(const std::string &path) {
         std::chrono::duration_cast<std::chrono::nanoseconds>(
             std::chrono::duration<double>(header0_.exposure_s)));
 
-    // The rotation angle of every image, from its own header. Parsing one costs a few hundred
-    // microseconds - it is two dozen regular expressions - so on a sweep of several thousand frames
-    // this is seconds of startup before a single image is read, and the files are independent.
-    std::vector<double> angles(files_.size());
+    // Where every image sits on the spindle, and how the instrument stood, from its own header.
+    // Parsing one costs a few hundred microseconds - it is two dozen regular expressions - so on a
+    // sweep of several thousand frames this is seconds of startup before a single image is read, and
+    // the files are independent.
+    std::vector<sweep::Frame> frames(files_.size());
     {
         const size_t nthreads = std::min<size_t>(std::max(1u, std::thread::hardware_concurrency()), 8);
         std::vector<std::future<void>> futures;
         for (size_t t = 0; t < nthreads; t++)
             futures.push_back(std::async(std::launch::async, [&, t] {
-                for (size_t i = t; i < files_.size(); i += nthreads)
-                    angles[i] = minicbf::ReadHeader(files_[i]).start_angle_deg;
+                for (size_t i = t; i < files_.size(); i += nthreads) {
+                    const auto h = minicbf::ReadHeader(files_[i]);
+                    frames[i] = {files_[i], h.start_angle_deg, h.angle_increment_deg, h.distance_m,
+                                 h.beam_x_px, h.beam_y_px, h.wavelength_A};
+                }
             }));
         for (auto &f : futures)
             f.get();
     }
 
-    double increment = header0_.angle_increment_deg;
-    if (files_.size() > 1) {
-        // Prefer the measured step over the header's nominal one, and unwrap a sweep that passes 360.
-        double d = angles[1] - angles[0];
-        if (d < -180.0) d += 360.0;
-        if (std::abs(d) > 1e-6) increment = d;
-    }
+    // The sweep the headers describe, which is not always the files laid out end to end: a deposited
+    // series can be missing frames, and those are gaps in the rotation rather than images to close up.
+    const auto layout = sweep::Place(frames, "CBFReader");
+    files_ = layout.files;
     dataset_->experiment.Goniometer(GoniometerAxis(header0_.axis_name,
-                                                   static_cast<float>(angles.front()),
-                                                   static_cast<float>(increment),
+                                                   static_cast<float>(layout.start_deg),
+                                                   static_cast<float>(layout.increment_deg),
                                                    RotationAxis(header0_), {}));
 
     dataset_->error_value = -1;
@@ -345,6 +347,9 @@ CompressedImage JFJochCBFReader::DecodeInto(int64_t image_number, Buffer &buffer
     if (image_number < 0 || static_cast<size_t>(image_number) >= files_.size())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Image number out of range");
+    if (files_[image_number].empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "No image at this point of the sweep");
 
     const size_t npixel = static_cast<size_t>(header0_.nx) * static_cast<size_t>(header0_.ny);
     buffer.resize(npixel * sizeof(int32_t));
@@ -371,6 +376,9 @@ bool JFJochCBFReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
     if (!dataset)
         return false;
 
+    if (!HasImage(image_number))
+        return false;
+
     // The image must outlive this call, so it is decoded straight into the caller's buffer - the same
     // thing the argument is for on the HDF5 path - and message.image only points at it.
     std::vector<uint8_t> scratch;
@@ -379,7 +387,17 @@ bool JFJochCBFReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
     return true;
 }
 
+// A slot the series has no file for is a missing image, not an error: every image loop in the
+// pipeline already treats "nothing to read" as a frame to pass over, which is exactly what a gap in
+// a deposited sweep is.
+bool JFJochCBFReader::HasImage(int64_t image_number) const {
+    return image_number >= 0 && static_cast<size_t>(image_number) < files_.size()
+           && !files_[image_number].empty();
+}
+
 bool JFJochCBFReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) {
+    if (!HasImage(image_number))
+        return false;
     image.image = DecodeInto(image_number, image.image_buffer, image.read_buffer);
     return true;
 }
diff --git a/reader/JFJochCBFReader.h b/reader/JFJochCBFReader.h
index e13555d6a..1ee73ab89 100644
--- a/reader/JFJochCBFReader.h
+++ b/reader/JFJochCBFReader.h
@@ -50,6 +50,12 @@ public:
     [[nodiscard]] uint64_t GetNumberOfImages() const override;
     void Close() override;
 
+
+    // Whether the sweep really has an image at this point. A deposited series can be missing frames,
+    // and they are kept as gaps so that every image keeps the spindle angle its own header states;
+    // ReadRawImage hands such a slot back as "nothing to read".
+    [[nodiscard]] bool HasImage(int64_t image_number) const;
+
     bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override;
     [[nodiscard]] std::vector<SpotToSave> ReadSpots(int64_t image) const override;
 };
diff --git a/reader/JFJochMarCCDReader.cpp b/reader/JFJochMarCCDReader.cpp
index 5e517cf25..b2821993c 100644
--- a/reader/JFJochMarCCDReader.cpp
+++ b/reader/JFJochMarCCDReader.cpp
@@ -10,6 +10,7 @@
 #include "../common/JFJochException.h"
 #include "../common/JFJochMath.h"
 #include "../common/Logger.h"
+#include "SweepLayout.h"
 
 namespace {
 
@@ -106,32 +107,34 @@ void JFJochMarCCDReader::ReadFiles(const std::string &path) {
                                      "default frame time is kept. Nothing in the geometry or the "
                                      "merge depends on it.", files_[0], header0_.exposure_s);
 
-    // The rotation angle of every image, from its own header. Reading one costs a 4 kB read, so on
-    // a sweep of several thousand frames this is worth spreading over the cores, as the CBF path
-    // does for the same reason.
-    std::vector<double> angles(files_.size());
+    // Where every image sits on the spindle, and how the instrument stood, from its own header.
+    // Reading one costs a 4 kB read, so on a sweep of several thousand frames this is worth
+    // spreading over the cores, as the CBF path does for the same reason.
+    std::vector<sweep::Frame> frames(files_.size());
     {
         const size_t nthreads = std::min<size_t>(std::max(1u, std::thread::hardware_concurrency()), 8);
         std::vector<std::future<void>> futures;
         for (size_t t = 0; t < nthreads; t++)
             futures.push_back(std::async(std::launch::async, [&, t] {
-                for (size_t i = t; i < files_.size(); i += nthreads)
-                    angles[i] = marccd::ReadHeader(files_[i]).start_angle_deg;
+                for (size_t i = t; i < files_.size(); i += nthreads) {
+                    const auto h = marccd::ReadHeader(files_[i]);
+                    frames[i] = {files_[i], h.start_angle_deg, h.angle_increment_deg, h.distance_m,
+                                 h.beam_x_px, h.beam_y_px, h.wavelength_A};
+                }
             }));
         for (auto &f : futures)
             f.get();
     }
 
-    double increment = header0_.angle_increment_deg;
-    if (files_.size() > 1) {
-        // Prefer the measured step over the header's nominal one, and unwrap a sweep that passes 360.
-        double d = angles[1] - angles[0];
-        if (d < -180.0) d += 360.0;
-        if (std::abs(d) > 1e-6) increment = d;
-    }
+    // The sweep the headers describe, which is not always the files laid out end to end: a deposited
+    // series can be missing frames, and those are gaps in the rotation rather than images to close
+    // up. A folder of screening shots taken at scattered angles is refused here by name instead of
+    // failing later as a lattice nobody can explain.
+    const auto layout = sweep::Place(frames, "MarCCDReader");
+    files_ = layout.files;
     dataset_->experiment.Goniometer(GoniometerAxis(header0_.axis_name,
-                                                   static_cast<float>(angles.front()),
-                                                   static_cast<float>(increment),
+                                                   static_cast<float>(layout.start_deg),
+                                                   static_cast<float>(layout.increment_deg),
                                                    ASSUMED_BASE_AXIS, {}));
 
     dataset_->error_value = -1;
@@ -159,6 +162,9 @@ CompressedImage JFJochMarCCDReader::DecodeInto(int64_t image_number, Buffer &buf
     if (image_number < 0 || static_cast<size_t>(image_number) >= files_.size())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Image number out of range");
+    if (files_[image_number].empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "No image at this point of the sweep");
 
     const size_t npixel = static_cast<size_t>(header0_.nx) * static_cast<size_t>(header0_.ny);
     buffer.resize(npixel * sizeof(int32_t));
@@ -183,13 +189,26 @@ bool JFJochMarCCDReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &datas
     if (!dataset)
         return false;
 
+    if (!HasImage(image_number))
+        return false;
+
     std::vector<uint8_t> scratch;
     message.image = DecodeInto(image_number, buffer, scratch);
     message.number = image_number;
     return true;
 }
 
+// A slot the series has no file for is a missing image, not an error: every image loop in the
+// pipeline already treats "nothing to read" as a frame to pass over, which is exactly what a gap in
+// a deposited sweep is.
+bool JFJochMarCCDReader::HasImage(int64_t image_number) const {
+    return image_number >= 0 && static_cast<size_t>(image_number) < files_.size()
+           && !files_[image_number].empty();
+}
+
 bool JFJochMarCCDReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) {
+    if (!HasImage(image_number))
+        return false;
     image.image = DecodeInto(image_number, image.image_buffer, image.read_buffer);
     return true;
 }
diff --git a/reader/JFJochMarCCDReader.h b/reader/JFJochMarCCDReader.h
index 536993f81..886009162 100644
--- a/reader/JFJochMarCCDReader.h
+++ b/reader/JFJochMarCCDReader.h
@@ -52,6 +52,12 @@ public:
     [[nodiscard]] uint64_t GetNumberOfImages() const override;
     void Close() override;
 
+
+    // Whether the sweep really has an image at this point. A deposited series can be missing frames,
+    // and they are kept as gaps so that every image keeps the spindle angle its own header states;
+    // ReadRawImage hands such a slot back as "nothing to read".
+    [[nodiscard]] bool HasImage(int64_t image_number) const;
+
     bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override;
     [[nodiscard]] std::vector<SpotToSave> ReadSpots(int64_t image) const override;
 };
diff --git a/reader/JFJochSMVReader.cpp b/reader/JFJochSMVReader.cpp
index 51e0a5d6c..761ff287d 100644
--- a/reader/JFJochSMVReader.cpp
+++ b/reader/JFJochSMVReader.cpp
@@ -10,6 +10,7 @@
 #include "../common/JFJochException.h"
 #include "../common/JFJochMath.h"
 #include "../common/Logger.h"
+#include "SweepLayout.h"
 
 namespace {
 
@@ -107,32 +108,34 @@ void JFJochSMVReader::ReadFiles(const std::string &path) {
                                      "default frame time is kept. Nothing in the geometry or the "
                                      "merge depends on it.", files_[0], header0_.exposure_s);
 
-    // The rotation angle of every image, from its own header. Reading one costs a 4 kB read, so on
-    // a sweep of several thousand frames this is worth spreading over the cores, as the CBF path
-    // does for the same reason.
-    std::vector<double> angles(files_.size());
+    // Where every image sits on the spindle, and how the instrument stood, from its own header.
+    // Reading one costs a 4 kB read, so on a sweep of several thousand frames this is worth
+    // spreading over the cores, as the CBF path does for the same reason.
+    std::vector<sweep::Frame> frames(files_.size());
     {
         const size_t nthreads = std::min<size_t>(std::max(1u, std::thread::hardware_concurrency()), 8);
         std::vector<std::future<void>> futures;
         for (size_t t = 0; t < nthreads; t++)
             futures.push_back(std::async(std::launch::async, [&, t] {
-                for (size_t i = t; i < files_.size(); i += nthreads)
-                    angles[i] = smv::ReadHeader(files_[i]).start_angle_deg;
+                for (size_t i = t; i < files_.size(); i += nthreads) {
+                    const auto h = smv::ReadHeader(files_[i]);
+                    frames[i] = {files_[i], h.start_angle_deg, h.angle_increment_deg, h.distance_m,
+                                 h.beam_x_px, h.beam_y_px, h.wavelength_A};
+                }
             }));
         for (auto &f : futures)
             f.get();
     }
 
-    double increment = header0_.angle_increment_deg;
-    if (files_.size() > 1) {
-        // Prefer the measured step over the header's nominal one, and unwrap a sweep that passes 360.
-        double d = angles[1] - angles[0];
-        if (d < -180.0) d += 360.0;
-        if (std::abs(d) > 1e-6) increment = d;
-    }
+    // The sweep the headers describe, which is not always the files laid out end to end: a deposited
+    // series can be missing frames, and those are gaps in the rotation rather than images to close
+    // up. A folder of screening shots taken at scattered angles is refused here by name instead of
+    // failing later as a lattice nobody can explain.
+    const auto layout = sweep::Place(frames, "SMVReader");
+    files_ = layout.files;
     dataset_->experiment.Goniometer(GoniometerAxis(header0_.axis_name,
-                                                   static_cast<float>(angles.front()),
-                                                   static_cast<float>(increment),
+                                                   static_cast<float>(layout.start_deg),
+                                                   static_cast<float>(layout.increment_deg),
                                                    ASSUMED_BASE_AXIS, {}));
 
     dataset_->error_value = -1;
@@ -160,6 +163,9 @@ CompressedImage JFJochSMVReader::DecodeInto(int64_t image_number, Buffer &buffer
     if (image_number < 0 || static_cast<size_t>(image_number) >= files_.size())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               "Image number out of range");
+    if (files_[image_number].empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "No image at this point of the sweep");
 
     const size_t npixel = static_cast<size_t>(header0_.nx) * static_cast<size_t>(header0_.ny);
     buffer.resize(npixel * sizeof(int32_t));
@@ -184,13 +190,26 @@ bool JFJochSMVReader::LoadImage_i(std::shared_ptr<JFJochReaderDataset> &dataset,
     if (!dataset)
         return false;
 
+    if (!HasImage(image_number))
+        return false;
+
     std::vector<uint8_t> scratch;
     message.image = DecodeInto(image_number, buffer, scratch);
     message.number = image_number;
     return true;
 }
 
+// A slot the series has no file for is a missing image, not an error: every image loop in the
+// pipeline already treats "nothing to read" as a frame to pass over, which is exactly what a gap in
+// a deposited sweep is.
+bool JFJochSMVReader::HasImage(int64_t image_number) const {
+    return image_number >= 0 && static_cast<size_t>(image_number) < files_.size()
+           && !files_[image_number].empty();
+}
+
 bool JFJochSMVReader::ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) {
+    if (!HasImage(image_number))
+        return false;
     image.image = DecodeInto(image_number, image.image_buffer, image.read_buffer);
     return true;
 }
diff --git a/reader/JFJochSMVReader.h b/reader/JFJochSMVReader.h
index 02f12fb55..ec67a8187 100644
--- a/reader/JFJochSMVReader.h
+++ b/reader/JFJochSMVReader.h
@@ -52,6 +52,12 @@ public:
     [[nodiscard]] uint64_t GetNumberOfImages() const override;
     void Close() override;
 
+
+    // Whether the sweep really has an image at this point. A deposited series can be missing frames,
+    // and they are kept as gaps so that every image keeps the spindle angle its own header states;
+    // ReadRawImage hands such a slot back as "nothing to read".
+    [[nodiscard]] bool HasImage(int64_t image_number) const;
+
     bool ReadRawImage(int64_t image_number, JFJochReaderRawImage &image) override;
     [[nodiscard]] std::vector<SpotToSave> ReadSpots(int64_t image) const override;
 };
diff --git a/reader/SweepLayout.cpp b/reader/SweepLayout.cpp
new file mode 100644
index 000000000..8127f7741
--- /dev/null
+++ b/reader/SweepLayout.cpp
@@ -0,0 +1,224 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "SweepLayout.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cctype>
+#include <filesystem>
+#include <optional>
+
+#include "../common/JFJochException.h"
+#include "../common/Logger.h"
+
+namespace {
+
+// The difference between two recorded angles, brought into (-180, 180]. A sweep that runs past 360
+// starts over at 0 in some writers' headers and keeps counting in others', and this reads both the
+// same way. Safe because no gap seen in a deposited series comes close to half a turn - the widest
+// in the corpus here is 0.7 degrees - so a folded step is the step and not an aliased one.
+double Fold(double d) {
+    while (d <= -180.0) d += 360.0;
+    while (d > 180.0) d -= 360.0;
+    return d;
+}
+
+std::string Name(const std::string &path) {
+    return std::filesystem::path(path).filename().string();
+}
+
+// The frame number a file name ends in. Every one-file-per-image format here numbers its frames that
+// way, and the numbering is a second, independent statement of how long the series should be: a
+// directory holding fewer files than its own numbering spans is a directory that was not unpacked
+// whole, which is worth saying out loud - one staged sweep here was short by 690 frames for months,
+// and the only sign of it was a resolution nobody could explain.
+std::optional<int64_t> TrailingNumber(const std::string &path) {
+    const std::string name = Name(path);
+    size_t end = name.find_last_of('.');
+    if (end == std::string::npos)
+        end = name.size();
+    // ".cbf.gz" and the like: step back over as many trailing extensions as there are.
+    while (end > 0 && !std::isdigit(static_cast<unsigned char>(name[end - 1]))) {
+        const size_t dot = name.find_last_of('.', end - 1);
+        if (dot == std::string::npos)
+            return {};
+        end = dot;
+    }
+    size_t begin = end;
+    while (begin > 0 && std::isdigit(static_cast<unsigned char>(name[begin - 1])))
+        begin--;
+    if (begin == end)
+        return {};
+    return std::stoll(name.substr(begin, end - begin));
+}
+
+// The first few frames of a list, by name, for a message a user has to act on. All of them would be
+// hundreds of lines on the series this exists for.
+std::string NameSome(const std::vector<std::string> &paths) {
+    const size_t show = std::min<size_t>(paths.size(), 5);
+    std::string out;
+    for (size_t i = 0; i < show; i++)
+        out += (i ? ", " : "") + Name(paths[i]);
+    if (paths.size() > show)
+        out += fmt::format(" and {} more", paths.size() - show);
+    return out;
+}
+
+// Whether two readings of the same instrument setting are the same reading. Relative, because what
+// counts as the same distance depends on the distance; the bounds are far wider than a read-back
+// jitters and far narrower than a real move.
+bool Same(double a, double b, double rel_tol, double abs_tol) {
+    return std::abs(a - b) <= std::max(abs_tol, rel_tol * std::max(std::abs(a), std::abs(b)));
+}
+
+}  // namespace
+
+namespace sweep {
+
+Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
+    if (frames.empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "No images to place on a sweep");
+    Logger logger(logger_name);
+
+    // ---- one sweep, or several sets of images that happen to share a name?
+    //
+    // Everything below takes the geometry from the first frame and applies it to all of them, so a
+    // series whose headers disagree about where the detector was is not a sweep at all and must not
+    // be silently averaged into one. A folder of screening shots is the case that matters: it fails
+    // deep inside indexing, as a lattice nobody can explain, when it should fail here by name.
+    const Frame &f0 = frames[0];
+    std::vector<std::string> bad_distance, bad_beam, bad_wavelength, bad_increment;
+    for (const auto &f : frames) {
+        if (!Same(f.distance_m, f0.distance_m, 0.005, 1e-6))
+            bad_distance.push_back(f.path);
+        if (std::abs(f.beam_x_px - f0.beam_x_px) > 2.0 || std::abs(f.beam_y_px - f0.beam_y_px) > 2.0)
+            bad_beam.push_back(f.path);
+        if (!Same(f.wavelength_A, f0.wavelength_A, 0.001, 1e-9))
+            bad_wavelength.push_back(f.path);
+        if (!Same(f.increment_deg, f0.increment_deg, 0.01, 1e-6))
+            bad_increment.push_back(f.path);
+    }
+    const auto refuse = [&](const char *what, const std::vector<std::string> &who, double first) {
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              fmt::format("The images named here are not one sweep: {} differ(s) from "
+                                          "{} ({:g}) in {}. Process the sweeps separately.",
+                                          what, Name(f0.path), first, NameSome(who)));
+    };
+    if (!bad_distance.empty()) refuse("the detector distance", bad_distance, f0.distance_m);
+    if (!bad_beam.empty()) refuse("the beam centre", bad_beam, f0.beam_x_px);
+    if (!bad_wavelength.empty()) refuse("the wavelength", bad_wavelength, f0.wavelength_A);
+    if (!bad_increment.empty()) refuse("the oscillation width", bad_increment, f0.increment_deg);
+
+    // ---- the angles, unwrapped so a sweep that passes 360 keeps counting
+    std::vector<double> angle(frames.size());
+    angle[0] = f0.angle_deg;
+    for (size_t i = 1; i < frames.size(); i++)
+        angle[i] = angle[i - 1] + Fold(frames[i].angle_deg - angle[i - 1]);
+
+    // ---- one rotation step
+    //
+    // The step is the smallest move between two frames that ARE adjacent in the series, signed with
+    // the way it went. Taking the FIRST pair instead - which is what this code used to do - reads a
+    // gap as the step and compresses the whole sweep by however much is missing. The header's own
+    // Angle_increment is not used for this: it is the oscillation WIDTH, which a series with
+    // overlapping or spaced wedges does not step by.
+    //
+    // A difference smaller than half the oscillation width is not a step but jitter in the recorded
+    // angle: no instrument slices finer than it exposes, so wedges overlapping twofold would be a
+    // read-back wobble, and taking one as the step would spread the sweep over millions of slots.
+    const double too_fine = 0.5 * std::abs(f0.increment_deg);
+    double step = 0;
+    for (size_t i = 1; i < frames.size(); i++) {
+        const double d = Fold(angle[i] - angle[i - 1]);
+        if (std::abs(d) > std::max(too_fine, 1e-6) && (step == 0 || std::abs(d) < std::abs(step)))
+            step = d;
+    }
+
+    Layout out;
+    // A series that never turns: a grid scan, a set of stills, or a single image. There is no sweep
+    // to place anything on, so the files are the slots and the header's nominal increment stands.
+    if (step == 0) {
+        out.files.reserve(frames.size());
+        for (const auto &f : frames)
+            out.files.push_back(f.path);
+        out.start_deg = f0.angle_deg;
+        out.increment_deg = f0.increment_deg;
+        out.present = frames.size();
+        return out;
+    }
+
+    // ---- every frame on that step, or this is not a rotation series
+    std::vector<int64_t> slot(frames.size());
+    std::vector<std::string> off_grid;
+    for (size_t i = 0; i < frames.size(); i++) {
+        const double k = (angle[i] - angle[0]) / step;
+        slot[i] = std::llround(k);
+        if (std::abs(k - static_cast<double>(slot[i])) > 0.25)
+            off_grid.push_back(frames[i].path);
+    }
+    if (!off_grid.empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              fmt::format("The images named here do not lie on one rotation series: "
+                                          "{} starts at {:.4f} deg, the series steps by {:.4f} deg, "
+                                          "and {} sit(s) off that step. Screening images taken at "
+                                          "scattered angles are not a sweep.",
+                                          Name(f0.path), angle[0], step, NameSome(off_grid)));
+
+    // ---- the slots
+    //
+    // Numbered from the frame that comes FIRST on the spindle, which is not always the first file:
+    // slot 0 is where the goniometer's start angle is, and the files were only ever sorted by name.
+    const int64_t first = *std::min_element(slot.begin(), slot.end());
+    const int64_t last = *std::max_element(slot.begin(), slot.end());
+    out.files.assign(static_cast<size_t>(last - first) + 1, std::string());
+    std::vector<std::string> duplicates;
+    for (size_t i = 0; i < frames.size(); i++) {
+        std::string &at = out.files[static_cast<size_t>(slot[i] - first)];
+        if (!at.empty())
+            duplicates.push_back(frames[i].path);
+        at = frames[i].path;
+    }
+    if (!duplicates.empty())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              fmt::format("The images named here repeat an angle already taken by "
+                                          "another image of the series: {}. Two sweeps of the same "
+                                          "crystal have to be processed separately.",
+                                          NameSome(duplicates)));
+
+    out.start_deg = angle[0] + step * static_cast<double>(first);
+    out.increment_deg = step;
+    out.present = frames.size();
+
+    if (out.present < out.files.size())
+        logger.Warning("{} of the {} images the sweep spans are present; the {} missing ones are "
+                       "left as gaps, so every image keeps the spindle angle its own header states "
+                       "({:.2f} to {:.2f} deg). The merge will be that much less complete.",
+                       out.present, out.files.size(), out.files.size() - out.present,
+                       out.start_deg,
+                       out.start_deg + step * static_cast<double>(out.files.size() - 1));
+
+    // The numbering says the same thing a second way, and says it about the ends of the series too,
+    // which the angles cannot: a sweep missing its first and last frames still spans only the angles
+    // that are there. Where the two disagree with the file count, the directory is short.
+    int64_t lo = 0, hi = 0;
+    bool numbered = true;
+    for (size_t i = 0; i < frames.size() && numbered; i++) {
+        const auto n = TrailingNumber(frames[i].path);
+        if (!n.has_value())
+            numbered = false;
+        else if (i == 0)
+            lo = hi = *n;
+        else
+            lo = std::min(lo, *n), hi = std::max(hi, *n);
+    }
+    if (numbered && hi - lo + 1 > static_cast<int64_t>(out.present))
+        logger.Warning("The file numbering runs {}..{}, which is {} frames, but the directory holds "
+                       "{}: {} are not there. If this series should be complete, it was not unpacked "
+                       "or copied whole - check the source.",
+                       lo, hi, hi - lo + 1, out.present, hi - lo + 1 - static_cast<int64_t>(out.present));
+    return out;
+}
+
+}  // namespace sweep
diff --git a/reader/SweepLayout.h b/reader/SweepLayout.h
new file mode 100644
index 000000000..31767f1c6
--- /dev/null
+++ b/reader/SweepLayout.h
@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+// Where the frames of a one-file-per-image sweep sit on the spindle.
+//
+// A deposited series of CBF / marCCD / SMV files is not always complete: frames go missing between
+// the beamline and the archive, and the numbers that are left are scattered through the range. Every
+// one of these formats writes each image's own start angle in its own header, so the sweep is fully
+// recoverable - but only if the frames are placed at the angles they state rather than laid out
+// end to end. Reading a gapped series as contiguous compresses the sweep: one deposited 179.8 degree
+// series of 1108 files out of 1800 came out as 111 degrees, and every frame past the first gap was
+// analysed at the wrong spindle angle.
+//
+// So the sweep is a grid of SLOTS, one per rotation step over the range the headers span, and a frame
+// occupies the slot its own angle puts it in. A slot with no file is a missing image, not a compressed
+// out one: the reader hands it back as "nothing to read", which every image loop already handles, and
+// the goniometer's start + increment * image_number is then the true angle of every image.
+namespace sweep {
+
+// What one frame's own header says about where it sits and how the instrument stood while it was
+// taken. The last four are not used to place the frame - they are what the whole series has to agree
+// on for it to be one sweep at all.
+struct Frame {
+    std::string path;
+    double angle_deg = 0;
+    double increment_deg = 0;
+    double distance_m = 0;
+    double beam_x_px = 0;
+    double beam_y_px = 0;
+    double wavelength_A = 0;
+};
+
+struct Layout {
+    std::vector<std::string> files;   // one entry per slot; empty where the series has no frame
+    double start_deg = 0;             // angle of slot 0
+    double increment_deg = 0;         // one slot, signed with the direction the sweep turns
+    size_t present = 0;               // files that are really there (files.size() - the gaps)
+};
+
+// Place the frames on the sweep they describe. frames must be in collection order (the order the
+// file names sort in) and must not be empty.
+//
+// Throws JFJochException, naming the frames, when the series is not one sweep: when the headers
+// disagree about the instrument, when two frames claim the same angle, or when the angles do not sit
+// on a single rotation step - a folder of screening images taken at scattered angles is not a sweep,
+// and silently averaging it into one is how such a set comes out as an indexing failure instead of a
+// clear refusal.
+//
+// A series that does not turn at all - one angle repeated, a grid scan or a set of stills - is left
+// exactly as it came, one slot per file, with the header's nominal increment.
+//
+// logger_name is the reader's own logger, so the gap report names the format the user passed.
+Layout Place(const std::vector<Frame> &frames, const std::string &logger_name);
+
+}  // namespace sweep
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 1b9ef6040..fa5452b7e 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -50,6 +50,7 @@ ADD_EXECUTABLE(jfjoch_test
         ModuleSummationTest.cpp
         ZMQMetadataSocketTest.cpp
         JFJochReaderTest.cpp
+        SweepLayoutTest.cpp
         ShadowFinderTest.cpp
         ParallelForTest.cpp
         RugnuxTest.cpp
diff --git a/tests/SweepLayoutTest.cpp b/tests/SweepLayoutTest.cpp
new file mode 100644
index 000000000..9655afe01
--- /dev/null
+++ b/tests/SweepLayoutTest.cpp
@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_all.hpp>
+
+#include "../common/JFJochException.h"
+#include "../reader/SweepLayout.h"
+
+namespace {
+
+// A series of frames all taken at the same instrument setting, at the angles given.
+std::vector<sweep::Frame> Series(const std::vector<double> &angles, double increment) {
+    std::vector<sweep::Frame> out;
+    out.reserve(angles.size());
+    for (size_t i = 0; i < angles.size(); i++)
+        out.push_back({"f" + std::to_string(i) + ".cbf", angles[i], increment, 0.2, 1000, 1000, 1.0});
+    return out;
+}
+
+}  // namespace
+
+TEST_CASE("SweepLayout_Contiguous") {
+    std::vector<double> angles;
+    for (int i = 0; i < 100; i++)
+        angles.push_back(20.0 + 0.1 * i);
+    const auto l = sweep::Place(Series(angles, 0.1), "test");
+    CHECK(l.files.size() == 100);
+    CHECK(l.present == 100);
+    CHECK(l.start_deg == Catch::Approx(20.0));
+    CHECK(l.increment_deg == Catch::Approx(0.1));
+    for (size_t i = 0; i < l.files.size(); i++)
+        CHECK(l.files[i] == "f" + std::to_string(i) + ".cbf");
+}
+
+TEST_CASE("SweepLayout_Gapped") {
+    // Frames 3, 4 and 7 of a ten-frame sweep never made it into the archive. The sweep is still ten
+    // steps wide and every frame keeps its own angle.
+    const auto l = sweep::Place(Series({0.0, 0.1, 0.2, 0.5, 0.6, 0.8, 0.9}, 0.1), "test");
+    REQUIRE(l.files.size() == 10);
+    CHECK(l.present == 7);
+    CHECK(l.increment_deg == Catch::Approx(0.1));
+    CHECK(l.files[2] == "f2.cbf");
+    CHECK(l.files[3].empty());
+    CHECK(l.files[4].empty());
+    CHECK(l.files[5] == "f3.cbf");
+    CHECK(l.files[7].empty());
+    CHECK(l.files[9] == "f6.cbf");
+}
+
+TEST_CASE("SweepLayout_PastFullTurn") {
+    // A writer that starts over at 0 rather than counting on past 360.
+    const auto l = sweep::Place(Series({359.7, 359.8, 359.9, 0.0, 0.1}, 0.1), "test");
+    CHECK(l.files.size() == 5);
+    CHECK(l.present == 5);
+    CHECK(l.increment_deg == Catch::Approx(0.1));
+}
+
+TEST_CASE("SweepLayout_Reversed") {
+    const auto l = sweep::Place(Series({10.0, 9.5, 9.0, 8.0}, 0.5), "test");
+    REQUIRE(l.files.size() == 5);
+    CHECK(l.increment_deg == Catch::Approx(-0.5));
+    CHECK(l.files[3].empty());
+    CHECK(l.files[4] == "f3.cbf");
+}
+
+TEST_CASE("SweepLayout_Stills") {
+    // Nothing turns: the files are the images, and the header's nominal increment stands.
+    const auto l = sweep::Place(Series({45.0, 45.0, 45.0}, 0.1), "test");
+    CHECK(l.files.size() == 3);
+    CHECK(l.present == 3);
+    CHECK(l.start_deg == Catch::Approx(45.0));
+    CHECK(l.increment_deg == Catch::Approx(0.1));
+}
+
+TEST_CASE("SweepLayout_ScreeningImagesRefused") {
+    // Five shots at scattered angles are not a sweep, and must not be laid out as one.
+    CHECK_THROWS_AS(sweep::Place(Series({0.0, 90.0, 45.0, 300.0, 270.0}, 0.5), "test"),
+                    JFJochException);
+}
+
+TEST_CASE("SweepLayout_MovedDetectorRefused") {
+    auto frames = Series({0.0, 0.1, 0.2, 0.3}, 0.1);
+    frames[2].distance_m = 0.3;
+    CHECK_THROWS_AS(sweep::Place(frames, "test"), JFJochException);
+}
+
+TEST_CASE("SweepLayout_SecondWavelengthRefused") {
+    auto frames = Series({0.0, 0.1, 0.2, 0.3}, 0.1);
+    frames[3].wavelength_A = 1.9;
+    CHECK_THROWS_AS(sweep::Place(frames, "test"), JFJochException);
+}
+
+TEST_CASE("SweepLayout_RepeatedAngleRefused") {
+    // Two sweeps of the same crystal concatenated: the second covers angles the first already has.
+    CHECK_THROWS_AS(sweep::Place(Series({0.0, 0.1, 0.2, 0.1, 0.2}, 0.1), "test"), JFJochException);
+}
-- 
2.54.0


From 2fdc4d3bdfccedeef120636f7de0647d58c85b49 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 10:31:01 +0200
Subject: [PATCH 074/122] Post-refinement: the distance hypothesis is decided
 at the fit, on the excitation residual

Whether a sweep determines its detector distance at all was decided by running the canonical pass
twice - once at the post-refined distance, once at the header's - and keeping whichever realised the
lower held-out residual, the header's on a tie. The first-stage test that sent a run down that arm
compared the free and held fits on the POOLED held-out residual, and pooling is what made it
uninformative: the positional family cannot see the distance along the degenerate direction, so it
dilutes the one family that can, while the unpaired standard error of a heavy-tailed mean of squares
is 2-25 % of the mean against in-fit differences of 0.1-1 %. The test therefore said "cannot tell" on
four fifths of the fitted sweeps and the arm ran on most of a corpus, buying by prior what it could
not measure.

The two hypotheses are now compared on the one residual family that can tell them apart. The
excitation residual never involves the detector, so it is blind to the distance itself; what it sees
is the cell scale, and a held fit at a wrong header distance is forced into a wrong cell scale by the
spot positions, which the rocking angles then refuse - measured on a sweep whose header was 1.4 %
long, the held fit's held-out excitation residual is seventeen times the free fit's. Where freeing
the distance lowers that residual by more than its own standard error the free fit is committed as
before; where it does not, the held fit is committed - header distance, refined beam, cell,
orientation and axis - and the walk and the commit run held. The positional residual is deliberately
not consulted: its in-fit gain along the degenerate direction is the one re-integration erases.

The question is asked only while the run is still at the file's distance. A run that has walked off
the header has already refuted that hypothesis by re-integrating, and asking it again at every round
stalls a walk short of its fixed point, because the excitation standard error at the walk's tail is
outlier-dominated (measured: a walk stopped 0.4 % early, seven passes, cell 0.65 % off against
0.26 %, ISa 10.6 against 14.0).

So there is no arm, and with it go the two probe passes that measured it and the canonical pass
the losing arm used to cost: the decision costs two Ceres solves. On thirteen
rotation sweeps covering both verdicts, every decision the arm took by evidence or by its tie rule is
reproduced at the fit, except where the excitation family sees what the pooled test could not and the
free distance - the better cell against an external reference - is taken instead; merged intensities
are unchanged where the verdict is.

POSTREFINE_DISTANCE_HELD now means "the committed fit held the header distance", and is cleared where
a later geometry walk left it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CPU_DATA_ANALYSIS_INDEXING.md            |   2 +-
 image_analysis/geom_refinement/PostRefine.cpp | 116 ++++++++++--------
 image_analysis/geom_refinement/PostRefine.h   |  16 +--
 rugnux/Rugnux.cpp                             | 108 ++--------------
 rugnux/Rugnux.h                               |  10 +-
 5 files changed, 94 insertions(+), 158 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_INDEXING.md b/docs/CPU_DATA_ANALYSIS_INDEXING.md
index 8c6a0dac1..712c252aa 100644
--- a/docs/CPU_DATA_ANALYSIS_INDEXING.md
+++ b/docs/CPU_DATA_ANALYSIS_INDEXING.md
@@ -326,7 +326,7 @@ The refinement above (§7.2) runs per image against that image's spots. For rota
 
    The geometry the run commits is re-fitted on all the reflections once the held-out half has approved it — a walk from where it arrived, one step wide; everything else from nominal in the wide box — and the bounds are asked again of that fit rather than only of the half that earned it. A move outside them leaves the geometry at nominal, as every other refusal does, and the refusal says so in the report (`POSTREFINE_REFUSED`, with what the fit wanted) rather than passing silently. Detector tilt is held fixed, being gauge-coupled to the crystal orientation on a single crystal.
 
-   **Whether the data determine the distance at all is asked, not assumed.** At a detector far enough away that no reflection reaches more than a few degrees of $2\theta$, a longer distance and a larger cell move every spot the same way to first order — the difference is of order $\sin^2\theta$ of the spot's own position, about 0.4 px rms per per cent of distance over a 2M detector at 820 mm against 2–3 px at the distances a crystal is usually collected at — and the rocking angles pin the cell scale only through the same $\sin\theta$. The joint fit then finds a distance/cell pair that fits its own observations a little better than the header, commits it, and the pass re-integrated there finds the next pair: a walk along the degenerate direction that the realised residual never ratifies (measured on such a sweep: a header at 820 mm walked to 846 mm with the cell 3.3 % too large, the realised held-out residual flat at every round). So the same fit is asked once more with the distance **held at the header**, every other block as free as before — the nested hypothesis "the header distance is right". Where the free distance lowers the held-out residual below the held fit's by more than that residual's own standard error, it has paid decisively and is committed exactly as before, which is every sweep whose $2\theta$ reaches tens of degrees and whose header is wrong. Where it has not, the fit cannot say — its own gain is not what decides, because a re-integration at the new distance need not realise it — so **both hypotheses are carried**: the canonical pass runs at the free geometry as before and once more at the header distance, and the run keeps the one whose *re-integrated* held-out residual is lower, the header's on a tie (the report says so: `POSTREFINE_DISTANCE_HELD`, and the pass decision names both residuals). Nothing is tuned here: the only inputs are the standard errors of the residuals themselves, the same noise the geometry walk's rounds have to beat. The wavelength is never refined on a single crystal for the same reason in its exact form: it scales the spot positions and the rocking angles identically to the cell, so no sweep can tell the two apart at any $2\theta$.
+   **Whether the data determine the distance at all is asked, not assumed.** At a detector far enough away that no reflection reaches more than a few degrees of $2\theta$, a longer distance and a larger cell move every spot the same way to first order — the difference is of order $\sin^2\theta$ of the spot's own position, about 0.4 px rms per per cent of distance over a 2M detector at 820 mm against 2–3 px at the distances a crystal is usually collected at. The joint fit then finds a distance/cell pair that fits its own spot positions a little better than the header, commits it, and the pass re-integrated there finds the next pair: a walk along the degenerate direction that the realised residual never ratifies (measured on such a sweep: a header at 820 mm walked to 846 mm with the cell 3.3 % too large, the realised held-out residual flat at every round). So the same fit is asked once more with the distance **held at the header**, every other block as free as before — the nested hypothesis "the header distance is right" — and the two are compared on the one residual family that can tell them apart: the **excitation** residual. It never involves the detector, so it is blind to the distance itself; what it sees is the cell scale, and a held fit at a wrong header distance is forced into a wrong cell scale by the spot positions, which the rocking angles then refuse (measured: a header 1.4 % long leaves the held fit's excitation residual seventeen times the free fit's). Where freeing the distance lowers the held-out excitation residual below the held fit's by more than that residual's own standard error, the free fit is committed exactly as before; where it does not, the held fit is — header distance, refined beam, cell, orientation and axis — and the report says so (`POSTREFINE_DISTANCE_HELD`). The positional residual is deliberately not consulted for this: it is the family whose in-fit gain along the degenerate direction re-integration erases, and pooled with the excitation family it either drowns a decisive excitation gain in its own noise (a 54 % excitation gain read as 9 % pooled against a 9 % noise) or lends the degenerate direction a gain that is not there. Nothing is tuned here: the only input is the standard error of the residual itself, the same noise the geometry walk's rounds have to beat. The wavelength is never refined on a single crystal for the same reason in its exact form: it scales the spot positions and the rocking angles identically to the cell, so no sweep can tell the two apart at any $2\theta$.
 3. **Pass 2** re-indexes de novo and re-integrates at the committed geometry. Only the **detector distance and beam centre** carry over: the refined cell, orientation and axis are what make the distance identifiable, but pass 2 re-indexes from scratch, so they are not propagated. Where that re-index indexes too few frames the run falls back to pass 1's lattice and integrates it at the refined geometry — and the cell is then **scaled to the distance it will be used at**, since a real-space cell is measured against the distance its spots were seen at, and carrying it across a distance change otherwise scales the whole cell by the ratio of the two. The orientation is untouched.
 
 The space group is determined **after** pass 2, on the geometry the run refined, and pass 1 does not search at all: a decision taken on the worse of the two passes and then carried forward is a constraint on the better one, and would have to be reconciled with what pass 2 later found. The guard that chooses which pass is written compares each pass's **first** merge — $P1$ on both sides, full resolution range, before the correction surfaces — which both passes produce anyway, so it never compares statistics computed in two different space groups. What it compares there is the **signal each pass measured**: the count of unique reflections merged at $I/\sigma \ge 2$. Self-consistency cannot do this job — against an external arbiter the signal count named the more accurate geometry on 23 of 27 arm-dataset pairs where $R_\mathrm{meas}$, $CC_{1/2}$ and ISa managed 13, a coin flip — and that merge's own $CC_{1/2}$ least of all, being pooled over the whole range, uncut and uncorrected, so the shells with no signal in them dominate it and they are exactly the shells a geometry move disturbs (it reads 0.13 on a crystal whose data merge at 0.995). The refined pass is sent back only where it merges more unique reflections than its cell can hold, where it measured decisively less signal (10 %, and only where it holds no more reflections either — a wider integration disk pulls weak reflections in and dilutes the strong fraction without measuring less), or where it lost the axial rows the systematic absences are read off. One index-time veto remains and is keyed to pass 1's **lattice** rather than its group: a centred pass-1 lattice against a primitive pass-2 one.
diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index d2c86d4b8..6bf0dc2cc 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -501,10 +501,12 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
             // summed over below is the same weighting the solver itself applies.
             // se_out, where asked for: the standard error of the returned mean over the residual values
             // it averages.
+            // exc_se_out, where asked for: the same standard error for the excitation mean alone.
             auto joint_cost = [&](Subset s, const double bm[2], const double ds[1], const double rv[3],
                                   const double q0[3], const double q1[3], const double q2[3],
-                                  double &pos_out, double &exc_out, double *se_out = nullptr) {
-                double cp = 0.0, ce = 0.0, c4 = 0.0;
+                                  double &pos_out, double &exc_out, double *se_out = nullptr,
+                                  double *exc_se_out = nullptr) {
+                double cp = 0.0, ce = 0.0, c4 = 0.0, c4e = 0.0;
                 size_t np = 0, ne = 0;
                 for (size_t oi = 0; oi < n_obs; ++oi) {
                     const Partial *pp = obs[oi];
@@ -528,6 +530,7 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                     r(rv, q0, q1, q2, &res);
                     ce += res * res;
                     c4 += res * res * res * res;
+                    c4e += res * res * res * res;
                     ++ne;
                 }
                 pos_out = np ? cp / np : 0.0;
@@ -537,6 +540,9 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 if (se_out)
                     *se_out = (np + ne) > 1 ? std::sqrt(std::max(0.0, c4 / n - mean * mean) / (n - 1.0))
                                             : std::numeric_limits<double>::quiet_NaN();
+                if (exc_se_out)
+                    *exc_se_out = ne > 1 ? std::sqrt(std::max(0.0, c4e / ne - exc_out * exc_out) / (ne - 1.0))
+                                         : std::numeric_limits<double>::quiet_NaN();
                 return mean;
             };
 
@@ -663,55 +669,74 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 double distance_corr[4];
                 bool convJ = solve_joint(FIT, /*wide=*/true, /*fix_distance=*/false, bm_f, ds_f, rv_f,
                                          q0_f, q1_f, q2_f, distance_corr);
-                double cv_ref_se = NAN;
+                double exc_ref_se = NAN;
                 double cv_ref = convJ ? joint_cost(VAL, bm_f, ds_f, rv_f, q0_f, q1_f, q2_f,
-                                                   pos_ref, exc_ref, &cv_ref_se)
+                                                   pos_ref, exc_ref, nullptr, &exc_ref_se)
                                       : cv_nom;
                 int steps = 1;
 
                 // Do these data determine the distance at all? At a detector far enough away that
                 // no reflection reaches more than a few degrees of 2theta, a longer distance and a
                 // larger cell move every spot the same way to first order (the difference is of
-                // order sin^2 theta of the spot's own position), and the rocking angles pin the
-                // cell scale only through the same sin theta. The joint fit then finds a
-                // distance/cell pair that fits its own observations a little better than the
+                // order sin^2 theta of the spot's own position). The joint fit then finds a
+                // distance/cell pair that fits its own spot positions a little better than the
                 // header, commits it, and the pass re-integrated there finds the next pair - a
                 // walk along the degenerate direction that the realised residual never ratifies.
                 // So the same fit is asked once more with the distance HELD at the header, every
                 // other block as free as before - the nested hypothesis "the header distance is
-                // right". Where the free distance lowers the held-out residual below the held fit's
-                // by more than the standard error of that residual - the same noise a round of the
-                // geometry walk has to beat (HeldOutResidualFell) - it has paid decisively and is
-                // committed exactly as before. Where it has not, this fit cannot say: its own gain is
-                // not what decides, because the pass re-integrated at the new distance need not
-                // realise it (measured: a 0.6 % in-fit gain at nearly three times its paired scatter,
-                // none of it realised) while a sweep at a short distance realises a gain of that size
-                // several times over. So both hypotheses are carried - the free fit committed as
-                // before, the held fit's beam beside it - and RunAllPasses runs the canonical pass at
-                // each and keeps the one whose RE-INTEGRATED held-out residual is lower, the header's
-                // on a tie.
+                // right" - and the two are compared on the one residual family that can tell them
+                // apart. The excitation residual never involves the detector, so it is blind to the
+                // distance itself; what it sees is the cell scale, and a held fit at a wrong header
+                // distance is forced into a wrong cell scale by the spot positions, which the
+                // rocking angles then refuse (measured: a header 1.4 % long leaves the held fit's
+                // excitation residual seventeen times the free fit's). Where freeing the distance
+                // lowers the held-out excitation residual below the held fit's by more than the
+                // standard error of that residual - the same noise a round of the geometry walk has
+                // to beat (HeldOutResidualFell) - the free fit is committed exactly as before. Where
+                // it does not, the held fit is the candidate from here on: what the walk, the gate
+                // and the commit below see. The positional residual is deliberately not consulted
+                // for this. Its in-fit gain along the degenerate direction is the one re-integration
+                // erases, and pooled with the excitation family it either drowns a decisive
+                // excitation gain in its own noise (measured: a 54 % excitation gain read as 9 %
+                // pooled against a 9 % noise) or lends the degenerate direction a gain that is not
+                // there.
                 double bm_h[2] = {beam_x0, beam_y0}, ds_h[1] = {dist0};
                 double rv_h[3], q0_h[3], q1_h[3], q2_h[3];
                 for (int j = 0; j < 3; ++j) {
                     rv_h[j] = ax0[j]; q0_h[j] = p0_0[j]; q1_h[j] = p1_0[j]; q2_h[j] = p2_0[j];
                 }
-                const bool convH = convJ && solve_joint(FIT, /*wide=*/true, /*fix_distance=*/true,
-                                                        bm_h, ds_h, rv_h, q0_h, q1_h, q2_h);
-                double pos_h = 0.0, exc_h = 0.0, cv_h = cv_nom, cv_h_se = NAN;
+                // A run that has already walked off the header has refuted that hypothesis by
+                // re-integrating - the rounds of a walk are judged on what they realise - so the fit
+                // is not asked to hold a distance that is no longer the header's.
+                const bool convH = settings.distance_at_header && convJ
+                                   && solve_joint(FIT, /*wide=*/true, /*fix_distance=*/true, bm_h, ds_h,
+                                                  rv_h, q0_h, q1_h, q2_h);
+                double pos_h = 0.0, exc_h = 0.0, cv_h = cv_nom, exc_h_se = NAN;
                 if (convH)
-                    cv_h = joint_cost(VAL, bm_h, ds_h, rv_h, q0_h, q1_h, q2_h, pos_h, exc_h, &cv_h_se);
-                const double noise = std::hypot(cv_ref_se, cv_h_se);
-                const bool distance_pays = convH && std::isfinite(noise) && cv_ref < cv_h - noise;
-                const bool distance_undecided = convH && !distance_pays;
-                logger.Info("Post-refine GEOM distance: free {:.3f} mm gives held-out {:.3e} +- {:.1e}; held "
-                            "at the header {:.3f} mm gives {:.3e} +- {:.1e} (positional {:.3e}, excitation "
-                            "{:.3e}); free minus held {:+.3e} against the noise {:.1e} => {}; the free fit's "
-                            "formal sd(distance) {:.4f} %, corr(distance, cell a/b/c) {:.4f} {:.4f} {:.4f}",
-                            ds_f[0], cv_ref, cv_ref_se, dist0, cv_h, cv_h_se, pos_h, exc_h, cv_ref - cv_h,
-                            noise,
-                            distance_undecided ? "this fit cannot tell, both are carried to the canonical pass"
-                                               : "the free distance pays",
-                            100.0 * distance_corr[0], distance_corr[1], distance_corr[2], distance_corr[3]);
+                    cv_h = joint_cost(VAL, bm_h, ds_h, rv_h, q0_h, q1_h, q2_h, pos_h, exc_h, nullptr,
+                                      &exc_h_se);
+                const double noise = std::hypot(exc_ref_se, exc_h_se);
+                const bool hold_distance = convH && !(std::isfinite(noise) && exc_ref < exc_h - noise);
+                if (settings.distance_at_header)
+                    logger.Info("Post-refine GEOM distance: free {:.3f} mm gives held-out excitation {:.3e} +- "
+                                "{:.1e} (positional {:.3e}); held at the header {:.3f} mm gives {:.3e} +- "
+                                "{:.1e} (positional {:.3e}); free minus held {:+.3e} against the noise {:.1e} "
+                                "=> {}; the free fit's formal sd(distance) {:.4f} %, corr(distance, cell "
+                                "a/b/c) {:.4f} {:.4f} {:.4f}",
+                                ds_f[0], exc_ref, exc_ref_se, pos_ref, dist0, exc_h, exc_h_se, pos_h,
+                                exc_ref - exc_h, noise,
+                                hold_distance ? "the rocking angles do not ask for it, the header distance is held"
+                                : convH       ? "the free distance pays"
+                                              : "the held fit did not converge, the free distance stands",
+                                100.0 * distance_corr[0], distance_corr[1], distance_corr[2],
+                                distance_corr[3]);
+                if (hold_distance) {
+                    bm_f[0] = bm_h[0]; bm_f[1] = bm_h[1]; ds_f[0] = ds_h[0];
+                    for (int j = 0; j < 3; ++j) {
+                        rv_f[j] = rv_h[j]; q0_f[j] = q0_h[j]; q1_f[j] = q1_h[j]; q2_f[j] = q2_h[j];
+                    }
+                    cv_ref = cv_h; pos_ref = pos_h; exc_ref = exc_h;
+                }
 
                 // A larger move is no longer refused for its size - but it is not taken as one solve
                 // asserted it either. It is re-fitted as a WALK: each step seeded where the last one
@@ -732,8 +757,8 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                         for (int j = 0; j < 3; ++j) {
                             rv_s[j] = rv_f[j]; q0_s[j] = q0_f[j]; q1_s[j] = q1_f[j]; q2_s[j] = q2_f[j];
                         }
-                        if (!solve_joint(FIT, /*wide=*/false, /*fix_distance=*/false, bm_s, ds_s, rv_s,
-                                         q0_s, q1_s, q2_s))
+                        if (!solve_joint(FIT, /*wide=*/false, hold_distance, bm_s, ds_s, rv_s, q0_s, q1_s,
+                                         q2_s))
                             break;
                         double pos_s = 0.0, exc_s = 0.0;
                         const double cv_s = joint_cost(VAL, bm_s, ds_s, rv_s, q0_s, q1_s, q2_s,
@@ -809,7 +834,7 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                             axv[j] = rv_f[j]; p0[j] = q0_f[j]; p1[j] = q1_f[j]; p2[j] = q2_f[j];
                         }
                     }
-                    solve_joint(ALL, !walked, /*fix_distance=*/false, beam, dist, axv, p0, p1, p2);   // commit: re-fit on all data
+                    solve_joint(ALL, !walked, hold_distance, beam, dist, axv, p0, p1, p2);   // commit: re-fit on all data
                     ds_log[0] = dist[0]; bm_log[0] = beam[0]; bm_log[1] = beam[1];
                     for (int j = 0; j < 3; ++j) { q1_log[j] = p1[j]; q2_log[j] = p2[j]; }
                     refused = out_of_bounds(beam, p2);
@@ -818,16 +843,10 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                         for (int j = 0; j < 3; ++j) {
                             axv[j] = ax0[j]; p0[j] = p0_0[j]; p1[j] = p1_0[j]; p2[j] = p2_0[j];
                         }
-                    } else if (distance_undecided) {
-                        // The other arm, re-fitted on all the data the same way: its beam at the
-                        // header distance is what the canonical pass at that distance runs with.
-                        if (solve_joint(ALL, /*wide=*/true, /*fix_distance=*/true, bm_h, ds_h, rv_h, q0_h,
-                                        q1_h, q2_h)
-                            && out_of_bounds(bm_h, q2_h) == nullptr)
-                            result.held_arm_beam_px = std::array<double, 2>{bm_h[0], bm_h[1]};
                     }
                 }
                 commit = (refused == nullptr);
+                result.distance_held = commit && hold_distance;
                 // Name which test refused it. Several different things reject here and the geometry that
                 // comes out is the same in all of them, so a run that silently keeps its header geometry
                 // says nothing about whether the fit was bad, the improvement too small, or the move too
@@ -836,9 +855,8 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 // without the log.
                 const std::string verdict = commit ? fmt::format("COMMIT ({} step{}{})", steps,
                                                                  steps == 1 ? "" : "s",
-                                                                 result.held_arm_beam_px
-                                                                     ? ", the header distance carried as the other arm"
-                                                                     : "")
+                                                                 hold_distance ? ", distance held at the header"
+                                                                               : "")
                                                    : "reject (" + std::string(refused) + ")";
                 // The cell the log names is the EFFECTIVE one - what the residual's B matrix builds
                 // from the blocks - not the blocks themselves, whose unused components a high-symmetry
@@ -871,7 +889,9 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 // A move of more than one step is a walk, not a correction next to where it started,
                 // and it is the one the old bound refused outright. It is committed here and ratified
                 // where it can be: by re-indexing at it (see RunAllPasses).
-                result.large_move = commit && beyond_a_step(dist, p1);
+                // A held distance has nothing to walk: the walk is the distance finding the rest of an
+                // error the rocking angles have just said they do not see.
+                result.large_move = commit && !hold_distance && beyond_a_step(dist, p1);
             } else {
                 logger.Info("Post-refine GEOM: only {} positional observations - the joint fit needs the "
                             "spot positions as well as the rocking angles, so nothing is refined", n_obs);
diff --git a/image_analysis/geom_refinement/PostRefine.h b/image_analysis/geom_refinement/PostRefine.h
index 682107817..b5dcf079b 100644
--- a/image_analysis/geom_refinement/PostRefine.h
+++ b/image_analysis/geom_refinement/PostRefine.h
@@ -49,14 +49,9 @@ struct PostRefineResult {
     // from. Such a move is not refused for its size - it is RATIFIED by re-integrating and re-indexing
     // at it, which a second lattice does not survive and a wrong header does (see RunAllPasses).
     bool large_move = false;
-    // The same fit with the distance HELD at the header, where the free distance did not lower the
-    // held-out residual below it by more than the noise of that residual: the beam centre that fit
-    // committed, at the header distance. The free fit is what `geom`, `cell` and the *_after fields
-    // carry, exactly as before; this is the other hypothesis, carried so that the canonical stage
-    // can run at both and keep the one whose RE-INTEGRATED residual is lower (see RunAllPasses).
-    // Absent where the free distance paid decisively, or where nothing was committed.
-    std::optional<std::array<double, 2>> held_arm_beam_px;
-    // Set by RunAllPasses where that comparison kept the header distance: the report names it.
+    // What was committed is the fit with the distance HELD at the header - everything else as free as
+    // ever - because freeing it did not lower the held-out excitation residual by more than that
+    // residual's noise (see the joint fit in PostRefine.cpp). The report names it.
     bool distance_held = false;
     // The held-out residual at the geometry the fit STARTED from - what the integration this fit was
     // handed actually realises there, before the fit moves anything - and its standard error over the
@@ -89,6 +84,11 @@ struct PostRefineSettings {
                                       // spot positions) and the detector distance + beam centre, in one
                                       // cross-validated fit. The only supported refinement mode.
     double excitation_weight = 1.0;   // weight of the phi/excitation residual vs the positional one
+    // The geometry handed in still has the file's distance, so "the header distance is right" is a
+    // hypothesis the fit can hold and test (PostRefineResult::distance_held). Once a run has moved off
+    // the header - a walk, see RunAllPasses - that hypothesis is already refuted and the distance is
+    // simply free.
+    bool distance_at_header = true;
     int min_events = 50;
     int num_threads = 1;
     // An independent measurement of the beam centre in pixels, where the run has one (rugnux's pre-scan
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index d859e510f..4b7b32632 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1867,6 +1867,7 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
         // from the same place (the beam-centre arbitration below).
         const DiffractionExperiment experiment_before_first_pass = experiment_;
         const int64_t max_spot_count_snapshot = experiment_.GetDatasetSettings().GetMaxSpotCount();
+        header_distance_mm_ = experiment_.GetDetectorDistance_mm();
         prepass_detector_geometry_.reset();
         prepass_rotation_scale_.reset();
         prepass_result_.reset();
@@ -2085,83 +2086,6 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
                        .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
         };
 
-        // Where the pre-pass could not tell whether its distance move paid (held_arm_beam_px: the
-        // free distance lowered the fit's own held-out residual by less than that residual's noise),
-        // the other hypothesis - the header distance, with the beam the same fit found there - is
-        // measured too, and the two are judged on what they REALISE: the held-out residual a pass
-        // re-integrated and re-indexed at that geometry measures there, the comparison the walk below
-        // makes between its rounds. Where the free arm wins the run goes on at the post-refined
-        // distance; where the header's wins, or the two cannot be told apart, the header's stands -
-        // it is the hypothesis that asserts nothing, so a tie is its - and the distance walk below is
-        // not entered: the data have just said they cannot place the distance. Measured on a sweep at
-        // 820 mm reaching 2theta ~ 9 deg, where the fit's own gain never realises: the free arm's
-        // re-integrated residual sat within 0.6 % of the header's at a noise of 8 %, and the cell it
-        // carried was 1 % too large. On a sweep at 110 mm reaching 57 deg, a 0.14 % distance move the
-        // pre-pass could not decide realised 3.7 % against a noise of 1.5 %, and the cell it carried
-        // matched the reference to 0.04 %.
-        //
-        // Both arms are measured BEFORE the canonical pass, by passes that stop as soon as the
-        // post-refinement has measured (postrefine_probe_only_). The residual is all the comparison
-        // reads, and it is in hand before the scaling engine is built, so neither arm pays for a
-        // merge, a space-group search or a set of correction surfaces - and only the arm that wins is
-        // ever run as a canonical pass. Judging the arms on written passes instead cost the loser's
-        // whole pass and, where the header won, a third pass that reproduced the loser's numbers
-        // digit for digit.
-        std::string distance_arm;     // the arm decision, for the pass decision text
-        bool distance_arm_kept_header = false;
-        int arm_passes = 0;
-        if (!cancelled_ && prepass_detector_geometry_ && pass1.post_refine
-            && pass1.post_refine->held_arm_beam_px) {
-            const std::array<float, 5> free_geometry = current_geometry();
-            std::array<float, 5> held_geometry = free_geometry;
-            held_geometry[0] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[0]);
-            held_geometry[1] = static_cast<float>((*pass1.post_refine->held_arm_beam_px)[1]);
-            held_geometry[2] = header_geometry[2];
-            logger.Info("Two-pass: the pre-pass could not tell whether moving the distance {:.3f} -> {:.3f} mm "
-                        "paid, so the header distance is re-integrated as well and the two are "
-                        "judged on the held-out residual each realises", header_geometry[2],
-                        free_geometry[2]);
-            postrefine_probe_only_ = true;
-            const auto free_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
-            ++arm_passes;
-            set_geometry(held_geometry);
-            const auto held_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
-            ++arm_passes;
-            postrefine_probe_only_ = false;
-            const double realised_free = free_arm.post_refine ? free_arm.post_refine->held_out_before : NAN;
-            const double realised_held = held_arm.post_refine ? held_arm.post_refine->held_out_before : NAN;
-            const double se_free = free_arm.post_refine ? free_arm.post_refine->held_out_before_se : NAN;
-            const double se_held = held_arm.post_refine ? held_arm.post_refine->held_out_before_se : NAN;
-            if (!cancelled_ && free_arm.post_refine && held_arm.post_refine
-                && HeldOutResidualFell(*held_arm.post_refine, *free_arm.post_refine)) {
-                logger.Info("Two-pass: re-integrated at the post-refined distance {:.3f} mm the held-out "
-                            "residual is {:.3e} against {:.3e} at the header's {:.3f} mm (standard errors "
-                            "{:.1e} and {:.1e}) - the move is realised and stands", free_geometry[2],
-                            realised_free, realised_held, held_geometry[2], se_free, se_held);
-                set_geometry(free_geometry);
-                distance_arm = fmt::format(
-                        "the header distance {:.3f} mm was run as well and realised a held-out residual of "
-                        "{:.3e} against {:.3e} at the post-refined {:.3f} mm, so the post-refined distance "
-                        "stands", held_geometry[2], realised_held, realised_free, free_geometry[2]);
-            } else if (!cancelled_) {
-                logger.Info("Two-pass: re-integrated at the header distance {:.3f} mm the held-out residual "
-                            "is {:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}; standard "
-                            "errors {:.1e} and {:.1e}) - these data do not determine the distance, and the "
-                            "header's stands", held_geometry[2], realised_held, free_geometry[2],
-                            realised_free, se_held, se_free);
-                distance_arm_kept_header = true;
-                pass1.post_refine->distance_held = true;
-                pass1.post_refine->beam_x_after_px = held_geometry[0];
-                pass1.post_refine->beam_y_after_px = held_geometry[1];
-                pass1.post_refine->distance_after_mm = held_geometry[2];
-                distance_arm = fmt::format(
-                        "the header distance {:.3f} mm kept: re-integrated there the held-out residual is "
-                        "{:.3e}, which the post-refined {:.3f} mm does not beat ({:.3e}), so these data do "
-                        "not determine the distance", held_geometry[2], realised_held, free_geometry[2],
-                        realised_free);
-            }
-        }
-
         logger.Info("Rotation two-pass geometry post-refinement: second pass (refined geometry, canonical) -> {}_*",
                     base_prefix);
         auto pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
@@ -2210,7 +2134,7 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             best_fit = *pass2.post_refine;
             walk_rounds = fmt::format("{:.3f} mm / {:.3e}", best_geometry[2], best_fit.held_out_before);
         }
-        while (!cancelled_ && prepass_detector_geometry_ && !distance_arm_kept_header
+        while (!cancelled_ && prepass_detector_geometry_
                && pass2.post_refine && pass2.post_refine->detector_refined
                && (pass2.post_refine->large_move || geometry_rounds > 0)) {
             if (geometry_rounds == MAX_GEOMETRY_ROUNDS) {
@@ -2276,10 +2200,13 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass1.post_refine->beam_x_after_px = best_geometry[0];
             pass1.post_refine->beam_y_after_px = best_geometry[1];
             pass1.post_refine->distance_after_mm = best_geometry[2];
+            // A first pass that held the header distance and a walk that then left it: the run's
+            // decision is the walk's.
+            pass1.post_refine->distance_held = false;
         }
         pass2.post_refine = pass1.post_refine;
-        pass2.pass_number = 2 + arm_passes + walk_passes;
-        pass2.pass_count = 2 + arm_passes + walk_passes;
+        pass2.pass_number = 2 + walk_passes;
+        pass2.pass_count = 2 + walk_passes;
         if (geometry_rounds > 0)
             pass2.pass_decision = fmt::format(
                     "post-refined geometry walked {} round{} and kept round {}, detector distance {:.3f} mm "
@@ -2414,8 +2341,6 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass2.pass_decision = (prepass_detector_geometry_ || prepass_rotation_scale_)
                     ? "post-refined geometry adopted"
                     : "the post-refinement committed no geometry change, so this pass reproduces the first";
-        if (!distance_arm.empty())
-            pass2.pass_decision = distance_arm + "; " + pass2.pass_decision;
         pass2.geometry_not_converged = geometry_not_converged;
         return pass2;
     }
@@ -5210,6 +5135,11 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     prs.crystal_system = rot->search_result.system;
                     prs.num_threads = static_cast<int>(config_.nthreads);
                     prs.refine_geometry = true;
+                    // Only a pass still at the file's distance can hold it as a hypothesis; a pass
+                    // that has walked off it (the geometry walk in RunAllPasses) is past that question.
+                    prs.distance_at_header = !std::isfinite(header_distance_mm_)
+                            || std::fabs(experiment_.GetDetectorDistance_mm() - header_distance_mm_)
+                               < 1e-3 * header_distance_mm_;
                     // The centre the pre-scan measured, where the fit was precise enough to be used as
                     // a centre at all (the same ceiling --estimate-beam-center adopts one on). It does
                     // not move the geometry - it only tells the bound on step B's beam move where else
@@ -5284,20 +5214,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // before the engine is built rather than beside it - the gathered observations and their
         // rocking events are gigabytes on a long axis, and beside the engine's own arrays they set
         // the pass's memory high-water mark.
-        if (postrefine_probe_ && !geometry_prepass && is_rotation) {
+        if (postrefine_probe_ && !geometry_prepass && is_rotation)
             post_refine_geometry();
-            // A pass the distance arm runs to compare two geometries has now produced the only thing
-            // the comparison reads - the held-out residual of the fit just measured. Stop here rather
-            // than scale, search, fit surfaces and merge for a result nothing looks at.
-            if (postrefine_probe_only_) {
-                result.processing_time_s = std::chrono::duration<double>(
-                        std::chrono::steady_clock::now() - start_time).count();
-                logger.Info("Distance-arm probe: {} images integrated and post-refined in {:.2f} s "
-                            "(the arm reads the held-out residual only, so this pass does not merge)",
-                            result.images_processed, result.processing_time_s);
-                return result;
-            }
-        }
         if (is_rotation) {
             if (experiment_.GetRefineRotationWedgeInScaling()
                 || rot_ss.GetRotationWedgeForScaling().has_value())
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 6f8fe4f7c..6e606e086 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -555,12 +555,10 @@ class Rugnux {
     // whether it has finished walking is a question only reflections integrated after the move can
     // answer; RunAllPasses turns this on for the passes that answer it.
     bool postrefine_probe_ = false;
-    // Whether such a pass exists ONLY for that measurement. The distance arm reads the held-out
-    // residual the probe returns and nothing else, so a pass run for it stops as soon as the probe
-    // has measured - which is before the scaling engine is built. Everything below that point (the
-    // merges, the space-group search, the correction surfaces, the reports) is work no comparison
-    // looks at, and on a long sweep it is four fifths of the pass.
-    bool postrefine_probe_only_ = false;
+    // The file's detector distance, from before the first pass of the rotation two-pass: a pass whose
+    // distance is still this one asks the post-refinement to test "the header distance is right"
+    // (PostRefineSettings::distance_at_header); a pass that has walked off it does not.
+    double header_distance_mm_ = std::numeric_limits<double>::quiet_NaN();
 
     // Pre-scan: read a spread sample of frames and take three things off them - the shadow of the beam
     // stop and its holder, added to the pixel mask (config_.detect_beam_stop), the beam centre
-- 
2.54.0


From 845296cf0faea22a2c4b853fcc0eab6356db6f9b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 16:26:13 +0200
Subject: [PATCH 075/122] battery: override the 8xbp open-arm reference cell

The 8XBP deposition (RCSB, verified against the cached mmCIF) gives
C 1 2 1, 148.29 50.78 60.21 90 92.33 90, collected 2023-06-23. The
sweep in the open arm was collected 2023-06-21 and gives b = 51.83,
2.0% from the deposited b, with a and c agreeing to 0.1%; the reduced
primitive volume ratio is 1.02 and the set fails the lattice test.

DIALS 3.29 indexes the same master de novo at b = 51.777(11), 0.09%
from rugnux and 90 sigma from the deposit, and the deposited model
refines against the rugnux merge at R-free 0.30 / CC 0.89. The
deposited cell therefore does not describe these images.

ref_override supplies the DIALS cell in place of the deposited one.
The deposited space group and d_min are kept, and ref still records
the deposition. No scoring code and no threshold is changed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/open.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/battery/open.json b/tools/battery/open.json
index 86c6da617..f7aeb01a7 100644
--- a/tools/battery/open.json
+++ b/tools/battery/open.json
@@ -96,7 +96,7 @@
  {"id": "8tyy", "input": "8tyy/CPS_2_1_000001.cbf", "ref": {"sg": "F 4 3 2", "sgno": 209, "cell": [214.891, 214.891, 214.891, 90.0, 90.0, 90.0], "dmin": 1.68}, "tags": ["cbf", "cubic"]},
  {"id": "8u0i", "input": "8u0i/8u0i/data/dI-2-05a_4_00001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [50.317, 50.317, 90.596, 90.0, 90.0, 90.0], "dmin": 1.541}, "tags": ["cbf", "tetragonal"]},
  {"id": "8v4o", "input": "8v4o/CaalA_00629_a_FS11-AMP_8v4o/data/PSL-1602_2180_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [139.46, 139.46, 544.99, 90.0, 90.0, 120.0], "dmin": 2.7}, "tags": ["h5", "hexagonal"]},
- {"id": "8xbp", "input": "8xbp/8xbp/data/puck2872_3_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [148.29, 50.78, 60.21, 90.0, 92.33, 90.0], "dmin": 1.99}, "tags": ["h5", "monoclinic"]},
+ {"id": "8xbp", "input": "8xbp/8xbp/data/puck2872_3_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [148.29, 50.78, 60.21, 90.0, 92.33, 90.0], "dmin": 1.99}, "ref_override": {"cell": [148.736, 51.777, 60.181, 90.0, 92.36, 90.0]}, "ref_override_why": "the uploaded sweep is a different crystal from the one the deposited cell describes: master data_collection_date 2023-06-21, deposited _diffrn_detector.pdbx_collection_date 2023-06-23, and the deposited b = 50.78 is 2.0% from the b these images give. The override is the cell DIALS 3.29 indexes de novo on this master, b = 51.777(11); the deposited space group and d_min are kept", "tags": ["h5", "monoclinic"]},
  {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "tags": ["cbf", "trigonal"]},
  {"id": "8xtf", "input": "8xtf/1102/puck03_12_1_master.h5", "ref": {"sg": "H 3 2", "sgno": 155, "cell": [211.75, 211.75, 67.42, 90.0, 90.0, 120.0], "dmin": 2.13}, "tags": ["h5", "trigonal"]},
  {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "tags": ["cbf", "trigonal"]},
-- 
2.54.0


From 91edacdf718939537326a991b6e97523c9881fa4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 10:14:44 +0200
Subject: [PATCH 076/122] Refine the pseudo-translation vector on the whole
 dataset, not the gate's band

The translational-NCS vector was refined only on d >= 4 A, the band its
detection gate reads, where an error of 0.02 costs the contrast almost
nothing. The L-test's partner steps and the twin-immune zone's per-class
normalisation then assign a class, cos(2 pi h.u), to reflections at full
resolution, where the phase error is |h| times the error in the vector: past
about |h| = 12 the classes were no longer the physical ones, and on one corpus
crystal they were anti-correlated with them over a whole band.

The vector is now re-refined against all the intensities, up a ladder that
doubles the number of reflections read at each step and starts each step from
the previous one's answer, so the phase is never extrapolated further than it
is known. The objective is the correlation between E^2 and cos(2 pi h.u) -
neither the gate's max/min bin ratio nor the fitted amplitude survives a
full-resolution population, both being ratios that run away where the cosine
has little variance. The gate itself is untouched: which crystals are called
is unchanged, only where the vector points.

Measured as that correlation in bands of |h|, before against after:
0.57/0.61, 0.42/0.52, 0.19/0.30, 0.14/0.18 on one crystal and 0.14/0.52,
-0.15/0.42, 0.00/0.20, -0.02/0.09 on another. The acentric control of the
twin-immune zone moves towards its analytic 0.736 where the classes change
(0.671 -> 0.748 on one), and no space-group or twinning verdict moves.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/TranslationalNCS.cpp          | 148 ++++++++++++++++++
 tests/TranslationalNCSTest.cpp                |  45 +++++-
 2 files changed, 188 insertions(+), 5 deletions(-)

diff --git a/image_analysis/scale_merge/TranslationalNCS.cpp b/image_analysis/scale_merge/TranslationalNCS.cpp
index 7b5a91e07..7c0634f3b 100644
--- a/image_analysis/scale_merge/TranslationalNCS.cpp
+++ b/image_analysis/scale_merge/TranslationalNCS.cpp
@@ -8,6 +8,7 @@
 #include <cstring>
 #include <iomanip>
 #include <limits>
+#include <numbers>
 #include <numeric>
 #include <random>
 #include <sstream>
@@ -114,6 +115,37 @@ namespace {
                     }
         return best;
     }
+
+    // How well a vector explains the intensities of the first `n` reflections under the physical
+    // model <E^2> = A (1 + f cos(2 pi h.u)): the correlation between E^2 and cos(2 pi h.u).
+    //
+    // The gate above scores a vector by the max/min ratio of the phase-bin means instead. That is the
+    // right statistic for the gate - it is what the null is drawn against - but it is the wrong one to
+    // REFINE on a full-resolution population, because a ratio is maximised by emptying one bin: on a
+    // 118,000-reflection merge the max/min search walked to a vector 0.015 away from the correlation's
+    // answer while reporting 1.2e4. The fitted amplitude f itself is no better, for the mirror reason:
+    // f is a slope divided by an intercept, so it runs away wherever the cosine has little variance
+    // over the data, and the search drifts to exactly such a vector (measured: 0.06 off a synthetic
+    // half-integer translation). The correlation has neither failure - it is 1 only where the cosine
+    // follows the intensities.
+    double CosineCorrelation(const std::vector<std::array<int, 3>> &hkl, const std::vector<double> &e2,
+                             const std::array<double, 3> &u, size_t n) {
+        double sc = 0.0, scc = 0.0, sy = 0.0, syy = 0.0, scy = 0.0;
+        for (size_t i = 0; i < n; ++i) {
+            const double c = std::cos(2.0 * std::numbers::pi
+                                      * (hkl[i][0] * u[0] + hkl[i][1] * u[1] + hkl[i][2] * u[2]));
+            sc += c;
+            scc += c * c;
+            sy += e2[i];
+            syy += e2[i] * e2[i];
+            scy += c * e2[i];
+        }
+        const double nn = static_cast<double>(n);
+        const double vc = scc - sc * sc / nn, vy = syy - sy * sy / nn;
+        if (!(vc > 0.0) || !(vy > 0.0))
+            return 0.0;
+        return (scy - sc * sy / nn) / std::sqrt(vc * vy);
+    }
 }
 
 TranslationalNCSResult AnalyzeTranslationalNCS(const std::vector<MergedReflection> &merged,
@@ -573,6 +605,122 @@ TranslationalNCSResult AnalyzeTranslationalNCS(const std::vector<MergedReflectio
 
     result.near_extinct_class = result.detected && result.modulation >= kNearExtinctModulation;
 
+    // ------------------------------------------------ the vector the phase CLASSES are assigned with
+    //
+    // Everything above is measured on d >= 4 A, where |h| stays under about 15 and an error of 0.02 in
+    // u costs the contrast almost nothing - the gate's vector is refined only to the accuracy the gate
+    // needs. But the consumers of this vector (the L-test's partner steps, and the twin-immune zone's
+    // per-class normalisation) assign a CLASS, cos(2 pi h.u), to reflections at FULL resolution, and
+    // the phase error there is |h| times the error in u. At |h| = 20 an error of 0.02 is a third of a
+    // turn and the classes are no longer the physical ones. Measured as the correlation between E^2
+    // and cos(2 pi h.u) in bands of |h| on two of this corpus's pseudo-translations, the gate's
+    // vector against this one: 0.57/0.61 at |h| < 8, 0.42/0.52, 0.19/0.30, 0.14/0.18 past |h| = 22 on
+    // the first; 0.14/0.52, -0.15/0.42, 0.00/0.20, -0.02/0.09 on the second, whose classes the gate's
+    // vector gets ANTI-correlated with the real ones over a whole band.
+    //
+    // So u is re-refined on the whole data, up a ladder: each step reads twice as many reflections as
+    // the one before, in order of |h|, and starts from the previous step's answer with a search step
+    // of a quarter of the phase ambiguity 1/|h| of the highest order it reads. The vector is never
+    // asked to extrapolate further than it is known, which is what lets a greedy search cross a
+    // resolution range whose objective has a local maximum every 1/|h| in each direction. Refining on
+    // the whole data in one go instead walks into the nearest of those.
+    //
+    // Nothing above is re-read: `modulation`, `modulation_null` and `detected` stay the gate's, so
+    // which crystals are called stays exactly as it was. Only where the vector points changes.
+    if (result.detected) {
+        std::vector<std::array<int, 3>> cls_hkl;
+        std::vector<double> cls_e2;
+        {
+            std::vector<int> idx;
+            for (size_t i = 0; i < merged.size(); ++i)
+                if (std::isfinite(merged[i].I) && std::isfinite(merged[i].d) && merged[i].d > 0.0
+                    && acentric(merged[i]))
+                    idx.push_back(static_cast<int>(i));
+            // Equal-count shells sorted by |h|, so that every stage of the ladder reads a population
+            // that is already normalised and can be taken as a prefix.
+            std::sort(idx.begin(), idx.end(), [&](int a, int b) {
+                return std::max({std::abs(merged[a].h), std::abs(merged[a].k), std::abs(merged[a].l)})
+                       < std::max({std::abs(merged[b].h), std::abs(merged[b].k), std::abs(merged[b].l)});
+            });
+            std::vector<int> by_d = idx;
+            std::sort(by_d.begin(), by_d.end(), [&](int a, int b) { return merged[a].d > merged[b].d; });
+            std::vector<double> e2_of(merged.size(), std::numeric_limits<double>::quiet_NaN());
+            const size_t n_shells = std::max<size_t>(1, by_d.size() / 500);
+            for (size_t s = 0; s < n_shells; ++s) {
+                const size_t lo = s * by_d.size() / n_shells, hi = (s + 1) * by_d.size() / n_shells;
+                double sum = 0.0;
+                for (size_t i = lo; i < hi; ++i)
+                    sum += merged[by_d[i]].I;
+                const double mean = sum / static_cast<double>(hi - lo);
+                if (mean <= 0.0)
+                    continue;
+                for (size_t i = lo; i < hi; ++i)
+                    e2_of[by_d[i]] = merged[by_d[i]].I / mean;
+            }
+            for (int i : idx)
+                if (std::isfinite(e2_of[i]) && e2_of[i] <= kWilsonOutlierE2) {
+                    cls_hkl.push_back({merged[i].h, merged[i].k, merged[i].l});
+                    cls_e2.push_back(e2_of[i]);
+                }
+        }
+        // The steps of the ladder double the number of reflections read rather than the |h| ceiling,
+        // so that the first step always has a population to refine on whatever the cell is and no
+        // step is skipped for being empty.
+        std::array<double, 3> u = u_refined;
+        for (size_t n = kMinModulationReflections; !cls_hkl.empty(); n *= 2) {
+            n = std::min(n, cls_hkl.size());
+            const int h_top = std::max({std::abs(cls_hkl[n - 1][0]), std::abs(cls_hkl[n - 1][1]),
+                                        std::abs(cls_hkl[n - 1][2])});
+            // A quarter of the phase ambiguity 1/|h| of the highest order this step reads: large
+            // enough to walk to the maximum, small enough that the first probe cannot land in the
+            // neighbouring one.
+            double step = h_top > 0 ? 0.25 / h_top : std::max({step0[0], step0[1], step0[2]});
+            double best = CosineCorrelation(cls_hkl, cls_e2, u, n);
+            for (int round = 0; round < 8; ++round) {
+                for (bool improved = true; improved;) {
+                    improved = false;
+                    // All 26 neighbours, not the 6 along the axes: the phase is h.u, so a vector
+                    // whose class comes mostly from one combination of the axes - h/3 + 2k/3, say -
+                    // sits in a valley that runs diagonally, and a search that only moves one
+                    // component at a time stalls on its wall (measured: 0.005 short in two
+                    // components at once, a quarter of a turn by |h| = 60).
+                    for (int dx = -1; dx <= 1; ++dx)
+                        for (int dy = -1; dy <= 1; ++dy)
+                            for (int dz = -1; dz <= 1; ++dz) {
+                                if (dx == 0 && dy == 0 && dz == 0)
+                                    continue;
+                                const std::array<double, 3> v{u[0] + dx * step, u[1] + dy * step,
+                                                              u[2] + dz * step};
+                                const double f = CosineCorrelation(cls_hkl, cls_e2, v, n);
+                                if (f > best + 1e-9) {
+                                    best = f;
+                                    u = v;
+                                    improved = true;
+                                }
+                            }
+                }
+                step *= 0.5;
+            }
+            if (n == cls_hkl.size())
+                break;
+        }
+        // A greedy climb up the ladder can still end on an alias: a stage whose population is small
+        // and whose objective is flat over the step it searches with can hand the next stage a start
+        // one phase turn out, and from there the finer steps cannot come back. The two candidates are
+        // carried to the end and the whole data decide between them, which is the one place where
+        // both are directly comparable.
+        if (!cls_hkl.empty()
+            && CosineCorrelation(cls_hkl, cls_e2, u_refined, cls_hkl.size())
+                       > CosineCorrelation(cls_hkl, cls_e2, u, cls_hkl.size()))
+            u = u_refined;
+        for (int i = 0; i < 3; ++i)
+            result.vector_frac[i] = u[i] - std::floor(u[i]);
+        contrast(mod_e2, u, &result.phase_bin_mean_e2);
+        result.vector_length_A = DistanceToOrigin(cell, Vec3{result.vector_frac[0], result.vector_frac[1],
+                                                             result.vector_frac[2]},
+                                                  std::vector<Vec3>{{0.0, 0.0, 0.0}});
+    }
+
     // Is the vector a rational translation of the reported cell? If it is, the cell contains a
     // sub-lattice: the pseudo-translation is a candidate for a REAL lattice translation the indexing
     // missed, and the reported cell is a supercell candidate rather than a settled result.
diff --git a/tests/TranslationalNCSTest.cpp b/tests/TranslationalNCSTest.cpp
index 9221f7e1b..ebf90f622 100644
--- a/tests/TranslationalNCSTest.cpp
+++ b/tests/TranslationalNCSTest.cpp
@@ -84,12 +84,11 @@ TEST_CASE("A pseudo-translation is detected and its vector recovered", "[tncs]")
     CHECK(r.undeclared_lattice_translations.empty());
     CHECK(r.peak_z > 5.0);
     CHECK(r.modulation > 2.5 * r.modulation_null);
-    // The vector is refined to maximise the modulation, not to minimise its distance from the truth,
-    // and the greedy search will trade a little accuracy for a little contrast. It is a starting
-    // point for a molecular-replacement program (which refines it), not a measured constant, so the
-    // tolerance here is the honest one - about 0.05 fractional, roughly 5 A on a 100 A axis.
+    // The vector is refined against the intensities of the whole dataset, so it is good to about a
+    // thousandth of a cell edge - which is what the phase classes below need, and a good deal better
+    // than a molecular-replacement program needs as a starting point.
     for (int i = 0; i < 3; ++i)
-        CHECK(std::fabs(r.vector_frac[i] - 0.5) < 0.05);
+        CHECK(std::fabs(r.vector_frac[i] - 0.5) < 0.01);
     CHECK(r.commensurate);
     CHECK(r.commensurate_denominator == 2);
     // A half-integer pseudo-translation is pseudo-centring, not a wrong cell: the suppressed class is
@@ -237,3 +236,39 @@ TEST_CASE("A near-extinct class is reported as a sub-lattice", "[tncs]") {
     CHECK(r.near_extinct_class);
     CHECK(TranslationalNCSToText(r).find("supercell candidate") != std::string::npos);
 }
+
+// The vector is not only reported: the L-test picks its partner steps with it and the twin-immune
+// zone normalises within the phase classes cos(2 pi h.u) it assigns, at FULL resolution. The phase
+// error of a class is |h| times the error in the vector, so a vector refined only on the band the
+// detection gate reads (d >= 4 A, |h| under about 15) classifies nothing beyond that band. Pin the
+// accuracy the classes need, on a vector that is NOT a simple fraction of the cell - a translation
+// between two copies generally is not, and the accuracy must not come from rounding to one.
+TEST_CASE("The pseudo-translation vector classifies the highest orders, not only the gate's band",
+          "[tncs]") {
+    const gemmi::UnitCell cell = Cell(70.0, 85.0, 110.0);
+    const gemmi::SpaceGroup *sg = gemmi::find_spacegroup_by_name("P 1");
+    // P1, because that is the merge the twin-immune zone reads, and because a vector with all three
+    // components irrational is only compatible with the intensities of a crystal that has no rotation
+    // to make it periodic in.
+    const std::array<double, 3> u{0.2917, 0.5883, 0.1234};
+    const auto merged = Synthetic(cell, "P 1", &u, kRealisticDepth);
+    const auto r = AnalyzeTranslationalNCS(merged, cell, sg);
+
+    REQUIRE(r.detected);
+    CHECK_FALSE(r.commensurate);
+
+    // What the accuracy is for: the class of a reflection well past the gate's band.
+    auto cls = [](const std::array<double, 3> &v, const MergedReflection &m) {
+        return std::cos(2.0 * std::numbers::pi * (m.h * v[0] + m.k * v[1] + m.l * v[2])) >= 0.0;
+    };
+    int wrong = 0, n = 0;
+    for (const auto &m : merged) {
+        if (std::max({std::abs(m.h), std::abs(m.k), std::abs(m.l)}) < 15)
+            continue;
+        wrong += cls(r.vector_frac, m) != cls(u, m);
+        ++n;
+    }
+    REQUIRE(n > 1000);
+    CHECK(wrong < n / 20);
+}
+
-- 
2.54.0


From e6d5257b93618bb30c9b01bc5dc522f132b005b8 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:02:12 +0200
Subject: [PATCH 077/122] Ask the metric's own lattice where the class in hand
 names a different one

The "the cell metric carries more rotations than the class in hand" ask fired only
when the metric carried MORE. A lattice class is named from a Niggli-reduced cell on
relative tolerances, so it can also name more symmetry than the lattice carries: a
cell whose gamma is 1.4 degrees off 120 is named hexagonal, and one with a = b whose
gamma is 2 degrees off 90 is named tetragonal, where Le Page - which measures each
two-fold's obliquity - finds four rotations and a C-centred orthorhombic conventional
cell at 0.02 to 0.05 degrees. Asked only on ">", the comparison was then 4 against 12
(or 8) and the ask stayed silent, so the crystal was searched under a holohedry its
own lattice does not have, every operator of that holohedry was refused, and it fell
to a primitive monoclinic subgroup - the one mechanism built to rescue that case
disarmed by the very over-call it exists to correct.

Ask whenever the two differ. The ask adopts only on a strictly higher point group
confirmed by the same search with the same gates, so asking against a lower metric
class cannot demote; it costs one search.

Measured on three rotation datasets whose true lattice is C-centred orthorhombic and
which were indexed on its primitive sub-cell: two now reach the C-centred cell and
adopt C 2 2 2 and C 2 2 2_1, both agreeing with an independent POINTLESS run on the
same P1 merge to the third decimal of every cell edge. The third reaches the same cell
and is then refused by the merge chi^2 ratio at 1.96 against a bound of 1.85 - a
separate gate, untouched here. Eight datasets that decide correctly today, five of
them exercising this ask, are unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index fa13e6200..faa4c0768 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6162,7 +6162,21 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     // The metric's own class, where no search has been given it yet. Where one has -
                     // the centred-lattice test above reindexes into a metric candidate's cell and runs
                     // the full search there - asking it again would only re-run the same question.
-                    if (static_cast<size_t>(metric->n_operators) > asked_rotations)
+                    //
+                    // DIFFERENT, not merely greater. asked_rotations is what the class in hand CLAIMS,
+                    // and a class can claim more rotations than the lattice carries: the character
+                    // table names a class from a Niggli-reduced cell on relative tolerances, so a cell
+                    // whose gamma is a degree and a half off 120 is named hexagonal while Le Page, which
+                    // measures each two-fold's obliquity, finds four rotations and a C-centred
+                    // orthorhombic cell. Asked only on ">" the comparison was then 4 against 12 and the
+                    // ask stayed silent - so the crystal was searched under a holohedry its own lattice
+                    // does not have, every operator of it was refused, and it fell to a subgroup, with
+                    // the one mechanism built to rescue that disarmed by the over-call it exists to
+                    // correct. Where the metric's group is not the group the class in hand names, the
+                    // metric's own cell has not been asked about, whichever of the two is larger.
+                    // Asking cannot demote: ask_metric_lattice adopts only on a STRICTLY higher point
+                    // group, so an ask against a lower metric class costs one search and nothing else.
+                    if (static_cast<size_t>(metric->n_operators) != asked_rotations)
                         ask_metric_lattice(*metric, false);
 
                     // That question is all-or-nothing, and it is asked at the TOP of the metric
-- 
2.54.0


From d70399a290b592f1cd9ff2471ce67b4f9c72290b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 16:18:15 +0200
Subject: [PATCH 078/122] Fit the rotation step to the whole sweep, not to one
 recorded pair

A 2700 frame, 540 degree sweep was refused at load as "screening images taken at
scattered angles". Nothing about it is irregular: every consecutive difference is
a clean step, and the headers simply write the start angle modulo 360, so the
second and third revolutions repeat angles the first already had.

The unwrap handled that correctly. What failed was the STEP. It was taken to be
the smallest difference between two adjacent frames - a single recorded value, and
of all the samples the one biased furthest low by read-back noise. These headers
are written from 32-bit floats, so that one sample was 1.3e-4 low, and placing a
frame by dividing its distance from the FIRST frame by that step multiplied the
error by the frame number: by frame 1924 the drift had reached a quarter of a step
and the on-grid check refused the rest of the sweep.

The fix separates the two jobs the step was doing. The smallest difference is now
only a guess, used to count how many steps apart each pair of NEIGHBOURS is; a
local difference carries the noise of one reading and nothing accumulates, however
long the sweep. The step itself is then a straight line fitted through (steps,
angle) over every frame, so the noise averages out instead of one unlucky pair
setting the scale for thousands of frames. Over the whole corpus this changes the
step for 4 of 82 numbered series and leaves the other 78 bit-identical; of the 4,
three were drifting by 0.17 to 0.35 of a step across the sweep and one by 1e-8.

Counting steps between neighbours is also what carries a sweep past a full turn:
each fold is one step forward, so the count keeps climbing through 360 and a frame
taken on the second revolution lands beyond the first rather than on top of it. A
series that genuinely goes BACK - two sweeps of one crystal concatenated - folds to
a large negative count in a single pair and still collides, so that refusal keeps
working; its message now says what it means.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/SweepLayout.cpp    | 80 ++++++++++++++++++++++++++++++---------
 tests/SweepLayoutTest.cpp | 59 +++++++++++++++++++++++++++++
 2 files changed, 121 insertions(+), 18 deletions(-)

diff --git a/reader/SweepLayout.cpp b/reader/SweepLayout.cpp
index 8127f7741..981fa0137 100644
--- a/reader/SweepLayout.cpp
+++ b/reader/SweepLayout.cpp
@@ -117,29 +117,33 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
     for (size_t i = 1; i < frames.size(); i++)
         angle[i] = angle[i - 1] + Fold(frames[i].angle_deg - angle[i - 1]);
 
-    // ---- one rotation step
+    // ---- a first guess at the rotation step
     //
-    // The step is the smallest move between two frames that ARE adjacent in the series, signed with
-    // the way it went. Taking the FIRST pair instead - which is what this code used to do - reads a
-    // gap as the step and compresses the whole sweep by however much is missing. The header's own
+    // The smallest move between two frames that ARE adjacent in the series, signed with the way it
+    // went. Taking the FIRST pair instead - which is what this code used to do - reads a gap as the
+    // step and compresses the whole sweep by however much is missing. The header's own
     // Angle_increment is not used for this: it is the oscillation WIDTH, which a series with
     // overlapping or spaced wedges does not step by.
     //
     // A difference smaller than half the oscillation width is not a step but jitter in the recorded
     // angle: no instrument slices finer than it exposes, so wedges overlapping twofold would be a
     // read-back wobble, and taking one as the step would spread the sweep over millions of slots.
+    //
+    // It is only a guess, and deliberately the crudest one: a single recorded difference, and the
+    // one biased furthest low by the read-back noise. It is used below to count STEPS between
+    // neighbours, never to place a frame outright.
     const double too_fine = 0.5 * std::abs(f0.increment_deg);
-    double step = 0;
+    double guess = 0;
     for (size_t i = 1; i < frames.size(); i++) {
         const double d = Fold(angle[i] - angle[i - 1]);
-        if (std::abs(d) > std::max(too_fine, 1e-6) && (step == 0 || std::abs(d) < std::abs(step)))
-            step = d;
+        if (std::abs(d) > std::max(too_fine, 1e-6) && (guess == 0 || std::abs(d) < std::abs(guess)))
+            guess = d;
     }
 
     Layout out;
     // A series that never turns: a grid scan, a set of stills, or a single image. There is no sweep
     // to place anything on, so the files are the slots and the header's nominal increment stands.
-    if (step == 0) {
+    if (guess == 0) {
         out.files.reserve(frames.size());
         for (const auto &f : frames)
             out.files.push_back(f.path);
@@ -149,15 +153,51 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
         return out;
     }
 
-    // ---- every frame on that step, or this is not a rotation series
+    // ---- how many steps apart each pair of NEIGHBOURS is
+    //
+    // Counted from one local difference at a time, so nothing accumulates: a recorded angle carries
+    // a few parts in 100000 of read-back noise (these headers are written from 32-bit floats), which
+    // is nowhere near half a step for one pair however long the sweep is. Measuring the frame's
+    // position against the FIRST frame instead multiplies that noise by the frame number - on a 2700
+    // frame sweep the guess above was 1.3e-4 low and by frame 1924 the drift had reached a quarter
+    // of a step, so a perfectly regular series was refused as scattered.
+    //
+    // This is also what carries a sweep past a full turn. Each fold is one step forward, so the
+    // count keeps climbing through 360 and a frame taken on the second revolution lands beyond the
+    // first, not on top of it. A series that genuinely jumps BACK - two sweeps of one crystal
+    // concatenated - folds to a large negative count in a single pair and collides below.
     std::vector<int64_t> slot(frames.size());
-    std::vector<std::string> off_grid;
+    slot[0] = 0;
+    for (size_t i = 1; i < frames.size(); i++)
+        slot[i] = slot[i - 1] + std::llround(Fold(angle[i] - angle[i - 1]) / guess);
+
+    // ---- the step the whole series agrees on
+    //
+    // A straight line through (steps, angle): every frame's own header has a say, so the read-back
+    // noise averages out instead of one unlucky pair setting the scale for thousands of frames.
+    double mean_slot = 0, mean_angle = 0;
     for (size_t i = 0; i < frames.size(); i++) {
-        const double k = (angle[i] - angle[0]) / step;
-        slot[i] = std::llround(k);
-        if (std::abs(k - static_cast<double>(slot[i])) > 0.25)
-            off_grid.push_back(frames[i].path);
+        mean_slot += static_cast<double>(slot[i]);
+        mean_angle += angle[i];
     }
+    mean_slot /= static_cast<double>(frames.size());
+    mean_angle /= static_cast<double>(frames.size());
+    double cov = 0, var = 0;
+    for (size_t i = 0; i < frames.size(); i++) {
+        const double ds = static_cast<double>(slot[i]) - mean_slot;
+        cov += ds * (angle[i] - mean_angle);
+        var += ds * ds;
+    }
+    // Two frames a step apart give var > 0; var == 0 only if every frame landed on one step, which
+    // the guess above has already ruled out.
+    const double step = var > 0 ? cov / var : guess;
+    const double start = mean_angle - step * mean_slot;
+
+    // ---- every frame on that step, or this is not a rotation series
+    std::vector<std::string> off_grid;
+    for (size_t i = 0; i < frames.size(); i++)
+        if (std::abs(angle[i] - (start + step * static_cast<double>(slot[i]))) > 0.25 * std::abs(step))
+            off_grid.push_back(frames[i].path);
     if (!off_grid.empty())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                               fmt::format("The images named here do not lie on one rotation series: "
@@ -180,14 +220,18 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
             duplicates.push_back(frames[i].path);
         at = frames[i].path;
     }
+    // A sweep of more than one full turn reaches the same recorded angle again and is NOT this: it
+    // gets there by stepping forward the whole way, so its second revolution occupies fresh slots.
+    // What collides here is a series that jumped back - two sweeps of one crystal concatenated.
     if (!duplicates.empty())
         throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
-                              fmt::format("The images named here repeat an angle already taken by "
-                                          "another image of the series: {}. Two sweeps of the same "
-                                          "crystal have to be processed separately.",
+                              fmt::format("The images named here go back to a point of the rotation "
+                                          "an earlier image of the series already took: {}. Two "
+                                          "sweeps of the same crystal have to be processed "
+                                          "separately.",
                                           NameSome(duplicates)));
 
-    out.start_deg = angle[0] + step * static_cast<double>(first);
+    out.start_deg = start + step * static_cast<double>(first);
     out.increment_deg = step;
     out.present = frames.size();
 
diff --git a/tests/SweepLayoutTest.cpp b/tests/SweepLayoutTest.cpp
index 9655afe01..ee472c4d2 100644
--- a/tests/SweepLayoutTest.cpp
+++ b/tests/SweepLayoutTest.cpp
@@ -3,6 +3,8 @@
 
 #include <catch2/catch_all.hpp>
 
+#include <cmath>
+
 #include "../common/JFJochException.h"
 #include "../reader/SweepLayout.h"
 
@@ -55,6 +57,63 @@ TEST_CASE("SweepLayout_PastFullTurn") {
     CHECK(l.increment_deg == Catch::Approx(0.1));
 }
 
+TEST_CASE("SweepLayout_MultiTurn") {
+    // One continuous 540 degree sweep, 2700 frames of 0.2 deg, whose headers write the start angle
+    // modulo 360: from frame 1476 on, every angle repeats one the first revolution already had. The
+    // second and third revolutions must occupy fresh slots, not land on top of the first.
+    std::vector<double> angles;
+    for (int i = 0; i < 2700; i++)
+        angles.push_back(std::fmod(65.0 + 0.2 * i, 360.0));
+    const auto l = sweep::Place(Series(angles, 0.2), "test");
+    REQUIRE(l.files.size() == 2700);
+    CHECK(l.present == 2700);
+    CHECK(l.start_deg == Catch::Approx(65.0));
+    CHECK(l.increment_deg == Catch::Approx(0.2));
+    // The sweep really is 540 degrees wide, and no frame was dropped on top of another.
+    CHECK(l.increment_deg * static_cast<double>(l.files.size() - 1) == Catch::Approx(539.8));
+    CHECK(l.files.back() == "f2699.cbf");
+}
+
+TEST_CASE("SweepLayout_MultiTurnWithReadbackNoise") {
+    // The same sweep as a real header writes it: the recorded angles come from 32-bit floats, so
+    // each is a few parts in 100000 off the grid. Estimating the step from ONE recorded difference
+    // scales that noise by the frame number - the series it was measured on drifted a quarter of a
+    // step by frame 1924 and was refused as scattered.
+    std::vector<double> angles;
+    for (int i = 0; i < 2700; i++)
+        angles.push_back(std::fmod(static_cast<double>(static_cast<float>(65.0 + 0.2 * i)), 360.0));
+    const auto l = sweep::Place(Series(angles, 0.2), "test");
+    REQUIRE(l.files.size() == 2700);
+    CHECK(l.present == 2700);
+    CHECK(l.increment_deg == Catch::Approx(0.2).epsilon(1e-6));
+    CHECK(l.start_deg == Catch::Approx(65.0).epsilon(1e-6));
+}
+
+TEST_CASE("SweepLayout_MultiTurnGapped") {
+    // Past 360 AND missing frames: the two have to work together, because a gap is what the step
+    // guess has to survive and a full turn is what the step count has to carry through.
+    std::vector<double> angles;
+    for (int i = 0; i < 2000; i++)
+        if (i % 7 != 3)
+            angles.push_back(std::fmod(10.0 + 0.25 * i, 360.0));
+    const auto l = sweep::Place(Series(angles, 0.25), "test");
+    CHECK(l.files.size() == 2000);
+    CHECK(l.present == angles.size());
+    CHECK(l.increment_deg == Catch::Approx(0.25));
+    CHECK(l.files[3].empty());
+    CHECK(l.files[1999] == "f" + std::to_string(angles.size() - 1) + ".cbf");
+}
+
+TEST_CASE("SweepLayout_ConcatenatedSweepsStillRefused") {
+    // Two 90 degree sweeps of one crystal in one directory. Unlike a sweep that runs past 360, this
+    // one goes BACK: the second series returns to angles the first already covered without having
+    // stepped forward through a whole turn to get there.
+    std::vector<double> angles;
+    for (int i = 0; i < 90; i++) angles.push_back(0.5 * i);
+    for (int i = 0; i < 90; i++) angles.push_back(0.5 * i);
+    CHECK_THROWS_AS(sweep::Place(Series(angles, 0.5), "test"), JFJochException);
+}
+
 TEST_CASE("SweepLayout_Reversed") {
     const auto l = sweep::Place(Series({10.0, 9.5, 9.0, 8.0}, 0.5), "test");
     REQUIRE(l.files.size() == 5);
-- 
2.54.0


From c4d74dd021a338e6934ec653d82d5da269ba56f4 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 10:57:35 +0200
Subject: [PATCH 079/122] Rotation scaling: the per-frame scale is restrained
 to be smooth over the rotation inside the loop

The alternating scale fit has a second degenerate direction beyond the gauge, and that one is not
harmless. A frame whose scale drifts below its neighbours' loses its vote in the references it is
fitted against - an observation's weight there goes as G^2 - which moves the references away from
it, which drives its scale further down. Where every frame is measured against hundreds of
reflections the references barely notice one frame and the loop settles; on a fine-sliced sweep of
a small cell, where a frame holds two or three reflections and a rocking curve spans a dozen or
more frames, the frames at the tails of the curves lose against the frames at their peaks and the
loop walks the bulk of the sweep down fifteen decades. The convergence test then said the loop had
settled, because its own weight (frame observations at G^2) vanishes for exactly the frames that
are collapsing.

So the scale is now smoothed over the rotation INSIDE the loop, at the window the merge already
smoothed G over afterwards (the post-loop smoothing is the same operation and is not repeated):
every frame in a window shares the window's geometric mean, no frame can lose its vote alone, and
what a frame's own observations cannot determine its neighbourhood's do. The window is floored at
six rocking curves - within one curve a change of scale and an error of the partiality model are
the same thing, and a window holding a curve or two fits the model's error as scale. The step test
is weighted by each frame's observation count alone, and a loop whose step has not fallen below
nine tenths of its smallest value for five rounds stops and says so rather than walking further.

Measured against the previous behaviour: a fine-sliced sweep that collapsed to P1 with CC1/2 0.000
merges in its true orthorhombic group at CC1/2 0.95; a monoclinic small-cell set goes from an
unusable 2.13 A merge to 0.81 A at R_meas 11.5%; another from R_meas 33% / ISa 2.2 to 6.1% / 14.2;
two powder-ring sets and a short-sweep tetragonal one improve. The space group is unchanged on
every protein control measured, and the short-sweep and de-novo orthorhombic gains of the
convergent loop are kept.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 163 ++++++++++--------
 .../scale_merge/RotationScaleMerge.h          |  17 +-
 rugnux/ResultReport.cpp                       |   6 +-
 3 files changed, 101 insertions(+), 85 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 8bf050f1c..1a8fa8039 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -38,6 +38,8 @@ namespace {
     // The per-frame scaling loop has settled when the scales moved less than this between two
     // iterations, as the rms of |log(G_new/G_old)| over the frames fitted in both.
     constexpr double SCALING_TOLERANCE = 1e-3;
+    // The per-frame scale is smoothed over at least this many rocking curves (see Run).
+    constexpr int SMOOTH_G_MIN_ROCKING_EVENTS = 6;
 
     // A fitted per-frame scale below this fraction of the run's median is not a measurement of anything:
     // it would mean the frame received 2% of its neighbours' dose while still producing indexable spots.
@@ -1408,7 +1410,7 @@ void RotationScaleMerge::UpdateCorr(std::vector<Obs> &obs, const std::vector<dou
 }
 
 RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
-        const char *what, std::vector<double> &g, const std::vector<int32_t> &frame_obs_count,
+        const char *what, std::vector<double> &g, const std::vector<int32_t> &frame_obs_count, int window,
         const std::function<void()> &iterate,
         const std::function<void(const std::vector<uint8_t> &, const std::vector<double> &)> &rescale) {
     // Alternating least squares on a bilinear model: the reference intensities given the scales, the
@@ -1417,41 +1419,66 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
     // every round, so the scales never stop moving however many rounds they are given. The gauge is
     // therefore pinned after every iteration: G is divided by the run's typical frame scale (the
     // precision-weighted G_ref every other frame measure is read against) and the observations' corr
-    // multiplied by it, which changes no relative scale and no merged intensity. What is left to
-    // converge is the relative scales, and the loop stops when they stop moving.
+    // multiplied by it, which changes no relative scale and no merged intensity.
+    //
+    // It has a second degenerate direction, and that one is not harmless: a frame whose scale drifts
+    // below its neighbours' loses its vote in the references it is fitted against (an observation's
+    // weight there goes as G^2), which moves the references away from it, which drives its scale
+    // further down. On a merge where every frame is measured against hundreds of reflections the
+    // references barely notice one frame and the loop settles; on a fine-sliced small-molecule sweep,
+    // where a frame holds two or three reflections and a rocking curve spans a dozen frames, the
+    // frames at the tails of the rocking curves lost against the frames at their peaks and the loop
+    // walked the bulk of the sweep down fifteen decades while reporting itself settled. So the scale
+    // is restrained to be smooth over the rotation INSIDE the loop, at the window the merge already
+    // smooths G over afterwards (XDS's DELPHI): every frame in a window shares the window's geometric
+    // mean, so no frame can lose its vote alone, and what a frame's own observations cannot determine
+    // its neighbourhood's do. The post-loop smoothing is then this same operation and is not repeated.
+    //
+    // The loop stops when the relative scales stop moving - the rms of |log(G_new/G_old)| over the
+    // frames, each weighted by its observation count and nothing else (a weight that vanishes with G
+    // is what let a collapsing sweep report itself settled) - or when they stop settling: a step that
+    // has not fallen below nine tenths of its smallest value for five rounds is a loop on a flat or
+    // rising valley, and more rounds of it can only walk further. Both leave the frames where they are
+    // and say so.
     ScalingLoopOutcome out;
     std::vector<uint8_t> scaled_any(n_frames, 0);
-    std::vector<double> g_prev(n_frames, 0.0);
+    std::vector<double> g_prev(n_frames, 0.0), g_smooth;
     std::vector<int64_t> n_obs(n_frames, 0);
     std::vector<double> ratio(n_frames, 1.0);
+    double best_step = INFINITY;
+    int rounds_since_best = 0;
     for (int it = 0; it < scaling_iter; ++it) {
         iterate();
         out.iterations = it + 1;
-        for (int f = 0; f < n_frames; ++f) {
+        for (int f = 0; f < n_frames; ++f)
             scaled_any[f] |= frame_scaled_scratch[f];
-            n_obs[f] = scaled_any[f] && std::isfinite(g[f]) && g[f] > 0.0 ? frame_obs_count[f] : 0;
+        // What each frame's corr is multiplied by: the fitted G over the G it ends the round with.
+        for (int f = 0; f < n_frames; ++f)
+            ratio[f] = scaled_any[f] && std::isfinite(g[f]) && g[f] > 0.0 ? g[f] : 1.0;
+        if (window > 1) {
+            frame_scaled_scratch = scaled_any;
+            ComputeSmoothGWindow(g, window, g_smooth);
+            for (int f = 0; f < n_frames; ++f)
+                if (scaled_any[f] && std::isfinite(g_smooth[f]) && g_smooth[f] > 0.0)
+                    g[f] = g_smooth[f];
         }
+        for (int f = 0; f < n_frames; ++f)
+            n_obs[f] = scaled_any[f] && std::isfinite(g[f]) && g[f] > 0.0 ? frame_obs_count[f] : 0;
         const double g_ref = TypicalFrameScale(g, n_obs);
         for (int f = 0; f < n_frames; ++f) {
-            ratio[f] = scaled_any[f] ? g_ref : 1.0;
-            if (scaled_any[f]) g[f] /= g_ref;
+            if (!scaled_any[f] || !(std::isfinite(g[f]) && g[f] > 0.0)) { ratio[f] = 1.0; continue; }
+            g[f] /= g_ref;
+            ratio[f] /= g[f];
         }
         rescale(scaled_any, ratio);
         if (it > 0) {
-            // The step, weighted by what each frame carries into the merge - its observations at its
-            // scale squared, which is how the inverse-variance weight of a scaled observation goes.
-            // A frame the crystal did not diffract on has its scale fitted on noise and wanders by
-            // orders of magnitude every iteration (measured on a sweep 60% out of the beam: scales
-            // at 1e-7 of the typical frame, still moving at the cap); it carries nothing into the
-            // merge and is dropped from it after the loop, so it does not hold the loop open either.
             double ss = 0.0, sw = 0.0;
             int n = 0;
             for (int f = 0; f < n_frames; ++f)
                 if (scaled_any[f] && g_prev[f] > 0.0 && g[f] > 0.0) {
                     const double d = std::log(g[f] / g_prev[f]);
-                    const double w = frame_obs_count[f] * g[f] * g[f];
-                    ss += w * d * d;
-                    sw += w;
+                    ss += frame_obs_count[f] * d * d;
+                    sw += frame_obs_count[f];
                     ++n;
                 }
             out.step = sw > 0.0 ? std::sqrt(ss / sw) : 0.0;
@@ -1461,6 +1488,13 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
                 out.converged = true;
                 break;
             }
+            if (out.step < 0.9 * best_step) {
+                best_step = out.step;
+                rounds_since_best = 0;
+            } else if (++rounds_since_best >= 5) {
+                out.stalled = true;
+                break;
+            }
         }
         g_prev = g;
     }
@@ -1468,6 +1502,11 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
     if (out.converged)
         logger.Info("Per-frame scaling ({}): settled after {} iterations (rms |dlogG| {:.1e})", what,
                     out.iterations, out.step);
+    else if (out.stalled)
+        logger.Warning("Per-frame scaling ({}): stopped after {} iterations - the scales stopped settling "
+                       "(rms |dlogG| {:.1e}, not below {:.1e} for five rounds); more rounds would only walk "
+                       "them, so everything read off this merge is read off an unsettled state", what,
+                       out.iterations, out.step, best_step);
     else
         logger.Warning("Per-frame scaling ({}): NOT settled after the cap of {} iterations - the scales "
                        "were still moving by rms |dlogG| {:.1e} (tolerance {:.0e}); everything read off "
@@ -3182,11 +3221,14 @@ void RotationScaleMerge::ComputeSmoothGWindow(const std::vector<double> &g, int
     const int half = window / 2;
     g_smooth.assign(n, NAN);
 
-    // No collapsed-scale handling here: DropCollapsedScales has already run on g, so every fitted
-    // entry is credible. That matters because the window average is a GEOMETRIC mean - a scale
-    // collapsing toward zero would not just corrupt its own frame, its logarithm would drag the whole
-    // window down, and where the only fitted frames in a window ARE the collapsed ones the mean would
-    // average the fault with itself and make it permanent.
+    // No collapsed-scale handling here, and the caller is the scaling loop, which runs BEFORE
+    // DropCollapsedScales - so a frame the crystal did not diffract on is in the window with the rest.
+    // The window average is a GEOMETRIC mean, so such a frame drags its whole window down by its
+    // logarithm, and is itself lifted toward its neighbours. That is the point on a fine-sliced sweep
+    // (a frame with two reflections cannot be told from a dead one by its own scale) and it is the
+    // price on a sweep with a genuinely dead stretch: the stretch is no longer far enough below the
+    // median for DropCollapsedScales to see it, and what removes it is the sweep ledger's
+    // delta-CC1/2, which asks what the frames cost rather than how small their scale came out.
     for (int o = 0; o < n; ++o) {
         double sum_log = 0.0;
         int count = 0;
@@ -3260,22 +3302,6 @@ bool RotationScaleMerge::DropCollapsedScales(const std::vector<uint8_t> &fitted_
     return n_dropped > 0;
 }
 
-void RotationScaleMerge::SmoothG(std::vector<Obs> &obs, std::vector<double> &g, int window) const {
-    const int n = static_cast<int>(g.size());
-    std::vector<double> g_smooth;
-    ComputeSmoothGWindow(g, window, g_smooth);
-    for (auto &o : obs) {
-        const int f = o.frame;
-        if (!frame_scaled_scratch[f] || !std::isfinite(g[f]) || g[f] <= 0.0 || !std::isfinite(g_smooth[f]))
-            continue;
-        if (std::isfinite(o.corr))
-            o.corr = static_cast<float>(o.corr * (g[f] / g_smooth[f]));
-    }
-    for (int f = 0; f < n; ++f)
-        if (frame_scaled_scratch[f] && std::isfinite(g[f]) && g[f] > 0.0 && std::isfinite(g_smooth[f]))
-            g[f] = g_smooth[f];
-}
-
 // The same guard on the scale-fulls pass, which refits G from scratch and so can collapse a frame the
 // partials guard passed. Detection and remedy are both DropCollapsedScales': the frame's fulls leave the
 // merge. Merging them unscaled - the old behaviour - asserts G = 1 for a frame whose scale is
@@ -4717,6 +4743,27 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     std::vector<double> partial_mean;
     bool scaled_on_gpu = false;
 
+    // The smoothing window (--smooth-g, XDS DELPHI-like), applied inside both scaling loops - and
+    // never narrower than SMOOTH_G_MIN_ROCKING_EVENTS rocking curves. Within one rocking curve a
+    // change of scale and an error of the partiality model are the same thing, so a window that
+    // holds only a curve or two fits the model's error as scale: measured on a fine-sliced
+    // small-molecule sweep whose curves span 17 frames, the 5 deg window (a curve and a half) let
+    // the loop walk to a 140x spread of scales across the sweep, three curves to 25x, six curves to
+    // a settled 6x. On protein data at ordinary mosaicity 5 deg already holds ten or more curves and
+    // the floor changes nothing.
+    const auto s = x.GetScalingSettings();
+    const double smooth_g_deg = s.GetSmoothGDegrees();
+    const auto gonio = x.GetGoniometer();
+    const double osc_deg = gonio ? std::fabs(gonio->GetIncrement_deg()) : 0.0;
+    int smooth_window = 1;
+    if (smooth_g_deg > 0.0 && osc_deg > 1e-6) {
+        smooth_window = std::max(static_cast<int>(std::lround(smooth_g_deg / osc_deg)),
+                                 SMOOTH_G_MIN_ROCKING_EVENTS * RockingEventFrames());
+        if (smooth_window % 2 == 0) ++smooth_window;
+        logger.Info("Per-frame scale smoothing window: {} frames ({:.1f} deg; {} deg asked, rocking "
+                    "curves span {} frames)", smooth_window, smooth_window * osc_deg, smooth_g_deg,
+                    RockingEventFrames());
+    }
     ScalingLoopOutcome partial_loop;
 #ifdef JFJOCH_USE_CUDA
     if (gpu_active_) {
@@ -4727,7 +4774,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         // fit this iteration keeps the G it had (its corr was left where it was).
         std::vector<double> g_dev(n_frames);
         std::vector<uint8_t> scaled_dev(n_frames);
-        partial_loop = RunScalingLoop("partials", g_partial, frame_count, [&] {
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window, [&] {
             gpu_->ScalePartials(1, min_partiality, d_min_limit.has_value());
             gpu_->GetG(g_dev.data(), scaled_dev.data());
             for (int f = 0; f < n_frames; ++f)
@@ -4740,7 +4787,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     }
 #endif
     if (!scaled_on_gpu) {
-        partial_loop = RunScalingLoop("partials", g_partial, frame_count, [&] {
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window, [&] {
             ReduceGroupMeans(partials, n_groups, partial_mean);
             FitPerFrameG(partials, frame_start, frame_count, partial_mean, /*unity=*/false, g_partial);
             UpdateCorr(partials, g_partial, frame_scaled_scratch);
@@ -4790,37 +4837,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         }
     }
 
-    // --- 2. Smooth G across frames (XDS DELPHI-like) before the combine. ---
-    const auto s = x.GetScalingSettings();
-    const double smooth_g_deg = s.GetSmoothGDegrees();
-    const auto gonio = x.GetGoniometer();
-    const double osc_deg = gonio ? std::fabs(gonio->GetIncrement_deg()) : 0.0;
-    if (smooth_g_deg > 0.0 && osc_deg > 1e-6) {
-        int window = std::max(1, static_cast<int>(std::lround(smooth_g_deg / osc_deg)));
-        if (window % 2 == 0) ++window;
-        bool smoothed_on_gpu = false;
-#ifdef JFJOCH_USE_CUDA
-        if (gpu_active_) {
-            // Apply smooth-G to the resident corr: the host builds the per-frame ratio g/g_smooth (+ an
-            // apply flag), the kernel multiplies corr in place. Same guard / arithmetic as host SmoothG.
-            std::vector<double> g_smooth;
-            ComputeSmoothGWindow(g_partial, window, g_smooth);
-            std::vector<uint8_t> apply(n_frames, 0);
-            std::vector<double> ratio(n_frames, 1.0);
-            for (int f = 0; f < n_frames; ++f)
-                if (frame_scaled_scratch[f] && std::isfinite(g_partial[f]) && g_partial[f] > 0.0
-                    && std::isfinite(g_smooth[f])) {
-                    apply[f] = 1;
-                    ratio[f] = g_partial[f] / g_smooth[f];
-                }
-            gpu_->SmoothCorr(apply.data(), ratio.data());
-            for (int f = 0; f < n_frames; ++f) if (apply[f]) g_partial[f] = g_smooth[f];
-            smoothed_on_gpu = true;
-        }
-#endif
-        if (!smoothed_on_gpu)
-            SmoothG(partials, g_partial, window);
-    }
+    // --- 2. G is smoothed across frames (XDS DELPHI-like) inside the scaling loop above. ---
 
     // Per-frame CC + write G/CC/mosaicity back onto the partials (once). On the GPU the group means +
     // per-frame CC run on the resident (already smoothed) corr; only the tiny per-frame cc/cc_n come back.
@@ -4992,7 +5009,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
             if (static_cast<int>(g_full.size()) != n_frames) g_full.assign(n_frames, 1.0);
             std::vector<double> g_dev(n_frames);
             std::vector<uint8_t> scaled_dev(n_frames);
-            fulls_loop = RunScalingLoop("fulls", g_full, f_count, [&] {
+            fulls_loop = RunScalingLoop("fulls", g_full, f_count, smooth_window, [&] {
                 gpu_->ScaleFulls(1, min_partiality);
                 gpu_->GetG(g_dev.data(), scaled_dev.data());
                 for (int f = 0; f < n_frames; ++f)
@@ -5052,7 +5069,7 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     // --- 4. Scale the fulls (XDS order, Unity model). ---
     if (scale_fulls && !scaled_fulls_on_gpu) {
         std::vector<double> full_mean;
-        fulls_loop = RunScalingLoop("fulls", g_full, fulls_frame_count, [&] {
+        fulls_loop = RunScalingLoop("fulls", g_full, fulls_frame_count, smooth_window, [&] {
             ReduceGroupMeans(fulls, n_groups, full_mean);
             FitPerFrameG(fulls, fulls_frame_start, fulls_frame_count, full_mean, /*unity=*/true, g_full);
             UpdateCorr(fulls, g_full, frame_scaled_scratch);
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 6cc953c67..a07017460 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -445,12 +445,13 @@ private:
 
     // The alternating per-frame scale fit run to convergence: `iterate` fits every frame once against
     // the current reference (leaving G in `g` and the frames it fitted in frame_scaled_scratch),
-    // `rescale` multiplies the corr of the flagged frames' observations by a per-frame ratio. Pins the
-    // gauge after every iteration and stops when the scales settle or the cap is reached. On return
-    // frame_scaled_scratch flags every frame fitted in any iteration.
-    struct ScalingLoopOutcome { int iterations = 0; bool converged = false; double step = 0.0; };
+    // `rescale` multiplies the corr of the flagged frames' observations by a per-frame ratio. Smooths G
+    // over `window` frames and pins the gauge after every iteration; stops when the scales settle, stop
+    // settling, or the cap is reached. On return frame_scaled_scratch flags every frame fitted in any
+    // iteration.
+    struct ScalingLoopOutcome { int iterations = 0; bool converged = false; bool stalled = false; double step = 0.0; };
     ScalingLoopOutcome RunScalingLoop(const char *what, std::vector<double> &g,
-                                      const std::vector<int32_t> &frame_obs_count,
+                                      const std::vector<int32_t> &frame_obs_count, int window,
                                       const std::function<void()> &iterate,
                                       const std::function<void(const std::vector<uint8_t> &,
                                                                const std::vector<double> &)> &rescale);
@@ -459,10 +460,8 @@ private:
     void UpdateCorr(std::vector<Obs> &obs, const std::vector<double> &g,
                     const std::vector<uint8_t> &frame_scaled) const;
 
-    void SmoothG(std::vector<Obs> &obs, std::vector<double> &g, int window) const;
-
-    // The windowed geometric mean of G over frames (the shared first half of SmoothG); the GPU path
-    // applies the resulting ratio to the resident corr in a kernel instead of the host obs loop.
+    // The windowed geometric mean of G over frames; the scaling loop applies the resulting ratio to
+    // the observations' corr (on the GPU, to the resident corr in a kernel).
     void ComputeSmoothGWindow(const std::vector<double> &g, int window,
                               std::vector<double> &g_smooth) const;
 
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 0243ff06e..ee1d83a79 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -754,9 +754,9 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                                        result.scaling_converged ? "" : " (NOT settled)"), true));
             if (!result.scaling_converged || !result.search_scaling_converged)
                 Warn(doc, PathologyCode::SCALING_NOT_CONVERGED, fmt::format(
-                        "the per-frame scales of {} were still moving when the iteration cap stopped "
-                        "them, so everything read off that merge is read off an unsettled state "
-                        "(--scaling-iterations raises the cap)",
+                        "the per-frame scales of {} were still moving when the scaling loop stopped "
+                        "(at its cap, or because they had stopped settling - the log says which), so "
+                        "everything read off that merge is read off an unsettled state",
                         !result.scaling_converged && !result.search_scaling_converged
                             ? "the space-group search merge and the final merge"
                             : !result.scaling_converged ? "the final merge"
-- 
2.54.0


From 574419dc6ccf11bd2f8bbba7d4f53f2723642d07 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 10:34:36 +0200
Subject: [PATCH 080/122] Lattice class: carry the free class and decide it on
 what the pass realises

The Bravais class is chosen by a walk that reads two axes as EQUAL when they
agree to a fixed relative tolerance, and the class carrying that equality is
then imposed on everything below: the cell is refined with a = b, reflections
are predicted from it, and they are integrated at those predicted positions.
On a small cell the tolerance is far wider than the spot positions resolve, so
a genuinely orthorhombic crystal whose a and b differ by 2 % is integrated as
tetragonal and every decision downstream is read off the wreckage.

Measure the equality instead of assuming it. The indexer already refines each
candidate a second time with nothing held, so the first pass now reports how
far that free refinement leaves the two axes apart. A relative split of eps
displaces a reflection at radius r by eps/2 * r pixels: where that displacement
at the far corner of the detector stays inside the integration disc, imposing
the equality moves nothing out of its own box and the higher symmetry is kept
with no extra pass. Where it does not, both hypotheses are run as probe-only
passes - the promoted class, and the class the same walk carries when it is
granted no length equality at all - and whichever realises the lower held-out
positional residual is kept, the promoted class on a tie.

Two small-molecule sets whose axes differ by 2 % now index, refine and merge in
their own orthorhombic lattice instead of a tetragonal mean: one goes from a
cell 1 % wrong and P 1 at CC1/2 0.19 to the deposited cell within 0.2 % and
P 2 2 2 at CC1/2 0.95, the other from a tetragonal mean to a cell matching its
reference to 0.4 %. Protein sets whose symmetry is real (P41212, P4222, I23,
P6422, F4132) are unchanged: their free refinements leave the axes 0.02-0.10 %
apart, a few tenths of a pixel, so the question is never asked. Where it was
asked on a weak sweep whose free refinement diverged, the arms decided for the
higher symmetry and the output was identical.

No new threshold: the comparison is the integration radius the run already
integrates at, and the arms are judged by HeldOutResidualFell, as the geometry
walk's rounds are. postrefine_probe_only_ returns for the arms' sake - a pass
run only to measure stops before the scaling engine is built, so neither arm
pays for a merge or a space-group search.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 common/IndexingSettings.cpp                   |   9 ++
 common/IndexingSettings.h                     |  10 ++
 .../lattice_search/LatticeSearch.cpp          |  13 ++
 image_analysis/lattice_search/LatticeSearch.h |   8 +
 .../rotation_indexer/RotationIndexer.cpp      |  10 ++
 rugnux/Rugnux.cpp                             | 142 +++++++++++++++++-
 rugnux/Rugnux.h                               |  13 ++
 tests/LatticeSearchTest.cpp                   |  29 ++++
 8 files changed, 231 insertions(+), 3 deletions(-)

diff --git a/common/IndexingSettings.cpp b/common/IndexingSettings.cpp
index 6b3c994c8..8d35f57b1 100644
--- a/common/IndexingSettings.cpp
+++ b/common/IndexingSettings.cpp
@@ -223,6 +223,15 @@ float IndexingSettings::GetRotationIndexingAngularStride_deg() const {
     return rotation_indexing_angular_stride_deg;
 }
 
+IndexingSettings & IndexingSettings::LatticeClassDemoted(bool input) {
+    lattice_class_demoted = input;
+    return *this;
+}
+
+bool IndexingSettings::GetLatticeClassDemoted() const {
+    return lattice_class_demoted;
+}
+
 bool IndexingSettings::GetIndexIceRings() const {
     return index_ice_rings;
 }
diff --git a/common/IndexingSettings.h b/common/IndexingSettings.h
index 852c951d1..a779fda7b 100644
--- a/common/IndexingSettings.h
+++ b/common/IndexingSettings.h
@@ -62,6 +62,14 @@ private:
     bool blocking_behavior = true;
     bool index_ice_rings = false;
 
+    // Refuse the Bravais class the metric was promoted to on a LENGTH equality, and index in the
+    // class left when that equality is struck out. Not a user setting: rugnux runs one pass with it
+    // and one without, and keeps the one whose re-integrated held-out positional residual is lower
+    // (see RunAllPasses). The promotion is decided against a 3 % relative tolerance on a cell the
+    // spot positions place to ~0.1 %, so on a small cell a genuinely orthorhombic crystal is
+    // integrated with a = b imposed and nothing downstream can recover from it.
+    bool lattice_class_demoted = false;
+
     bool enable_rotation_indexing = false;
     float rotation_indexing_min_angular_range_deg = 20.0;
     float rotation_indexing_angular_stride_deg = 0.5;
@@ -89,6 +97,7 @@ public:
     IndexingSettings& RotationIndexingAngularStride_deg(float input);
     IndexingSettings& BlockingBehavior(bool input);
     IndexingSettings& MaxExtraLattices(int64_t input);
+    IndexingSettings& LatticeClassDemoted(bool input);
 
     [[nodiscard]] int64_t GetViableCellMinSpots() const;
     [[nodiscard]] IndexingAlgorithmEnum GetAlgorithm() const;
@@ -110,4 +119,5 @@ public:
     [[nodiscard]] float GetRotationIndexingAngularStride_deg() const;
     [[nodiscard]] bool GetBlockingBehavior() const;
     [[nodiscard]] int64_t GetMaxExtraLattices() const;
+    [[nodiscard]] bool GetLatticeClassDemoted() const;
 };
diff --git a/image_analysis/lattice_search/LatticeSearch.cpp b/image_analysis/lattice_search/LatticeSearch.cpp
index b22a331c3..232c5d05f 100644
--- a/image_analysis/lattice_search/LatticeSearch.cpp
+++ b/image_analysis/lattice_search/LatticeSearch.cpp
@@ -476,6 +476,19 @@ std::optional<LatticeSearchResult> LatticeSearchForClass(const CrystalLattice &L
     return SearchCharacters(L, dist_tolerance, angle_tolerance, &only);
 }
 
+
+bool ClassImposesLengthEquality(gemmi::CrystalSystem system) {
+    switch (system) {
+        case gemmi::CrystalSystem::Tetragonal:
+        case gemmi::CrystalSystem::Trigonal:
+        case gemmi::CrystalSystem::Hexagonal:
+        case gemmi::CrystalSystem::Cubic:
+            return true;
+        default:
+            return false;
+    }
+}
+
 double MetricDeviation(const LatticeSearchResult &sr) {
     const UnitCell uc = sr.conventional.GetUnitCell();
     double angle = 0.0, length = 0.0;
diff --git a/image_analysis/lattice_search/LatticeSearch.h b/image_analysis/lattice_search/LatticeSearch.h
index 06f3dead8..396219423 100644
--- a/image_analysis/lattice_search/LatticeSearch.h
+++ b/image_analysis/lattice_search/LatticeSearch.h
@@ -48,6 +48,14 @@ std::optional<LatticeSearchResult> LatticeSearchForClass(const CrystalLattice& L
                                                          double dist_tolerance = LATTICE_SEARCH_DIST_TOLERANCE,
                                                          double angle_tolerance_deg = LATTICE_SEARCH_ANGLE_TOLERANCE_DEG);
 
+// Whether the conventional metric of this class asserts an equality between cell LENGTHS (a = b, and
+// for cubic a = b = c). Those are the promotions the relative tolerance above admits far more widely
+// than the spot positions resolve; every other class is carried by its angles alone. The walk run
+// with dist_tolerance = 0 grants no such equality, and so returns the class the metric carries on
+// its angles alone - the OTHER hypothesis about any of these promotions, which rugnux runs as its
+// own pass and judges on what it realises (see RunAllPasses).
+bool ClassImposesLengthEquality(gemmi::CrystalSystem system);
+
 // How far the matched lattice's metric sits from the IDEAL metric of its class, as a fraction of the
 // tolerance that admitted it: 0 is exactly the class, 1 is the edge of what the walk accepts. The
 // walk computes this and throws it away - a cell 0.02 deg from being C-centred monoclinic and one
diff --git a/image_analysis/rotation_indexer/RotationIndexer.cpp b/image_analysis/rotation_indexer/RotationIndexer.cpp
index 90845254a..568f21297 100644
--- a/image_analysis/rotation_indexer/RotationIndexer.cpp
+++ b/image_analysis/rotation_indexer/RotationIndexer.cpp
@@ -160,8 +160,18 @@ void RotationIndexer::RunIndexing() {
         // 60 validation frames and an F-cubic one relabelled trigonal indexed 0 of 60, where the same
         // frames index at 36/60 and 51/60 without a group. The group is applied where it belongs - to
         // the scaling and the merge.
+        const bool demote_class = experiment.GetIndexingSettings().GetLatticeClassDemoted();
         auto build_sr = [&](const CrystalLattice &cand) -> LatticeSearchResult {
             auto ls = LatticeSearch(cand);
+            // The other hypothesis about a promotion that rests on a = b: walk the characters again
+            // granting NO length equality at all, and take the class the metric carries on its angles
+            // alone. Not the same as striking one class out - the tetragonal-P lattice also has a
+            // C-centred orthorhombic character, which is a different (doubled) cell and rests on the
+            // very equality in question. The caller runs this as its own pass and keeps whichever pass
+            // realises the lower held-out positional residual. The hexagonal re-expression below is a
+            // promotion of the same kind, so it is not applied here.
+            if (demote_class && ClassImposesLengthEquality(ls.system))
+                return LatticeSearch(cand, /*dist_tolerance=*/0.0);
             if (!IsHexagonalSystem(ls.system) && IsMetricallyHexagonal(ls.primitive_reduced)) {
                 ls.conventional = HexagonalConventional(ls.primitive_reduced);
                 ls.system = gemmi::CrystalSystem::Hexagonal;
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 4b7b32632..fa13e6200 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -2086,6 +2086,106 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
                        .PoniRot1_rad(g[3]).PoniRot2_rad(g[4]);
         };
 
+        // The lattice arms below run passes that exist ONLY to measure - see there - so the
+        // count of passes the run made has to include them even though they write nothing.
+        int arm_passes = 0;
+
+        // The metric symmetry, asked of the spots rather than of the tolerance that admitted it. The
+        // Bravais class is chosen by a walk that reads two axes as EQUAL when they agree to a fixed
+        // relative tolerance, and the class carrying that equality is then imposed everywhere below:
+        // the cell is refined with a = b, reflections are predicted from it and integrated at the
+        // predicted positions. On a small cell the tolerance is far wider than the positions resolve -
+        // a 5.8 A axis pair 2.4 % apart is read as tetragonal, and the mean the constraint substitutes
+        // mispredicts the outermost reflections by a good ten pixels against an integration disc of
+        // four - so a genuinely orthorhombic crystal is integrated as tetragonal and every decision
+        // downstream, up to the space group, is read off the wreckage.
+        //
+        // So the equality is measured rather than assumed. The indexer already refines the same
+        // candidate a second time with nothing held, and pass 1 reports how far that free refinement
+        // leaves the two axes apart (lattice_length_split). A relative split of eps displaces a
+        // reflection at radius r by eps/2 * r pixels, so the question "do these data resolve it" has
+        // an answer in the units the integration works in: where that displacement at the far corner
+        // of the detector stays inside the integration disc, imposing the equality moves nothing out
+        // of its own box and the higher symmetry is kept with no pass run. Where it does not, both
+        // hypotheses are run - the promoted class, and the class the same walk carries when it is
+        // granted no length equality at all - and whichever REALISES the lower held-out residual on a
+        // re-integrated, re-indexed pass is kept, the
+        // promoted class on a tie, because it is the one that asserts more. Both arms are probe-only
+        // passes (postrefine_probe_only_): the residual is all the comparison reads and it is in hand
+        // before the scaling engine is built, so neither arm pays for a merge, a space-group search or
+        // a set of correction surfaces, and only the class that wins is ever run as a canonical pass.
+        std::string lattice_arm;      // the arm decision, for the pass decision text
+        if (!cancelled_ && pass1.lattice_length_split && pass1.rotation_lattice_type) {
+            const double split = *pass1.lattice_length_split;
+            const double dx = std::max(experiment_.GetBeamX_pxl(),
+                                       static_cast<float>(experiment_.GetXPixelsNum()) - experiment_.GetBeamX_pxl());
+            const double dy = std::max(experiment_.GetBeamY_pxl(),
+                                       static_cast<float>(experiment_.GetYPixelsNum()) - experiment_.GetBeamY_pxl());
+            const double r_corner_px = std::hypot(dx, dy);
+            const double miss_px = 0.5 * split * r_corner_px;
+            const double disc_px = experiment_.GetBraggIntegrationSettings().GetR1();
+            if (miss_px > disc_px) {
+                logger.Info("Metric symmetry: {} was promoted on a = b, but the free refinement leaves "
+                            "the two axes {:.2f} % apart - {:.1f} px of misprediction at the far corner "
+                            "against an integration disc of {:.1f} px. Both classes are re-integrated "
+                            "and judged on the held-out residual each realises",
+                            gemmi::crystal_system_str(pass1.rotation_lattice_type->crystal_system),
+                            100.0 * split, miss_px, disc_px);
+                // The arms are compared on the post-refinement's held-out residual, so they have to
+                // measure one: a canonical pass only does where the pre-pass moved the geometry.
+                const bool probe_was = postrefine_probe_;
+                postrefine_probe_ = true;
+                postrefine_probe_only_ = true;
+                const auto promoted_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
+                ++arm_passes;
+                IndexingSettings demoted_settings = experiment_.GetIndexingSettings();
+                demoted_settings.LatticeClassDemoted(true);
+                experiment_.ImportIndexingSettings(demoted_settings);
+                const auto demoted_arm = RunPipeline(observer, /*write_output=*/false, /*geometry_prepass=*/false);
+                ++arm_passes;
+                postrefine_probe_only_ = false;
+                postrefine_probe_ = probe_was;
+                const double realised_promoted = promoted_arm.post_refine ? promoted_arm.post_refine->held_out_before : NAN;
+                const double realised_demoted = demoted_arm.post_refine ? demoted_arm.post_refine->held_out_before : NAN;
+                const auto class_text = [](const ProcessResult &r) {
+                    return r.rotation_lattice_type
+                           ? fmt::format("{}-centred {}", r.rotation_lattice_type->centering,
+                                         gemmi::crystal_system_str(r.rotation_lattice_type->crystal_system))
+                           : std::string("no lattice");
+                };
+                if (!cancelled_ && promoted_arm.post_refine && demoted_arm.post_refine
+                    && HeldOutResidualFell(*promoted_arm.post_refine, *demoted_arm.post_refine)) {
+                    logger.Warning("Metric symmetry: re-integrated as {} the held-out residual is {:.3e} "
+                                   "against {:.3e} as {} - the equality is not this crystal's, and the "
+                                   "run goes on without it", class_text(demoted_arm), realised_demoted,
+                                   realised_promoted, class_text(promoted_arm));
+                    lattice_arm = fmt::format(
+                            "the metric symmetry was promoted to {} on axes the free refinement leaves "
+                            "{:.2f} % apart; re-integrated as {} the held-out residual is {:.3e} against "
+                            "{:.3e}, so the equality was dropped", class_text(promoted_arm), 100.0 * split,
+                            class_text(demoted_arm), realised_demoted, realised_promoted);
+                } else if (!cancelled_) {
+                    IndexingSettings promoted_settings = experiment_.GetIndexingSettings();
+                    promoted_settings.LatticeClassDemoted(false);
+                    experiment_.ImportIndexingSettings(promoted_settings);
+                    logger.Info("Metric symmetry: re-integrated as {} the held-out residual is {:.3e}, "
+                                "which {} does not beat ({:.3e}) - the higher symmetry stands",
+                                class_text(promoted_arm), realised_promoted, class_text(demoted_arm),
+                                realised_demoted);
+                    lattice_arm = fmt::format(
+                            "{} was run as well and realised a held-out residual of {:.3e} against {:.3e} "
+                            "as {}, so the metric symmetry stands", class_text(demoted_arm),
+                            realised_demoted, realised_promoted, class_text(promoted_arm));
+                }
+            } else {
+                logger.Info("Metric symmetry: {} asserts a = b and the free refinement leaves the two "
+                            "axes {:.2f} % apart - {:.1f} px at the far corner, inside the integration "
+                            "disc of {:.1f} px, so these data do not resolve the difference",
+                            gemmi::crystal_system_str(pass1.rotation_lattice_type->crystal_system),
+                            100.0 * split, miss_px, disc_px);
+            }
+        }
+
         logger.Info("Rotation two-pass geometry post-refinement: second pass (refined geometry, canonical) -> {}_*",
                     base_prefix);
         auto pass2 = RunPipeline(observer, /*write_output=*/true, /*geometry_prepass=*/false);
@@ -2205,8 +2305,8 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass1.post_refine->distance_held = false;
         }
         pass2.post_refine = pass1.post_refine;
-        pass2.pass_number = 2 + walk_passes;
-        pass2.pass_count = 2 + walk_passes;
+        pass2.pass_number = 2 + arm_passes + walk_passes;
+        pass2.pass_count = 2 + arm_passes + walk_passes;
         if (geometry_rounds > 0)
             pass2.pass_decision = fmt::format(
                     "post-refined geometry walked {} round{} and kept round {}, detector distance {:.3f} mm "
@@ -2341,6 +2441,8 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
             pass2.pass_decision = (prepass_detector_geometry_ || prepass_rotation_scale_)
                     ? "post-refined geometry adopted"
                     : "the post-refinement committed no geometry change, so this pass reproduces the first";
+        if (!lattice_arm.empty())
+            pass2.pass_decision = lattice_arm + "; " + pass2.pass_decision;
         pass2.geometry_not_converged = geometry_not_converged;
         return pass2;
     }
@@ -4869,6 +4971,28 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             };
             result.rotation_lattice_found = true;
             result.rotation_lattice_type = end_msg.rotation_lattice_type;
+            // What the equality this class asserts is worth on a REFINED cell. The indexer refines the
+            // same candidate a second time with nothing held (its pseudo-symmetry guard) and hands that
+            // cell over whenever the constrained one won; it was seeded from the primitive reduced cell
+            // and comes back in that basis, so the class's own reindex re-expresses it in the
+            // conventional one and a and b can be read off it. Measured here, decided in RunAllPasses,
+            // which is where there is a pass to compare it against.
+            if (rot->unconstrained && ClassImposesLengthEquality(rot->search_result.system)) {
+                const UnitCell free_uc =
+                        rot->unconstrained->lattice.Multiply(rot->search_result.reindex).GetUnitCell();
+                double split = std::fabs(free_uc.a - free_uc.b) / (0.5 * (free_uc.a + free_uc.b));
+                if (rot->search_result.system == gemmi::CrystalSystem::Cubic)
+                    split = std::max(split, std::fabs(free_uc.b - free_uc.c)
+                                            / (0.5 * (free_uc.b + free_uc.c)));
+                if (std::isfinite(split)) {
+                    result.lattice_length_split = split;
+                    logger.Info("Rotation lattice: {}-centred {} asserts a = b; the free refinement of "
+                                "the same candidate leaves them {:.2f} % apart ({:.4f} / {:.4f} A)",
+                                rot->search_result.centering,
+                                gemmi::crystal_system_str(rot->search_result.system),
+                                100.0 * split, free_uc.a, free_uc.b);
+                }
+            }
             // The consensus cell below is this lattice's conventional cell, so this is the centring
             // it is written in - the pair the volume comparisons in Run() need.
             result.consensus_centering = rot->search_result.centering;
@@ -5214,8 +5338,20 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // before the engine is built rather than beside it - the gathered observations and their
         // rocking events are gigabytes on a long axis, and beside the engine's own arrays they set
         // the pass's memory high-water mark.
-        if (postrefine_probe_ && !geometry_prepass && is_rotation)
+        if (postrefine_probe_ && !geometry_prepass && is_rotation) {
             post_refine_geometry();
+            // A pass the lattice arms run to compare two Bravais classes has now produced the only
+            // thing the comparison reads - the held-out residual of the fit just measured. Stop here
+            // rather than scale, search, fit surfaces and merge for a result nothing looks at.
+            if (postrefine_probe_only_) {
+                result.processing_time_s = std::chrono::duration<double>(
+                        std::chrono::steady_clock::now() - start_time).count();
+                logger.Info("Lattice-arm probe: {} images integrated and post-refined in {:.2f} s "
+                            "(the arm reads the held-out residual only, so this pass does not merge)",
+                            result.images_processed, result.processing_time_s);
+                return result;
+            }
+        }
         if (is_rotation) {
             if (experiment_.GetRefineRotationWedgeInScaling()
                 || rot_ss.GetRotationWedgeForScaling().has_value())
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 6e606e086..12fa96e32 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -232,6 +232,13 @@ struct ProcessResult {
     // The metric symmetry the rotation lattice was classified in - the class GeometryRefiner holds the
     // cell to and the space-group search enumerates under. Empty when no rotation lattice was found.
     std::optional<LatticeMessage> rotation_lattice_type;
+    // Where that class asserts a = b: how far apart the FREE (triclinic) refinement of the same
+    // candidate - which the indexer runs anyway, as its pseudo-symmetry guard - leaves those two
+    // axes, relative. The class was decided against a fixed relative tolerance on an UNREFINED FFT
+    // cell; this is the same equality measured on a refined one, and it is what RunAllPasses turns
+    // into pixels to ask whether this crystal's spot positions resolve the equality at all. Empty
+    // where the class asserts no length equality, or where the free refinement is not available.
+    std::optional<double> lattice_length_split;
     MeanProcessingTime mean_processing_time{};
     std::optional<std::string> written_master_path;
     std::string merge_statistics_text;   // populated when scaling/merging ran
@@ -555,6 +562,12 @@ class Rugnux {
     // whether it has finished walking is a question only reflections integrated after the move can
     // answer; RunAllPasses turns this on for the passes that answer it.
     bool postrefine_probe_ = false;
+    // Whether such a pass exists ONLY for that measurement. The lattice-class arms (see RunAllPasses)
+    // read the held-out residual the probe returns and nothing else, so a pass run for one of them
+    // stops as soon as the probe has measured - which is before the scaling engine is built.
+    // Everything below that point - the merges, the space-group search, the correction surfaces, the
+    // reports - is work no comparison looks at, and on a long sweep it is four fifths of the pass.
+    bool postrefine_probe_only_ = false;
     // The file's detector distance, from before the first pass of the rotation two-pass: a pass whose
     // distance is still this one asks the post-refinement to test "the header distance is right"
     // (PostRefineSettings::distance_at_header); a pass that has walked off it does not.
diff --git a/tests/LatticeSearchTest.cpp b/tests/LatticeSearchTest.cpp
index 56d9094e2..fb16da942 100644
--- a/tests/LatticeSearchTest.cpp
+++ b/tests/LatticeSearchTest.cpp
@@ -639,3 +639,32 @@ TEST_CASE("SymmetrizeMetric puts a cell onto the metric its group fixes") {
     CHECK(turned_fixed.Vec0() * turned.Vec0()
           == Catch::Approx(turned_fixed.Vec0().Length() * turned.Vec0().Length()).epsilon(1e-4));
 }
+
+TEST_CASE("LatticeSearch - a pseudo-tetragonal cell is tetragonal at the walk's tolerance and "
+          "orthorhombic with no length equality granted") {
+    // a and b 2.4 % apart: inside LATTICE_SEARCH_DIST_TOLERANCE, far outside what spot positions
+    // resolve. The two hypotheses rugnux carries forward are exactly these two answers.
+    const double a = 5.795, b = 5.933, c = 12.362;
+    CrystalLattice L(Coord(a, 0, 0), Coord(0, b, 0), Coord(0, 0, c));
+
+    const auto promoted = LatticeSearch(L);
+    CHECK(promoted.system == gemmi::CrystalSystem::Tetragonal);
+    CHECK(promoted.centering == 'P');
+    CHECK(ClassImposesLengthEquality(promoted.system));
+
+    const auto free_class = LatticeSearch(L, /*dist_tolerance=*/0.0);
+    CHECK(free_class.system == gemmi::CrystalSystem::Orthorhombic);
+    CHECK(free_class.centering == 'P');
+    const auto uc = free_class.conventional.GetUnitCell();
+    check_uc(uc, a, b, c, 90.0, 90.0, 90.0, 1e-2, 1e-2);
+}
+
+TEST_CASE("ClassImposesLengthEquality names the classes whose metric asserts a = b") {
+    CHECK(ClassImposesLengthEquality(gemmi::CrystalSystem::Tetragonal));
+    CHECK(ClassImposesLengthEquality(gemmi::CrystalSystem::Trigonal));
+    CHECK(ClassImposesLengthEquality(gemmi::CrystalSystem::Hexagonal));
+    CHECK(ClassImposesLengthEquality(gemmi::CrystalSystem::Cubic));
+    CHECK_FALSE(ClassImposesLengthEquality(gemmi::CrystalSystem::Orthorhombic));
+    CHECK_FALSE(ClassImposesLengthEquality(gemmi::CrystalSystem::Monoclinic));
+    CHECK_FALSE(ClassImposesLengthEquality(gemmi::CrystalSystem::Triclinic));
+}
-- 
2.54.0


From ca0a9d4dfe3aec58106ebb21b0bcbbca398f814f Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:02:24 +0200
Subject: [PATCH 081/122] Keep an absence at its row's own strength in the
 screw evidence it refutes

A screw zone's evidence drops its largest member to defend against one badly-measured
reflection whose sigma lies about it, and such a reflection is by construction weak - a
fraction of the row it sits on. A member that has passed the violation test AND stands
at or above the mean of its row's own present class is a different animal: not a
measurement that moved, but a reflection that is there. Trimming it removed the single
datum that refutes the claim, and the violation-count deferral then read the inflated
evidence to forgive the very violation that had been trimmed out of it.

Nested screw ORDERS are decided entirely on this. 6_1 extinguishes l != 6n and 6_2/6_4
extinguish l != 3n, so the two differ only on l = 3n not 6n. On a hexagonal crystal
whose 00l row holds five present reflections, the strongest of the whole row lay in
that difference: trimmed, 6_1 read the row as perfectly dead and won on the count of
absences alone - nine at 50.6 nats with one violation against seven at 43.3 with none
- and the run reported the wrong screw order with the right one ranked below it. With
the violation left in, 6_1 reads 6.8 and is refused. An independent POINTLESS run on
the same P1 merge puts the 6_1 condition at probability 0.000 and the 3n condition at
0.998.

Trim only among members that are not both flagged present and at full row strength.
Both halves of the condition are needed and the corpus separates them: the reflection
above stands at 1.94 of its row's mean, where two monoclinic crystals whose 0k0 are
genuinely dead carry one violation each at 0.31 and 0.74 of their row - the
mis-measurement the trim exists for, and one that costs a real 2_1 if it stays in.
Zones with no violations are bit-identical, and so is every candidate whose absent
class is clean.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/SearchSpaceGroup.cpp          | 29 ++++++-
 tests/SearchSpaceGroupTest.cpp                | 79 +++++++++++++++++++
 2 files changed, 105 insertions(+), 3 deletions(-)

diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index 0a74c7e67..f180daa6c 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -2066,9 +2066,10 @@ SearchSpaceGroupResult SearchSpaceGroup(
             // see the deferral below - so there the count is the one instrument still standing.
             auto& z = zones[a.row];
             z.n_absent += 1;
-            if (a.i_over_sigma > present_cut &&
+            const bool violation = a.i_over_sigma > present_cut &&
                 (opt.present_e_squared <= 0.0 ||
-                 a.e_squared_expected > opt.present_e_squared * row_scale)) {
+                 a.e_squared_expected > opt.present_e_squared * row_scale);
+            if (violation) {
                 ++screw_violations;
                 // Per zone as well: the count-veto deferral below is licensed zone by zone.
                 z.n_violations += 1;
@@ -2077,7 +2078,29 @@ SearchSpaceGroupResult SearchSpaceGroup(
             if (mit != row_mean.end() && mit->second > 0.0) {
                 const double u = std::max(0.0, a.e_squared_expected) / mit->second;
                 z.sum_u += u;
-                z.max_u = std::max(z.max_u, u);
+                // AN ABSENCE AT ITS ROW'S OWN MEAN IS NOT AN OUTLIER. TrimmedZoneSum drops the
+                // zone's largest member to defend against one badly-measured reflection whose sigma
+                // lies about it, and such a reflection is by construction WEAK - a fraction of the
+                // row it sits on. A member that has passed the violation test AND stands at or above
+                // the mean of its row's own present class is a different animal: not a measurement
+                // that moved, but a reflection that is there. Trimming it removes the single datum
+                // that refutes the claim, and the inflated evidence is then read by the deferral
+                // below to forgive the very violation that was trimmed out of it.
+                //
+                // Nested screw ORDERS are decided entirely on this. 6_1 predicts l = 6n and 6_2/6_4
+                // predict l = 3n, so the two differ only on l = 3n not 6n; where the strongest
+                // reflection of the whole row lies in that difference, trimming it let 6_1 read the
+                // row as perfectly dead and win on the count of absences alone - measured on a
+                // hexagonal crystal, nine absences at 50.6 nats with one violation beat seven at
+                // 43.3 with none, and read 6.8 with the violation left in.
+                //
+                // Both halves of the condition are needed, and the corpus separates them cleanly:
+                // that reflection stands at 1.94 of its row's mean, where a monoclinic crystal whose
+                // eight 0k0 are genuinely dead carries one violation at 0.31 of its row - the
+                // mis-measurement the trim exists for, and one that must stay trimmable or a real
+                // 2_1 is lost. Everything below the row mean is trimmed exactly as before.
+                if (!(violation && u >= 1.0))
+                    z.max_u = std::max(z.max_u, u);
                 z.n_control = static_cast<int>(row_present_esq.at(a.row).size());
             }
         }
diff --git a/tests/SearchSpaceGroupTest.cpp b/tests/SearchSpaceGroupTest.cpp
index cd193ae87..88123bdd3 100644
--- a/tests/SearchSpaceGroupTest.cpp
+++ b/tests/SearchSpaceGroupTest.cpp
@@ -578,6 +578,85 @@ TEST_CASE("A screw zone's evidence does not hang on its largest absence", "[Sear
     CHECK(TrimmedZoneSum(0.0, 0.0, 8) == 0.0);
 }
 
+// Screw ORDERS on one axial row are nested: 6_1 extinguishes l != 6n and 6_2/6_4 extinguish
+// l != 3n, so 6_1's absent class is 6_2's plus the l = 3n that are not 6n, and the whole of the
+// evidence between the two lies in that difference. Trimming the zone's largest member defends
+// against one badly-measured reflection, but where the difference class holds the strongest
+// reflection on the row it trimmed away the only datum that refutes 6_1 - which then read the row
+// as dead, won on its two extra absences, and used the inflated evidence to excuse the very
+// violation it had discarded. A member that is both flagged PRESENT and standing at its row's own
+// mean is not an outlier, so it is not trimmed. Measured on a hexagonal crystal: nine absences at
+// 50.6 nats with one violation beat seven at 43.3 with none, and read 6.8 once the violation - at
+// 1.94 of its row - stayed in. The two sections here are the two sides of that bound.
+TEST_CASE("SearchSpaceGroup does not trim away the reflection that refutes a screw order",
+          "[SearchSpaceGroup]") {
+    SearchSpaceGroupOptions opt;
+    opt.merge_friedel = true;
+
+    SECTION("an absence at its row's own strength decides against the order that claims it") {
+        const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 64");
+        auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 12);
+
+        // The 00l row as such a crystal records it: l = 3n present, everything else dead, and one
+        // l = 3n that is NOT 6n - the class 6_1 has to call absent and 6_4 does not - by far the
+        // strongest reflection on the row.
+        int on_row = 0;
+        for (auto& r : merged) {
+            if (r.h != 0 || r.k != 0)
+                continue;
+            const int l = std::abs(r.l);
+            ++on_row;
+            if (l % 3 != 0)      r.I = 0.0f;    // extinguished by the 3n condition, in both candidates
+            else if (l % 6 == 0) r.I = 300.0f;  // the control class 6_1 keeps for itself
+            else                 r.I = (l == 9) ? 4000.0f : 5.0f;
+        }
+        REQUIRE(on_row >= 8);
+
+        const auto result = SearchSpaceGroup(merged, opt);
+        INFO(SearchSpaceGroupResultToText(result));
+        REQUIRE(result.best_space_group.has_value());
+        std::vector<std::string> accepted{result.best_space_group->short_name()};
+        for (const auto& alt : result.alternatives)
+            accepted.push_back(alt.short_name());
+        // P6_2 and P6_4 are enantiomorphs and indistinguishable from intensities; P6_1/P6_5 are a
+        // different claim and must not be what comes out.
+        CHECK(std::find(accepted.begin(), accepted.end(), "P64") != accepted.end());
+        CHECK(std::find(accepted.begin(), accepted.end(), "P61") == accepted.end());
+        CHECK(std::find(accepted.begin(), accepted.end(), "P65") == accepted.end());
+    }
+
+    SECTION("one weak absence that moved is still an outlier, and the screw survives it") {
+        // The other side of the bound, and the case the trim was built for: a genuine 2_1 whose
+        // 0k0-odd class is dead but for one reflection at a third of its row, measured with a sigma
+        // that makes it read present. Trimmable as before - it is nowhere near the row's strength -
+        // and losing that would cost a real screw.
+        const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 21 1");
+        auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 18);
+
+        const gemmi::GroupOps gops = sg.operations();
+        int absent = 0;
+        float row_strength = 0.0f;
+        for (const auto& r : merged)
+            if (r.h == 0 && r.l == 0 && !gops.is_systematically_absent(gemmi::Op::Miller{{r.h, r.k, r.l}}))
+                row_strength = std::max(row_strength, r.I);
+        for (auto& r : merged) {
+            if (r.h != 0 || r.l != 0)
+                continue;
+            if (!gops.is_systematically_absent(gemmi::Op::Miller{{r.h, r.k, r.l}}))
+                continue;
+            ++absent;
+            r.I = absent == 1 ? 0.3f * row_strength : 0.0f;
+            r.sigma = 0.3f;
+        }
+        REQUIRE(absent >= 6);
+
+        const auto result = SearchSpaceGroup(merged, opt);
+        INFO(SearchSpaceGroupResultToText(result));
+        REQUIRE(result.best_space_group.has_value());
+        CHECK(result.best_space_group->short_name() == "P21");
+    }
+}
+
 // A zone whose predicted absences were never measurable must not outscore a zone that is genuinely
 // dead. sum_u is a sum of max(0, E^2)/row_mean, so it is EXACTLY zero when every absent reflection in
 // the zone merged non-positive - and the Beta tail then diverges, worth ~690 nats per reflection. That
-- 
2.54.0


From 8ecaba13416498c09a6b20df34cd0134067aadc9 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 11:18:37 +0200
Subject: [PATCH 082/122] Rotation scaling: a collapsed frame stays out of the
 smoothing window

Smoothing the per-frame scale inside the loop runs before the guard that drops frames whose scale
collapsed, and the window is a geometric mean - so a frame the crystal did not diffract on was both
dragging its whole window down by its logarithm and being lifted toward its neighbours, which is how
it escaped the guard meant to drop it. Measured: on sweeps with a genuinely dead stretch the guard
went from eight fires at up to a million times below the median to five at six hundred times, and on
a long clean sweep with a dead block from six fires to none.

A frame already below the guard's floor is now left out of every window and keeps its own fitted
scale, so what reaches the guard is the scale the fit produced. The floor is the guard's own, read
the same way - no new criterion and no new constant.

The guard's fires come back where the fit still collapses those frames (on the two dead-stretch
sets to seven and six, at up to three and seven million times below the median; on the long clean
sweep to six, the count it had before), and with them the error-model asymptote: ISa 7.9 back to 9.2
on one dead-stretch set, 36.7 to 38.0 on the clean one. Where the restraint stops the fit from
driving a frame below the floor at all there is nothing to exclude and nothing changes. No result
moves the wrong way: the fine-sliced, small-cell and powder sets keep the merges the restraint
recovered - two of them improve, one by CC1/2 0.916 to 0.943 - and every space group is unchanged,
including the short-sweep tetragonal pair and the de-novo orthorhombic set the loop was fixed for.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 35 ++++++++++++++-----
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 1a8fa8039..c2445a590 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3221,19 +3221,36 @@ void RotationScaleMerge::ComputeSmoothGWindow(const std::vector<double> &g, int
     const int half = window / 2;
     g_smooth.assign(n, NAN);
 
-    // No collapsed-scale handling here, and the caller is the scaling loop, which runs BEFORE
-    // DropCollapsedScales - so a frame the crystal did not diffract on is in the window with the rest.
-    // The window average is a GEOMETRIC mean, so such a frame drags its whole window down by its
-    // logarithm, and is itself lifted toward its neighbours. That is the point on a fine-sliced sweep
-    // (a frame with two reflections cannot be told from a dead one by its own scale) and it is the
-    // price on a sweep with a genuinely dead stretch: the stretch is no longer far enough below the
-    // median for DropCollapsedScales to see it, and what removes it is the sweep ledger's
-    // delta-CC1/2, which asks what the frames cost rather than how small their scale came out.
+    // The caller is the scaling loop, which runs BEFORE DropCollapsedScales, so a frame the crystal
+    // did not diffract on is still here. The window average is a GEOMETRIC mean, so left in it such a
+    // frame would drag its whole window down by its logarithm AND be lifted toward its neighbours -
+    // which is how it would escape the guard that is meant to drop it. A frame already below the
+    // guard's floor is therefore left out of every window and keeps its own fitted scale (g_smooth
+    // stays NAN, which the caller reads as "leave this frame alone"), so what reaches
+    // DropCollapsedScales is the scale the fit actually produced.
+    //
+    // The floor is the guard's, read the same way: MIN_CREDIBLE_SCALE_RATIO of the MEDIAN fitted
+    // scale, not of the precision-weighted typical frame - see DropCollapsedScales for why the median.
+    std::vector<double> fitted;
+    fitted.reserve(n);
+    for (int f = 0; f < n; ++f)
+        if (frame_scaled_scratch[f] && std::isfinite(g[f]) && g[f] > 0.0)
+            fitted.push_back(g[f]);
+    if (fitted.empty())
+        return;
+    const size_t mid = fitted.size() / 2;
+    std::nth_element(fitted.begin(), fitted.begin() + mid, fitted.end());
+    const double g_floor = fitted[mid] * MIN_CREDIBLE_SCALE_RATIO;
+
+    auto credible = [&](int f) {
+        return frame_scaled_scratch[f] && std::isfinite(g[f]) && g[f] >= g_floor;
+    };
     for (int o = 0; o < n; ++o) {
+        if (!credible(o)) continue;
         double sum_log = 0.0;
         int count = 0;
         for (int j = std::max(0, o - half); j <= std::min(n - 1, o + half); ++j) {
-            if (frame_scaled_scratch[j] && std::isfinite(g[j]) && g[j] > 0.0) {
+            if (credible(j)) {
                 sum_log += std::log(g[j]);
                 ++count;
             }
-- 
2.54.0


From df4be47c84ae30c037bf4cbfdf462e5ad847dd2a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:22:13 +0200
Subject: [PATCH 083/122] rugnux: decide the beam-centre axis harmonic in the
 one direction nothing else repairs

The beam-centre check indexes a second first pass at the measured centre and,
where the two centres return cells related by an integer volume factor, says so
and decides nothing. That abstention is right in general - the validation frame
count leans to the sub-cell, since a cell twice as long must place every spot
twice as accurately to score the same - but it leaves one direction
unrecoverable. Where the MEASURED centre holds the LARGER cell, the run starts
on the sub-cell and stays there: the second pass re-finds the larger cell at the
refined geometry and its supercell guard refuses it for being larger than
pass 1's. The run then merges a halved axis at full indexing rate, with good
merging statistics and nothing to say it is wrong.

Decide that one direction, on the pooled spots rather than on the frames: the
excess each lattice puts on itself over its own wrong-spindle null, which is the
measurement the failed-pass branch of the same check already adopts a centre on,
and the one statistic that does not credit a denser lattice for accidental hits.
The opposite direction is deliberately left alone - a second pass is free to drop
to the smaller cell and does, on every corpus crystal that reaches this branch
that way.

Measured on a tetragonal crystal whose header centre is 3.6 px out across the
spindle, more than the geometry absorbs: the file's centre gives a halved a axis
(43/60 frames, 25.4% of the pooled spots on the lattice) and the measured one the
deposited cell (60/60, 43.3%). Before, the run merged the halved cell and the
deposited model refined to R-free 0.575; after, it merges the deposited lattice
to 1.62 A with R-free 0.254 against the deposition's 0.203.

Five other corpus crystals reach the same branch with the measured centre on the
SMALLER cell; all five are unchanged (space group, cell and R-free identical), as
are two crystals whose halved or doubled axis comes from elsewhere.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/RUGNUX_ADVANCED.md |  2 +-
 rugnux/Rugnux.cpp       | 92 ++++++++++++++++++++++++++++++++---------
 rugnux/rugnux_cli.cpp   |  2 +-
 3 files changed, 75 insertions(+), 21 deletions(-)

diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 85a82d01a..9df974f79 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -235,7 +235,7 @@ Geometry:
 
 | Option | Description |
 | --- | --- |
-| `--beam-center-check[=off]` | Measure the beam centre from the isotropy of the scattered background on **every** run, report how far the file's value is from it — against how right this particular geometry needs it to be — and index a **second first pass** at the measured centre to see whether the two centres give the same lattice. The fit reads the projection `--detect-beam-stop` already builds, so it costs no extra frames. **On by default**; `=off` disables. Nothing is committed on a run that indexes: the measured centre is adopted only where the file's centre indexes nothing and the measured one indexes a majority, and a disagreement between two passes that both worked is reported with both cells and left undecided |
+| `--beam-center-check[=off]` | Measure the beam centre from the isotropy of the scattered background on **every** run, report how far the file's value is from it — against how right this particular geometry needs it to be — and index a **second first pass** at the measured centre to see whether the two centres give the same lattice. The fit reads the projection `--detect-beam-stop` already builds, so it costs no extra frames. **On by default**; `=off` disables. On a run that indexes, the measured centre is adopted in two cases only: where the file's centre indexes nothing and the measured one indexes a majority, and where the two cells are related by an integer volume factor, the measured centre's is the **larger** one, and it carries materially more of the pooled validation spots than the file's does (each cell scored against its own wrong-spindle null, so a denser lattice is not credited for accidental hits). That one direction is the axis harmonic a centre error along the spindle produces, and nothing downstream repairs it; every other disagreement is reported with both cells and left undecided |
 | `--beam-center-search[=N\|off]` | After a first pass that indexes fewer than half the validation frames, step the centre a pixel at a time out to N px along **each** detector axis and keep the first rung that indexes a majority. **On by default** (12 px); `=off` disables. It runs only after a pass that has already failed, and spot finding is not repeated, so a run that indexes never pays for it. Both detector directions are searched: a centre error *across* the spindle collapses the indexed fraction and announces itself, while one *along* it holds the frame count up and quietly returns an axis harmonic |
 | `--estimate-beam-center` | Measure the direct beam before indexing, from the symmetry of the spots where the sweep reaches at least half a turn and from the radial background profile where it does not; the value in the file is kept where neither can measure it. Off by default |
 | `--no-fit-spindle` | With the above, keep the rotation axis given in the file instead of fitting its skew about the beam |
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index fa13e6200..7e8320448 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -3144,6 +3144,20 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             return static_cast<double>(e.on_lattice - e.by_chance) > SPOT_BUDGET_SIGNIFICANCE_Z * sigma;
         };
 
+        // The same quantity for COMPARING two lattices: the share of the pooled spots each one puts on
+        // itself over and above what a wrong spindle angle puts there. Each is scored against its own
+        // null, so a denser lattice is not credited for the spots it catches by accident - which is
+        // what makes the comparison fair between a cell and its axis harmonic.
+        auto excess = [](const PooledEvidence &e) {
+            return static_cast<double>(e.on_lattice - e.by_chance)
+                   / static_cast<double>(std::max<int64_t>(1, e.spots));
+        };
+        auto rate_var = [](const PooledEvidence &e) {
+            const double n = static_cast<double>(std::max<int64_t>(1, e.spots));
+            const double p = static_cast<double>(e.on_lattice) / n;
+            return p * (1.0 - p) / n;
+        };
+
         // How deep into an image's intensity-ordered spot list this lattice is still being seen - the
         // measured spot budget. Same frames, same per-image path as count_indexed above, but scoring the
         // spots rather than the frames: each frame's spots are tallied by rank and the run keeps the
@@ -3738,9 +3752,10 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         //   * the file's centre indexes and the two agree on the lattice -> keep the file's centre and
         //     say they agree. This is the overwhelming majority, and saying it is worth the pass: it
         //     is a free statement that the header is good enough for this crystal;
-        //   * they index and disagree -> say so, with both cells and their primitive-volume ratio,
-        //     and change nothing. Naming a disagreement is useful; resolving it needs an arbiter
-        //     nobody has.
+        //   * they index and disagree -> say so, with both cells and their primitive-volume ratio.
+        //     Which of an integer-related pair is real is not decided on the frame counts, for the
+        //     reason above; it is decided, in ONE direction only, on the pooled spots - see the
+        //     branch itself. Naming the disagreement is useful even where nothing is decided.
         //
         // Where the file's centre indexes nothing and the measured one does not either, the axis-sign
         // question is asked AGAIN at the measured centre before giving up. The two unknowns are
@@ -3888,15 +3903,6 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                         restore_beam_center(header_x, header_y);
                         if (best.result.has_value())
                             at_header = pooled_evidence(*indexer, *best.result);
-                        auto excess = [](const PooledEvidence &e) {
-                            return static_cast<double>(e.on_lattice - e.by_chance)
-                                   / static_cast<double>(std::max<int64_t>(1, e.spots));
-                        };
-                        auto rate_var = [](const PooledEvidence &e) {
-                            const double n = static_cast<double>(std::max<int64_t>(1, e.spots));
-                            const double p = static_cast<double>(e.on_lattice) / n;
-                            return p * (1.0 - p) / n;
-                        };
                         const double margin = excess(at_measured) - excess(at_header);
                         const double margin_sigma = std::sqrt(rate_var(at_measured) + rate_var(at_header));
                         if (alt.result.has_value() && beats_chance(at_measured)
@@ -4020,14 +4026,62 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                                                   "beam centre is what settles which",
                                                                   ratio)
                                                     : "");
-                            // Deliberately no decision. The frame counts above are the one statistic
+                            // Deliberately no decision on the frame counts. They are the one statistic
                             // that must not choose: on the measured case the harmonic indexed MORE.
-                            logger.Warning("Beam centre check: the run keeps the file's centre. The "
-                                           "frame counts cannot arbitrate this - a cell twice as long "
-                                           "must place every spot twice as accurately to score the "
-                                           "same, so the harmonic is often the one that indexes more. "
-                                           "Re-run with --estimate-beam-center to measure the centre "
-                                           "from the spot symmetry, which is exact geometry");
+                            //
+                            // One direction is decided, and only one: where the MEASURED centre holds
+                            // the LARGER of an integer-related pair. That is the case nothing else in
+                            // the run repairs - the frame count leans to the sub-cell, and the second
+                            // pass refuses a lattice larger than pass 1's (the supercell guard below),
+                            // so a run that starts on the sub-cell stays on it. The opposite direction
+                            // needs no help here: the second pass is free to drop to the smaller cell
+                            // and does, on every corpus crystal that reaches this branch that way.
+                            //
+                            // Decided on the pooled excess over chance, the same measurement the
+                            // failed-pass branch above adopts a centre on. Each lattice is scored
+                            // against its own wrong-spindle null, so the larger cell is not credited
+                            // for the spots a denser lattice catches by accident.
+                            const double nearest_n = std::round(ratio);
+                            const bool integer_harmonic = nearest_n >= 2.0 && nearest_n <= 4.0
+                                                          && std::abs(ratio - nearest_n) < 0.15;
+                            bool adopted_measured = false;
+                            if (integer_harmonic && alt.vol > best.vol) {
+                                const PooledEvidence at_header = pooled_evidence(*indexer, *best.result);
+                                try_beam_center(measured_x, measured_y);
+                                const PooledEvidence at_measured = pooled_evidence(*indexer, *alt.result);
+                                const double margin = excess(at_measured) - excess(at_header);
+                                const double margin_sigma = std::sqrt(rate_var(at_measured)
+                                                                      + rate_var(at_header));
+                                adopted_measured = beats_chance(at_measured)
+                                                   && margin > SPOT_BUDGET_SIGNIFICANCE_Z * margin_sigma;
+                                if (adopted_measured) {
+                                    logger.Warning("Beam centre check: the larger cell is the measured "
+                                                   "centre's, and it is the one the spots are on - "
+                                                   "{:.1f}% of the pooled validation spots lie on it "
+                                                   "against {:.1f}% on the file's cell (chance {:.1f}% "
+                                                   "and {:.1f}%) - so the {:.2f}x is a real axis and not "
+                                                   "a harmonic, and the run adopts the measured centre",
+                                                   100.0 * at_measured.on_lattice
+                                                           / std::max<int64_t>(1, at_measured.spots),
+                                                   100.0 * at_header.on_lattice
+                                                           / std::max<int64_t>(1, at_header.spots),
+                                                   100.0 * at_measured.by_chance
+                                                           / std::max<int64_t>(1, at_measured.spots),
+                                                   100.0 * at_header.by_chance
+                                                           / std::max<int64_t>(1, at_header.spots),
+                                                   ratio);
+                                    best = alt;
+                                } else {
+                                    restore_beam_center(header_x, header_y);
+                                }
+                            }
+                            if (!adopted_measured)
+                                logger.Warning("Beam centre check: the run keeps the file's centre. The "
+                                               "frame counts cannot arbitrate this - a cell twice as long "
+                                               "must place every spot twice as accurately to score the "
+                                               "same, so the harmonic is often the one that indexes more. "
+                                               "Re-run with --estimate-beam-center to measure the centre "
+                                               "from the spot symmetry, which is exact geometry");
                         }
                     } else {
                         logger.Info("Beam centre check: the measured centre ({:.2f},{:.2f}) indexes "
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index df93d5a02..9c10383ec 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -112,7 +112,7 @@ void print_usage() {
     std::cout << "   --detect-beam-stop[=N|off]       Find the beam stop and its holder in a projection of N images and add them to the pixel mask (bit 9), so nothing shadowed by them is integrated. ON by default (60 images); =off disables. Reflections behind the stop are attenuated but not flagged, so they are integrated low with a plausible sigma and no existing rejection catches them" << std::endl;
     std::cout << "   --estimate-beam-center           Place the beam centre before anything is indexed, and use it in place of the header value when it is measured precisely enough. On a sweep that reaches half a turn it comes from the symmetry of the spot positions - the frames 180 deg apart are each other's mirror image, and every reflection is recorded twice - and where the sweep does not reach that far, from the isotropy of the scattered background, which needs only a few frames. It reads frames of its own, chosen as pairs half a turn apart, so it does not change the mask --detect-beam-stop finds. Ignored when --beam-x/--beam-y are given, and when a stills geometry refinement has already placed the centre from indexed spots" << std::endl;
     std::cout << "   --beam-center-search[=N|off]     After a first pass that indexes fewer than half the validation frames, try the beam centre a pixel at a time out to N px along each detector axis and keep the first one that indexes a majority. A beam-centre error is fixed in the lab frame, so it smears the accumulated reciprocal-space cloud and the FFT takes an axis harmonic instead of the true axis; nothing downstream repairs that. ON by default (12 px); =off disables. It runs only after a pass that has already failed, so a run that indexes never pays for it" << std::endl;
-    std::cout << "   --beam-center-check[=off]        Measure the beam centre from the isotropy of the scattered background on EVERY run, report how far the file's value is from it, and index a second first pass with it to see whether the two centres give the same lattice. The fit reads the projection --detect-beam-stop already builds, so it costs no extra frames. Nothing is committed on a run that indexes: the measured centre is adopted only where the file's indexes nothing and the measured one indexes a majority. ON by default; =off disables" << std::endl;
+    std::cout << "   --beam-center-check[=off]        Measure the beam centre from the isotropy of the scattered background on EVERY run, report how far the file's value is from it, and index a second first pass with it to see whether the two centres give the same lattice. The fit reads the projection --detect-beam-stop already builds, so it costs no extra frames. On a run that indexes, the measured centre is adopted in two cases only: where the file's centre indexes nothing and the measured one indexes a majority, and where the two centres return cells related by an integer volume factor and the measured centre's is the LARGER one AND carries materially more of the pooled spots - the axis harmonic a centre error along the spindle produces, which nothing downstream repairs. ON by default; =off disables" << std::endl;
     std::cout << "   --no-fit-spindle                 Take the goniometer axis from the file rather than measuring the spindle's rotation about the beam from the spots. Measuring it is the DEFAULT and the file is never right: every master writes an exact lab axis and no goniometer is one. Both mirror lines of the beam-centre estimator turn with the spindle, so an axis a few tenths of a milliradian out smears the vote until a neighbouring tooth wins. Only has an effect with --estimate-beam-center" << std::endl;
     std::cout << std::endl;
 
-- 
2.54.0


From b877d61a422f23b64a99844053ce18fab5c9cea9 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:13:53 +0200
Subject: [PATCH 084/122] Lattice class: read the length equality in the
 class's own basis

The departure from a = b that decides whether the metric-symmetry arms run at
all was read by pushing the free (triclinic) refinement through the search
result's `reindex`. That matrix is stale for a whole population: where the walk
matches a metrically hexagonal lattice on its C-centred orthorhombic character,
RotationIndexer re-expresses `conventional` in hexagonal axes but leaves
`reindex` describing the setting it replaced. The C-centred setting has
b = a*sqrt(3) BY CONSTRUCTION, so a against b there is
2(sqrt(3)-1)/(sqrt(3)+1) = 53.6 % apart on every hexagonal lattice there is,
whatever the crystal.

So the gate fired on the whole hexagonal and trigonal population - eighteen
sets in one corpus run, all reporting 53.1-53.7 % - and the arms then decided
two classes that fit equally well on differences in the third or fourth
significant figure. Three of those coin flips landed on the ortho-hexagonal
supercell and took a P 61 2 2, a P 65 2 2 and a P 31 with them.

The departure is now computed by LengthEqualityDeparture, which derives the
primitive-to-conventional map from the pair of cells the search result carries
instead of trusting `reindex`, and reads a against b in that basis. The two
cells describe one lattice, so the map is the integer relabelling of its basis
vectors. The measurement no longer depends on which character the walk happened
to match.

Re-measured, the hexagonal and trigonal sets report 0.00-0.41 %, the band the
tetragonal and cubic proteins were already in, and the gate does not fire on any
of them; the genuine pseudo-symmetric small-molecule cases stand alone at 0.98,
1.85 and 2.61 %. The three lost groups come back, and the sets that merely
tolerated the noise are bit-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../lattice_search/LatticeSearch.cpp          | 29 ++++++++++++++
 image_analysis/lattice_search/LatticeSearch.h | 15 +++++++
 rugnux/Rugnux.cpp                             | 29 +++++---------
 tests/LatticeSearchTest.cpp                   | 40 +++++++++++++++++++
 4 files changed, 95 insertions(+), 18 deletions(-)

diff --git a/image_analysis/lattice_search/LatticeSearch.cpp b/image_analysis/lattice_search/LatticeSearch.cpp
index 232c5d05f..2515d259d 100644
--- a/image_analysis/lattice_search/LatticeSearch.cpp
+++ b/image_analysis/lattice_search/LatticeSearch.cpp
@@ -489,6 +489,35 @@ bool ClassImposesLengthEquality(gemmi::CrystalSystem system) {
     }
 }
 
+double LengthEqualityDeparture(const LatticeSearchResult &sr, const CrystalLattice &free_primitive) {
+    if (!ClassImposesLengthEquality(sr.system))
+        return 0.0;
+
+    // Rows are basis vectors, and CrystalLattice::Multiply(M) forms row i as sum_j M[i][j] * row j,
+    // so conventional = M * primitive_reduced and M = conventional * primitive_reduced^-1.
+    const auto rows = [](const CrystalLattice &L) {
+        const Coord v[3] = {L.Vec0(), L.Vec1(), L.Vec2()};
+        Eigen::Matrix3d A;
+        for (int i = 0; i < 3; i++)
+            A.row(i) << v[i].x, v[i].y, v[i].z;
+        return A;
+    };
+    const Eigen::Matrix3d prim = rows(sr.primitive_reduced);
+    if (std::fabs(prim.determinant()) < 1e-12)
+        return 0.0;
+    // Rounded because it IS an integer matrix - a centred conventional cell is a whole-number
+    // supercell of its primitive one - and rounding is what says so.
+    const Eigen::Matrix3d M = (rows(sr.conventional) * prim.inverse()).array().round();
+
+    const UnitCell uc = free_primitive.Multiply(gemmi::Mat33(M(0, 0), M(0, 1), M(0, 2),
+                                                             M(1, 0), M(1, 1), M(1, 2),
+                                                             M(2, 0), M(2, 1), M(2, 2))).GetUnitCell();
+    double dep = std::fabs(uc.a - uc.b) / (0.5 * (uc.a + uc.b));
+    if (sr.system == gemmi::CrystalSystem::Cubic)
+        dep = std::max(dep, std::fabs(uc.b - uc.c) / (0.5 * (uc.b + uc.c)));
+    return std::isfinite(dep) ? dep : 0.0;
+}
+
 double MetricDeviation(const LatticeSearchResult &sr) {
     const UnitCell uc = sr.conventional.GetUnitCell();
     double angle = 0.0, length = 0.0;
diff --git a/image_analysis/lattice_search/LatticeSearch.h b/image_analysis/lattice_search/LatticeSearch.h
index 396219423..07317a5b6 100644
--- a/image_analysis/lattice_search/LatticeSearch.h
+++ b/image_analysis/lattice_search/LatticeSearch.h
@@ -56,6 +56,21 @@ std::optional<LatticeSearchResult> LatticeSearchForClass(const CrystalLattice& L
 // own pass and judges on what it realises (see RunAllPasses).
 bool ClassImposesLengthEquality(gemmi::CrystalSystem system);
 
+// How far `free_primitive` departs from the length equality `sr`'s class asserts, relative: the
+// larger of |a-b| and (cubic only) |b-c| over their mean, read in that class's CONVENTIONAL basis.
+// 0 where the class asserts no length equality.
+//
+// `free_primitive` is a lattice in `sr.primitive_reduced`'s basis - the free (triclinic) refinement
+// of the same candidate - and the point of the function is to put it in the basis where a and b are
+// the pair the class equates. The basis map is derived from the `primitive_reduced` / `conventional`
+// pair `sr` carries, NOT from `sr.reindex`: a caller that re-expresses a metrically hexagonal
+// lattice in hexagonal axes rewrites `conventional` and leaves `reindex` describing the C-centred
+// orthorhombic setting it replaced, and that setting has b = a*sqrt(3) BY CONSTRUCTION - so reading
+// a against b through the stale matrix reports 2(sqrt(3)-1)/(sqrt(3)+1) = 53.6 % on EVERY hexagonal
+// lattice there is, whatever the crystal. The two cells describe one lattice, so the map between
+// them is the integer relabelling of its basis vectors.
+double LengthEqualityDeparture(const LatticeSearchResult &sr, const CrystalLattice &free_primitive);
+
 // How far the matched lattice's metric sits from the IDEAL metric of its class, as a fraction of the
 // tolerance that admitted it: 0 is exactly the class, 1 is the edge of what the walk accepts. The
 // walk computes this and throws it away - a cell 0.02 deg from being C-centred monoclinic and one
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index fa13e6200..33dc977bc 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -4973,25 +4973,18 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             result.rotation_lattice_type = end_msg.rotation_lattice_type;
             // What the equality this class asserts is worth on a REFINED cell. The indexer refines the
             // same candidate a second time with nothing held (its pseudo-symmetry guard) and hands that
-            // cell over whenever the constrained one won; it was seeded from the primitive reduced cell
-            // and comes back in that basis, so the class's own reindex re-expresses it in the
-            // conventional one and a and b can be read off it. Measured here, decided in RunAllPasses,
-            // which is where there is a pass to compare it against.
+            // cell over whenever the constrained one won; it comes back in the primitive reduced
+            // basis, and LengthEqualityDeparture puts it in the basis where a and b are the pair this
+            // class equates. Measured here, decided in RunAllPasses, which is where there is a pass to
+            // compare it against.
             if (rot->unconstrained && ClassImposesLengthEquality(rot->search_result.system)) {
-                const UnitCell free_uc =
-                        rot->unconstrained->lattice.Multiply(rot->search_result.reindex).GetUnitCell();
-                double split = std::fabs(free_uc.a - free_uc.b) / (0.5 * (free_uc.a + free_uc.b));
-                if (rot->search_result.system == gemmi::CrystalSystem::Cubic)
-                    split = std::max(split, std::fabs(free_uc.b - free_uc.c)
-                                            / (0.5 * (free_uc.b + free_uc.c)));
-                if (std::isfinite(split)) {
-                    result.lattice_length_split = split;
-                    logger.Info("Rotation lattice: {}-centred {} asserts a = b; the free refinement of "
-                                "the same candidate leaves them {:.2f} % apart ({:.4f} / {:.4f} A)",
-                                rot->search_result.centering,
-                                gemmi::crystal_system_str(rot->search_result.system),
-                                100.0 * split, free_uc.a, free_uc.b);
-                }
+                const double split = LengthEqualityDeparture(rot->search_result,
+                                                             rot->unconstrained->lattice);
+                result.lattice_length_split = split;
+                logger.Info("Rotation lattice: {}-centred {} asserts a = b; the free refinement of "
+                            "the same candidate departs from that by {:.2f} %",
+                            rot->search_result.centering,
+                            gemmi::crystal_system_str(rot->search_result.system), 100.0 * split);
             }
             // The consensus cell below is this lattice's conventional cell, so this is the centring
             // it is written in - the pair the volume comparisons in Run() need.
diff --git a/tests/LatticeSearchTest.cpp b/tests/LatticeSearchTest.cpp
index fb16da942..675c08a15 100644
--- a/tests/LatticeSearchTest.cpp
+++ b/tests/LatticeSearchTest.cpp
@@ -668,3 +668,43 @@ TEST_CASE("ClassImposesLengthEquality names the classes whose metric asserts a =
     CHECK_FALSE(ClassImposesLengthEquality(gemmi::CrystalSystem::Monoclinic));
     CHECK_FALSE(ClassImposesLengthEquality(gemmi::CrystalSystem::Triclinic));
 }
+
+TEST_CASE("LengthEqualityDeparture reads a = b in the class's own basis, not a stale reindex") {
+    // A hexagonal lattice whose conventional cell has been re-expressed in hexagonal axes while
+    // `reindex` still describes the C-centred orthorhombic setting the walk matched - what
+    // RotationIndexer does. The departure must be read through the primitive/conventional pair, not
+    // that matrix: the C-ortho setting has b = a*sqrt(3) by construction, so reading a against b
+    // there reports 53.6 % on every hexagonal lattice, whatever the crystal.
+    const double a = 60.0, c = 95.0;
+    // Primitive hexagonal cell: two equal axes at 120 deg, third perpendicular.
+    const CrystalLattice prim(Coord(a, 0, 0), Coord(-a / 2, a * std::sqrt(3.0) / 2, 0), Coord(0, 0, c));
+
+    LatticeSearchResult sr;
+    sr.system = gemmi::CrystalSystem::Hexagonal;
+    sr.centering = 'P';
+    sr.primitive_reduced = prim;
+    sr.conventional = prim;                                  // already the hexagonal setting
+    // The stale matrix: the ortho-hexagonal C-centred setting (a, a + 2b, c).
+    sr.reindex = gemmi::Mat33(1, 0, 0, 1, 2, 0, 0, 0, 1);
+
+    // The free refinement of the same lattice: a and b 0.5 % apart, no more.
+    const double b_free = a * 1.005;
+    const CrystalLattice free_prim(Coord(a, 0, 0),
+                                   Coord(-b_free / 2, b_free * std::sqrt(3.0) / 2, 0),
+                                   Coord(0, 0, c));
+
+    CHECK(LengthEqualityDeparture(sr, free_prim) == Catch::Approx(0.005).margin(5e-4));
+
+    // Reading it through the stale reindex is the defect this pins: the sqrt(3) signature.
+    const UnitCell wrong = free_prim.Multiply(sr.reindex).GetUnitCell();
+    CHECK(std::fabs(wrong.a - wrong.b) / (0.5 * (wrong.a + wrong.b)) > 0.4);
+}
+
+TEST_CASE("LengthEqualityDeparture is zero for a class that asserts no length equality") {
+    LatticeSearchResult sr;
+    sr.system = gemmi::CrystalSystem::Orthorhombic;
+    sr.centering = 'P';
+    sr.primitive_reduced = CrystalLattice(Coord(10, 0, 0), Coord(0, 20, 0), Coord(0, 0, 30));
+    sr.conventional = sr.primitive_reduced;
+    CHECK(LengthEqualityDeparture(sr, sr.primitive_reduced) == 0.0);
+}
-- 
2.54.0


From 2f453e018f6b03af08291441dcb114785fd77dff Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:55:56 +0200
Subject: [PATCH 085/122] Record the battery rows where our reduction and a
 deposition disagree

Five open-arm rows do not reproduce their deposited space group or cell. Four are
scoring rows that disagreed with a published entry with nothing written down about
why, which is not a state a reader should have to discover from the manifest.

A tetragonal row whose deposited asymmetric unit holds two chains related by the very
two-fold the higher group adds, to 0.16 A CA RMSD - coordinate error at its
resolution - is overridden to the higher group. Merging there costs 0.0006 in R_meas
for 1.75x the multiplicity and correlates better with the deposited model, and an
independent reference implementation reads the same point group on our own P1 merge.
The refinement comparison is recorded as SPLIT: one purpose-built program makes the
higher group better at half the parameters and calls the deposited assignment
incorrect, an independent restrained refinement on a symmetry-consistent free set
makes the lower group better, and the gap between refinement protocols exceeds the
difference being measured.

One trigonal row becomes unscored rather than overridden: the evidence points at a
higher point group but the deposited copies differ by more than coordinate error, and
a purpose-built program settles on a different supergroup whose operators these data
do not support. The set runs; it is not scored.

Two trigonal rows had already been overridden, by editing the reference itself, with
no reason recorded. The deposition is restored verbatim to ref and the change moved
into ref_override, which leaves the effective reference and every verdict unchanged.
One of them carries strong centric-zone evidence; the other is marked OPEN, because
the one test that separates real symmetry from pseudo-symmetry reads against the
promotion the row is scored on, and may belong unscored instead.

The documentation frames all of these as open questions rather than as errors in the
PDB, and states the limit that applies to every one of them: a merohedral twin at a
fraction of exactly one half and a crystal that genuinely has the higher symmetry
predict identical intensities, so no test available to us can show that an operator
holds exactly rather than very nearly.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/EXTERNAL_TEST_DATA.md | 95 ++++++++++++++++++++++++++++++++++++++
 tools/battery/open.json    |  8 ++--
 2 files changed, 99 insertions(+), 4 deletions(-)

diff --git a/docs/EXTERNAL_TEST_DATA.md b/docs/EXTERNAL_TEST_DATA.md
index ada10d76d..815ad710c 100644
--- a/docs/EXTERNAL_TEST_DATA.md
+++ b/docs/EXTERNAL_TEST_DATA.md
@@ -341,6 +341,101 @@ reports released structure factors (`status_code_sf = REL`) for every one of the
 result from this pipeline can therefore be checked against the deposited model or against the
 deposited intensities.
 
+## Rows where our reduction and the deposition disagree
+
+Five of the 153 rows are ones where `rugnux` does not reproduce the deposited space group or
+cell, and where we have looked at the disagreement closely enough to change how the row is
+scored. They are collected here because a scoring row that silently disagrees with a published
+entry is not something a reader should have to discover from the code.
+
+**These are open questions, not errors we are attributing to the PDB.** A deposited entry was
+arrived at by someone who had something we do not: a model that had to refine, and usually more
+knowledge of the crystal than the images carry. Where we describe evidence below, it is evidence
+about *what these images support*, which is a narrower thing than what the crystal is. In every
+one of the symmetry rows the possibility that the crystal really has the lower symmetry, with a
+pseudo-symmetry too exact for any test available to us to see, remains live - see the limit at
+the end of this section.
+
+How the manifest records it, in `tools/battery/open.json`:
+
+- `ref` always keeps the deposited values verbatim, so the deposition is never lost.
+- `ref_override` replaces only the fields the battery scores against, and `ref_override_why`
+  records the evidence and its limits.
+- `unscored` is for a row we cannot defend a reference for in either direction: the set still
+  runs, and its merging statistics are still reported, but it is not scored.
+
+### 8XBP is a question about provenance, not about symmetry
+
+8XBP is different in kind from the other four and should not be read alongside them. Nothing
+here concerns the deposited model or its space group. The question is whether the raw images
+uploaded with the entry are the same crystal the deposited cell describes: the master file
+records `data_collection_date` 2023-06-21 where the entry records a collection date of
+2023-06-23, and the deposited *b* = 50.78 A is 2.0% away from the *b* these images give. Two
+independent signals, one of them nothing to do with our processing. The override replaces the
+cell with the one DIALS 3.29 indexes de novo on this master and keeps the deposited space group
+and resolution.
+
+### Four trigonal and tetragonal rows where we read a higher point group
+
+| PDB | Deposited | `rugnux` reads | Row is now | Where it stands |
+|---|---|---|---|---|
+| 6TOC | P 4<sub>2</sub> | P 4<sub>2</sub> 2 2 | overridden | strong, but the refinement test is not unanimous |
+| 8XTE | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | overridden | strong; rests on the centric-zone test |
+| 8XTG | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | overridden | **open** - our own best test argues against it |
+| 6PXB | P 3<sub>2</sub> | P 3<sub>1</sub> 1 2 / P 3<sub>2</sub> 1 2 | unscored | unresolved in either direction |
+
+The 8XTE and 8XTG overrides predate the 8XBP and 6TOC ones and were carried in the manifest for
+some time with no reason recorded against them; the reasons were written down later, when this
+section was added, rather than at the time the rows were changed.
+
+**6TOC.** The deposited asymmetric unit holds two chains, and they are related by the very
+two-fold the higher group adds, to 0.16 A C-alpha RMSD over 43 residues - coordinate error at
+the deposited 1.85 A. Merging in P 4<sub>2</sub> 2 2 costs 0.0006 in R<sub>meas</sub> for 1.75
+times the multiplicity, and correlates better with the deposited model than the P 4<sub>2</sub>
+merge does. POINTLESS, run independently on our own P1 merge, reads the same point group. The
+refinement test - refine in each candidate group and compare R-free, which is the one comparison
+not biased toward the group the deposited model was refined in - does **not** come out
+unanimous: ZANUDA 1.097 makes P 4<sub>2</sub> 2 2 the better group at half the parameters and
+reports the deposited assignment incorrect, while an independent Refmac 5.8.0431 comparison on a
+symmetry-consistent free set makes P 4<sub>2</sub> the better one, by less than the spread
+between refinement protocols. So the row is overridden on the structural and merging evidence,
+with the refinement evidence recorded as split.
+
+**8XTE.** The distinguishing test is the twin-immune centric zone: reflections that the higher
+group makes centric but the subgroup does not are their own twin mates, so a merohedral twin law
+cannot make them read centric. They read `<|E^2-1|>` = 0.946 +/- 0.012 against a centric
+expectation of 0.968 and an acentric one of 0.736. Re-refinement on a shared free set, with the
+twin law removed from both sides, favours the higher group. The deposited entry's published R
+values are themselves reproducible only with a twin law the entry does not declare, at a twin
+fraction of 0.50 - and a 0.50-twinned target already has the symmetry in question.
+
+**8XTG.** This row is genuinely open and is flagged as such in the manifest. Every
+correlation-based instrument we have - our own operator correlations, and POINTLESS on our P1
+merge - reads the higher point group, but the centric-zone test, the only one of them that can
+separate real symmetry from pseudo-symmetry, reads `<|E^2-1|>` = 0.869 at -44.9 nats: between
+the two expectations, and on the wrong side. The L-test indicates a twin fraction near 0.20-0.26.
+Whether this crystal is partially twinned or purely pseudo-symmetric has not been established,
+and our own best test argues against the promotion the row is scored on.
+
+**6PXB.** Unscored rather than overridden, because the evidence does not settle either way. Our
+merge and POINTLESS both read a 312 point group, the added two-folds correlate at or above the
+level of the three-folds nobody disputes, and merging in the higher group *lowers*
+R<sub>meas</sub> at twice the multiplicity. Against that, the deposited asymmetric unit's six
+chains pair under the added two-fold at 0.3-0.7 A, which is more than coordinate error at 1.75 A,
+and ZANUDA settles on a different trigonal supergroup - 321 rather than 312 - whose operators
+these data do not support. Neither answer is established, so the set runs and is not scored.
+
+### The limit that applies to all four
+
+A merohedral twin at a twin fraction of exactly 0.5 and a crystal that genuinely has the higher
+symmetry predict **identical** intensities. No amount of data and no refinement R separates them,
+and the same holds, approximately, for a pseudo-symmetry that is merely very exact. Every test
+described above measures how nearly a symmetry operator holds on these images; none of them can
+show that it holds exactly. Where the higher symmetry is right, merging in it gains multiplicity
+and completeness; where it is a pseudo-symmetry that close, merging in it costs nothing
+measurable either. That is why these rows are described as open questions, and why none of them
+should be read as a statement that a deposited model is wrong.
+
 ## Dataset directories whose name is not the PDB code
 
 | Directory | PDB code in the table | Why |
diff --git a/tools/battery/open.json b/tools/battery/open.json
index f7aeb01a7..2770a8f21 100644
--- a/tools/battery/open.json
+++ b/tools/battery/open.json
@@ -33,11 +33,11 @@
  {"id": "6oel", "input": "6oel/1449-8_3_001.img", "ref": {"sg": "F 41 3 2", "sgno": 210, "cell": [328.1, 328.1, 328.1, 90.0, 90.0, 90.0], "dmin": 3.1}, "tags": ["SMV", "cubic"], "tiers": {"smoke": "SMV reader (ADSC), cubic F4132"}},
  {"id": "6p8p", "input": "6p8p/14_12_1_0001.cbf", "ref": {"sg": "P 4", "sgno": 75, "cell": [97.525, 97.525, 60.134, 90.0, 90.0, 90.0], "dmin": 1.635}, "tags": ["cbf", "tetragonal"]},
  {"id": "6pb3", "input": "6pb3/14_16_1_000001.cbf", "ref": {"sg": "P 6", "sgno": 168, "cell": [100.436, 100.436, 48.86, 90.0, 90.0, 120.0], "dmin": 2.048}, "tags": ["cbf", "hexagonal"]},
- {"id": "6pxb", "input": "6pxb/TJB1_3_rachel_1_0001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [64.021, 64.021, 119.447, 90.0, 90.0, 120.0], "dmin": 1.747}, "tags": ["cbf", "trigonal"]},
+ {"id": "6pxb", "input": "6pxb/TJB1_3_rachel_1_0001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [64.021, 64.021, 119.447, 90.0, 90.0, 120.0], "dmin": 1.747}, "unscored": "disputed and open in both directions - see unscored_why", "unscored_why": "our merge and POINTLESS (Laue confidence 0.999) both read point group 312 on these images where the deposition is P 32, the added two-folds correlate at or above the level of the 3-folds nobody disputes, and merging in P 32 1 2 lowers R_meas from 0.0716 to 0.0662 at twice the multiplicity. Against that, the deposited model's six chains pair under the added two-fold at 0.3-0.7 A, which is more than coordinate error at 1.75 A, and ZANUDA settles on a different trigonal supergroup (P 32 2 1) whose operators these data do not support (CC 0.18-0.47 against 0.75-0.99 for P 32 1 2's). Neither answer is established, so the set runs but is not scored. A perfect merohedral twin and true higher symmetry predict identical data, so pseudo-symmetry remains a live explanation either way", "tags": ["cbf", "trigonal"]},
  {"id": "6pxc", "input": "6pxc/TJB6_1_Rachel_1_0001.cbf", "ref": {"sg": "I 2 2 2", "sgno": 23, "cell": [44.19, 64.827, 87.239, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6r72", "input": "6r72/V-CK63-8-ld_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [117.805, 110.754, 155.615, 90.0, 93.23, 90.0], "dmin": 3.95}, "pinned": true, "tags": ["h5", "monoclinic"]},
  {"id": "6rlr", "input": "6rlr/_b4_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [39.986, 39.998, 63.643, 80.39, 76.29, 68.15], "dmin": 2.0}, "tags": ["h5", "triclinic", "twin"]},
- {"id": "6toc", "input": "6toc/zenodo/dts_1_00001.cbf", "ref": {"sg": "P 42", "sgno": 77, "cell": [31.523, 31.523, 81.599, 90.0, 90.0, 90.0], "dmin": 1.853}, "tags": ["cbf", "tetragonal", "twin"]},
+ {"id": "6toc", "input": "6toc/zenodo/dts_1_00001.cbf", "ref": {"sg": "P 42", "sgno": 77, "cell": [31.523, 31.523, 81.599, 90.0, 90.0, 90.0], "dmin": 1.853}, "ref_override": {"sg": "P 42 2 2", "sgno": 93}, "ref_override_why": "our merge and an independent POINTLESS run on the same P1 merge both read point group 422, and the deposited model's own two chains are related by the added two-fold to 0.16 A CA RMSD over 43 residues, which is coordinate error at 1.85 A. Merging in P 42 2 2 costs 0.0006 in R_meas for 1.75x the multiplicity and correlates better with the deposited model (0.9802 vs 0.9764 at 1.853 A). ZANUDA 1.097 refines P 42 2 2 to R-free 0.2561 against P 42's 0.2636 at half the parameters and calls the deposited assignment incorrect, but an independent refmac 5.8.0431 comparison on a symmetry-consistent free set puts P 42 ahead by 0.004-0.020 depending on cycle count, so the refinement test is NOT unanimous and its protocol spread exceeds the difference being measured. Pseudo-symmetry exact enough to escape every test we have remains a live explanation. The deposited cell and d_min are kept", "tags": ["cbf", "tetragonal", "twin"]},
  {"id": "6ttn", "input": "6ttn/6ttn/data/H6H_33_01_hyo_full_1_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [39.894, 79.841, 104.701, 90.0, 90.0, 90.0], "dmin": 1.12}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6u7g", "input": "6u7g/6u7g/data/SNB02_11_8_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [99.555, 98.682, 147.525, 90.0, 104.6, 90.0], "dmin": 2.35}, "pinned": true, "tags": ["h5", "monoclinic"]},
  {"id": "6ukf", "input": "6ukf/6ukf/data/XDC-7_Pn6_000001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [61.018, 37.317, 69.027, 90.0, 109.768, 90.0], "dmin": 1.0}, "tags": ["cbf", "monoclinic"]},
@@ -97,9 +97,9 @@
  {"id": "8u0i", "input": "8u0i/8u0i/data/dI-2-05a_4_00001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [50.317, 50.317, 90.596, 90.0, 90.0, 90.0], "dmin": 1.541}, "tags": ["cbf", "tetragonal"]},
  {"id": "8v4o", "input": "8v4o/CaalA_00629_a_FS11-AMP_8v4o/data/PSL-1602_2180_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [139.46, 139.46, 544.99, 90.0, 90.0, 120.0], "dmin": 2.7}, "tags": ["h5", "hexagonal"]},
  {"id": "8xbp", "input": "8xbp/8xbp/data/puck2872_3_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [148.29, 50.78, 60.21, 90.0, 92.33, 90.0], "dmin": 1.99}, "ref_override": {"cell": [148.736, 51.777, 60.181, 90.0, 92.36, 90.0]}, "ref_override_why": "the uploaded sweep is a different crystal from the one the deposited cell describes: master data_collection_date 2023-06-21, deposited _diffrn_detector.pdbx_collection_date 2023-06-23, and the deposited b = 50.78 is 2.0% from the b these images give. The override is the cell DIALS 3.29 indexes de novo on this master, b = 51.777(11); the deposited space group and d_min are kept", "tags": ["h5", "monoclinic"]},
- {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "tags": ["cbf", "trigonal"]},
+ {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "ref_override": {"sg": "P 32 2 1", "sgno": 154}, "ref_override_why": "deposited P 32; this override predates the 8xbp and 6toc ones and was recorded here later. Our merge and POINTLESS both read point group 321, and the twin-immune centric zone of the added two-folds reads <|E^2-1|> = 0.946 +- 0.012 at +707.3 nats - essentially centric, which a merohedral twin law cannot produce. Re-refinement on a shared free set with the twin law removed from both sides gives P 32 2 1 0.2177/0.2322 against P 32 0.2460/0.2612, and the deposited entry's own R values reproduce only with an undeclared twin law h,-h-k,-l at alpha = 0.50, which is itself a 321-symmetric target. A perfect alpha = 0.5 merohedral twin and true 321 predict identical data, so no refinement R can close this; the case rests on the centric zone. The deposited cell and d_min are kept", "tags": ["cbf", "trigonal"]},
  {"id": "8xtf", "input": "8xtf/1102/puck03_12_1_master.h5", "ref": {"sg": "H 3 2", "sgno": 155, "cell": [211.75, 211.75, 67.42, 90.0, 90.0, 120.0], "dmin": 2.13}, "tags": ["h5", "trigonal"]},
- {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32 2 1", "sgno": 154, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "tags": ["cbf", "trigonal"]},
+ {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "ref_override": {"sg": "P 32 2 1", "sgno": 154}, "ref_override_why": "deposited P 32; this override predates the 8xbp and 6toc ones and was recorded here later. THE CASE IS OPEN. Our merge and POINTLESS (0.85 on our own P1 merge) read point group 321, but the twin-immune centric zone of the added two-folds reads <|E^2-1|> = 0.869 at -44.9 nats - between the centric and acentric expectations and negative - so the one test we have that separates real symmetry from pseudo-symmetry argues AGAINST the promotion, and the L-test indicates a twin fraction near 0.20-0.26. Whether the crystal is partially twinned or purely pseudo-symmetric is not established. This row may belong unscored rather than overridden. The deposited cell and d_min are kept", "tags": ["cbf", "trigonal"]},
  {"id": "8y74", "input": "8y74/1_1/1_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [125.782, 76.553, 87.143, 90.0, 92.449, 90.0], "dmin": 1.9}, "tags": ["h5", "monoclinic"]},
  {"id": "8ys9", "input": "8ys9/8YS9_xray-data_8ys9/data/SDS_09_18112_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [71.04, 77.68, 83.16, 90.0, 90.0, 90.0], "dmin": 1.46}, "tags": ["h5", "orthorhombic"]},
  {"id": "9b22", "input": "9b22/KlpnC_20447_a_B1-AR6-AMP_9b22/data/PSL-1011_1580_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [39.826, 92.659, 57.716, 90.0, 91.68, 90.0], "dmin": 1.3}, "tags": ["h5", "monoclinic"]},
-- 
2.54.0


From 4e4de57aae336db0259f4b0042fc7f036a49c646 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 17:41:59 +0200
Subject: [PATCH 086/122] Rugnux: two diagnostic outputs a person can check the
 run by eye with

Written on every rotation run, next to the reflections, with no flag to
switch them on:

<prefix>_detector.jpg - the mean projection the beam-stop pre-scan built,
which is the very image the shadow detection tested, coloured with the
viewer's own default map from common/ColorScale.h: white-to-indigo for the
counts, grey for the module and chip gaps, coral for the detected shadow,
magenta for the rest of the pixel mask. A shadow claimed where the
background is unbroken, or a dark patch left uncoloured, is then visible at
a glance instead of being a pixel count in the log. The projection is the
one the pre-scan already holds, so no frame is read twice; the picture is
rendered there and held as JPEG bytes until the canonical pass writes it,
because on a two-pass run the pre-scan belongs to the superseded pass.

<prefix>_plot.txt - one row per processed image, whitespace-separated with
a single '#' legend line over its own columns, so gnuplot plots it as it
stands: image, spindle angle, background, resolution, spot count, scale,
sigma_M, CC to merge, and whether the image's observations reached the
merged data. A quantity nothing measured is written nan, so the columns
never shift and no row is ever left out.

sigma_M is emitted as the pipeline produces it - a per-image Gaussian
rocking width, smoothed in frame order and filled with the run median where
a frame could not be fitted - and the documentation says so rather than
presenting it as a crystal property.

<prefix>_image.dat stays: the in-tree comparison scripts read it and it
carries the smoothing wedge, which the new file does not. The docs name
_plot.txt as the one to script against.

Measured on a 1800-image rotation sweep: 29.6/30.4 s before against
29.8/30.5 s after, and the merged reflections are byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/RUGNUX_REPORT.md          |   2 +-
 docs/RUGNUX_TUTORIAL.md        |  49 ++++++++++--
 rugnux/CMakeLists.txt          |   4 +-
 rugnux/DiagnosticOutput.cpp    | 128 +++++++++++++++++++++++++++++++
 rugnux/DiagnosticOutput.h      |  47 ++++++++++++
 rugnux/Rugnux.cpp              |  45 ++++++++++-
 rugnux/Rugnux.h                |   7 ++
 tests/CMakeLists.txt           |   1 +
 tests/DiagnosticOutputTest.cpp | 135 +++++++++++++++++++++++++++++++++
 9 files changed, 410 insertions(+), 8 deletions(-)
 create mode 100644 rugnux/DiagnosticOutput.cpp
 create mode 100644 rugnux/DiagnosticOutput.h
 create mode 100644 tests/DiagnosticOutputTest.cpp

diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index e46b6555f..9b50f8697 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -286,7 +286,7 @@ The vocabulary is **closed and stable**: a code is never renamed, and never reus
 meaning. New codes are only ever added, and adding one moves `REPORT_VERSION` at the next release.
 
 The columns are: `FIRST_IMAGE`/`LAST_IMAGE` — inclusive, in processed-image ordinals (the numbering
-of `<prefix>_image.dat` and of every other per-image array `rugnux` writes; with `-s`/`--stride` the
+of `<prefix>_plot.txt` and of every other per-image array `rugnux` writes; with `-s`/`--stride` the
 source image is `start + ordinal * stride`); `ROTATION` — the width of the range in degrees;
 `SEVERITY` — the fraction of the run's typical diffracting power missing over the range, 0 (as good
 as the run) to 1 (nothing at all); `SCALE` and `CC` — the range's mean per-image scale and
diff --git a/docs/RUGNUX_TUTORIAL.md b/docs/RUGNUX_TUTORIAL.md
index eca24607c..5c3b61e20 100644
--- a/docs/RUGNUX_TUTORIAL.md
+++ b/docs/RUGNUX_TUTORIAL.md
@@ -116,7 +116,7 @@ or of the run's own measured centre, whichever is nearer), and the second pass
 re-indexes de novo and re-integrates at the refined geometry. The refined pass is the canonical
 `<prefix>_*` output; the header-geometry pass merges only to choose the space group and to judge the
 refined pass against, and writes no merged files of its own — no `<prefix>_01.mtz`, `.cif`, `.hkl` or
-`_01_image.dat`. (Where a process file is asked for at all, with `--no-merge` or
+`_01_image.dat`, and no `_01_plot.txt` or `_01_detector.jpg`. (Where a process file is asked for at all, with `--no-merge` or
 `--write-process-h5`, each pass still writes its own, so `<prefix>_01_process.h5` appears beside
 `<prefix>_process.h5`.) Disable it with `--rotation-no-postrefine`.
 
@@ -244,10 +244,49 @@ goniometer axis but you want per-frame stills processing anyway, add `--force-st
 - `<prefix>_report.txt` — the **results report**: what the run determined, in a form both a person and
   a beamline script can read. Always written, next to the files above. See
   [The results report](RUGNUX_REPORT.md#the-results-report).
-- `<prefix>_image.dat` — one row per processed image, whitespace-separated, with a `#` header line
-  naming the columns: `image_number scale_G mosaicity_deg wedge_deg cc_to_merge cc_n` — the
-  per-image scale, mosaicity, smoothing wedge and correlation-to-merge behind the sweep-quality
-  table, ready for gnuplot or numpy.
+- `<prefix>_plot.txt` — **the per-image table**, one row per processed image, whitespace-separated,
+  with a single `#` legend line over its own columns so gnuplot plots it as it stands
+  (`plot '<prefix>_plot.txt' using 1:4`). Rotation runs only. The columns are:
+
+  | Column | Meaning |
+  |--------|---------|
+  | `image` | Processed-image ordinal, the numbering every per-image array `rugnux` writes uses; with `-s`/`--stride` the source image is `start + ordinal * stride`. |
+  | `angle_deg` | Spindle angle at mid-exposure. |
+  | `bkg` | Background estimate from the azimuthal profile (the `bkgEstimate` of the HDF5 file). |
+  | `resolution_A` | How far the image's spots reach, from spot finding alone. |
+  | `spots` | Spots found. |
+  | `scale_G` | Per-image scale factor fitted by scaling. |
+  | `sigma_M_deg` | Mosaicity as the rocking-curve **standard deviation** σ<sub>M</sub> in degrees — not a FWHM, and not XDS's `REFLECTING_RANGE`. See the note below. |
+  | `cc_to_merge` | Correlation of the image's own observations with the merged data. |
+  | `merged` | 1 where the image's observations are in the merged data, 0 where they are not — an image that never indexed, one an earlier guard dropped, and one ΔCC<sub>1/2</sub> convicted all read 0. |
+
+  A quantity nothing measured for an image is written `nan`, which gnuplot and numpy both skip; the
+  columns never shift and a row is never left out.
+
+  **Reading `sigma_M_deg`.** It is fitted per image — a maximum-likelihood Gaussian rocking width
+  over that image's own indexed spots — but it is then **smoothed in frame order** over the same
+  rotation window as the per-image scale (`--smooth-g`), and any frame too sparse to fit one of its
+  own is given the run's median. So the column varies only on the smoothing window's scale, and on a
+  weakly diffracting crystal it is close to, or exactly, a constant: that flatness is the honest
+  statement that the run measured no per-frame variation, not a placeholder. The value is the one
+  scaling used to recompute partialities. σ<sub>M</sub> here is the width of a Gaussian
+  rocking curve and nothing more — it is not a physical crystal mosaic spread, it absorbs beam
+  divergence and every other source of angular spread, and it reads systematically **low** against
+  XDS's `SIGMAR` (about 0.9× on the regression corpus). Use it to see whether the run's rocking
+  width moves across the sweep, not as a number to quote.
+- `<prefix>_detector.jpg` — **the detector as the run saw it**, so the beam stop and the module gaps
+  can be checked by eye. Rotation runs only, and only where `--detect-beam-stop` was left on (it is
+  by default). The picture is the mean projection over the frames the beam-stop detection sampled —
+  the very image it tested — coloured with `jfjoch_viewer`'s default map: white to indigo for the
+  counts, **grey** for the module and chip gaps, **coral** for the shadow the run detected, and
+  **magenta** for everything else the pixel mask holds. A shadow drawn where the background is
+  unbroken, or a dark patch the run left uncoloured, is visible at a glance; read it against the
+  `Beam stop shadow: N pixels ...` line in the log.
+- `<prefix>_image.dat` — the per-image **scaling** table: `image_number scale_G mosaicity_deg
+  wedge_deg cc_to_merge cc_n`, whitespace-separated with a `#` header line. It predates `_plot.txt`
+  and is kept because the in-tree comparison scripts read it and because it carries the per-image
+  mosaicity and smoothing wedge, which `_plot.txt` does not. **For anything new, script against
+  `_plot.txt`.**
 
 Merged statistics (⟨I/σ⟩, CC1/2, completeness, …), the error model and timing are printed to the
 console. By default the written resolution is trimmed automatically where CC1/2 falls off
diff --git a/rugnux/CMakeLists.txt b/rugnux/CMakeLists.txt
index 37d0b3e0d..a496e1088 100644
--- a/rugnux/CMakeLists.txt
+++ b/rugnux/CMakeLists.txt
@@ -23,13 +23,15 @@ ADD_LIBRARY(Rugnux STATIC
         ReportDocument.h
         SpotWidth.cpp
         SpotWidth.h
+        DiagnosticOutput.cpp
+        DiagnosticOutput.h
         SpindleCuspLoss.cpp
         SpindleCuspLoss.h
         WriteModel.cpp
         WriteModel.h
 )
 
-TARGET_LINK_LIBRARIES(Rugnux JFJochReader JFJochImageAnalysis JFJochWriter gemmi fftw3f)
+TARGET_LINK_LIBRARIES(Rugnux JFJochReader JFJochImageAnalysis JFJochWriter JFJochPreview gemmi fftw3f)
 
 # rugnux is the single offline analysis CLI; --mode picks what it does: mx (the full pipeline, the
 # default), azint, scale (re-scale/merge stored reflections) or calibration (powder-ring geometry).
diff --git a/rugnux/DiagnosticOutput.cpp b/rugnux/DiagnosticOutput.cpp
new file mode 100644
index 000000000..1c4d45e86
--- /dev/null
+++ b/rugnux/DiagnosticOutput.cpp
@@ -0,0 +1,128 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include "DiagnosticOutput.h"
+
+#include <algorithm>
+#include <cmath>
+#include <fstream>
+
+#include <spdlog/fmt/fmt.h>
+
+#include "../common/ColorScale.h"
+#include "../common/CompressedImage.h"
+#include "../common/JFJochException.h"
+#include "../image_analysis/scale_merge/Merge.h"
+#include "../preview/JFJochJPEG.h"
+
+namespace {
+    // The brightest 0.1 % of the measured pixels saturate, as the preview and the viewer set their
+    // contrast (preview/PreviewImage.cpp): a handful of hot pixels would otherwise take the whole
+    // range and leave the background - which is what the shadow is read off - a flat white.
+    float SaturationValue(const std::vector<float> &projection, const std::vector<uint32_t> &mask) {
+        std::vector<float> valid;
+        valid.reserve(projection.size());
+        for (size_t i = 0; i < projection.size(); i++)
+            if (mask[i] == 0 && std::isfinite(projection[i]))
+                valid.push_back(projection[i]);
+        if (valid.empty())
+            return 1.0f;
+        const size_t rank = valid.size() - std::max<size_t>(1, valid.size() / 1000);
+        std::nth_element(valid.begin(), valid.begin() + rank, valid.end());
+        return std::max(valid[rank], 1.0f);
+    }
+
+    float Element(const std::vector<float> &v, size_t i) {
+        return i < v.size() ? v[i] : NAN;
+    }
+}
+
+std::vector<rgb> DetectorDiagnosticRGB(const PixelMask &pixel_mask,
+                                       const std::vector<float> &mean_projection) {
+    constexpr uint32_t gap_bits = (1u << PixelMask::ModuleGapPixelBit)
+                                  | (1u << PixelMask::ChipGapPixelBit)
+                                  | (1u << PixelMask::ModuleEdgePixelBit);
+    constexpr uint32_t beam_stop_bit = 1u << PixelMask::BeamStopPixelBit;
+
+    const auto &mask = pixel_mask.GetMask();
+    if (mask.size() != mean_projection.size())
+        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
+                              "Mask and projection are of different size");
+
+    // Untouched: the viewer's defaults are the point, so that the JPEG and the picture the user
+    // knows from jfjoch_viewer say the same thing with the same colours.
+    ColorScale scale;
+    const rgb gap_color = scale.Apply(ColorScaleSpecial::Gap);
+    const rgb bad_color = scale.Apply(ColorScaleSpecial::BadPixel);
+    const rgb beam_stop_color = scale.Apply(ColorScaleSpecial::BeamStop);
+
+    const auto &lut = scale.LUTData();
+    const auto lut_size = static_cast<int64_t>(lut.size());
+    const float inv_range = static_cast<float>(lut_size - 1) / SaturationValue(mean_projection, mask);
+
+    // The shadow is tested BEFORE the rest of the mask, so a pixel the detection claims is never
+    // hidden under a noisy- or user-masked bit it also carries - the whole point is to see what
+    // the detection did. Gaps come first because nothing can be shadowed there: they carry no
+    // background for the comparison to miss.
+    std::vector<rgb> image(mean_projection.size());
+    for (size_t i = 0; i < image.size(); i++) {
+        if ((mask[i] & gap_bits) != 0)
+            image[i] = gap_color;
+        else if ((mask[i] & beam_stop_bit) != 0)
+            image[i] = beam_stop_color;
+        else if (mask[i] != 0 || !std::isfinite(mean_projection[i]))
+            image[i] = bad_color;
+        else {
+            const auto idx = static_cast<int64_t>(mean_projection[i] * inv_range + 0.5f);
+            image[i] = lut[std::clamp<int64_t>(idx, 0, lut_size - 1)];
+        }
+    }
+
+    return image;
+}
+
+std::string RenderDetectorDiagnostic(const DiffractionExperiment &experiment,
+                                     const PixelMask &pixel_mask,
+                                     const std::vector<float> &mean_projection) {
+    // Named, because CompressedImage does not own the pixels it is handed.
+    const std::vector<rgb> image = DetectorDiagnosticRGB(pixel_mask, mean_projection);
+    const CompressedImage rgb_image(image, experiment.GetXPixelsNumConv(),
+                                    experiment.GetYPixelsNumConv());
+    return WriteJPEGToMem(rgb_image, 85);
+}
+
+void WritePerImagePlot(const std::string &output_prefix, const PerImagePlot &plot,
+                       const std::optional<GoniometerAxis> &goniometer, size_t image_count) {
+    const std::string path = output_prefix + "_plot.txt";
+    std::ofstream file(path, std::ofstream::out | std::ofstream::trunc);
+    if (!file)
+        throw JFJochException(JFJochExceptionCategory::FileWriteError,
+                              "Cannot open " + path + " for writing");
+
+    // One comment line, its names over their own columns, and nothing else a plotting program has
+    // to be told to skip. The '#' takes the first character of the image-number field.
+    file << "#" << fmt::format("{:>5} {:>10} {:>12} {:>12} {:>8} {:>12} {:>13} {:>12} {:>7}\n",
+                               "image", "angle_deg", "bkg", "resolution_A", "spots", "scale_G",
+                               "sigma_M_deg", "cc_to_merge", "merged");
+
+    for (size_t i = 0; i < image_count; i++) {
+        const float angle = goniometer
+                                ? goniometer->GetAngle_deg(static_cast<float>(i))
+                                      + goniometer->GetWedge_deg() / 2.0f
+                                : NAN;
+        const float scale_g = Element(plot.scale_g, i);
+        // Did this image's observations reach the merged data? The sweep-quality diagnostic says so
+        // outright; where it did not run, an image with no fitted scale contributed nothing, which
+        // is the same statement by a weaker route.
+        const int merged = i < plot.frame_disposition.size()
+                               ? plot.frame_disposition[i]
+                                     != static_cast<uint8_t>(FrameDisposition::Rejected)
+                               : std::isfinite(scale_g);
+
+        file << fmt::format("{:>6} {:>10.4f} {:>12.4g} {:>12.4g} {:>8.0f} {:>12.5g} {:>13.4f}"
+                            " {:>12.4f} {:>7}\n",
+                            i, angle, Element(plot.bkg_estimate, i), Element(plot.resolution_A, i),
+                            Element(plot.spot_count, i), scale_g, Element(plot.mosaicity_deg, i),
+                            Element(plot.cc_to_merge, i), merged);
+    }
+}
diff --git a/rugnux/DiagnosticOutput.h b/rugnux/DiagnosticOutput.h
new file mode 100644
index 000000000..21009f81d
--- /dev/null
+++ b/rugnux/DiagnosticOutput.h
@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "../common/ColorScale.h"
+#include "../common/DiffractionExperiment.h"
+#include "../common/PixelMask.h"
+
+// Two files a person reads to check by eye what the run decided, written next to the reflections on
+// every rotation run: the detector as the pipeline saw it, and one row per image.
+
+// The mean projection the beam-stop pre-scan built, coloured with the viewer's own default map
+// (common/ColorScale.h): white-to-indigo for the counts, grey for the module and chip gaps, coral
+// for the detected shadow, magenta for everything else the mask holds. The shadow is a place where
+// the background is missing, so drawing the mask on top of the very projection the detection tested
+// is what makes a wrong shadow visible - a coral patch over unbroken background, or a dark patch
+// left uncoloured.
+std::vector<rgb> DetectorDiagnosticRGB(const PixelMask &pixel_mask,
+                                       const std::vector<float> &mean_projection);
+
+// The same picture as JPEG bytes, at the detector's own pixel count.
+std::string RenderDetectorDiagnostic(const DiffractionExperiment &experiment,
+                                     const PixelMask &pixel_mask,
+                                     const std::vector<float> &mean_projection);
+
+// The columns of <prefix>_plot.txt. Every vector is indexed by the processed-image ordinal - the
+// numbering of <prefix>_image.dat and of every other per-image array rugnux writes - and a value
+// nothing measured is NAN. frame_disposition holds FrameDisposition (Merge.h) and is empty when the
+// sweep-quality diagnostic did not run.
+struct PerImagePlot {
+    std::vector<float> bkg_estimate;
+    std::vector<float> resolution_A;
+    std::vector<float> spot_count;
+    std::vector<float> scale_g;
+    std::vector<float> mosaicity_deg;
+    std::vector<float> cc_to_merge;
+    std::vector<uint8_t> frame_disposition;
+};
+
+// Writes <output_prefix>_plot.txt: one '#' legend line naming the columns, then one whitespace-
+// separated row per image, so `plot '<f>' using 1:4` works with nothing in between.
+void WritePerImagePlot(const std::string &output_prefix, const PerImagePlot &plot,
+                       const std::optional<GoniometerAxis> &goniometer, size_t image_count);
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index fa13e6200..eacda1e79 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -7,6 +7,7 @@
 #include "WriteModel.h"
 #include "SpindleCuspLoss.h"
 #include "SpotWidth.h"
+#include "DiagnosticOutput.h"
 
 #include <algorithm>
 #include <atomic>
@@ -14,6 +15,7 @@
 #include <cmath>
 #include <condition_variable>
 #include <deque>
+#include <fstream>
 #include <functional>
 #include <future>
 #include <mutex>
@@ -1183,8 +1185,9 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru
         // frame of its own, and an unmasked shadow biases it by a few pixels at most, which is
         // three orders below what this comparison would notice. The centre the run reports and
         // consumes is the one fitted below instead, with the shadow out of the way.
+        const std::vector<float> projection = finder.GetMeanProjection();
         if (const auto ring_center = FindBeamCenterFromBackground(experiment_, pixel_mask_,
-                                                                  finder.GetMeanProjection())) {
+                                                                  projection)) {
             finder.BeamCenter(ring_center->beam_x_pxl, ring_center->beam_y_pxl);
             logger.Info("Beam stop: comparing each pixel against its ring about the measured "
                         "centre ({:.2f},{:.2f}) +- {:.2f} px, {:.2f} px from the file's",
@@ -1211,6 +1214,12 @@ void Rugnux::PreScan(int start_image, int images_to_process, int frame_count, Ru
             logger.Info("Beam stop shadow: {} pixels ({:.2f}% of the detector) found in {} images",
                         shadowed, 100.0 * static_cast<double>(shadowed) / static_cast<double>(shadow.size()),
                         finder.GetFrameCount());
+
+        // The diagnostic picture, rendered here because this is where the projection and the mask
+        // the detection has just written into it are both in hand; the file is written later, under
+        // the canonical prefix, since on a two-pass run this is the pre-pass.
+        if (config_.mode == ProcessMode::FullAnalysis && experiment_.IsRotationIndexing())
+            detector_diagnostic_jpeg_ = RenderDetectorDiagnostic(experiment_, pixel_mask_, projection);
     }
 
     // The beam centre is fitted again here, so that the shadow is in the mask by the time it is
@@ -7488,6 +7497,40 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                               /*trusted_path=*/true);
     }
 
+    // The two files a person checks the run by eye with. Rotation only - a stills run has no spindle
+    // angle and no sweep to project - and not on the geometry pre-pass or a pass that is thrown
+    // away, which would otherwise leave a stale _01 copy beside the real one.
+    if (full && write_files && !cancelled_ && !geometry_prepass && !superseded
+        && experiment_.IsRotationIndexing()) {
+        if (!detector_diagnostic_jpeg_.empty()) {
+            const std::string path = config_.output_prefix + "_detector.jpg";
+            std::ofstream f(path, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
+            if (f) {
+                f.write(detector_diagnostic_jpeg_.data(),
+                        static_cast<std::streamsize>(detector_diagnostic_jpeg_.size()));
+                logger.Info("Detector diagnostic image written to {}", path);
+            } else
+                logger.Warning("Cannot open {} for writing", path);
+        }
+
+        PerImagePlot plot;
+        plots.GetPlotRaw(plot.bkg_estimate, PlotType::BkgEstimate, "");
+        plots.GetPlotRaw(plot.resolution_A, PlotType::ResolutionEstimate, "");
+        plots.GetPlotRaw(plot.spot_count, PlotType::SpotCount, "");
+        if (indexer) {
+            // The same source as <prefix>_image.dat, so the two files cannot disagree.
+            const ScalingResult scaling(indexer->GetIntegrationOutcome());
+            plot.scale_g = scaling.image_scale_g;
+            plot.mosaicity_deg = scaling.mosaicity_deg;
+            plot.cc_to_merge = scaling.image_cc;
+        }
+        if (result.has_merge_statistics)
+            plot.frame_disposition = result.merge_statistics.sweep_quality.frame_disposition;
+        WritePerImagePlot(config_.output_prefix, plot, experiment_.GetGoniometer(),
+                          static_cast<size_t>(images_to_process));
+        logger.Info("Per-image table written to {}_plot.txt", config_.output_prefix);
+    }
+
     if (writer) {
         writer->WriteHDF5(end_msg);
         writer->Finalize();
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 12fa96e32..1aadb6cb2 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -491,6 +491,13 @@ class Rugnux {
     // first-pass ladder: they say how DEEP a pass reads without a resolution written into the program.
     std::vector<float> prescan_spot_quantile_d_A_;
 
+    // <prefix>_detector.jpg, rendered in the pre-scan from the projection the beam-stop detection
+    // tested and held until the canonical pass writes its files. Kept as the finished JPEG rather
+    // than as the projection: the picture is a few hundred kilobytes where the projection is four
+    // bytes a pixel, and the pre-scan is the only place where both the projection and the shadow it
+    // has just decided on exist. Empty outside a rotation run, and where the pre-scan did not look.
+    std::string detector_diagnostic_jpeg_;
+
     // Set by Run()'s supercell-collapse guard to force pass-1's full result into the second-pass indexer
     // (RunPipeline calls indexer->ForceRotationIndexerResult when this is set); reset right after that re-run.
     std::optional<RotationIndexerResult> force_rotation_result_;
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index fa5452b7e..6e90cd2bf 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -55,6 +55,7 @@ ADD_EXECUTABLE(jfjoch_test
         ParallelForTest.cpp
         RugnuxTest.cpp
         ResultReportTest.cpp
+        DiagnosticOutputTest.cpp
         PostRefineTest.cpp
         RugnuxLargeTest.cpp
         TestData.h
diff --git a/tests/DiagnosticOutputTest.cpp b/tests/DiagnosticOutputTest.cpp
new file mode 100644
index 000000000..bee2592fa
--- /dev/null
+++ b/tests/DiagnosticOutputTest.cpp
@@ -0,0 +1,135 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_test_macros.hpp>
+
+#include <cmath>
+#include <fstream>
+#include <sstream>
+
+#include "../rugnux/DiagnosticOutput.h"
+#include "../image_analysis/scale_merge/Merge.h"
+
+namespace {
+    bool same(const rgb &a, const rgb &b) {
+        return a.r == b.r && a.g == b.g && a.b == b.b;
+    }
+
+    // The columns of one row of <prefix>_plot.txt, whitespace-separated.
+    std::vector<std::string> Columns(const std::string &line) {
+        std::istringstream is(line);
+        std::vector<std::string> ret;
+        for (std::string token; is >> token;)
+            ret.push_back(token);
+        return ret;
+    }
+
+    std::vector<std::string> ReadLines(const std::string &path) {
+        std::ifstream f(path);
+        std::vector<std::string> ret;
+        for (std::string line; std::getline(f, line);)
+            ret.push_back(line);
+        return ret;
+    }
+}
+
+TEST_CASE("DiagnosticImage_Colors") {
+    ColorScale scale;
+
+    // One pixel of each kind, in the order the renderer tests them.
+    std::vector<uint32_t> mask_bits{
+            0,                                          // plain, no counts
+            0,                                          // plain, the brightest pixel
+            1u << PixelMask::ModuleGapPixelBit,
+            1u << PixelMask::BeamStopPixelBit,
+            1u << PixelMask::UserMaskedPixelBit,
+            (1u << PixelMask::ModuleGapPixelBit) | (1u << PixelMask::BeamStopPixelBit),
+            (1u << PixelMask::BeamStopPixelBit) | (1u << PixelMask::NoisyPixelBit)};
+    const PixelMask mask(mask_bits);
+    const std::vector<float> projection{0.0f, 1000.0f, NAN, NAN, NAN, NAN, NAN};
+
+    const auto image = DetectorDiagnosticRGB(mask, projection);
+    REQUIRE(image.size() == mask_bits.size());
+
+    CHECK(same(image[0], scale.Apply(0.0f)));                          // white: no counts
+    CHECK(same(image[1], scale.Apply(1.0f)));                          // indigo: the saturation value
+    CHECK(same(image[2], scale.Apply(ColorScaleSpecial::Gap)));        // grey
+    CHECK(same(image[3], scale.Apply(ColorScaleSpecial::BeamStop)));   // coral
+    CHECK(same(image[4], scale.Apply(ColorScaleSpecial::BadPixel)));   // magenta
+    // A gap cannot be shadowed - it carries no background for the detection to miss - so the gap
+    // wins; every other mask bit loses to the shadow, which is what the picture is there to show.
+    CHECK(same(image[5], scale.Apply(ColorScaleSpecial::Gap)));
+    CHECK(same(image[6], scale.Apply(ColorScaleSpecial::BeamStop)));
+}
+
+TEST_CASE("DiagnosticPlot_Format") {
+    const std::string prefix = "diagnostic_plot_format_test";
+
+    PerImagePlot plot;
+    plot.bkg_estimate = {1.0f, 2.0f, 3.0f, 4.0f};
+    plot.resolution_A = {2.5f, 2.4f, NAN, 2.6f};
+    plot.spot_count = {100.0f, 120.0f, 0.0f, 90.0f};
+    plot.scale_g = {1.0f, 1.1f, NAN, 0.9f};
+    plot.mosaicity_deg = {0.12f, 0.12f, NAN, 0.13f};
+    plot.cc_to_merge = {0.98f, 0.97f, NAN, 0.5f};
+    plot.frame_disposition = {static_cast<uint8_t>(FrameDisposition::Merged),
+                              static_cast<uint8_t>(FrameDisposition::Downgraded),
+                              static_cast<uint8_t>(FrameDisposition::Rejected),
+                              static_cast<uint8_t>(FrameDisposition::Rejected)};
+
+    const GoniometerAxis goniometer("omega", 10.0f, 0.5f, {0, 1, 0}, {});
+    WritePerImagePlot(prefix, plot, goniometer, 4);
+
+    const auto lines = ReadLines(prefix + "_plot.txt");
+    REQUIRE(lines.size() == 5);
+
+    // Exactly one legend row, and it is a comment.
+    REQUIRE(lines[0][0] == '#');
+    for (size_t i = 1; i < lines.size(); i++)
+        CHECK(lines[i].find('#') == std::string::npos);
+
+    const auto legend = Columns(lines[0]);
+    REQUIRE(legend.size() == 9);
+    CHECK(legend[0] == "#image");
+    CHECK(legend[1] == "angle_deg");
+    CHECK(legend[6] == "sigma_M_deg");
+    CHECK(legend[8] == "merged");
+
+    for (size_t i = 1; i < lines.size(); i++) {
+        const auto row = Columns(lines[i]);
+        REQUIRE(row.size() == legend.size());
+        CHECK(row[0] == std::to_string(i - 1));
+    }
+
+    // Mid-exposure angle: start + ordinal * increment + increment / 2.
+    CHECK(std::stof(Columns(lines[1])[1]) == 10.25f);
+    CHECK(std::stof(Columns(lines[3])[1]) == 11.25f);
+
+    // Merged and downgraded frames are in the merged data; a rejected one is not.
+    CHECK(Columns(lines[1])[8] == "1");
+    CHECK(Columns(lines[2])[8] == "1");
+    CHECK(Columns(lines[3])[8] == "0");
+    CHECK(Columns(lines[4])[8] == "0");
+
+    // A frame nothing measured leaves its own columns unplottable, not the row missing.
+    CHECK(Columns(lines[3])[3] == "nan");
+}
+
+TEST_CASE("DiagnosticPlot_NoDisposition") {
+    const std::string prefix = "diagnostic_plot_nodisp_test";
+
+    // Without the sweep-quality diagnostic, a frame counts as merged when it was scaled at all.
+    PerImagePlot plot;
+    plot.scale_g = {1.0f, NAN, 0.8f};
+    WritePerImagePlot(prefix, plot, {}, 3);
+
+    const auto lines = ReadLines(prefix + "_plot.txt");
+    REQUIRE(lines.size() == 4);
+    CHECK(Columns(lines[1])[8] == "1");
+    CHECK(Columns(lines[2])[8] == "0");
+    CHECK(Columns(lines[3])[8] == "1");
+
+    // No goniometer: the angle column is present and unplottable, so the columns never shift.
+    CHECK(Columns(lines[1]).size() == 9);
+    CHECK(Columns(lines[1])[1] == "nan");
+}
-- 
2.54.0


From 0c91749a4159a755009658a75ff01a7b09b69ac9 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:25:09 +0200
Subject: [PATCH 087/122] Battery: let a row accept more than one reference

A handful of open-arm rows disagree with their deposition on a knife edge that no test
available to us settles. They were handled three different ways - silently overridden to
our answer, marked unscored, or left failing - and none of the three says what is true:
either answer is acceptable as long as the program picks one of them.

A manifest row can now list `ref_alternatives`. Each entry replaces the reference fields
it names - a space group, a cell, or both - and the row passes if the answer matches any
of its references, the deposition included. `ref` keeps the deposited values verbatim in
every case. Every alternative must carry `why`: an accepted alternative with no stated
reason raises rather than passing, so the mechanism cannot be used to launder a failure.

The report keeps these rows visible rather than folding them into the passes: a summary
column counting them, their own segment in the verdict bars, and a section naming each
row, what we read, what was deposited and the reason both are accepted.

Five rows use it. Four are symmetry: a tetragonal row where the refinement test is split
and its spread exceeds the effect, and three trigonal rows where we read a higher point
group - one where the evidence favours our answer, one where our own twin-immune test
favours the deposition, one unresolved in either direction. The fifth is a cell: a real
tNCS supercell whose (0,1/2,1/2) sublattice is what was deposited, both being correct
descriptions of the same lattice. The documentation frames all of them as open questions,
not as errors in a deposition, and states the limit: a merohedral twin at exactly one half
and true higher symmetry predict identical intensities, so no test can close them even in
principle.

`test_score.py` covers the new path: both answers accepted, the other hand of an
alternative, a third answer still failing, the cell case, and the missing-justification
schema error.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/EXTERNAL_TEST_DATA.md  |  72 +++++++++++++++-------
 tools/battery/README.md     |  26 +++++++-
 tools/battery/open.json     |  10 +--
 tools/battery/render.py     |  11 ++--
 tools/battery/report.py     |  36 +++++++++--
 tools/battery/score.py      | 118 +++++++++++++++++++++++++++---------
 tools/battery/test_score.py |  97 +++++++++++++++++++++++++++++
 7 files changed, 299 insertions(+), 71 deletions(-)
 create mode 100644 tools/battery/test_score.py

diff --git a/docs/EXTERNAL_TEST_DATA.md b/docs/EXTERNAL_TEST_DATA.md
index 815ad710c..1fe70cc10 100644
--- a/docs/EXTERNAL_TEST_DATA.md
+++ b/docs/EXTERNAL_TEST_DATA.md
@@ -343,7 +343,7 @@ deposited intensities.
 
 ## Rows where our reduction and the deposition disagree
 
-Five of the 153 rows are ones where `rugnux` does not reproduce the deposited space group or
+Six of the 153 rows are ones where `rugnux` does not reproduce the deposited space group or
 cell, and where we have looked at the disagreement closely enough to change how the row is
 scored. They are collected here because a scoring row that silently disagrees with a published
 entry is not something a reader should have to discover from the code.
@@ -359,14 +359,23 @@ the end of this section.
 How the manifest records it, in `tools/battery/open.json`:
 
 - `ref` always keeps the deposited values verbatim, so the deposition is never lost.
-- `ref_override` replaces only the fields the battery scores against, and `ref_override_why`
-  records the evidence and its limits.
-- `unscored` is for a row we cannot defend a reference for in either direction: the set still
-  runs, and its merging statistics are still reported, but it is not scored.
+- `ref_alternatives` lists the *other* answers the row accepts. Each one replaces the reference
+  fields it names - a space group, a cell, or both - and the row passes if our answer matches any
+  of the references, the deposited one included. Each must carry `why`; an alternative with no
+  stated reason is a schema error, not a silent pass, so the mechanism cannot become a way to
+  turn a failure into a pass quietly. This is how the five knife-edge rows below are recorded:
+  we are not asserting that our answer is right, only that both descriptions are defensible and
+  that picking either one is acceptable. The report counts these rows separately from ordinary
+  passes and prints the reason, so a reader can see how many there are and judge each.
+- `ref_override` replaces the fields the battery scores against, with `ref_override_why`. It
+  *asserts* a corrected reference, so it is for a reference we can show to be wrong about these
+  images - 8XBP below - and not for a disagreement that is open.
+- `unscored` drops the row from scoring entirely. It is a last resort: it also loses a test that
+  still works, which is why an open question is now recorded as accepted alternatives instead.
 
 ### 8XBP is a question about provenance, not about symmetry
 
-8XBP is different in kind from the other four and should not be read alongside them. Nothing
+8XBP is different in kind from the other five and should not be read alongside them. Nothing
 here concerns the deposited model or its space group. The question is whether the raw images
 uploaded with the entry are the same crystal the deposited cell describes: the master file
 records `data_collection_date` 2023-06-21 where the entry records a collection date of
@@ -377,16 +386,18 @@ and resolution.
 
 ### Four trigonal and tetragonal rows where we read a higher point group
 
-| PDB | Deposited | `rugnux` reads | Row is now | Where it stands |
-|---|---|---|---|---|
-| 6TOC | P 4<sub>2</sub> | P 4<sub>2</sub> 2 2 | overridden | strong, but the refinement test is not unanimous |
-| 8XTE | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | overridden | strong; rests on the centric-zone test |
-| 8XTG | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | overridden | **open** - our own best test argues against it |
-| 6PXB | P 3<sub>2</sub> | P 3<sub>1</sub> 1 2 / P 3<sub>2</sub> 1 2 | unscored | unresolved in either direction |
+| PDB | Deposited | `rugnux` reads | Where it stands |
+|---|---|---|---|
+| 6TOC | P 4<sub>2</sub> | P 4<sub>2</sub> 2 2 | both acceptable; the refinement test is not unanimous |
+| 8XTE | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | both acceptable; ours is the better supported |
+| 8XTG | P 3<sub>2</sub> | P 3<sub>1</sub> 2 1 / P 3<sub>2</sub> 2 1 | both acceptable; the **deposition** is the better supported |
+| 6PXB | P 3<sub>2</sub> | P 3<sub>1</sub> 1 2 / P 3<sub>2</sub> 1 2 | both acceptable; unresolved in either direction |
 
-The 8XTE and 8XTG overrides predate the 8XBP and 6TOC ones and were carried in the manifest for
-some time with no reason recorded against them; the reasons were written down later, when this
-section was added, rather than at the time the rows were changed.
+All four accept either answer: the deposited group and the one we read both pass. None of them
+is a claim that the deposited assignment is wrong - each is a question we cannot close, and 8XTE
+and 8XTG do not lean the same way, so they should not be read in one voice. The two 8XT* rows
+were for a time scored against our own answer by editing the reference itself, with no reason
+recorded; the deposition is back in `ref` verbatim and the disagreement is stated here.
 
 **6TOC.** The deposited asymmetric unit holds two chains, and they are related by the very
 two-fold the higher group adds, to 0.16 A C-alpha RMSD over 43 residues - coordinate error at
@@ -398,8 +409,8 @@ not biased toward the group the deposited model was refined in - does **not** co
 unanimous: ZANUDA 1.097 makes P 4<sub>2</sub> 2 2 the better group at half the parameters and
 reports the deposited assignment incorrect, while an independent Refmac 5.8.0431 comparison on a
 symmetry-consistent free set makes P 4<sub>2</sub> the better one, by less than the spread
-between refinement protocols. So the row is overridden on the structural and merging evidence,
-with the refinement evidence recorded as split.
+between refinement protocols - the spread of the test exceeds the effect it is being asked to
+measure. Both answers are therefore accepted, with the refinement evidence recorded as split.
 
 **8XTE.** The distinguishing test is the twin-immune centric zone: reflections that the higher
 group makes centric but the subgroup does not are their own twin mates, so a merohedral twin law
@@ -407,15 +418,19 @@ cannot make them read centric. They read `<|E^2-1|>` = 0.946 +/- 0.012 against a
 expectation of 0.968 and an acentric one of 0.736. Re-refinement on a shared free set, with the
 twin law removed from both sides, favours the higher group. The deposited entry's published R
 values are themselves reproducible only with a twin law the entry does not declare, at a twin
-fraction of 0.50 - and a 0.50-twinned target already has the symmetry in question.
+fraction of 0.50 - and a 0.50-twinned target already has the symmetry in question. Of the four
+rows this is the one where the evidence most clearly favours what we read; it still cannot be
+closed, because the centric zone is the only test that speaks to it (see the limit below), so
+both answers are accepted.
 
 **8XTG.** This row is genuinely open and is flagged as such in the manifest. Every
 correlation-based instrument we have - our own operator correlations, and POINTLESS on our P1
 merge - reads the higher point group, but the centric-zone test, the only one of them that can
 separate real symmetry from pseudo-symmetry, reads `<|E^2-1|>` = 0.869 at -44.9 nats: between
 the two expectations, and on the wrong side. The L-test indicates a twin fraction near 0.20-0.26.
-Whether this crystal is partially twinned or purely pseudo-symmetric has not been established,
-and our own best test argues against the promotion the row is scored on.
+Whether this crystal is partially twinned or purely pseudo-symmetric has not been established.
+Here the better-supported answer is the deposited one, which is the opposite of 8XTE: the two
+rows look alike in the table and are not alike in the evidence. Both answers are accepted.
 
 **6PXB.** Unscored rather than overridden, because the evidence does not settle either way. Our
 merge and POINTLESS both read a 312 point group, the added two-folds correlate at or above the
@@ -423,9 +438,22 @@ level of the three-folds nobody disputes, and merging in the higher group *lower
 R<sub>meas</sub> at twice the multiplicity. Against that, the deposited asymmetric unit's six
 chains pair under the added two-fold at 0.3-0.7 A, which is more than coordinate error at 1.75 A,
 and ZANUDA settles on a different trigonal supergroup - 321 rather than 312 - whose operators
-these data do not support. Neither answer is established, so the set runs and is not scored.
+these data do not support. Neither answer is established in either direction, so both are
+accepted and the row still tests everything else about the set.
 
-### The limit that applies to all four
+### 9RCI: two defensible descriptions of one lattice
+
+The sixth row is not about symmetry but about which cell describes the crystal. The Patterson
+has an off-origin peak at 62.5% of the origin, so a genuine translational NCS relates the two
+halves of the cell `rugnux` reports, and the deposited cell is that supercell's
+(0, 1/2, 1/2)-centred sublattice to 0.17%. Both are correct descriptions of the same diffraction:
+one leaves the near-translation in the contents of a doubled cell, the other absorbs it into the
+lattice and indexes only the strong sublattice. Which one a program should prefer is a choice,
+not a measurement, so the row accepts either. The alternative cell recorded in the manifest is
+computed from the deposited cell alone (c' = b + 2c, centring removed), not copied from our
+output, so it stays a statement about the deposition's lattice.
+
+### The limit that applies to all four symmetry rows
 
 A merohedral twin at a twin fraction of exactly 0.5 and a crystal that genuinely has the higher
 symmetry predict **identical** intensities. No amount of data and no refinement R separates them,
diff --git a/tools/battery/README.md b/tools/battery/README.md
index 24944d3f8..b4d932462 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -7,6 +7,9 @@ ad-hoc runner scripts instead. The old ones (`rugnux_vs_xds.py`, `battery_run.py
 `battery2_serial.py`, `batstats.py`, ...) are retired because their numbers could not be compared
 with each other.
 
+`test_score.py` covers the scoring rules that decide a verdict (stdlib `unittest`, no data and no
+run needed): `cd tools/battery && python3 test_score.py`.
+
 ## Arms
 
 | arm | datasets | reference | manifest |
@@ -35,6 +38,18 @@ among the ones it offered, and the only axis the two groups differ on is one it
 called wrongly where the row WAS measured meets none of them and stays a `sym_screw` failure - this
 rule excuses an unanswerable question, never a wrong answer.
 
+**A row may accept more than one reference.** Where the deposition and our reduction disagree,
+the disagreement is real, and no test available to us settles it - a knife-edge - the row lists
+the other acceptable answer in `ref_alternatives` and passes if our answer matches any of its
+references. This is not a statement that our answer is right; it says both descriptions are
+defensible and that picking either one is acceptable. `ref` keeps the deposition verbatim, each
+alternative must carry a `why` a reader can check (an alternative without one is a schema error,
+not a silent pass), and the report counts these rows on their own - summary column `of which
+alt`, its own bar-chart segment, and an **Accepted alternatives** section printing each reason -
+so they are never folded into the ordinary passes. Prefer this to `unscored`, which drops the
+row from scoring altogether and loses a test that still works, and to `ref_override`, which
+asserts that the reference is wrong.
+
 **Data quality is not scored.** A verdict is about the lattice and the symmetry only. Resolution,
 CC1/2, R_meas (overall and lowest shell), completeness, multiplicity and ISa are reported beside
 XDS's or the deposition's values, in the per-set tables and plots, for a human to judge. On the XDS
@@ -260,7 +275,8 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 |---|---|
 | `set`, `arm`, `tags`, `input`, `cmd` | the set's id, arm, population tags, input file, and the exact command that ran |
 | `verdict` | `pass`, `fail`, `unscored` (no reference, or a question the data could not answer) or `not_run` (input missing) |
-| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` / `screw_undetermined` |
+| `cause` | why it failed: `crash`, `reader`, `indexing`, `timeout`, `lattice_halved`, `lattice_doubled`, `lattice_other`, `sym_under`, `sym_over`, `sym_screw`, `sym_other`, `false_lattice`; or `no_reference` / `no_input` / `reference_problem` / `screw_undetermined`; or, on a pass, `accepted_alternative` |
+| `accepted_alt`, `accepted_alt_why` | the alternative reference the answer matched and the reason the row accepts it, on a row that passed that way; null otherwise |
 | `reason` | one line for a human |
 | `sgno`, `sg`, `pg` / `sgno_ref`, `sg_ref`, `pg_ref` | space group number and name, and point group: ours (the data's own determination) / the reference's |
 | `sg_label` | the space group rugnux reported where `--model` put the model's enantiomorph on it, else null |
@@ -285,8 +301,9 @@ Every run writes the same report as Markdown and as a self-contained HTML page (
 SVG, no external files):
 
 - a header with the binary, build flags, host, subset, each arm's command and whether timing counts;
-- a **summary per arm** (pass / fail / unscored / not run, pass rate, median resolution gain, ISa,
-  R_meas, time) with a verdict bar chart, all from rugnux's own run;
+- a **summary per arm** (pass, of which accepted on an alternative reference / fail / unscored /
+  not run, pass rate, median resolution gain, ISa, R_meas, time) with a verdict bar chart, all
+  from rugnux's own run, and an **Accepted alternatives** section naming those rows and why;
 - a table **per population** (tags such as `cubic`, `cbf`, `lysozyme`) and the distributions of
   the main metrics;
 - plots per set (HTML only; hovering a point shows the set): d_min(rugnux) / d_min(reference)
@@ -377,6 +394,9 @@ whole range; the manifest keeps the rule used as `dmin_rule`.
   A reference measured by hand goes in `ref_override`, which `refs` leaves alone.
   A set whose reference is known to be wrong gets `"unscored": "<why>"`: it still runs, but
   scores `unscored` instead of pass or fail.
+  A set where two answers are both defensible gets
+  `"ref_alternatives": [{"sg": ..., "sgno": ..., "cell": [...], "why": "<reason>"}]` - the fields
+  given replace the reference's, the row passes on any of its references, and `why` is mandatory.
 - **Renamed data directories**: `battery.py remap --arm inhouse MAP.json --write`, where
   `MAP.json` is `{"old": "new"}` (renames the set and its directory) or
   `{"old id": {"id": "...", "input": "..."}}`. Each old id is recorded under `aliases` in the
diff --git a/tools/battery/open.json b/tools/battery/open.json
index 2770a8f21..dcbda7945 100644
--- a/tools/battery/open.json
+++ b/tools/battery/open.json
@@ -33,11 +33,11 @@
  {"id": "6oel", "input": "6oel/1449-8_3_001.img", "ref": {"sg": "F 41 3 2", "sgno": 210, "cell": [328.1, 328.1, 328.1, 90.0, 90.0, 90.0], "dmin": 3.1}, "tags": ["SMV", "cubic"], "tiers": {"smoke": "SMV reader (ADSC), cubic F4132"}},
  {"id": "6p8p", "input": "6p8p/14_12_1_0001.cbf", "ref": {"sg": "P 4", "sgno": 75, "cell": [97.525, 97.525, 60.134, 90.0, 90.0, 90.0], "dmin": 1.635}, "tags": ["cbf", "tetragonal"]},
  {"id": "6pb3", "input": "6pb3/14_16_1_000001.cbf", "ref": {"sg": "P 6", "sgno": 168, "cell": [100.436, 100.436, 48.86, 90.0, 90.0, 120.0], "dmin": 2.048}, "tags": ["cbf", "hexagonal"]},
- {"id": "6pxb", "input": "6pxb/TJB1_3_rachel_1_0001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [64.021, 64.021, 119.447, 90.0, 90.0, 120.0], "dmin": 1.747}, "unscored": "disputed and open in both directions - see unscored_why", "unscored_why": "our merge and POINTLESS (Laue confidence 0.999) both read point group 312 on these images where the deposition is P 32, the added two-folds correlate at or above the level of the 3-folds nobody disputes, and merging in P 32 1 2 lowers R_meas from 0.0716 to 0.0662 at twice the multiplicity. Against that, the deposited model's six chains pair under the added two-fold at 0.3-0.7 A, which is more than coordinate error at 1.75 A, and ZANUDA settles on a different trigonal supergroup (P 32 2 1) whose operators these data do not support (CC 0.18-0.47 against 0.75-0.99 for P 32 1 2's). Neither answer is established, so the set runs but is not scored. A perfect merohedral twin and true higher symmetry predict identical data, so pseudo-symmetry remains a live explanation either way", "tags": ["cbf", "trigonal"]},
+ {"id": "6pxb", "input": "6pxb/TJB1_3_rachel_1_0001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [64.021, 64.021, 119.447, 90.0, 90.0, 120.0], "dmin": 1.747}, "ref_alternatives": [{"sg": "P 31 1 2", "sgno": 151, "why": "Our merge and POINTLESS (Laue confidence 0.999) both read point group 312, the added two-folds correlate at or above the level of the three-folds nobody disputes, and merging in P 32 1 2 lowers R_meas from 0.0716 to 0.0662 at twice the multiplicity. Against that, the deposited model's six chains pair under the added two-fold at 0.3-0.7 A, which is more than coordinate error at 1.75 A, and ZANUDA settles on a different trigonal supergroup (P 32 2 1) whose operators these data do not support (CC 0.18-0.47 against 0.75-0.99 for P 32 1 2's). Neither answer is established in either direction, so both are accepted"}], "tags": ["cbf", "trigonal"]},
  {"id": "6pxc", "input": "6pxc/TJB6_1_Rachel_1_0001.cbf", "ref": {"sg": "I 2 2 2", "sgno": 23, "cell": [44.19, 64.827, 87.239, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6r72", "input": "6r72/V-CK63-8-ld_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [117.805, 110.754, 155.615, 90.0, 93.23, 90.0], "dmin": 3.95}, "pinned": true, "tags": ["h5", "monoclinic"]},
  {"id": "6rlr", "input": "6rlr/_b4_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [39.986, 39.998, 63.643, 80.39, 76.29, 68.15], "dmin": 2.0}, "tags": ["h5", "triclinic", "twin"]},
- {"id": "6toc", "input": "6toc/zenodo/dts_1_00001.cbf", "ref": {"sg": "P 42", "sgno": 77, "cell": [31.523, 31.523, 81.599, 90.0, 90.0, 90.0], "dmin": 1.853}, "ref_override": {"sg": "P 42 2 2", "sgno": 93}, "ref_override_why": "our merge and an independent POINTLESS run on the same P1 merge both read point group 422, and the deposited model's own two chains are related by the added two-fold to 0.16 A CA RMSD over 43 residues, which is coordinate error at 1.85 A. Merging in P 42 2 2 costs 0.0006 in R_meas for 1.75x the multiplicity and correlates better with the deposited model (0.9802 vs 0.9764 at 1.853 A). ZANUDA 1.097 refines P 42 2 2 to R-free 0.2561 against P 42's 0.2636 at half the parameters and calls the deposited assignment incorrect, but an independent refmac 5.8.0431 comparison on a symmetry-consistent free set puts P 42 ahead by 0.004-0.020 depending on cycle count, so the refinement test is NOT unanimous and its protocol spread exceeds the difference being measured. Pseudo-symmetry exact enough to escape every test we have remains a live explanation. The deposited cell and d_min are kept", "tags": ["cbf", "tetragonal", "twin"]},
+ {"id": "6toc", "input": "6toc/zenodo/dts_1_00001.cbf", "ref": {"sg": "P 42", "sgno": 77, "cell": [31.523, 31.523, 81.599, 90.0, 90.0, 90.0], "dmin": 1.853}, "ref_alternatives": [{"sg": "P 42 2 2", "sgno": 93, "why": "Our reduction and an independent POINTLESS run on our own P1 merge both read point group 422, and the deposited asymmetric unit's two chains are related by the very two-fold the higher group adds, to 0.16 A CA RMSD over 43 residues - coordinate error at 1.85 A. Merging in P 42 2 2 costs 0.0006 in R_meas for 1.75x the multiplicity and correlates better with the deposited model (0.9802 vs 0.9764). The refinement test is NOT unanimous: ZANUDA 1.097 refines P 42 2 2 to R-free 0.2561 against P 42's 0.2636 at half the parameters and reports the deposited assignment incorrect, while an independent Refmac 5.8.0431 comparison on a symmetry-consistent free set puts P 42 ahead by 0.004-0.020 depending on cycle count - less than the spread between refinement protocols. Neither answer is established: a pseudo-symmetry too exact for any test we have remains a live explanation, and so does the deposited assignment. Either is accepted"}], "tags": ["cbf", "tetragonal", "twin"]},
  {"id": "6ttn", "input": "6ttn/6ttn/data/H6H_33_01_hyo_full_1_0001.cbf", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [39.894, 79.841, 104.701, 90.0, 90.0, 90.0], "dmin": 1.12}, "tags": ["cbf", "orthorhombic"]},
  {"id": "6u7g", "input": "6u7g/6u7g/data/SNB02_11_8_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [99.555, 98.682, 147.525, 90.0, 104.6, 90.0], "dmin": 2.35}, "pinned": true, "tags": ["h5", "monoclinic"]},
  {"id": "6ukf", "input": "6ukf/6ukf/data/XDC-7_Pn6_000001.cbf", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [61.018, 37.317, 69.027, 90.0, 109.768, 90.0], "dmin": 1.0}, "tags": ["cbf", "monoclinic"]},
@@ -97,9 +97,9 @@
  {"id": "8u0i", "input": "8u0i/8u0i/data/dI-2-05a_4_00001.cbf", "ref": {"sg": "P 43 21 2", "sgno": 96, "cell": [50.317, 50.317, 90.596, 90.0, 90.0, 90.0], "dmin": 1.541}, "tags": ["cbf", "tetragonal"]},
  {"id": "8v4o", "input": "8v4o/CaalA_00629_a_FS11-AMP_8v4o/data/PSL-1602_2180_master.h5", "ref": {"sg": "P 61 2 2", "sgno": 178, "cell": [139.46, 139.46, 544.99, 90.0, 90.0, 120.0], "dmin": 2.7}, "tags": ["h5", "hexagonal"]},
  {"id": "8xbp", "input": "8xbp/8xbp/data/puck2872_3_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [148.29, 50.78, 60.21, 90.0, 92.33, 90.0], "dmin": 1.99}, "ref_override": {"cell": [148.736, 51.777, 60.181, 90.0, 92.36, 90.0]}, "ref_override_why": "the uploaded sweep is a different crystal from the one the deposited cell describes: master data_collection_date 2023-06-21, deposited _diffrn_detector.pdbx_collection_date 2023-06-23, and the deposited b = 50.78 is 2.0% from the b these images give. The override is the cell DIALS 3.29 indexes de novo on this master, b = 51.777(11); the deposited space group and d_min are kept", "tags": ["h5", "monoclinic"]},
- {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "ref_override": {"sg": "P 32 2 1", "sgno": 154}, "ref_override_why": "deposited P 32; this override predates the 8xbp and 6toc ones and was recorded here later. Our merge and POINTLESS both read point group 321, and the twin-immune centric zone of the added two-folds reads <|E^2-1|> = 0.946 +- 0.012 at +707.3 nats - essentially centric, which a merohedral twin law cannot produce. Re-refinement on a shared free set with the twin law removed from both sides gives P 32 2 1 0.2177/0.2322 against P 32 0.2460/0.2612, and the deposited entry's own R values reproduce only with an undeclared twin law h,-h-k,-l at alpha = 0.50, which is itself a 321-symmetric target. A perfect alpha = 0.5 merohedral twin and true 321 predict identical data, so no refinement R can close this; the case rests on the centric zone. The deposited cell and d_min are kept", "tags": ["cbf", "trigonal"]},
+ {"id": "8xte", "input": "8xte/1101/G2_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [208.77, 208.77, 67.22, 90.0, 90.0, 120.0], "dmin": 1.99}, "ref_alternatives": [{"sg": "P 31 2 1", "sgno": 152, "why": "The evidence favours the higher group here. The twin-immune centric zone of the added two-folds - reflections the higher group makes centric, which are their own twin mates and so cannot be made to read centric by a merohedral twin law - gives <|E^2-1|> = 0.946 +/- 0.012 against a centric expectation of 0.968 and an acentric 0.736, at +707 nats. Re-refinement on a shared free set with the twin law removed from both sides favours P 3_2 2 1 (0.2177/0.2322) over P 3_2 (0.2460/0.2612), and the deposited entry's published R values reproduce only with an undeclared twin law h,-h-k,-l at alpha = 0.50, which is itself a 321-symmetric target. No refinement R can close the question in principle, because a merohedral twin at exactly alpha = 0.5 and true 321 predict identical intensities; the case rests on the centric zone. Both answers are accepted, ours being the better supported"}], "tags": ["cbf", "trigonal"]},
  {"id": "8xtf", "input": "8xtf/1102/puck03_12_1_master.h5", "ref": {"sg": "H 3 2", "sgno": 155, "cell": [211.75, 211.75, 67.42, 90.0, 90.0, 120.0], "dmin": 2.13}, "tags": ["h5", "trigonal"]},
- {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "ref_override": {"sg": "P 32 2 1", "sgno": 154}, "ref_override_why": "deposited P 32; this override predates the 8xbp and 6toc ones and was recorded here later. THE CASE IS OPEN. Our merge and POINTLESS (0.85 on our own P1 merge) read point group 321, but the twin-immune centric zone of the added two-folds reads <|E^2-1|> = 0.869 at -44.9 nats - between the centric and acentric expectations and negative - so the one test we have that separates real symmetry from pseudo-symmetry argues AGAINST the promotion, and the L-test indicates a twin fraction near 0.20-0.26. Whether the crystal is partially twinned or purely pseudo-symmetric is not established. This row may belong unscored rather than overridden. The deposited cell and d_min are kept", "tags": ["cbf", "trigonal"]},
+ {"id": "8xtg", "input": "8xtg/1100/mpag15_1_00001.cbf", "ref": {"sg": "P 32", "sgno": 145, "cell": [199.54, 199.54, 67.15, 90.0, 90.0, 120.0], "dmin": 2.0}, "ref_alternatives": [{"sg": "P 31 2 1", "sgno": 152, "why": "The evidence favours the DEPOSITION here, and this row must not be read as the 8xte one. Every correlation-based instrument we have - our own operator correlations, POINTLESS (0.85 on our P1 merge) - reads point group 321, but our own twin-immune centric-zone test, the only one that separates real symmetry from pseudo-symmetry, reads <|E^2-1|> = 0.869 at -44.9 nats, between the two expectations and on the wrong side, i.e. AGAINST the promotion, with an L-test twin fraction of 0.20-0.26. Whether this crystal is partially twinned or purely pseudo-symmetric is not established. Both answers are accepted, the deposition being the better supported"}], "tags": ["cbf", "trigonal"]},
  {"id": "8y74", "input": "8y74/1_1/1_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [125.782, 76.553, 87.143, 90.0, 92.449, 90.0], "dmin": 1.9}, "tags": ["h5", "monoclinic"]},
  {"id": "8ys9", "input": "8ys9/8YS9_xray-data_8ys9/data/SDS_09_18112_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [71.04, 77.68, 83.16, 90.0, 90.0, 90.0], "dmin": 1.46}, "tags": ["h5", "orthorhombic"]},
  {"id": "9b22", "input": "9b22/KlpnC_20447_a_B1-AR6-AMP_9b22/data/PSL-1011_1580_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [39.826, 92.659, 57.716, 90.0, 91.68, 90.0], "dmin": 1.3}, "tags": ["h5", "monoclinic"]},
@@ -130,7 +130,7 @@
  {"id": "9q41", "input": "9q41/apoSPDS_1_master.h5", "ref": {"sg": "C 2 2 21", "sgno": 20, "cell": [118.568, 133.704, 82.369, 90.0, 90.0, 90.0], "dmin": 1.95}, "tags": ["h5", "orthorhombic"]},
  {"id": "9q66", "input": "9q66/PREP_JP417_D8a_12694_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [105.853, 67.294, 158.019, 90.0, 99.109, 90.0], "dmin": 2.01}, "tags": ["h5", "monoclinic"]},
  {"id": "9qw8", "input": "9qw8/MX-2555/run_03_datacollection [2023-09-08 22:19:51]/FKBP12BRD4-5519-6-BD1-PPU688_w1_1_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [35.648, 35.65, 100.919, 86.458, 84.218, 72.475], "dmin": 1.8}, "tags": ["h5", "triclinic"]},
- {"id": "9rci", "input": "9rci/FEN1-CD029134_A09-3_AD049A-10_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [35.869, 39.297, 100.916, 98.3, 90.32, 90.09], "dmin": 1.662}, "tags": ["h5", "triclinic", "tncs"]},
+ {"id": "9rci", "input": "9rci/FEN1-CD029134_A09-3_AD049A-10_1_master.h5", "ref": {"sg": "P 1", "sgno": 1, "cell": [35.869, 39.297, 100.916, 98.3, 90.32, 90.09], "dmin": 1.662}, "ref_alternatives": [{"cell": [35.869, 39.297, 199.976, 87.087, 90.341, 90.09], "why": "The deposited cell is the (0,1/2,1/2)-centred sublattice of the supercell we report, to 0.17%, and both descriptions of this lattice are defensible. The Patterson has an off-origin peak at 62.5% of the origin, so a real translational NCS relates the two halves of our cell: describing the crystal by the doubled cell with the near-translation left in the content, or by its sublattice with the near-translation absorbed into the lattice, is a choice, not a measurement. The alternative cell is the deposited one doubled along c with the centring removed (c' = b + 2c), computed from the deposited cell alone - not from our output"}], "tags": ["h5", "triclinic", "tncs"]},
  {"id": "9rcs", "input": "9rcs/760_B7_x1_1_master.h5", "ref": {"sg": "P 1 21 1", "sgno": 4, "cell": [70.01, 78.8, 82.34, 90.0, 88.64, 90.0], "dmin": 3.012}, "tags": ["h5", "monoclinic", "cdte"]},
  {"id": "9rp9", "input": "9rp9/data_9RP9/data/TAR148-TAR148_X2_1_master.h5", "ref": {"sg": "C 1 2 1", "sgno": 5, "cell": [73.48, 59.78, 91.67, 90.0, 100.85, 90.0], "dmin": 2.1}, "tags": ["h5", "monoclinic"]},
  {"id": "9sl0", "input": "9sl0/wt-1_9sl0/data/design-Yan-HLA-WT-1_1_5_1_master.h5", "ref": {"sg": "P 21 21 21", "sgno": 19, "cell": [60.181, 80.201, 111.589, 90.0, 90.0, 90.0], "dmin": 1.6}, "tags": ["h5", "orthorhombic"]},
diff --git a/tools/battery/render.py b/tools/battery/render.py
index f54d1fa30..e6c8e161a 100644
--- a/tools/battery/render.py
+++ b/tools/battery/render.py
@@ -125,13 +125,14 @@ class Doc:
 
 # ------------------------------------------------------------------ plots (inline SVG, no libraries)
 
-STATUS = {"pass": "var(--good)", "fail": "var(--critical)", "unscored": "var(--neutral)",
-          "not_run": "var(--warning)"}
+STATUS = {"pass": "var(--good)", "accepted_alt": "var(--series1)", "fail": "var(--critical)",
+          "unscored": "var(--neutral)", "not_run": "var(--warning)"}
 
 
 def verdict_bars(rows):
-    """One horizontal bar per arm, split pass / fail / unscored / not run.
-    rows: [(arm, {verdict: count})]."""
+    """One horizontal bar per arm, split pass / accepted alt / fail / unscored / not run.
+    rows: [(arm, {status: count})], where a status is a verdict, except that a pass carried by an
+    accepted alternative reference is counted on its own."""
     e = html.escape
     w, left, bar, gap = 900, 90, 22, 14
     h = 30 + len(rows) * (bar + gap)
@@ -141,7 +142,7 @@ def verdict_bars(rows):
     for v, col in STATUS.items():                         # legend, above the bars
         out.append(f'<rect x="{x}" y="4" width="10" height="10" rx="2" fill="{col}"/>'
                    f'<text x="{x + 14}" y="13">{v.replace("_", " ")}</text>')
-        x += 90
+        x += 100
     for i, (arm, cnt) in enumerate(rows):
         y = 26 + i * (bar + gap)
         out.append(f'<text x="0" y="{y + bar / 2 + 4}">{e(arm)}</text>')
diff --git a/tools/battery/report.py b/tools/battery/report.py
index 724d0e6a2..aef3ddd89 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -246,6 +246,13 @@ def scored(rs):
     return [r for r in rs if r["verdict"] in ("pass", "fail")]
 
 
+def status(r):
+    """The verdict, except that a pass carried by an accepted alternative reference (score.py,
+    `alternatives`) is counted on its own, so a reader sees how many rows the battery passed on a
+    second acceptable answer rather than on the deposition."""
+    return "accepted_alt" if r.get("cause") == "accepted_alternative" else r["verdict"]
+
+
 def rate(rs):
     s = scored(rs)
     n = sum(r["verdict"] == "pass" for r in s)
@@ -284,24 +291,29 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     order = {arm: i for i, arm in enumerate(arms)}
 
     doc.h(2, "Summary")
-    head = ["arm", "sets", "pass", "fail", "unscored", "not run", "pass rate",
+    head = ["arm", "sets", "pass", "of which alt", "fail", "unscored", "not run", "pass rate",
             "median res. gain", "median ISa", "median R_meas", "median time s", "total time min"]
     rows = []
     for arm in arms:
         rs = [r for r in res if r["arm"] == arm]
         cnt = {x: sum(r["verdict"] == x for r in rs) for x in ("pass", "fail", "unscored", "not_run")}
+        cnt["accepted_alt"] = sum(status(r) == "accepted_alt" for r in rs)
         xs = crystals(rs)
-        rows.append([arm, len(rs), cnt["pass"], cnt["fail"], cnt["unscored"], cnt["not_run"], rate(rs),
+        rows.append([arm, len(rs), cnt["pass"], cnt["accepted_alt"], cnt["fail"], cnt["unscored"],
+                     cnt["not_run"], rate(rs),
                      f(median(r.get("res_gain_pct") for r in xs), "{:+.1f}%"),
                      f(median(r.get("isa") for r in xs), "{:.1f}"),
                      pct(median(r.get("r_meas") for r in xs)),
                      f(median(r.get("wall_s") for r in rs), "{:.0f}"),
                      f(sum(r.get("wall_s") or 0 for r in rs) / 60, "{:.1f}")])
-    doc.table(head, rows, num=range(1, 12))
-    doc.svg(verdict_bars([(arm, {x: sum(r["verdict"] == x and r["arm"] == arm for r in res)
-                                 for x in ("pass", "fail", "unscored", "not_run")})
+    doc.table(head, rows, num=range(1, 13))
+    doc.svg(verdict_bars([(arm, {x: sum(status(r) == x and r["arm"] == arm for r in res)
+                                 for x in ("pass", "accepted_alt", "fail", "unscored", "not_run")})
                           for arm in arms]), "verdicts per arm")
-    doc.p("Pass rate is over the scored sets (pass + fail). Every number in this table is rugnux's own "
+    doc.p("Pass rate is over the scored sets (pass + fail). `of which alt` counts the passes that "
+          "are already in `pass`: rows where the answer matched an accepted alternative reference "
+          "rather than the deposition, listed under Accepted alternatives below. In the bar chart "
+          "they are drawn as their own segment. Every number in this table is rugnux's own "
           "run at its own resolution cut: what a user gets. Resolution gain is (reference d_min - our "
           "d_min) / reference d_min: positive = finer than the deposition, or than XDS. Medians leave "
           "out the no-crystal controls. R_meas and CC1/2 are pooled over each run's own resolution "
@@ -429,6 +441,18 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     if other:
         doc.p("Not scored: " + "; ".join(f"{r['set']} ({r['reason']})" for r in other))
 
+    alt = [r for r in res if status(r) == "accepted_alt"]
+    if alt:
+        doc.h(3, "Accepted alternatives")
+        doc.p(f"{len(alt)} of the passes above are rows that accept more than one reference: the "
+              "deposition and our reduction disagree, the disagreement is real, and no test "
+              "available to us settles it, so either answer passes as long as the program picks "
+              "one of them. These are open questions, not errors attributed to the deposition; "
+              "the manifest's `ref` keeps the deposited values verbatim in every one of them.")
+        doc.ul(f"{r['set']} ({r['arm']}): we report {r.get('sg') or '-'}, the reference is "
+               f"{r.get('sg_ref') or '-'}; accepted as {r['accepted_alt']}. {r['accepted_alt_why']}"
+               for r in sorted(alt, key=lambda r: (r["arm"], r["set"])))
+
     doc.h(3, "Per set")
     doc.p("Space group: on the open arm the data's own determination. Where --model put the model's "
           "enantiomorph on the label, the label is in the note and the group scored is the search's.")
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 6f494bb65..d033a7239 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -4,6 +4,10 @@ One dataset, one verdict, one cause, decided in this order: did it run -> is the
 is the symmetry right. Data quality is not scored: it is reported for a human to judge. The order matters:
 a halved axis also makes the screw along it unobservable, and counting that row twice would hide
 the defect that cost the reflections.
+
+A row may accept more than one reference (`ref_alternatives`, see `alternatives`): where two
+descriptions of the same crystal are both defensible and nothing available to us decides between
+them, either answer passes, and the report says which rows those are.
 """
 import itertools
 import os
@@ -131,12 +135,46 @@ def sg_name(sgno):
     return gemmi.find_spacegroup_by_number(int(sgno)).hm if sgno else None
 
 
+def alternatives(entry):
+    """The other answers a row accepts, from its `ref_alternatives`.
+
+    A knife-edge row - one where the deposition and our reduction disagree, the disagreement is
+    real, and no test available to us settles it - says so here instead of being quietly overridden
+    to our answer or dropped from scoring. Each alternative replaces the reference fields it names
+    (a space group, a cell, or both) and the row passes if our answer matches ANY of the
+    references, the deposited one included. `ref` keeps the deposition verbatim either way.
+
+    Every alternative must carry `why`: a reason a reader can check. Without one this would be a
+    way to launder a failure into a pass, so it is a schema error, not a silent pass."""
+    out = []
+    for i, alt in enumerate(entry.get("ref_alternatives") or []):
+        where = f"{entry.get('id', '?')}: ref_alternatives[{i}]"
+        if not (alt.get("why") or "").strip():
+            raise ValueError(f"{where} has no 'why'; an accepted alternative must state why both "
+                             "answers are acceptable")
+        if not set(alt) & {"sg", "sgno", "cell"}:
+            raise ValueError(f"{where} replaces nothing; give the sg, the cell, or both")
+        out.append(alt)
+    return out
+
+
+def alt_label(alt):
+    """How an accepted alternative is named in one line: its space group, its cell, or both."""
+    bits = []
+    if alt.get("sg") or alt.get("sgno"):
+        bits.append(alt.get("sg") or sg_name(alt["sgno"]))
+    if alt.get("cell"):
+        bits.append("cell " + " ".join(f"{x:g}" for x in alt["cell"][:3]))
+    return ", ".join(bits)
+
+
 def judge(entry, rep, run_note):
     """Score one set. entry is its manifest row (with 'ref'), rep its parsed report, run_note
     what the runner saw ('', 'timeout', 'exit N: message', 'no input')."""
     ref = dict(entry.get("ref") or {})
     if entry.get("ref_override"):          # a reference measured by hand, replacing the file's
         ref.update(entry["ref_override"])
+    alts = alternatives(entry)             # raises on a row that accepts an answer for no reason
     r = {
         "sgno": None, "sg": None, "pg": None,
         "sgno_ref": ref.get("sgno"), "sg_ref": ref.get("sg") or sg_name(ref.get("sgno")),
@@ -156,7 +194,7 @@ def judge(entry, rep, run_note):
         # on rugnux's own free set, so a trend number, not the depositor's R-free
         "rfree": fnum(rep.get("R_FREE")), "rwork": fnum(rep.get("R_WORK")),
         "model_fit": rep.get("MODEL_FIT"), "cc_model": fnum(rep.get("CC_MODEL_OVERALL")),
-        "sg_label": None,
+        "sg_label": None, "accepted_alt": None, "accepted_alt_why": None,
     }
     # the same merge binned over the reference's range (--report-resolution, XDS arms)
     r.update({k: fnum(rep.get(k.upper())) for k in REFRES_KEYS})
@@ -220,30 +258,37 @@ def judge(entry, rep, run_note):
     if entry.get("unscored"):              # a reference known to be wrong: run, but do not score
         return verdict("unscored", "reference_problem", entry["unscored"])
 
-    vr, edge = lattice_match(r["cell"], space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
-                             ref["cell"], space_group(ref.get("sg"), ref["sgno"]))
-    r["volume_ratio"] = round(vr, 4)
-    if not (0.95 < vr < 1.05 and edge < 0.02):
-        if 0.45 <= vr <= 0.55:
-            return verdict("fail", "lattice_halved", f"primitive volume ratio {vr:.2f}")
-        if 1.9 <= vr <= 2.1:
-            return verdict("fail", "lattice_doubled", f"primitive volume ratio {vr:.2f}")
-        return verdict("fail", "lattice_other",
+    def against(cand):
+        """Score the answer against one reference: (the numbers it yields, None) if that reference
+        accepts the answer, (the numbers, (verdict, cause, reason)) if it does not."""
+        n = {"volume_ratio": None, "sg_relation": None}
+        vr, edge = lattice_match(r["cell"], space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
+                                 cand["cell"], space_group(cand.get("sg"), cand["sgno"]))
+        n["volume_ratio"] = round(vr, 4)
+        if not (0.95 < vr < 1.05 and edge < 0.02):
+            if 0.45 <= vr <= 0.55:
+                return n, ("fail", "lattice_halved", f"primitive volume ratio {vr:.2f}")
+            if 1.9 <= vr <= 2.1:
+                return n, ("fail", "lattice_doubled", f"primitive volume ratio {vr:.2f}")
+            return n, ("fail", "lattice_other",
                        f"primitive volume ratio {vr:.2f}, reduced edges off by {edge:.1%}")
 
-    # XDS never tests a screw axis, so against an XDS reference only the point group can be
-    # judged - unless the group was measured by hand (sg_measured).
-    by_sg = entry["arm"] == "open" or ref.get("sg_measured")
-    if by_sg:
-        rel = sgequiv.describe(ref["sgno"], r["sgno"])
-        r["sg_relation"] = rel
-        ok = rel in ("match", "hand only (needs anomalous)", "UNDECIDABLE from intensities")
-    else:
-        ok = r["pg"] == r["pg_ref"]
-    if not ok:
+        # XDS never tests a screw axis, so against an XDS reference only the point group can be
+        # judged - unless the group was measured by hand (sg_measured).
+        by_sg = entry["arm"] == "open" or cand.get("sg_measured")
+        pg_cand = point_group(cand["sgno"])
+        if by_sg:
+            rel = sgequiv.describe(cand["sgno"], r["sgno"])
+            n["sg_relation"] = rel
+            ok = rel in ("match", "hand only (needs anomalous)", "UNDECIDABLE from intensities")
+        else:
+            ok = r["pg"] == pg_cand
+        if ok:
+            return n, None
+        sg_cand = cand.get("sg") or sg_name(cand["sgno"])
         order = len(gemmi.find_spacegroup_by_number(r["sgno"]).operations().sym_ops)
-        order_ref = len(gemmi.find_spacegroup_by_number(ref["sgno"]).operations().sym_ops)
-        if r["pg"] == r["pg_ref"]:
+        order_ref = len(gemmi.find_spacegroup_by_number(cand["sgno"]).operations().sym_ops)
+        if r["pg"] == pg_cand:
             # A screw the data never tested is not a wrong answer, it is an unanswerable question:
             # the axial row it lives on was not recorded at all (the spindle's blind cone), so the
             # run offers every member of the set as an alternative and writes the one claiming no
@@ -257,17 +302,30 @@ def judge(entry, rep, run_note):
             offered = [gemmi.find_spacegroup_by_name(x.strip())
                        for x in (rep.get("SPACE_GROUP_ALTERNATIVES") or "").split("|")]
             differ = screw_axes_differing(space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
-                                          space_group(ref.get("sg"), ref["sgno"]))
+                                          space_group(cand.get("sg"), cand["sgno"]))
             if (undetermined != {"NONE"} and differ and differ <= undetermined
-                    and any(o and o.number == ref["sgno"] for o in offered)):
-                return verdict("unscored", "screw_undetermined",
-                               f"{r['sg']} vs reference {r['sg_ref']}: the screw along "
-                               f"{', '.join(sorted(differ))} is undeterminable from these data "
-                               f"(offered {rep.get('SPACE_GROUP_ALTERNATIVES')})")
-            return verdict("fail", "sym_screw", f"{r['sg']} vs reference {r['sg_ref']}")
+                    and any(o and o.number == cand["sgno"] for o in offered)):
+                return n, ("unscored", "screw_undetermined",
+                           f"{r['sg']} vs reference {sg_cand}: the screw along "
+                           f"{', '.join(sorted(differ))} is undeterminable from these data "
+                           f"(offered {rep.get('SPACE_GROUP_ALTERNATIVES')})")
+            return n, ("fail", "sym_screw", f"{r['sg']} vs reference {sg_cand}")
         cause = ("sym_under" if order < order_ref else
                  "sym_over" if order > order_ref else "sym_other")
-        return verdict("fail", cause, f"{r['sg']} vs reference {r['sg_ref']}")
+        return n, ("fail", cause, f"{r['sg']} vs reference {sg_cand}")
+
+    # The deposition (with any ref_override) decides, and its numbers are the ones reported: an
+    # accepted alternative changes the verdict, never what the row says about the deposition.
+    numbers, problem = against(ref)
+    r.update(numbers)
+    for alt in (alts if problem and problem[0] == "fail" else []):
+        if against(dict(ref, **{k: v for k, v in alt.items() if k != "why"}))[1] is None:
+            r["accepted_alt"], r["accepted_alt_why"] = alt_label(alt), alt["why"]
+            return verdict("pass", "accepted_alternative",
+                           f"{r['sg']} vs reference {r['sg_ref']}: accepted alternative "
+                           f"{r['accepted_alt']} - a knife-edge this battery does not decide")
+    if problem:
+        return verdict(*problem)
 
     # Data quality (CC1/2, R_meas, resolution, ISa) is reported, never scored: that is for a human.
     note = ""
diff --git a/tools/battery/test_score.py b/tools/battery/test_score.py
new file mode 100644
index 000000000..79d5d2e76
--- /dev/null
+++ b/tools/battery/test_score.py
@@ -0,0 +1,97 @@
+"""Targeted tests of score.py, the part a wrong answer would be laundered through.
+
+Plain stdlib unittest, so it runs with `python3 tools/battery/test_score.py` (or
+`python3 -m unittest`) from this directory, without pytest and without a battery run.
+"""
+import unittest
+
+import score
+
+
+def report(sg, sgno, cell, **extra):
+    """The three report keys the scorer needs, plus whatever a case adds."""
+    return dict({"SPACE_GROUP_NAME": sg, "SPACE_GROUP_NUMBER": str(sgno),
+                 "UNIT_CELL_CONSTANTS": " ".join(f"{x:.3f}" for x in cell)}, **extra)
+
+
+# A deposited trigonal reference and the higher group our reduction reads on it: the shape of
+# the accepted-alternative rows, with a synthetic cell, not a real one.
+TRIGONAL = [80.0, 80.0, 150.0, 90.0, 90.0, 120.0]
+DEPOSITED = {"sg": "P 32", "sgno": 145, "cell": TRIGONAL, "dmin": 2.0}
+
+
+def entry(**extra):
+    return dict({"id": "test_set", "arm": "open", "ref": DEPOSITED}, **extra)
+
+
+class AcceptedAlternatives(unittest.TestCase):
+    def test_deposition_still_decides_on_its_own(self):
+        """Without alternatives the higher group is a symmetry failure, as before."""
+        r = score.judge(entry(), report("P 31 2 1", 152, TRIGONAL), "")
+        self.assertEqual((r["verdict"], r["cause"]), ("fail", "sym_over"))
+
+    def test_either_answer_passes(self):
+        """Both the deposited group and the alternative pass, and only the second is marked."""
+        e = entry(ref_alternatives=[{"sg": "P 31 2 1", "sgno": 152, "why": "a stated reason"}])
+        dep = score.judge(e, report("P 32", 145, TRIGONAL), "")
+        self.assertEqual((dep["verdict"], dep["cause"], dep["accepted_alt"]), ("pass", None, None))
+        alt = score.judge(e, report("P 31 2 1", 152, TRIGONAL), "")
+        self.assertEqual((alt["verdict"], alt["cause"]), ("pass", "accepted_alternative"))
+        self.assertEqual(alt["accepted_alt"], "P 31 2 1")
+        self.assertIn("a stated reason", alt["accepted_alt_why"])
+        # the row still describes the answer against the DEPOSITION, not against the alternative
+        self.assertEqual(alt["sg_ref"], "P 32")
+
+    def test_the_other_hand_of_an_alternative_passes_too(self):
+        """P 31 2 1 and P 32 2 1 differ by hand only, which intensities cannot decide."""
+        e = entry(ref_alternatives=[{"sg": "P 31 2 1", "sgno": 152, "why": "a stated reason"}])
+        r = score.judge(e, report("P 32 2 1", 154, TRIGONAL), "")
+        self.assertEqual((r["verdict"], r["cause"]), ("pass", "accepted_alternative"))
+
+    def test_a_third_answer_still_fails(self):
+        """An alternative accepts one other answer, not any other answer."""
+        e = entry(ref_alternatives=[{"sg": "P 31 2 1", "sgno": 152, "why": "a stated reason"}])
+        r = score.judge(e, report("P 31 1 2", 151, TRIGONAL), "")
+        self.assertEqual(r["verdict"], "fail")
+
+    def test_alternative_cell(self):
+        """A supercell alternative: the deposited cell is its (0,1/2,1/2) sublattice, so the
+        deposition alone scores the answer as a doubled lattice and the alternative accepts it."""
+        sub = [35.869, 39.297, 100.916, 98.3, 90.32, 90.09]
+        sup = [35.869, 39.297, 199.976, 87.087, 90.341, 90.09]      # c' = b + 2c, centring removed
+        e = {"id": "test_cell", "arm": "open", "ref": {"sg": "P 1", "sgno": 1, "cell": sub}}
+        r = score.judge(e, report("P 1", 1, sup), "")
+        self.assertEqual((r["verdict"], r["cause"]), ("fail", "lattice_doubled"))
+        e["ref_alternatives"] = [{"cell": sup, "why": "a stated reason"}]
+        r = score.judge(e, report("P 1", 1, sup), "")
+        self.assertEqual((r["verdict"], r["cause"]), ("pass", "accepted_alternative"))
+        self.assertTrue(r["accepted_alt"].startswith("cell "))
+        self.assertEqual(r["volume_ratio"], 2.0)      # still reported against the deposition
+
+    def test_a_justification_is_mandatory(self):
+        """An accepted alternative with no reason is a schema error, not a silent pass: this is
+        the check that keeps the mechanism from becoming a way to launder a failure."""
+        for alt in ({"sg": "P 31 2 1", "sgno": 152},
+                    {"sg": "P 31 2 1", "sgno": 152, "why": "  "}):
+            with self.assertRaises(ValueError) as cm:
+                score.judge(entry(ref_alternatives=[alt]), report("P 31 2 1", 152, TRIGONAL), "")
+            self.assertIn("why", str(cm.exception))
+
+    def test_an_alternative_must_replace_something(self):
+        with self.assertRaises(ValueError):
+            score.judge(entry(ref_alternatives=[{"why": "a stated reason"}]),
+                        report("P 32", 145, TRIGONAL), "")
+
+    def test_the_manifest_rows_are_valid(self):
+        """Every committed row's alternatives pass the schema check."""
+        import json
+        import os
+        for name in ("open.json", "inhouse.json"):
+            path = os.path.join(os.path.dirname(os.path.abspath(__file__)), name)
+            with open(path) as f:
+                for e in json.load(f)["sets"]:
+                    score.alternatives(e)
+
+
+if __name__ == "__main__":
+    unittest.main()
-- 
2.54.0


From 20326af6b64107da21d2c9b3fb0591b67d322626 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:29:14 +0200
Subject: [PATCH 088/122] docs: the rc.172 changelog

Four lines for 118 commits: the broker GPU-memory leak that cancelled
collections, the rotation scaling loop now running to convergence (which
moves merged intensities and every decision read off them), the
per-frame sweep placement that makes gapped and angle-wrapped CCD/CBF
series read correctly, and the two diagnostic files a rotation run now
writes without being asked.

Left out deliberately, as developer-facing or niche: -A no longer
changing what a rotation run decides, --report-resolution, the R-free
holohedry keying, the mmCIF twin loop, and every internal refactor.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md
index 7a7d86dc4..aae489881 100644
--- a/docs/CHANGELOG.md
+++ b/docs/CHANGELOG.md
@@ -4,6 +4,9 @@
 ### 1.0.0-rc.172
 
 * Fixed `jfjoch_broker` cancelling every data collection with a CUDA "out of memory" error after long operation: GPU memory no longer leaks with each collection.
+* Rugnux scales a rotation sweep until the per-frame scales settle instead of for a fixed three rounds, and says so when they did not - merged intensities, and the space group, resolution cut and frame rejection read off them, change accordingly; `--scaling-iterations` is now the cap on that loop (default 100).
+* Rugnux places every frame of a marCCD, SMV or miniCBF series at the spindle angle its own header states, so a series with missing frames, or with angles written modulo 360, is no longer read at the wrong geometry or refused.
+* Every rotation run writes two diagnostic files beside its reflections: `<prefix>_detector.jpg`, the detector projection with the pixel mask and the detected beam-stop shadow drawn on it, and `<prefix>_plot.txt`, one row per image.
 
 ### 1.0.0-rc.171
 
-- 
2.54.0


From e61454a27bebe78d42d7a2cdc0332e3a5be144fe Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:40:33 +0200
Subject: [PATCH 089/122] Three defects found by code review

The twin-law report block dereferenced the adopted space group without the
guard every other use of it carries; a de-novo run whose search refused a
point group but left no adopted group would crash there, after the merge.

The joint post-refinement's distance-correlation array was read on every run
that holds the header distance, but only written when the solve is usable, so
an unusable first solve printed four indeterminate values as correlations.

The merge-degradation gate ran neither of its two branches when the data
confirm more than one operator and the best of them is itself close to the
random-pairing end: the contrast has no scale to read on such a merge, but the
candidate was then promoted on no merge-degradation evidence at all. It now
falls back to the noise-floor ratio, as it does when only one operator is
confirmed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/geom_refinement/PostRefine.cpp   |  3 ++-
 image_analysis/scale_merge/SearchSpaceGroup.cpp | 11 ++++++-----
 rugnux/Rugnux.cpp                               |  3 ++-
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/image_analysis/geom_refinement/PostRefine.cpp b/image_analysis/geom_refinement/PostRefine.cpp
index 6bf0dc2cc..a2fc800f0 100644
--- a/image_analysis/geom_refinement/PostRefine.cpp
+++ b/image_analysis/geom_refinement/PostRefine.cpp
@@ -666,7 +666,8 @@ PostRefineResult PostRefineRotationGeometry(PostRefineObservations observations,
                 for (int j = 0; j < 3; ++j) {
                     rv_f[j] = ax0[j]; q0_f[j] = p0_0[j]; q1_f[j] = p1_0[j]; q2_f[j] = p2_0[j];
                 }
-                double distance_corr[4];
+                // Only written when the joint solve is usable, and read unconditionally below.
+                double distance_corr[4] = {NAN, NAN, NAN, NAN};
                 bool convJ = solve_joint(FIT, /*wide=*/true, /*fix_distance=*/false, bm_f, ds_f, rv_f,
                                          q0_f, q1_f, q2_f, distance_corr);
                 double exc_ref_se = NAN;
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index f180daa6c..df62dfde0 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -1645,9 +1645,11 @@ SearchSpaceGroupResult SearchSpaceGroup(
         //     the crystal itself defines: the best-agreeing operator anywhere at one end, unrelated
         //     reflections (random_pairing_r) at the other. A genuine operator sits at the clean end,
         //     a false one at the random end (see min_operator_r_contrast).
-        //   - The first step out of P1, where only one operator is confirmed at all, has no other
-        //     operator to be the clean end - fall back to the merge's own random-noise R floor
-        //     (max_operator_r_over_floor).
+        //   - Where there is no clean end to measure from - the first step out of P1, where only one
+        //     operator is confirmed at all, and the merge whose best operator is itself close to the
+        //     random end - fall back to the merge's own random-noise R floor
+        //     (max_operator_r_over_floor). The contrast has no scale to read on those, but leaving
+        //     the candidate ungated would promote it on no merge-degradation evidence at all.
         bool r_refused = false;
         double r_gate_value = std::numeric_limits<double>::quiet_NaN();
         if (std::isfinite(c.r_added)) {
@@ -1657,8 +1659,7 @@ SearchSpaceGroupResult SearchSpaceGroup(
                 r_gate_value = (result.random_pairing_r - c.r_added)
                                / (result.random_pairing_r - global_best_r);
                 r_refused = r_gate_value < opt.min_operator_r_contrast;
-            } else if (n_confirmed_ops < 2
-                       && std::isfinite(result.merge_r_floor) && result.merge_r_floor > 0.0) {
+            } else if (std::isfinite(result.merge_r_floor) && result.merge_r_floor > 0.0) {
                 r_gate_value = c.r_added / result.merge_r_floor;
                 r_refused = r_gate_value > opt.max_operator_r_over_floor;
             }
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 0efca9fa0..10a46f362 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6922,7 +6922,8 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             result.twinning.laue_class_was_chosen_by_promotion = promoted_point_group;
             // A refusal that stood on the twin-immune zone names the law: the first operator the
             // refused group adds, at the fraction its own disagreement implies (a lower bound).
-            if (result.space_group_search && result.space_group_search->refused_point_group_representative
+            if (twin_sg && result.space_group_search
+                && result.space_group_search->refused_point_group_representative
                 && result.twin_zone_decision.find("acentric, the added") != std::string::npos) {
                 const auto &sgs = *result.space_group_search;
                 const gemmi::GroupOps hi = sgs.refused_point_group_representative->operations();
-- 
2.54.0


From ae19223549e64190e36dc6be9a107d3580dbb6f2 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:56:42 +0200
Subject: [PATCH 090/122] battery: judge an undetermined screw in our own axes

The screw_undetermined rule compared the axial rows of our answer with those of
the reference as deposited. Which axis carries the disagreement is a property of
the setting, so where the two cells are a permutation of each other the rule
looked at one axis and SPACE_GROUP_SCREW_UNDETERMINED named another, and a row
whose open screw the run had explicitly declined to decide was scored as a wrong
space group. The comparison now runs against the offered alternative of the
reference's number, which is already written in our axes; a group offered under
more than one setting fires if any of them fits.

Verdicts moved on 7mzt only (fail/sym_screw -> unscored/screw_undetermined) in
both persisted runs re-scored; no other row changed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/score.py      | 25 ++++++++++++-------
 tools/battery/test_score.py | 48 +++++++++++++++++++++++++++++++++++++
 2 files changed, 65 insertions(+), 8 deletions(-)

diff --git a/tools/battery/score.py b/tools/battery/score.py
index d033a7239..6d213c039 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -298,17 +298,26 @@ def judge(entry, rep, run_note):
             # the reference is among the groups it offered, and the ONLY axis the two differ on is
             # one it named. A screw called wrongly where the row WAS measured meets none of them
             # and stays a failure.
+            # WHICH axis carries the disagreement is a property of the setting, and the two sides
+            # are named in different ones: the reference in the deposition's axis labels, ours - and
+            # SPACE_GROUP_SCREW_UNDETERMINED with it - in our own. Where the cells are a permutation
+            # of each other the two never meet: a deposited P 21 21 2 differs from our P 21 21 21 on
+            # c, while the same group written in our axes differs on b, the axis actually left open.
+            # So the axes are compared against the offered group, which is already in our setting;
+            # the reference being among the offered is a condition anyway, and a group offered under
+            # more than one setting passes if any of them fits.
             undetermined = set((rep.get("SPACE_GROUP_SCREW_UNDETERMINED") or "NONE").split())
             offered = [gemmi.find_spacegroup_by_name(x.strip())
                        for x in (rep.get("SPACE_GROUP_ALTERNATIVES") or "").split("|")]
-            differ = screw_axes_differing(space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"]),
-                                          space_group(cand.get("sg"), cand["sgno"]))
-            if (undetermined != {"NONE"} and differ and differ <= undetermined
-                    and any(o and o.number == cand["sgno"] for o in offered)):
-                return n, ("unscored", "screw_undetermined",
-                           f"{r['sg']} vs reference {sg_cand}: the screw along "
-                           f"{', '.join(sorted(differ))} is undeterminable from these data "
-                           f"(offered {rep.get('SPACE_GROUP_ALTERNATIVES')})")
+            ours = space_group(rep.get("SPACE_GROUP_NAME"), r["sgno"])
+            for o in (x for x in offered if x and x.number == cand["sgno"]):
+                differ = screw_axes_differing(ours, o)
+                if undetermined != {"NONE"} and differ and differ <= undetermined:
+                    here = f" (here {o.hm})" if o.hm != sg_cand else ""
+                    return n, ("unscored", "screw_undetermined",
+                               f"{r['sg']} vs reference {sg_cand}{here}: the screw along "
+                               f"{', '.join(sorted(differ))} is undeterminable from these data "
+                               f"(offered {rep.get('SPACE_GROUP_ALTERNATIVES')})")
             return n, ("fail", "sym_screw", f"{r['sg']} vs reference {sg_cand}")
         cause = ("sym_under" if order < order_ref else
                  "sym_over" if order > order_ref else "sym_other")
diff --git a/tools/battery/test_score.py b/tools/battery/test_score.py
index 79d5d2e76..51898bc8a 100644
--- a/tools/battery/test_score.py
+++ b/tools/battery/test_score.py
@@ -93,5 +93,53 @@ class AcceptedAlternatives(unittest.TestCase):
                     score.alternatives(e)
 
 
+# A screw along an axis the sweep never recorded: an unanswerable question, not a wrong answer.
+# The cells are synthetic, and the second is the first cyclically permuted.
+ORTHO = [97.0, 108.0, 113.0, 90.0, 90.0, 90.0]
+ORTHO_PERMUTED = [113.0, 97.0, 108.0, 90.0, 90.0, 90.0]
+
+
+class ScrewUndetermined(unittest.TestCase):
+    def judge(self, ref_cell, undetermined, alternatives):
+        """Our P 21 21 21 on ORTHO against a deposited P 21 21 2 on ref_cell."""
+        e = {"id": "test_screw", "arm": "open",
+             "ref": {"sg": "P 21 21 2", "sgno": 18, "cell": ref_cell}}
+        return score.judge(e, report("P 21 21 21", 19, ORTHO,
+                                     SPACE_GROUP_SCREW_UNDETERMINED=undetermined,
+                                     SPACE_GROUP_ALTERNATIVES=alternatives), "")
+
+    def test_same_setting(self):
+        """The plain case: the reference is offered verbatim and the open axis is the one they
+        differ on."""
+        r = self.judge(ORTHO, "c", "P 21 21 2")
+        self.assertEqual((r["verdict"], r["cause"]), ("unscored", "screw_undetermined"))
+
+    def test_permuted_setting(self):
+        """The deposition's axes are a cyclic permutation of ours, so it names the open screw c
+        while we name it b. The comparison must be made in OUR setting - against the offered
+        group of the reference's number - or the rule misses a row it covers."""
+        r = self.judge(ORTHO_PERMUTED, "b", "P 21 2 21")
+        self.assertEqual((r["verdict"], r["cause"]), ("unscored", "screw_undetermined"))
+        self.assertIn("the screw along b", r["reason"])
+
+    def test_a_wrong_screw_still_fails(self):
+        """The open axis is not the axis the two differ on: in our own setting the disagreement
+        sits on b while the run says it could not determine a, so the b row WAS measured. That is
+        a wrong answer and stays one - the new framing must not turn every permutation into an
+        excuse."""
+        r = self.judge(ORTHO_PERMUTED, "a", "P 21 2 21")
+        self.assertEqual((r["verdict"], r["cause"]), ("fail", "sym_screw"))
+
+    def test_nothing_undetermined_still_fails(self):
+        """Every axial row measured: no rule to apply."""
+        r = self.judge(ORTHO, "NONE", "")
+        self.assertEqual((r["verdict"], r["cause"]), ("fail", "sym_screw"))
+
+    def test_the_reference_must_be_among_the_offered(self):
+        """An open axis alone does not excuse a group the run never offered."""
+        r = self.judge(ORTHO, "b", "P 21 21 21")
+        self.assertEqual((r["verdict"], r["cause"]), ("fail", "sym_screw"))
+
+
 if __name__ == "__main__":
     unittest.main()
-- 
2.54.0


From a6c21bd84aee0db2ed54546481d6e70015dff8d2 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:58:09 +0200
Subject: [PATCH 091/122] Carry the twin-immune zone verdict as a value, not as
 report text

The report decided whether to name a twin law by substring-matching
ProcessResult::twin_zone_decision, a field every zone read overwrites.
A run reads the zone up to four times, so the match saw the last
comparison made rather than the refusal that stood, and TWIN_LAW and the
_pdbx_reflns_twin mmCIF loop could appear on a crystal whose refusal was
overturned - or be missing on one whose refusal stood.

TwinZoneVerdict already returns the verdict; it now records it on the
result, and the decision point reads that.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 7 ++++++-
 rugnux/Rugnux.h   | 6 ++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 10a46f362..bfa6def4f 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1785,6 +1785,11 @@ namespace {
                 z.tncs_normalised ? ", normalised per pseudo-translation class" : "",
                 verdict < 0 ? "acentric, the added operators are a twin law or a pseudo-symmetry"
                 : verdict > 0 ? "centric, the added operators are real" : "undecided");
+        // The verdict as a VALUE, for the report to act on. Every caller acts on a decisive read -
+        // the refusal stands or it is overturned - so recording it here records the decision, where
+        // matching on the text records only the last comparison the run happened to make.
+        if (verdict != 0)
+            result.twin_zone_refusal_stood = verdict < 0;
         return verdict;
     }
 
@@ -6924,7 +6929,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // refused group adds, at the fraction its own disagreement implies (a lower bound).
             if (twin_sg && result.space_group_search
                 && result.space_group_search->refused_point_group_representative
-                && result.twin_zone_decision.find("acentric, the added") != std::string::npos) {
+                && result.twin_zone_refusal_stood) {
                 const auto &sgs = *result.space_group_search;
                 const gemmi::GroupOps hi = sgs.refused_point_group_representative->operations();
                 const gemmi::GroupOps lo = twin_sg->operations();
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index 1aadb6cb2..e80f35dd2 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -364,6 +364,12 @@ struct ProcessResult {
     // The twin-immune zone read for a promotion a twin gate refused (the H ratio or the added-operator
     // R), and what was decided on it. Empty when no twin gate fired.
     std::string twin_zone_decision;
+    // What that zone DECIDED, carried as a value beside the text: true where the refusal STOOD (the
+    // added operators read acentric and are recorded as a twin law), false where the zone overturned
+    // the refusal or decided nothing. A run reads the zone up to four times and each read rewrites
+    // the text, so the decision cannot be recovered from the text - matching on it named the twin law
+    // of whichever comparison happened to be made last rather than of the refusal that stood.
+    bool twin_zone_refusal_stood = false;
     // Per lattice twin law outside the adopted group: the operator's own H, the fraction it implies
     // and its correlation, on the final merge. Report-only.
     std::vector<std::string> twin_law_evidence;
-- 
2.54.0


From ccda9f043f84a17631ed1847c1b8669d31459522 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:58:46 +0200
Subject: [PATCH 092/122] Record the twin-immune zone only where it decided the
 refusal

twin_zone_decision was documented as empty when no twin gate fired, but
an undecided read - no zone reflections, or evidence inside the margin -
wrote it too, and the report then printed "a twin gate refused this
promotion, and the twin-immune zone of the operators it adds decided it"
over a line reading "undecided".

An undecided read now goes to the log and leaves the field alone, so the
field holds what was decided and the prose is true of it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 20 ++++++++++++++------
 rugnux/Rugnux.h   |  5 ++++-
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index bfa6def4f..7d659b8f5 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -1767,16 +1767,17 @@ namespace {
             return 0;
         const auto z = AnalyzeTwinImmuneZone(p1_merged, cell, *higher.point_group_representative,
                                              *lower.point_group_representative, tncs_vector);
+        Logger logger("Rugnux");
         if (z.zones.empty() || z.zones[0].n == 0) {
-            result.twin_zone_decision = fmt::format("{} over {}: no zone reflections in the shells with signal "
-                                                    "({} merged reflections read) -> undecided",
-                                                    higher.point_group_hm, lower.point_group_hm, p1_merged.size());
+            logger.Info("Twin-immune zone {} over {}: no zone reflections in the shells with signal "
+                        "({} merged reflections read) - undecided", higher.point_group_hm,
+                        lower.point_group_hm, p1_merged.size());
             return 0;
         }
         const auto &zone = z.zones[0];
         const int verdict = zone.calibrated_evidence_nats <= -DECISIVE_NATS ? -1
                             : zone.calibrated_evidence_nats >= DECISIVE_NATS ? +1 : 0;
-        result.twin_zone_decision = fmt::format(
+        const std::string text = fmt::format(
                 "{} over {}: operators {}; n {} <|E^2-1|> {:.3f} +- {:.3f} (control {:.3f}, {:+.3f} nats per "
                 "reflection above acentric), evidence {:+.1f} nats, calibrated {:+.1f} ({:.2f}-{:.2f} A{}) -> {}",
                 higher.point_group_hm, lower.point_group_hm, zone.operators, zone.n, zone.mean_abs_e2_minus_1,
@@ -1785,11 +1786,18 @@ namespace {
                 z.tncs_normalised ? ", normalised per pseudo-translation class" : "",
                 verdict < 0 ? "acentric, the added operators are a twin law or a pseudo-symmetry"
                 : verdict > 0 ? "centric, the added operators are real" : "undecided");
+        // Recorded only where the zone DECIDED something. An undecided read decides nothing - the
+        // rule stays as it was - and recording it had the report announce "a twin gate refused this
+        // promotion, and the twin-immune zone decided it" over a line that says the opposite.
+        if (verdict == 0) {
+            logger.Info("Twin-immune zone {}", text);
+            return 0;
+        }
+        result.twin_zone_decision = text;
         // The verdict as a VALUE, for the report to act on. Every caller acts on a decisive read -
         // the refusal stands or it is overturned - so recording it here records the decision, where
         // matching on the text records only the last comparison the run happened to make.
-        if (verdict != 0)
-            result.twin_zone_refusal_stood = verdict < 0;
+        result.twin_zone_refusal_stood = verdict < 0;
         return verdict;
     }
 
diff --git a/rugnux/Rugnux.h b/rugnux/Rugnux.h
index e80f35dd2..8c43eb14e 100644
--- a/rugnux/Rugnux.h
+++ b/rugnux/Rugnux.h
@@ -362,7 +362,10 @@ struct ProcessResult {
     // or that it never confirmed the operators. Empty when the arms agreed.
     std::string space_group_arm_override;
     // The twin-immune zone read for a promotion a twin gate refused (the H ratio or the added-operator
-    // R), and what was decided on it. Empty when no twin gate fired.
+    // R), and what it decided. Empty where no zone DECIDED one: where no gate fired, and equally where
+    // a zone was read and came out undecided (too few reflections, or inside the margin), which leaves
+    // the rule as it was and is reported to the log rather than here. The report renders this field as
+    // the decision that was taken, so a read that took none must not appear in it.
     std::string twin_zone_decision;
     // What that zone DECIDED, carried as a value beside the text: true where the refusal STOOD (the
     // added operators read acentric and are recorded as a twin law), false where the zone overturned
-- 
2.54.0


From d2edd7408978c6bf1b946ecef0c9ae486daf0e6c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:59:20 +0200
Subject: [PATCH 093/122] Do not report a lattice-arm comparison that was not
 made

A lattice arm that indexed nothing (or post-refined nothing) measures no
held-out residual, and PASS_DECISION then read "realised a held-out
residual of nan against 1.234e-03 ..., so the metric symmetry stands" -
a comparison the run could not make, stated as one it did. The fallback
itself is right: the metric symmetry stands. Only the claim changes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 35 +++++++++++++++++++++++++++--------
 1 file changed, 27 insertions(+), 8 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 7d659b8f5..627a94efb 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -2190,14 +2190,33 @@ ProcessResult Rugnux::RunAllPasses(RugnuxObserver *observer) {
                     IndexingSettings promoted_settings = experiment_.GetIndexingSettings();
                     promoted_settings.LatticeClassDemoted(false);
                     experiment_.ImportIndexingSettings(promoted_settings);
-                    logger.Info("Metric symmetry: re-integrated as {} the held-out residual is {:.3e}, "
-                                "which {} does not beat ({:.3e}) - the higher symmetry stands",
-                                class_text(promoted_arm), realised_promoted, class_text(demoted_arm),
-                                realised_demoted);
-                    lattice_arm = fmt::format(
-                            "{} was run as well and realised a held-out residual of {:.3e} against {:.3e} "
-                            "as {}, so the metric symmetry stands", class_text(demoted_arm),
-                            realised_demoted, realised_promoted, class_text(promoted_arm));
+                    // An arm that indexed nothing, or post-refined nothing, measures no residual. The
+                    // metric symmetry stands either way - that is the arm whose absence of evidence is
+                    // not evidence against it - but the run must not report a comparison it could not
+                    // make: written as a number, a missing residual came out as "realised a held-out
+                    // residual of nan against 1.234e-03, so the metric symmetry stands".
+                    const bool compared = std::isfinite(realised_promoted) && std::isfinite(realised_demoted);
+                    if (compared) {
+                        logger.Info("Metric symmetry: re-integrated as {} the held-out residual is {:.3e}, "
+                                    "which {} does not beat ({:.3e}) - the higher symmetry stands",
+                                    class_text(promoted_arm), realised_promoted, class_text(demoted_arm),
+                                    realised_demoted);
+                        lattice_arm = fmt::format(
+                                "{} was run as well and realised a held-out residual of {:.3e} against {:.3e} "
+                                "as {}, so the metric symmetry stands", class_text(demoted_arm),
+                                realised_demoted, realised_promoted, class_text(promoted_arm));
+                    } else {
+                        const char *which = !std::isfinite(realised_demoted) && !std::isfinite(realised_promoted)
+                                            ? "neither arm measured a held-out residual"
+                                            : !std::isfinite(realised_demoted)
+                                              ? "the demoted arm measured no held-out residual"
+                                              : "the promoted arm measured no held-out residual";
+                        logger.Info("Metric symmetry: {}, so the two could not be compared - the higher "
+                                    "symmetry stands", which);
+                        lattice_arm = fmt::format(
+                                "{} was run as well, but {}, so the two could not be compared and the "
+                                "metric symmetry stands untested", class_text(demoted_arm), which);
+                    }
                 }
             } else {
                 logger.Info("Metric symmetry: {} asserts a = b and the free refinement leaves the two "
-- 
2.54.0


From 5c6dedea71b0e7af29cabbf6a31780f25edd8ca7 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 18:59:59 +0200
Subject: [PATCH 094/122] Do not read the oscillation width as the rotation
 step

SweepLayout rejected any inter-frame difference below half the header's
oscillation width as read-back jitter. A series that steps by less than
it exposes - overlapping wedges, or a writer that puts the whole sweep's
range in that field - then had every difference rejected, no step was
found, and the files fell into the "series that never turns" branch,
which lays them out end to end and, unlike the gapped path, said
nothing. The jitter bound is now absolute (1e-4 deg, below any step an
instrument makes and above 32-bit float read-back noise), and the
end-to-end fallback warns when the angles do span a rotation.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/SweepLayout.cpp    | 24 ++++++++++++++++++++----
 tests/SweepLayoutTest.cpp | 21 +++++++++++++++++++++
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/reader/SweepLayout.cpp b/reader/SweepLayout.cpp
index 981fa0137..67cda450f 100644
--- a/reader/SweepLayout.cpp
+++ b/reader/SweepLayout.cpp
@@ -125,14 +125,20 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
     // Angle_increment is not used for this: it is the oscillation WIDTH, which a series with
     // overlapping or spaced wedges does not step by.
     //
-    // A difference smaller than half the oscillation width is not a step but jitter in the recorded
-    // angle: no instrument slices finer than it exposes, so wedges overlapping twofold would be a
-    // read-back wobble, and taking one as the step would spread the sweep over millions of slots.
+    // A difference below this is jitter in the recorded angle rather than a step, and taking one as
+    // the step would spread the sweep over millions of slots. The bound is ABSOLUTE and far below
+    // any move an instrument makes: these headers write their angles as 32-bit floats, which is a
+    // few parts in 100000 - under 1e-4 deg even at 360 - while the finest rotation step collected is
+    // a thousandth of a degree. Deriving it from the oscillation width instead, as this used to, is
+    // the same mistake the paragraph above warns of: a series with overlapping wedges steps by far
+    // less than it exposes, and some writers put the whole sweep's range in that field, so every
+    // inter-frame difference was rejected, the guess stayed zero and a turning series fell into the
+    // "never turns" branch below and was laid out end to end.
     //
     // It is only a guess, and deliberately the crudest one: a single recorded difference, and the
     // one biased furthest low by the read-back noise. It is used below to count STEPS between
     // neighbours, never to place a frame outright.
-    const double too_fine = 0.5 * std::abs(f0.increment_deg);
+    constexpr double too_fine = 1e-4;   // degrees
     double guess = 0;
     for (size_t i = 1; i < frames.size(); i++) {
         const double d = Fold(angle[i] - angle[i - 1]);
@@ -144,6 +150,16 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
     // A series that never turns: a grid scan, a set of stills, or a single image. There is no sweep
     // to place anything on, so the files are the slots and the header's nominal increment stands.
     if (guess == 0) {
+        // ... unless the angles say it DOES turn, over the series if never between two neighbours.
+        // Then this layout is a guess - the files end to end, at the nominal increment - and it has
+        // to say so, as the gapped path below does. Nothing else in this branch reports anything.
+        const double turned = std::abs(angle.back() - angle[0]);
+        if (turned > std::max(std::abs(f0.increment_deg), 1e-3))
+            logger.Warning("The angles of these {} images span {:.4f} deg, but no two neighbours are "
+                           "more than {:g} deg apart, so no rotation step can be read from them. They "
+                           "are laid out one after another at the header's {:.4f} deg - check that "
+                           "this is the sweep the files describe.",
+                           frames.size(), turned, too_fine, f0.increment_deg);
         out.files.reserve(frames.size());
         for (const auto &f : frames)
             out.files.push_back(f.path);
diff --git a/tests/SweepLayoutTest.cpp b/tests/SweepLayoutTest.cpp
index ee472c4d2..a3ef530d3 100644
--- a/tests/SweepLayoutTest.cpp
+++ b/tests/SweepLayoutTest.cpp
@@ -153,3 +153,24 @@ TEST_CASE("SweepLayout_RepeatedAngleRefused") {
     // Two sweeps of the same crystal concatenated: the second covers angles the first already has.
     CHECK_THROWS_AS(sweep::Place(Series({0.0, 0.1, 0.2, 0.1, 0.2}, 0.1), "test"), JFJochException);
 }
+
+TEST_CASE("SweepLayout_StepFinerThanTheOscillationWidth") {
+    // The header field is the oscillation WIDTH, and a series can step by far less than it exposes -
+    // or, on some writers, hold the whole sweep's range in that field. Taking it for the step
+    // rejected every inter-frame difference as jitter: the sweep then read as one that never turns
+    // and was laid out end to end, every frame past the first at the wrong angle.
+    std::vector<double> angles;
+    for (int i = 0; i < 100; i++)
+        angles.push_back(30.0 + 0.1 * i);
+
+    const auto wedges = sweep::Place(Series(angles, 1.0), "test");     // 1 deg wedges, 0.1 deg apart
+    REQUIRE(wedges.files.size() == 100);
+    CHECK(wedges.present == 100);
+    CHECK(wedges.start_deg == Catch::Approx(30.0));
+    CHECK(wedges.increment_deg == Catch::Approx(0.1));
+
+    const auto total = sweep::Place(Series(angles, 10.0), "test");     // the field holds the range
+    REQUIRE(total.files.size() == 100);
+    CHECK(total.present == 100);
+    CHECK(total.increment_deg == Catch::Approx(0.1));
+}
-- 
2.54.0


From 404b233aa8ceb9934146c1f2bb201bae14bd5005 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:00:58 +0200
Subject: [PATCH 095/122] Let format autodetection fail as an answer, not as an
 exception

MarCCD::CanRead and SMV::CanRead read the first plausible file of a
directory outside their own try, and the CLI made all three CanRead
calls outside the try that reports a bad input. "rugnux <dir>" whose
alphabetically-first plausible file is unreadable therefore terminated
with no message. CanRead now answers false for anything it cannot read,
and the CLI asks the question where it can report the answer.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/MarCCD.cpp     | 13 +++++++++----
 reader/SMV.cpp        | 13 +++++++++----
 rugnux/rugnux_cli.cpp | 10 +++++++---
 3 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/reader/MarCCD.cpp b/reader/MarCCD.cpp
index 288d244c1..a5ee68d3a 100644
--- a/reader/MarCCD.cpp
+++ b/reader/MarCCD.cpp
@@ -251,13 +251,18 @@ std::vector<std::string> CollectSweep(const std::string &path) {
     return out;
 }
 
+// Asked of every input before anything is read, including inputs that are not marCCD at all, so it
+// answers a question and never fails: a file it cannot open or make sense of is simply not one of
+// ours. The directory arm has to be inside the try as much as the single-file one - it opens the
+// first plausible file in the folder, which can be unreadable, and the throw came out of a call site
+// that does not catch it, ending the run with no message at all.
 bool CanRead(const std::string &path) {
     std::error_code ec;
-    if (std::filesystem::is_directory(path, ec))
-        return !CollectSweep(path).empty();
-    if (!PlausibleExtension(std::filesystem::path(path)))
-        return false;
     try {
+        if (std::filesystem::is_directory(path, ec))
+            return !CollectSweep(path).empty();
+        if (!PlausibleExtension(std::filesystem::path(path)))
+            return false;
         return !InstrumentHeader(path).empty();
     } catch (const JFJochException &) {
         return false;
diff --git a/reader/SMV.cpp b/reader/SMV.cpp
index 405582db1..d818cac6d 100644
--- a/reader/SMV.cpp
+++ b/reader/SMV.cpp
@@ -222,13 +222,18 @@ std::vector<std::string> CollectSweep(const std::string &path) {
     return out;
 }
 
+// Asked of every input before anything is read, including inputs that are not SMV at all, so it
+// answers a question and never fails: a file it cannot open or make sense of is simply not one of
+// ours. The directory arm has to be inside the try as much as the single-file one - it opens the
+// first plausible file in the folder, which can be unreadable, and the throw came out of a call site
+// that does not catch it, ending the run with no message at all.
 bool CanRead(const std::string &path) {
     std::error_code ec;
-    if (std::filesystem::is_directory(path, ec))
-        return !CollectSweep(path).empty();
-    if (!PlausibleExtension(std::filesystem::path(path)))
-        return false;
     try {
+        if (std::filesystem::is_directory(path, ec))
+            return !CollectSweep(path).empty();
+        if (!PlausibleExtension(std::filesystem::path(path)))
+            return false;
         const auto kv = HeaderBlock(path);
         return kv.has_value() && kv->count("SIZE1") && kv->count("SIZE2");
     } catch (const JFJochException &) {
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index 9c10383ec..69cbb1b70 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -1420,10 +1420,14 @@ static int RunRugnux(int argc, char **argv) {
     JFJochMarCCDReader marccd_reader;
     JFJochSMVReader smv_reader;
     JFJochReader *reader_ptr = nullptr;
-    const bool input_is_cbf = JFJochCBFReader::CanRead(input_file);
-    const bool input_is_marccd = !input_is_cbf && JFJochMarCCDReader::CanRead(input_file);
-    const bool input_is_smv = !input_is_cbf && !input_is_marccd && JFJochSMVReader::CanRead(input_file);
+    // Which format this is. Asked INSIDE the try: these open and read the file - a directory whose
+    // first plausible member cannot be read throws here - and an input the program cannot read has to
+    // come out as the message below, not as an unhandled exception with nothing printed at all.
+    bool input_is_cbf = false, input_is_marccd = false, input_is_smv = false;
     try {
+        input_is_cbf = JFJochCBFReader::CanRead(input_file);
+        input_is_marccd = !input_is_cbf && JFJochMarCCDReader::CanRead(input_file);
+        input_is_smv = !input_is_cbf && !input_is_marccd && JFJochSMVReader::CanRead(input_file);
         if (input_is_cbf) {
             cbf_reader.ReadFiles(input_file);
             reader_ptr = &cbf_reader;
-- 
2.54.0


From aecbcf3aaf506f46e45fafcf594cb1c4e8ea9eff Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:01:33 +0200
Subject: [PATCH 096/122] Clamp the marCCD header probe to the size of the file

The header offset comes from TIFF tag 34710 unchecked and is handed to
ReadPrefix, which allocates that many bytes before reading. This runs
during format autodetection, on files nobody has said are marCCD, so a
foreign or corrupt TIFF could have the program allocate ~4 GB for a
probe. The probe now reads at most what the file holds; a short read was
always the normal outcome and the caller already checks the size.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/MarCCD.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/reader/MarCCD.cpp b/reader/MarCCD.cpp
index a5ee68d3a..96af47893 100644
--- a/reader/MarCCD.cpp
+++ b/reader/MarCCD.cpp
@@ -60,6 +60,15 @@ std::vector<uint8_t> ReadPrefix(const std::string &path, size_t bytes) {
     std::ifstream f(path, std::ios::binary);
     if (!f)
         throw JFJochException(JFJochExceptionCategory::MockFileOpenError, "Cannot open " + path);
+    // Never allocate more than the file holds. One caller's count comes from the header-offset TIFF
+    // tag, which is a field of a file nobody has yet decided is ours - this runs on every input the
+    // program is given - and a foreign or corrupt TIFF can name four gigabytes there. Reading short
+    // is already the normal outcome (the caller checks the size it got back), so the clamp costs
+    // nothing.
+    f.seekg(0, std::ios::end);
+    const std::streamoff file_bytes = f.tellg();
+    f.seekg(0, std::ios::beg);
+    bytes = std::min(bytes, file_bytes > 0 ? static_cast<size_t>(file_bytes) : size_t(0));
     std::vector<uint8_t> out(bytes);
     f.read(reinterpret_cast<char *>(out.data()), static_cast<std::streamsize>(bytes));
     out.resize(static_cast<size_t>(f.gcount()));
-- 
2.54.0


From ba5b7cda81e04d16987aaba2f1d319e3db3decab Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:02:12 +0200
Subject: [PATCH 097/122] Do not let a marCCD file name 2-theta as the scanned
 circle

The scanned circle was read as the first start/end pair that differs,
and two_theta is the first pair in the goniostat block. A file that
leaves its end block at zero while the detector sits on a swung-out
2-theta arm therefore named the arm as the spindle and stopped before
reaching phi; with no rotation range recorded either, the increment fell
back to -start_angle, which differs per frame, and the sweep was refused
outright.

The header's own rotation_axis index (offset 732) is taken where it
names a spindle circle, and the pair scan is the fallback for files that
never filled it in - read past two_theta, which no sweep turns.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/MarCCD.cpp | 37 +++++++++++++++++++++++++------------
 1 file changed, 25 insertions(+), 12 deletions(-)

diff --git a/reader/MarCCD.cpp b/reader/MarCCD.cpp
index 96af47893..68ac7c171 100644
--- a/reader/MarCCD.cpp
+++ b/reader/MarCCD.cpp
@@ -38,6 +38,7 @@ constexpr size_t OFF_END_XTAL_TO_DETECTOR = 728;     // ... and at its end
 constexpr size_t OFF_EXPOSURE_TIME = 656;      // milliseconds
 constexpr size_t OFF_START_TWOTHETA = 668;     // millidegrees, and the seven that follow it
 constexpr size_t OFF_END_TWOTHETA = 700;       // the same seven, at the end of the exposure
+constexpr size_t OFF_ROTATION_AXIS = 732;      // which circle the sweep turned, as an index below
 constexpr size_t OFF_ROTATION_RANGE = 736;     // millidegrees
 constexpr size_t OFF_PIXELSIZE_X = 772;        // nanometres
 constexpr size_t OFF_PIXELSIZE_Y = 776;
@@ -146,21 +147,33 @@ Header Parse(const std::vector<uint8_t> &h, const std::string &path) {
     out.exposure_s = I32(h, OFF_EXPOSURE_TIME) * 1e-3;
     out.saturated_value = I32(h, OFF_SATURATED);
 
-    // Which circle moved. The header also carries a rotation_axis index, but the start/end pair
-    // that differs is the same answer read off the angles themselves, and it stays right on a file
-    // whose index field was never filled in.
+    // Which circle moved. The header names it as an index into the circle list, and that is taken
+    // where it names a spindle circle: reading the start/end pairs alone takes the FIRST pair that
+    // differs, and two_theta is the first of them, so a file that left its end block at zero while
+    // the detector sat on a swung-out 2-theta arm had the arm named as the spindle - and, with no
+    // rotation range recorded either, an increment of -start_angle that differs on every frame,
+    // which SweepLayout then refuses the whole sweep over.
+    //
+    // The index is not always filled in, and a file that leaves it at zero cannot be told from one
+    // that means two_theta by it, so the fallback is the pairs as before - read past two_theta,
+    // which is a detector circle and never the one a sweep turns.
     out.angle_increment_deg = I32(h, OFF_ROTATION_RANGE) * 1e-3;
-    for (size_t i = 0; i < N_CIRCLES; i++) {
+    const auto take_circle = [&](size_t i) {
         const double start = I32(h, OFF_START_TWOTHETA + 4 * i) * 1e-3;
         const double end = I32(h, OFF_END_TWOTHETA + 4 * i) * 1e-3;
-        if (start != end) {
-            out.axis_name = CIRCLE_NAMES[i];
-            out.start_angle_deg = start;
-            if (out.angle_increment_deg == 0.0)
-                out.angle_increment_deg = end - start;
-            break;
-        }
-    }
+        if (start == end)
+            return false;
+        out.axis_name = CIRCLE_NAMES[i];
+        out.start_angle_deg = start;
+        if (out.angle_increment_deg == 0.0)
+            out.angle_increment_deg = end - start;
+        return true;
+    };
+    const int32_t named = I32(h, OFF_ROTATION_AXIS);
+    if (named <= 0 || static_cast<size_t>(named) >= N_CIRCLES || !take_circle(static_cast<size_t>(named)))
+        for (size_t i = 1; i < N_CIRCLES; i++)
+            if (take_circle(i))
+                break;
     return out;
 }
 
-- 
2.54.0


From fe3a28a1c0cce4f5fadd476833cd7149d5162607 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:02:47 +0200
Subject: [PATCH 098/122] Drop the centring-absent reflections from the
 reported twin statistics

AnalyzeTwinning takes the lattice centring so that the reflections the
centring extinguishes stay out of both statistics, but only the
pre-promotion test passed it. The final, reported verdict and --mode
scale did not, and a merged ASU in a centred group still carries keys in
the absent class - noise, and an L-test partner step landing on one
pairs a real reflection with an absent one. Both now pass the adopted
group's centring.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp     | 10 +++++++++-
 rugnux/rugnux_cli.cpp |  6 +++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 627a94efb..883e1467e 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6943,8 +6943,16 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                result.tncs.peak_percent, result.tncs.vector_frac[0],
                                result.tncs.vector_frac[1], result.tncs.vector_frac[2],
                                result.tncs.vector_length_A);
+            // Without the reflections the lattice centring extinguishes, as the pre-promotion test
+            // above is measured: the merged ASU of a centred group still holds keys in the absent
+            // class (the merge writes what it was given), they are noise rather than intensities,
+            // and an L-test partner step that lands on one pairs a real reflection with an absent.
+            // This is the number the user reads, so it is the one that must be treated.
+            const char twin_centring = twin_sg ? twin_sg->centring_type()
+                                       : end_msg.rotation_lattice_type.has_value()
+                                         ? end_msg.rotation_lattice_type->centering : 'P';
             result.twinning = AnalyzeTwinning(sm.merged, twin_sg, 20,
-                                             TranslationalNCSVectorForLTest(result.tncs));
+                                             TranslationalNCSVectorForLTest(result.tncs), twin_centring);
             // Set on the struct the text below is rendered from. AnalyzeTwinning returns a fresh result
             // with this flag clear, so setting it only afterwards left the statistics text asserting
             // "No twinning: the Laue class is holohedral" as a fact while the report, rendering the same
diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index 69cbb1b70..bc47bde04 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -1868,8 +1868,12 @@ static int RunRugnux(int argc, char **argv) {
             tncs = AnalyzeTranslationalNCS(merged_reflections, gemmi::UnitCell(*uc), twin_sg);
         if (tncs.measurable)
             std::cout << std::endl << TranslationalNCSToText(tncs);
+        // Same as the full pipeline: without the reflections the lattice centring extinguishes. The
+        // merged ASU of a centred group still holds keys in the absent class, and they are noise, not
+        // intensities, in both statistics.
         const auto twinning = AnalyzeTwinning(merged_reflections, twin_sg, 20,
-                                             TranslationalNCSVectorForLTest(tncs));
+                                              TranslationalNCSVectorForLTest(tncs),
+                                              twin_sg ? twin_sg->centring_type() : 'P');
         std::cout << std::endl << TwinningAnalysisToText(twinning) << std::endl;
 
         // Diffraction anisotropy, exactly as the full pipeline computes it (Rugnux.cpp) - report-only,
-- 
2.54.0


From 1b9b6d7405f71e90fadb6f5614e4978ea4aad43f Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:03:53 +0200
Subject: [PATCH 099/122] Correct three stale comments

r_contrast_bound carried a calibration (0.70 against a bound of 0.65)
that min_operator_r_contrast and the ledger text no longer agree with;
TrimmedZoneSum's header still promised "its single largest member
dropped", which the caller no longer supplies since the screw fix
withholds a member standing at or above its row's mean; and
mean_relative_scale still said "/ run median" though the gauge is now
TypicalFrameScale. Comments only - no behaviour changes.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/scale_merge/Merge.h            |  4 +++-
 image_analysis/scale_merge/SearchSpaceGroup.h | 20 ++++++++++++-------
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/image_analysis/scale_merge/Merge.h b/image_analysis/scale_merge/Merge.h
index cf7b6df80..32fb5a61f 100644
--- a/image_analysis/scale_merge/Merge.h
+++ b/image_analysis/scale_merge/Merge.h
@@ -87,7 +87,9 @@ struct SweepQualityRange {
     // 1 = nothing at all. The rest are supporting numbers, relative to the run unless stated.
     float severity = 0.0f;
     float rotation_deg = 0.0f;         // width of the range
-    float mean_relative_scale = 1.0f;  // <per-image scale> / run median
+    // Gauged on the run's precision-weighted typical frame (TypicalFrameScale), not on its median
+    // frame, which on a sweep that spent most of its turn out of the beam is itself a dead one.
+    float mean_relative_scale = 1.0f;  // <per-image scale> / typical frame scale
     float mean_relative_cc = 1.0f;     // <per-image CC to merge> / run median
     float indexed_fraction = 1.0f;     // frames in the range that got a per-image scale at all
     float relative_b = NAN;            // mean of the radiation-damage monitor's per-batch B over the range
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index c02478a8a..df23a484b 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -155,11 +155,16 @@ double AbsenceEvidence(double sum_u, int n_absent, int n_control);
 // candidate's absences could score lower. See SearchSpaceGroup.cpp.
 double ScrewZoneEvidence(double sum_u, int n_absent);
 
-// A screw zone's sum with its single largest member dropped and rescaled to estimate the same
-// quantity (dividing by n - H_n, the expected sum of the other n-1 under the null, and multiplying
-// by n). ScrewZoneEvidence is a sum, so it is dominated by the largest one or two members of a class
-// that holds only a handful of reflections, and a zone's verdict could hang on one reflection whose
-// merged value moved with the scaling. See SearchSpaceGroup.cpp.
+// A screw zone's sum with `max_u` dropped and rescaled to estimate the same quantity (dividing by
+// n - H_n, the expected sum of the other n-1 under the null, and multiplying by n). ScrewZoneEvidence
+// is a sum, so it is dominated by the largest one or two members of a class that holds only a handful
+// of reflections, and a zone's verdict could hang on one reflection whose merged value moved with the
+// scaling. max_u is the largest TRIMMABLE member, not simply the largest: the caller withholds a
+// member that both violates the absence and stands at or above its row's own present mean, because
+// that is a reflection that is there rather than a measurement that moved, and trimming it removed
+// the single datum refuting the claim. The sum a withheld member leaves is therefore higher than a
+// true trim would give, which UNDER-states the evidence: this estimator only ever refuses a screw,
+// never asserts one. See SearchSpaceGroup.cpp.
 double TrimmedZoneSum(double sum_u, double max_u, int n_absent);
 
 struct SearchSpaceGroupOptions {
@@ -763,8 +768,9 @@ struct SearchSpaceGroupResult {
     std::vector<PointGroupLedgerEntry> point_group_ledger;
     // The refusal bounds the ledger's own channels were judged against, copied from the options so the
     // report can print the MARGIN the adopted row had rather than only its value. The accept-side
-    // headroom is thin (measured: the lowest genuine adopted contrast on a 149-dataset corpus is 0.70
-    // against a bound of 0.65), and a margin is the only form in which that is visible per run.
+    // headroom is thin (measured: the lowest genuine adopted contrast on the corpus is 0.77 against a
+    // bound of 0.72 - see min_operator_r_contrast, which is where these numbers are kept), and a
+    // margin is the only form in which that is visible per run.
     double r_contrast_bound = 0.0;
     double r_over_floor_bound = 0.0;
 
-- 
2.54.0


From b34f7b09a3d2bfa5532a12d831b1bdbd27cfa9a1 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:08:41 +0200
Subject: [PATCH 100/122] Rugnux: retire <prefix>_image.dat, and read the
 diagnostic picture off the background

_image.dat carried the per-image scaling table before _plot.txt existed, and the
two were written from the same ScalingResult with six columns between them. Drop
it: the writer, its call site and its documentation entries go, and _plot.txt
gains the one column of the old file that was not already there and is not dead -
cc_n, the number of observations cc_to_merge was taken over, without which that
correlation cannot be read at the sparse end of a sweep. The old file's wedge_deg
is NOT carried over: image_scale_wedge_deg is only ever reset, never assigned, so
that column was nan on every run that ever wrote it.

_plot.txt is now written on a stills run too - it is the only per-image scaling
table there is, and the columns a sweep would fill come out nan - while the
picture stays rotation-only, as only the rotation pre-scan builds the projection
it draws. "merged" reads nan rather than 0 where no merge stands behind the run,
so --no-merge no longer looks like a sweep every frame of which was thrown out.

The picture's contrast now comes from the background instead of the peaks: the
ramp saturates at eight times the median measured pixel, where it used to
saturate at the brightest 0.1 % as the preview and the viewer do. That percentile
belongs to the Bragg spots, so the background - which is what a shadow is read
off, being a place where it is MISSING - sat in the first few per cent of the
scale and rendered as a flat white. The median is pure background whatever the
crystal, and eight times it falls between the 94th and the 99th percentile of the
projection on every set measured. Two times the median, the first value tried,
falls at the 73rd to 90th instead and floods the inner half of the detector to a
flat indigo, hiding the deficit at the other end of the scale. The colours are
untouched - they are the viewer's, from common/ColorScale.h - and only the
intensity mapping moves.

Processing is unchanged: p.hkl and p.mtz are byte-identical before and after on a
rotation sweep, and the wall clock does not move.

rugnux_stills_ab.py reads scale_G from _plot.txt instead of the retired file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .gitignore                                   |  3 +-
 docs/RUGNUX.md                               |  2 +-
 docs/RUGNUX_TUTORIAL.md                      | 26 +++---
 image_analysis/scale_merge/Merge.h           |  2 +-
 image_analysis/scale_merge/ScalingResult.cpp | 28 -------
 image_analysis/scale_merge/ScalingResult.h   |  2 -
 rugnux/DiagnosticOutput.cpp                  | 41 +++++++---
 rugnux/DiagnosticOutput.h                    |  7 +-
 rugnux/Rugnux.cpp                            | 26 +++---
 rugnux_stills_ab.py                          | 13 +--
 tests/DiagnosticOutputTest.cpp               | 85 +++++++++++++++-----
 11 files changed, 139 insertions(+), 96 deletions(-)

diff --git a/.gitignore b/.gitignore
index 8ecf683a6..25ca7930a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,7 +27,8 @@ rugnux_anomalous*/
 *.cif
 *.pdb
 *.hkl
-*_image.dat
+*_plot.txt
+*_detector.jpg
 
 # Test fixtures are checked in deliberately; add them with an explicit path.
 !tests/**
diff --git a/docs/RUGNUX.md b/docs/RUGNUX.md
index 05b8f9ea7..e8dc69f05 100644
--- a/docs/RUGNUX.md
+++ b/docs/RUGNUX.md
@@ -63,7 +63,7 @@ myrun_unmerged.mtz   every observation before scaling, for pointless / aimless /
 myrun_P1.mtz         the same observations merged in P1, so a wrong space-group call can be
                      re-merged or re-refined without reprocessing (--no-p1-crosscheck skips it)
 myrun_report.txt     what the run determined: cell, space group, statistics, warnings
-myrun_image.dat      one row per image, for plotting how the crystal behaved over the sweep
+myrun_plot.txt       one row per image, for plotting how the crystal behaved over the sweep
 ```
 
 The two MTZ extras are most of the bytes a run writes — worth knowing when sizing a scratch
diff --git a/docs/RUGNUX_TUTORIAL.md b/docs/RUGNUX_TUTORIAL.md
index 5c3b61e20..90972a914 100644
--- a/docs/RUGNUX_TUTORIAL.md
+++ b/docs/RUGNUX_TUTORIAL.md
@@ -115,8 +115,8 @@ small move: under 1 % in distance, and the gauge-weak beam centre within 15 px o
 or of the run's own measured centre, whichever is nearer), and the second pass
 re-indexes de novo and re-integrates at the refined geometry. The refined pass is the canonical
 `<prefix>_*` output; the header-geometry pass merges only to choose the space group and to judge the
-refined pass against, and writes no merged files of its own — no `<prefix>_01.mtz`, `.cif`, `.hkl` or
-`_01_image.dat`, and no `_01_plot.txt` or `_01_detector.jpg`. (Where a process file is asked for at all, with `--no-merge` or
+refined pass against, and writes no merged files of its own — no `<prefix>_01.mtz`, `.cif` or
+`.hkl`, and no `_01_plot.txt` or `_01_detector.jpg`. (Where a process file is asked for at all, with `--no-merge` or
 `--write-process-h5`, each pass still writes its own, so `<prefix>_01_process.h5` appears beside
 `<prefix>_process.h5`.) Disable it with `--rotation-no-postrefine`.
 
@@ -246,7 +246,7 @@ goniometer axis but you want per-frame stills processing anyway, add `--force-st
   [The results report](RUGNUX_REPORT.md#the-results-report).
 - `<prefix>_plot.txt` — **the per-image table**, one row per processed image, whitespace-separated,
   with a single `#` legend line over its own columns so gnuplot plots it as it stands
-  (`plot '<prefix>_plot.txt' using 1:4`). Rotation runs only. The columns are:
+  (`plot '<prefix>_plot.txt' using 1:4`). The columns are:
 
   | Column | Meaning |
   |--------|---------|
@@ -258,10 +258,12 @@ goniometer axis but you want per-frame stills processing anyway, add `--force-st
   | `scale_G` | Per-image scale factor fitted by scaling. |
   | `sigma_M_deg` | Mosaicity as the rocking-curve **standard deviation** σ<sub>M</sub> in degrees — not a FWHM, and not XDS's `REFLECTING_RANGE`. See the note below. |
   | `cc_to_merge` | Correlation of the image's own observations with the merged data. |
-  | `merged` | 1 where the image's observations are in the merged data, 0 where they are not — an image that never indexed, one an earlier guard dropped, and one ΔCC<sub>1/2</sub> convicted all read 0. |
+  | `cc_n` | Observations that correlation was computed over; 0 where none was. |
+  | `merged` | 1 where the image's observations are in the merged data, 0 where they are not — an image that never indexed, one an earlier guard dropped, and one ΔCC<sub>1/2</sub> convicted all read 0. `nan` on a run that merged nothing, `--no-merge` included, where the question has no answer. |
 
   A quantity nothing measured for an image is written `nan`, which gnuplot and numpy both skip; the
-  columns never shift and a row is never left out.
+  columns never shift and a row is never left out. A stills run writes the table too, with `nan` in
+  the columns a sweep would fill; `--no-merge` writes it with the scaling columns `nan`.
 
   **Reading `sigma_M_deg`.** It is fitted per image — a maximum-likelihood Gaussian rocking width
   over that image's own indexed spots — but it is then **smoothed in frame order** over the same
@@ -279,14 +281,12 @@ goniometer axis but you want per-frame stills processing anyway, add `--force-st
   by default). The picture is the mean projection over the frames the beam-stop detection sampled —
   the very image it tested — coloured with `jfjoch_viewer`'s default map: white to indigo for the
   counts, **grey** for the module and chip gaps, **coral** for the shadow the run detected, and
-  **magenta** for everything else the pixel mask holds. A shadow drawn where the background is
-  unbroken, or a dark patch the run left uncoloured, is visible at a glance; read it against the
-  `Beam stop shadow: N pixels ...` line in the log.
-- `<prefix>_image.dat` — the per-image **scaling** table: `image_number scale_G mosaicity_deg
-  wedge_deg cc_to_merge cc_n`, whitespace-separated with a `#` header line. It predates `_plot.txt`
-  and is kept because the in-tree comparison scripts read it and because it carries the per-image
-  mosaicity and smoothing wedge, which `_plot.txt` does not. **For anything new, script against
-  `_plot.txt`.**
+  **magenta** for everything else the pixel mask holds. The scale saturates at eight times the
+  median measured pixel, not at the brightest pixels, so the background spans the ramp and the Bragg
+  spots clip: it is the background the picture is read for, since a shadow is a place the background
+  is missing. A shadow drawn where the
+  background is unbroken, or a dark patch the run left uncoloured, is visible at a glance; read it
+  against the `Beam stop shadow: N pixels ...` line in the log.
 
 Merged statistics (⟨I/σ⟩, CC1/2, completeness, …), the error model and timing are printed to the
 console. By default the written resolution is trimmed automatically where CC1/2 falls off
diff --git a/image_analysis/scale_merge/Merge.h b/image_analysis/scale_merge/Merge.h
index cf7b6df80..a1bff254f 100644
--- a/image_analysis/scale_merge/Merge.h
+++ b/image_analysis/scale_merge/Merge.h
@@ -78,7 +78,7 @@ enum class FrameDisposition {
 const char *FrameDispositionCode(FrameDisposition disposition);   // "merged", "downgraded", "rejected"
 
 struct SweepQualityRange {
-    // Inclusive, in processed-image ordinals - the numbering of <prefix>_image.dat and of every other
+    // Inclusive, in processed-image ordinals - the numbering of <prefix>_plot.txt and of every other
     // per-image array rugnux writes. With -s/--stride the source image is start + ordinal * stride.
     int first_image = 0;
     int last_image = 0;
diff --git a/image_analysis/scale_merge/ScalingResult.cpp b/image_analysis/scale_merge/ScalingResult.cpp
index 1a02d09e0..d5537cc3c 100644
--- a/image_analysis/scale_merge/ScalingResult.cpp
+++ b/image_analysis/scale_merge/ScalingResult.cpp
@@ -3,9 +3,6 @@
 
 #include "ScalingResult.h"
 #include <cmath>
-#include <fstream>
-
-#include "../../common/JFJochException.h"
 
 ScalingResult::ScalingResult(size_t n)
     : image_scale_g(n, NAN),
@@ -28,28 +25,3 @@ ScalingResult::ScalingResult(const std::vector<IntegrationOutcome> &v)
             image_cc_n[i] = v[i].image_scale_cc_n.value_or(0);
         }
 }
-
-void ScalingResult::SaveToFile(const std::string &filename) {
-    const std::string img_path = filename + "_image.dat";
-    std::ofstream img_file(img_path,  std::ofstream::out | std::ofstream::trunc);
-    if (!img_file) {
-        throw JFJochException(JFJochExceptionCategory::FileWriteError,
-                              "Cannot open " + img_path + " for writing");
-    }
-
-    // Header so the columns are self-describing (lines starting with '#' are comments for gnuplot/numpy).
-    img_file << "# image_number scale_G mosaicity_deg wedge_deg cc_to_merge cc_n\n";
-
-    for (size_t i = 0; i < image_scale_g.size(); ++i) {
-        img_file << i
-                << " " << image_scale_g[i]
-                << " " << mosaicity_deg[i]
-                << " " << rotation_wedge_deg[i]
-                << " " << image_cc[i]
-                << " " << image_cc_n[i]
-                << "\n";
-    }
-
-    img_file.close();
-}
-
diff --git a/image_analysis/scale_merge/ScalingResult.h b/image_analysis/scale_merge/ScalingResult.h
index 717d1915a..466848600 100644
--- a/image_analysis/scale_merge/ScalingResult.h
+++ b/image_analysis/scale_merge/ScalingResult.h
@@ -4,7 +4,6 @@
 #pragma once
 
 #include <vector>
-#include <string>
 #include "../IntegrationOutcome.h"
 
 struct ScalingResult {
@@ -15,5 +14,4 @@ struct ScalingResult {
     std::vector<int> image_cc_n;
     explicit ScalingResult(size_t n);
     explicit ScalingResult(const std::vector<IntegrationOutcome> &v);
-    void SaveToFile(const std::string &filename);
 };
diff --git a/rugnux/DiagnosticOutput.cpp b/rugnux/DiagnosticOutput.cpp
index 1c4d45e86..c7ba56fd3 100644
--- a/rugnux/DiagnosticOutput.cpp
+++ b/rugnux/DiagnosticOutput.cpp
@@ -16,9 +16,17 @@
 #include "../preview/JFJochJPEG.h"
 
 namespace {
-    // The brightest 0.1 % of the measured pixels saturate, as the preview and the viewer set their
-    // contrast (preview/PreviewImage.cpp): a handful of hot pixels would otherwise take the whole
-    // range and leave the background - which is what the shadow is read off - a flat white.
+    // The top of the ramp is eight times the MEDIAN of the measured pixels, not the brightest 0.1 %
+    // the preview and the viewer saturate at (preview/PreviewImage.cpp). That percentile belongs to
+    // the Bragg peaks, and with it setting the range the background lands in the first few per cent
+    // of the scale and reads as a flat white - which is exactly what the picture has to be read for,
+    // since a shadow is a place the background is MISSING. The median is pure background whatever
+    // the crystal, and eight times it lands between the 94th and the 99th percentile of the
+    // projection on every test set measured, which is the top of the background: the background
+    // spans the ramp radially, and the spots clip, which costs nothing here as they are not what is
+    // being judged. Twice the median - the first value tried - lands at the 73rd to 90th percentile
+    // instead and floods the whole inner half of the detector to a flat indigo, hiding the deficit
+    // just as the old contrast did, at the other end of the scale.
     float SaturationValue(const std::vector<float> &projection, const std::vector<uint32_t> &mask) {
         std::vector<float> valid;
         valid.reserve(projection.size());
@@ -27,14 +35,18 @@ namespace {
                 valid.push_back(projection[i]);
         if (valid.empty())
             return 1.0f;
-        const size_t rank = valid.size() - std::max<size_t>(1, valid.size() / 1000);
-        std::nth_element(valid.begin(), valid.begin() + rank, valid.end());
-        return std::max(valid[rank], 1.0f);
+        const size_t mid = valid.size() / 2;
+        std::nth_element(valid.begin(), valid.begin() + mid, valid.end());
+        return std::max(8.0f * valid[mid], 1.0f);
     }
 
     float Element(const std::vector<float> &v, size_t i) {
         return i < v.size() ? v[i] : NAN;
     }
+
+    int Element(const std::vector<int> &v, size_t i) {
+        return i < v.size() ? v[i] : 0;
+    }
 }
 
 std::vector<rgb> DetectorDiagnosticRGB(const PixelMask &pixel_mask,
@@ -101,9 +113,17 @@ void WritePerImagePlot(const std::string &output_prefix, const PerImagePlot &plo
 
     // One comment line, its names over their own columns, and nothing else a plotting program has
     // to be told to skip. The '#' takes the first character of the image-number field.
-    file << "#" << fmt::format("{:>5} {:>10} {:>12} {:>12} {:>8} {:>12} {:>13} {:>12} {:>7}\n",
+    file << "#" << fmt::format("{:>5} {:>10} {:>12} {:>12} {:>8} {:>12} {:>13} {:>12} {:>8}"
+                               " {:>7}\n",
                                "image", "angle_deg", "bkg", "resolution_A", "spots", "scale_G",
-                               "sigma_M_deg", "cc_to_merge", "merged");
+                               "sigma_M_deg", "cc_to_merge", "cc_n", "merged");
+
+    // Whether "merged" has anything to answer at all. With no merge behind the run - --no-merge, or
+    // a sweep nothing indexed on - a column of zeros would read as a sweep every frame of which was
+    // thrown out, which is a different statement from "no merge was made".
+    const bool merge_ran = !plot.frame_disposition.empty()
+                           || std::any_of(plot.scale_g.begin(), plot.scale_g.end(),
+                                          [](float g) { return std::isfinite(g); });
 
     for (size_t i = 0; i < image_count; i++) {
         const float angle = goniometer
@@ -120,9 +140,10 @@ void WritePerImagePlot(const std::string &output_prefix, const PerImagePlot &plo
                                : std::isfinite(scale_g);
 
         file << fmt::format("{:>6} {:>10.4f} {:>12.4g} {:>12.4g} {:>8.0f} {:>12.5g} {:>13.4f}"
-                            " {:>12.4f} {:>7}\n",
+                            " {:>12.4f} {:>8} {:>7}\n",
                             i, angle, Element(plot.bkg_estimate, i), Element(plot.resolution_A, i),
                             Element(plot.spot_count, i), scale_g, Element(plot.mosaicity_deg, i),
-                            Element(plot.cc_to_merge, i), merged);
+                            Element(plot.cc_to_merge, i), Element(plot.cc_n, i),
+                            merge_ran ? std::to_string(merged) : "nan");
     }
 }
diff --git a/rugnux/DiagnosticOutput.h b/rugnux/DiagnosticOutput.h
index 21009f81d..0566b2da5 100644
--- a/rugnux/DiagnosticOutput.h
+++ b/rugnux/DiagnosticOutput.h
@@ -28,9 +28,9 @@ std::string RenderDetectorDiagnostic(const DiffractionExperiment &experiment,
                                      const std::vector<float> &mean_projection);
 
 // The columns of <prefix>_plot.txt. Every vector is indexed by the processed-image ordinal - the
-// numbering of <prefix>_image.dat and of every other per-image array rugnux writes - and a value
-// nothing measured is NAN. frame_disposition holds FrameDisposition (Merge.h) and is empty when the
-// sweep-quality diagnostic did not run.
+// numbering of every per-image array rugnux writes - and a value nothing measured is NAN.
+// frame_disposition holds FrameDisposition (Merge.h) and is empty when the sweep-quality diagnostic
+// did not run.
 struct PerImagePlot {
     std::vector<float> bkg_estimate;
     std::vector<float> resolution_A;
@@ -38,6 +38,7 @@ struct PerImagePlot {
     std::vector<float> scale_g;
     std::vector<float> mosaicity_deg;
     std::vector<float> cc_to_merge;
+    std::vector<int> cc_n;
     std::vector<uint8_t> frame_disposition;
 };
 
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 10a46f362..4c82463ff 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -7184,7 +7184,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         // sweep (the per-image scaling the rotation merge already fits, binned by frame = dose). A
         // per-image CC that falls, and/or a mosaicity that rises, with frame number is the classic
         // radiation-damage signature - a data-quality-vs-dose read complementary to the fitted decay
-        // correction. The full per-image table is written to <prefix>_scaling.txt for detail. Both this
+        // correction. The full per-image table is written to <prefix>_plot.txt for detail. Both this
         // and the sweep-quality report below are text, so a superseded pass makes neither.
         if (experiment_.IsRotationIndexing() && !superseded) {
             const auto &outs = indexer->GetIntegrationOutcome();
@@ -7246,7 +7246,7 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             // Sweep-quality report: the stretches of the sweep over which the crystal delivered much
             // less than the rest of the run, what each one looks like, what became of it and what
             // keeping it costs the merged intensities. Frame numbers are processed-image ordinals,
-            // inclusive, as in <prefix>_image.dat.
+            // inclusive, as in <prefix>_plot.txt.
             const auto &sq = sm.statistics.sweep_quality;
             if (sq.measured) {
                 const int n_sweep = sq.frames_merged + sq.frames_downgraded + sq.frames_rejected;
@@ -7383,11 +7383,6 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
             WriteReflections(sm.merged, *result.consensus_cell, experiment_, sm.statistics,
                              em_report, result.twinning, config_.output_prefix,
                              static_cast<size_t>(std::max(1, config_.nthreads)));
-            // Per-image scaling table (G, B-factor, mosaicity, wedge, CC) for inspection / XDS
-            // comparison. The offline self-scaling result is otherwise not exposed (process.h5's
-            // per-image arrays are only filled on the online per-image path). Sourced from the
-            // partials, which carry the first-pass per-image scale.
-            ScalingResult(indexer->GetIntegrationOutcome()).SaveToFile(config_.output_prefix);
 
             // P1 cross-check dataset. The group the files above are written in was chosen by the
             // search, and if that choice is wrong nothing in them says so - every statistic was
@@ -7559,11 +7554,12 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                               /*trusted_path=*/true);
     }
 
-    // The two files a person checks the run by eye with. Rotation only - a stills run has no spindle
-    // angle and no sweep to project - and not on the geometry pre-pass or a pass that is thrown
-    // away, which would otherwise leave a stale _01 copy beside the real one.
-    if (full && write_files && !cancelled_ && !geometry_prepass && !superseded
-        && experiment_.IsRotationIndexing()) {
+    // The two files a person checks the run by eye with. Not on the geometry pre-pass or a pass that
+    // is thrown away, which would otherwise leave a stale _01 copy beside the real one. The table is
+    // written on a stills run too - it is the only per-image scaling table there is, and the columns
+    // a stills run cannot fill come out as nan; the picture is rotation-only at its source, since
+    // only the rotation pre-scan builds the projection it draws.
+    if (full && write_files && !cancelled_ && !geometry_prepass && !superseded) {
         if (!detector_diagnostic_jpeg_.empty()) {
             const std::string path = config_.output_prefix + "_detector.jpg";
             std::ofstream f(path, std::ofstream::out | std::ofstream::trunc | std::ofstream::binary);
@@ -7580,11 +7576,15 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
         plots.GetPlotRaw(plot.resolution_A, PlotType::ResolutionEstimate, "");
         plots.GetPlotRaw(plot.spot_count, PlotType::SpotCount, "");
         if (indexer) {
-            // The same source as <prefix>_image.dat, so the two files cannot disagree.
+            // The offline self-scaling result is otherwise not exposed - process.h5's per-image
+            // arrays are only filled on the online per-image path - so these columns are the only
+            // place a person or a comparison script can read it. Sourced from the partials, which
+            // carry the first-pass per-image scale.
             const ScalingResult scaling(indexer->GetIntegrationOutcome());
             plot.scale_g = scaling.image_scale_g;
             plot.mosaicity_deg = scaling.mosaicity_deg;
             plot.cc_to_merge = scaling.image_cc;
+            plot.cc_n = scaling.image_cc_n;
         }
         if (result.has_merge_statistics)
             plot.frame_disposition = result.merge_statistics.sweep_quality.frame_disposition;
diff --git a/rugnux_stills_ab.py b/rugnux_stills_ab.py
index eb8fa0366..c0190da1e 100755
--- a/rugnux_stills_ab.py
+++ b/rugnux_stills_ab.py
@@ -300,8 +300,8 @@ def parse_ring_loss(log):
     return {}
 
 
-def parse_image_dat(path):
-    """Per-image scale health from <prefix>_image.dat.
+def parse_plot_txt(path):
+    """Per-image scale health from <prefix>_plot.txt.
 
     This is here because it is what tells a real result from a spurious one. A stills merge is
     ScaleOnTheFly's per-image scale G, and images whose G collapses more than 50x below the run
@@ -313,16 +313,17 @@ def parse_image_dat(path):
     being tested. Print both arms' numbers and the difference is obvious."""
     if not path.exists():
         return {}
+    # Column 6 (0-based 5) of _plot.txt is scale_G; see the file's own '#' legend line.
     g, n = [], 0
     for line in path.read_text(errors="replace").splitlines():
         if line.startswith("#"):
             continue
         f = line.split()
-        if len(f) < 2:
+        if len(f) < 6:
             continue
         n += 1
         try:
-            v = float(f[1])
+            v = float(f[5])
         except ValueError:
             continue
         if v == v and v > 0:
@@ -337,7 +338,7 @@ def parse_image_dat(path):
 
 def collect(cif, report, log=None):
     r = parse_cif(cif)
-    r.update(parse_image_dat(pathlib.Path(str(cif)[:-4] + "_image.dat")))
+    r.update(parse_plot_txt(pathlib.Path(str(cif)[:-4] + "_plot.txt")))
     rep = parse_report(report)
     r["index_rate"] = _f(rep.get("INDEXING_RATE"), 100.0)
     r["images"] = _i(rep.get("IMAGES_PROCESSED"))
@@ -743,7 +744,7 @@ def main():
         print(f"  {'arm':<12} {'images scaled':>14} {'median G':>10} {'5th pct G':>11}   "
               f"(a median G far from 1, or an arm-to-arm change in 'images scaled', means the")
         print(f"  {'':<12} {'':>14} {'':>10} {'':>11}   "
-              f"per-image scaling - not this change - is moving the merge; see parse_image_dat)")
+              f"per-image scaling - not this change - is moving the merge; see parse_plot_txt)")
         warn_scale = False
         for name, reps in per_arm.items():
             for label, r, err, _ in reps:
diff --git a/tests/DiagnosticOutputTest.cpp b/tests/DiagnosticOutputTest.cpp
index bee2592fa..5cde8a597 100644
--- a/tests/DiagnosticOutputTest.cpp
+++ b/tests/DiagnosticOutputTest.cpp
@@ -36,8 +36,10 @@ namespace {
 TEST_CASE("DiagnosticImage_Colors") {
     ColorScale scale;
 
-    // One pixel of each kind, in the order the renderer tests them.
+    // One pixel of each kind, in the order the renderer tests them. Two measured pixels read zero,
+    // so the median is zero and the third one saturates.
     std::vector<uint32_t> mask_bits{
+            0,                                          // plain, no counts
             0,                                          // plain, no counts
             0,                                          // plain, the brightest pixel
             1u << PixelMask::ModuleGapPixelBit,
@@ -46,20 +48,44 @@ TEST_CASE("DiagnosticImage_Colors") {
             (1u << PixelMask::ModuleGapPixelBit) | (1u << PixelMask::BeamStopPixelBit),
             (1u << PixelMask::BeamStopPixelBit) | (1u << PixelMask::NoisyPixelBit)};
     const PixelMask mask(mask_bits);
-    const std::vector<float> projection{0.0f, 1000.0f, NAN, NAN, NAN, NAN, NAN};
+    const std::vector<float> projection{0.0f, 0.0f, 1000.0f, NAN, NAN, NAN, NAN, NAN};
 
     const auto image = DetectorDiagnosticRGB(mask, projection);
     REQUIRE(image.size() == mask_bits.size());
 
     CHECK(same(image[0], scale.Apply(0.0f)));                          // white: no counts
-    CHECK(same(image[1], scale.Apply(1.0f)));                          // indigo: the saturation value
-    CHECK(same(image[2], scale.Apply(ColorScaleSpecial::Gap)));        // grey
-    CHECK(same(image[3], scale.Apply(ColorScaleSpecial::BeamStop)));   // coral
-    CHECK(same(image[4], scale.Apply(ColorScaleSpecial::BadPixel)));   // magenta
+    CHECK(same(image[2], scale.Apply(1.0f)));                          // indigo: the saturation value
+    CHECK(same(image[3], scale.Apply(ColorScaleSpecial::Gap)));        // grey
+    CHECK(same(image[4], scale.Apply(ColorScaleSpecial::BeamStop)));   // coral
+    CHECK(same(image[5], scale.Apply(ColorScaleSpecial::BadPixel)));   // magenta
     // A gap cannot be shadowed - it carries no background for the detection to miss - so the gap
     // wins; every other mask bit loses to the shadow, which is what the picture is there to show.
-    CHECK(same(image[5], scale.Apply(ColorScaleSpecial::Gap)));
-    CHECK(same(image[6], scale.Apply(ColorScaleSpecial::BeamStop)));
+    CHECK(same(image[6], scale.Apply(ColorScaleSpecial::Gap)));
+    CHECK(same(image[7], scale.Apply(ColorScaleSpecial::BeamStop)));
+}
+
+TEST_CASE("DiagnosticImage_Contrast") {
+    ColorScale scale;
+
+    // The ramp saturates at eight times the MEDIAN of the measured pixels - 128 here, so 1024 - so
+    // the background spans the ramp and the peak clips. Set from the brightest pixels instead, as
+    // the preview and the viewer set their contrast, the peak would take the whole range and this
+    // background would sit at the very bottom of the scale, a flat white: a missing background is
+    // what a shadow is read off, so that picture cannot be judged.
+    std::vector<uint32_t> mask_bits{0, 0, 0, 0, 0};
+    const PixelMask mask(mask_bits);
+    const std::vector<float> projection{0.0f, 128.0f, 128.0f, 1024.0f, 5000.0f};
+
+    const auto image = DetectorDiagnosticRGB(mask, projection);
+    const auto &lut = scale.LUTData();
+    REQUIRE(image.size() == projection.size());
+
+    CHECK(same(image[0], lut.front()));
+    CHECK(same(image[1], lut[lut.size() / 8]));
+    CHECK(same(image[2], lut[lut.size() / 8]));
+    CHECK(same(image[3], lut.back()));
+    // Clipped, and that costs nothing here - the spots are not what the picture is judged on.
+    CHECK(same(image[4], lut.back()));
 }
 
 TEST_CASE("DiagnosticPlot_Format") {
@@ -72,6 +98,7 @@ TEST_CASE("DiagnosticPlot_Format") {
     plot.scale_g = {1.0f, 1.1f, NAN, 0.9f};
     plot.mosaicity_deg = {0.12f, 0.12f, NAN, 0.13f};
     plot.cc_to_merge = {0.98f, 0.97f, NAN, 0.5f};
+    plot.cc_n = {500, 480, 0, 120};
     plot.frame_disposition = {static_cast<uint8_t>(FrameDisposition::Merged),
                               static_cast<uint8_t>(FrameDisposition::Downgraded),
                               static_cast<uint8_t>(FrameDisposition::Rejected),
@@ -89,11 +116,12 @@ TEST_CASE("DiagnosticPlot_Format") {
         CHECK(lines[i].find('#') == std::string::npos);
 
     const auto legend = Columns(lines[0]);
-    REQUIRE(legend.size() == 9);
+    REQUIRE(legend.size() == 10);
     CHECK(legend[0] == "#image");
     CHECK(legend[1] == "angle_deg");
     CHECK(legend[6] == "sigma_M_deg");
-    CHECK(legend[8] == "merged");
+    CHECK(legend[8] == "cc_n");
+    CHECK(legend[9] == "merged");
 
     for (size_t i = 1; i < lines.size(); i++) {
         const auto row = Columns(lines[i]);
@@ -106,10 +134,13 @@ TEST_CASE("DiagnosticPlot_Format") {
     CHECK(std::stof(Columns(lines[3])[1]) == 11.25f);
 
     // Merged and downgraded frames are in the merged data; a rejected one is not.
-    CHECK(Columns(lines[1])[8] == "1");
-    CHECK(Columns(lines[2])[8] == "1");
-    CHECK(Columns(lines[3])[8] == "0");
-    CHECK(Columns(lines[4])[8] == "0");
+    CHECK(Columns(lines[1])[9] == "1");
+    CHECK(Columns(lines[2])[9] == "1");
+    CHECK(Columns(lines[3])[9] == "0");
+    CHECK(Columns(lines[4])[9] == "0");
+
+    // The count the correlation beside it was taken over.
+    CHECK(Columns(lines[1])[8] == "500");
 
     // A frame nothing measured leaves its own columns unplottable, not the row missing.
     CHECK(Columns(lines[3])[3] == "nan");
@@ -125,11 +156,29 @@ TEST_CASE("DiagnosticPlot_NoDisposition") {
 
     const auto lines = ReadLines(prefix + "_plot.txt");
     REQUIRE(lines.size() == 4);
-    CHECK(Columns(lines[1])[8] == "1");
-    CHECK(Columns(lines[2])[8] == "0");
-    CHECK(Columns(lines[3])[8] == "1");
+    CHECK(Columns(lines[1])[9] == "1");
+    CHECK(Columns(lines[2])[9] == "0");
+    CHECK(Columns(lines[3])[9] == "1");
 
     // No goniometer: the angle column is present and unplottable, so the columns never shift.
-    CHECK(Columns(lines[1]).size() == 9);
+    CHECK(Columns(lines[1]).size() == 10);
     CHECK(Columns(lines[1])[1] == "nan");
 }
+
+TEST_CASE("DiagnosticPlot_NoMerge") {
+    const std::string prefix = "diagnostic_plot_nomerge_test";
+
+    // Nothing was merged - --no-merge, or a sweep nothing indexed on - so "merged" has no answer to
+    // give and must not read as a sweep every frame of which was thrown out.
+    PerImagePlot plot;
+    plot.bkg_estimate = {12.0f, 13.0f};
+    plot.scale_g = {NAN, NAN};
+    WritePerImagePlot(prefix, plot, {}, 2);
+
+    const auto lines = ReadLines(prefix + "_plot.txt");
+    REQUIRE(lines.size() == 3);
+    CHECK(Columns(lines[1])[9] == "nan");
+    CHECK(Columns(lines[2])[9] == "nan");
+    // The columns a run without a merge still fills are there.
+    CHECK(std::stof(Columns(lines[1])[2]) == 12.0f);
+}
-- 
2.54.0


From 65b9ae1259908bd51cc24b7f865fea57b667ce5c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:23:32 +0200
Subject: [PATCH 101/122] Reader tests for the marCCD header-offset clamp and
 the 2-theta circle

Two cases on the existing byte-for-byte marCCD fixture: a file whose
end-angle block is zeroed while the detector sits on a 2-theta arm must
still name phi as the circle that turned, and a file whose tag 34710
names an offset far past its end must be refused rather than allocated
for. Also drops a bound in SweepLayout that the absolute jitter
threshold makes redundant.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 reader/SweepLayout.cpp     |  2 +-
 tests/JFJochReaderTest.cpp | 43 +++++++++++++++++++++++++++++++++++---
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/reader/SweepLayout.cpp b/reader/SweepLayout.cpp
index 67cda450f..6feae1122 100644
--- a/reader/SweepLayout.cpp
+++ b/reader/SweepLayout.cpp
@@ -142,7 +142,7 @@ Layout Place(const std::vector<Frame> &frames, const std::string &logger_name) {
     double guess = 0;
     for (size_t i = 1; i < frames.size(); i++) {
         const double d = Fold(angle[i] - angle[i - 1]);
-        if (std::abs(d) > std::max(too_fine, 1e-6) && (guess == 0 || std::abs(d) < std::abs(guess)))
+        if (std::abs(d) > too_fine && (guess == 0 || std::abs(d) < std::abs(guess)))
             guess = d;
     }
 
diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp
index d6a61c86f..6b0c0cc19 100644
--- a/tests/JFJochReaderTest.cpp
+++ b/tests/JFJochReaderTest.cpp
@@ -4147,6 +4147,9 @@ namespace {
         int32_t wavelength_e5A = 97872;
         int32_t saturated = 65535;
         int32_t depth = 2;
+        int32_t rotation_axis = 4;        // the circle that turned, as the header's own index (phi)
+        bool zero_end_block = false;      // a writer that fills the start angles and nothing else
+        uint32_t header_offset_tag = MARCCD_HEADER_OFF;   // what tag 34710 claims, true or not
         bool write_instrument_header = true;
     };
 
@@ -4169,7 +4172,7 @@ namespace {
             {277, 3, 1, 1},                                  // SamplesPerPixel
             {278, 4, 1, static_cast<uint32_t>(ny)},          // RowsPerStrip: one strip
             {279, 4, 1, static_cast<uint32_t>(npixel * 2)},  // StripByteCounts
-            {34710, 4, 1, MARCCD_HEADER_OFF},                // where the instrument header begins
+            {34710, 4, 1, f.header_offset_tag},              // where the instrument header begins
         };
         PutU16(file, 8, static_cast<uint16_t>(ifd.size()));
         size_t e = 10;
@@ -4195,8 +4198,11 @@ namespace {
             PutI32(file, h + 656, 1000);                         // exposure, ms
             PutI32(file, h + 668, f.two_theta_mdeg);             // start_twotheta
             PutI32(file, h + 684, f.start_phi_mdeg);             // start_phi
-            PutI32(file, h + 700, f.two_theta_mdeg);             // end_twotheta
-            PutI32(file, h + 716, f.end_phi_mdeg);               // end_phi
+            if (!f.zero_end_block) {
+                PutI32(file, h + 700, f.two_theta_mdeg);         // end_twotheta
+                PutI32(file, h + 716, f.end_phi_mdeg);           // end_phi
+            }
+            PutI32(file, h + 732, f.rotation_axis);
             PutI32(file, h + 736, f.rotation_range_mdeg);
             PutI32(file, h + 772, f.pixel_nm);
             PutI32(file, h + 776, f.pixel_nm);
@@ -4280,6 +4286,37 @@ TEST_CASE("JFJochMarCCDReader_Geometry", "[HDF5][Full]") {
         RemoveMarCCDSweep("marccdpix_", ".mccd");
     }
 
+    SECTION("a swung-out 2-theta arm is not the circle the sweep turned") {
+        // Some writers fill the start angles and leave the whole end block at zero. Reading the
+        // scanned circle as the first start/end pair that differs then picks two_theta, which is the
+        // first pair in the block, and a detector on a 2-theta arm was named as the spindle - with a
+        // start angle that does not move from frame to frame.
+        MarCCDFields f;
+        f.two_theta_mdeg = 20000;      // the detector swung out by 20 deg
+        f.zero_end_block = true;
+        f.rotation_axis = 0;           // ... and the index never filled in either
+        WriteMarCCDSweep("marccd2t_", ".mccd", nx, ny, f);
+        JFJochMarCCDReader reader;
+        REQUIRE_NOTHROW(reader.ReadFiles("marccd2t_001.mccd"));
+        const auto x = reader.GetDataset()->experiment;
+        REQUIRE(x.GetGoniometer().has_value());
+        CHECK(x.GetGoniometer()->GetName() == "phi");
+        CHECK(x.GetGoniometer()->GetStart_deg() == Catch::Approx(0.0));
+        CHECK(x.GetGoniometer()->GetIncrement_deg() == Catch::Approx(0.2));
+        reader.Close();
+        RemoveMarCCDSweep("marccd2t_", ".mccd");
+    }
+
+    SECTION("a header offset the file cannot hold is refused, not allocated") {
+        // The offset comes from TIFF tag 34710 and is read on every input the program is given, so a
+        // foreign or corrupt TIFF can name gigabytes on a file nobody has said is marCCD.
+        MarCCDFields f;
+        f.header_offset_tag = 4000000000u;
+        WriteMarCCDFrame("marccdfaroff_001.mccd", nx, ny, f);
+        CHECK_FALSE(JFJochMarCCDReader::CanRead("marccdfaroff_001.mccd"));
+        remove("marccdfaroff_001.mccd");
+    }
+
     SECTION("a TIFF that is not marCCD is refused, not misread") {
         // The name rule alone matches any numbered TIFF in the directory, so a file with no
         // instrument header must not be opened with a pixel size and a distance of zero.
-- 
2.54.0


From 0f3dbe6e809e51dea7731135e83a197f0aad155a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:33:26 +0200
Subject: [PATCH 102/122] Say why a directory could not be read, instead of
 opening it as HDF5

With the format probes no longer throwing, a directory no reader claims
fell through to the HDF5 reader, which is never what a directory is: the
answer - that no one-file-per-image sweep was found in it - came out
buried under a page of HDF5 stack output. It is now stated.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/rugnux_cli.cpp | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/rugnux/rugnux_cli.cpp b/rugnux/rugnux_cli.cpp
index bc47bde04..55f38c0c0 100644
--- a/rugnux/rugnux_cli.cpp
+++ b/rugnux/rugnux_cli.cpp
@@ -6,6 +6,7 @@
 #include <chrono>
 #include <cmath>
 #include <csignal>
+#include <filesystem>
 #include <future>
 #include <optional>
 #include <getopt.h>
@@ -1443,6 +1444,13 @@ static int RunRugnux(int argc, char **argv) {
             reader_ptr = &smv_reader;
             logger.Info("Read {} SMV images of the sweep containing {}",
                         smv_reader.GetNumberOfImages(), input_file);
+        } else if (std::filesystem::is_directory(input_file)) {
+            // A directory is never an HDF5 master, so handing it to the HDF5 reader only buries the
+            // real answer - that no one-file-per-image sweep was found in it - under a page of HDF5
+            // stack output.
+            logger.Error("{} holds no CBF, marCCD or SMV sweep this program can read (a directory is "
+                         "read as the sweep of frames it holds)", input_file);
+            exit(EXIT_FAILURE);
         } else {
             hdf5_reader.ReadFile(input_file);
             reader_ptr = &hdf5_reader;
-- 
2.54.0


From f9d174ba38c3a9b29537b7d42ae880d92d3c0f77 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:35:07 +0200
Subject: [PATCH 103/122] Report-only twin-immune zones: measure the tNCS on
 the merge they read

The zone table is read on the P1 cross-check merge but was normalised by
result.tncs, a pseudo-translation refined on the adopted group's merge. Where
the pseudo-translation is not compatible with the adopted symmetry that merge
has already averaged across its own phase classes, so the vector fitted there
is poorly determined: measured on one crystal, the correlation between E^2 and
cos(2 pi h.u) reads 0.04 on the group merge against 0.25 on the P1 one, with
the optimum elsewhere entirely. A vector that names the wrong classes
normalises the zone by noise. That merge is also the one a committed change of
basis re-indexes, so a vector measured before the search is not even in its
frame.

Measure it on the P1 cross-check merge itself instead. The nearest existing
vector, pre_tncs, is out of scope there and predates any change of basis, so
this is one extra AnalyzeTranslationalNCS (+2 to +10 s on the crystals
measured, the largest on a 800k-reflection P1 merge).

Report-only, and verified so: over five rotation crystals with a detected
pseudo-translation the merged reflections (p.hkl, p.mtz, p.cif, p_P1.mtz) are
byte-identical, and the adopted space group, the twinning verdict and
TWIN_ZONE_DECISION - the deciding path, which takes its vector from the merge
the search ran on - are unchanged. What moves is the reported
TWIN_ZONE_n/TWIN_ZONE_CONTROL rows: <|E^2-1|> by up to 0.02 on a zone and 0.06
on a control, the zone evidence by up to 35 nats out of 1000-1600.

Also say in the pseudo-symmetry text which vector the modulation belongs to:
the ratio is read on the search's own vector over d >= 4 A, which is what its
control is drawn against, while the vector printed beside it is that one
re-refined on the whole data.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/scale_merge/TranslationalNCS.cpp |  7 +++++--
 rugnux/Rugnux.cpp                               | 14 +++++++++++++-
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/image_analysis/scale_merge/TranslationalNCS.cpp b/image_analysis/scale_merge/TranslationalNCS.cpp
index 7c0634f3b..fc7f6cd32 100644
--- a/image_analysis/scale_merge/TranslationalNCS.cpp
+++ b/image_analysis/scale_merge/TranslationalNCS.cpp
@@ -767,9 +767,12 @@ std::string TranslationalNCSToText(const TranslationalNCSResult &result) {
     os << "\n  [z = " << std::setprecision(1) << result.peak_z << " against a permutation null of "
        << result.null_mean << " +- " << std::setprecision(2) << result.null_sd << "%]\n";
     if (result.modulation_measured)
-        os << "  Intensity modulation along that vector: " << std::setprecision(1) << result.modulation
+        os << "  Intensity modulation: " << std::setprecision(1) << result.modulation
            << "x between the strongest and weakest phase class [random-vector control "
-           << result.modulation_null << "x]\n";
+           << result.modulation_null << "x]\n"
+           << "  [read on the search's own vector over d >= 4 A, which is what the control is drawn\n"
+           << "  against; the vector reported above is that one re-refined on the whole data, so it\n"
+           << "  points more accurately and this number is not re-read off it]\n";
     if (!result.modulation_measured) {
         os << "  The modulation test could not be run - too few acentric reflections beyond 4 A - so\n"
            << "  the peak above stands alone.\n"
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 10a46f362..a1de9c4a3 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -7467,9 +7467,21 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                 // because it is folded under no symmetry, at full resolution and production-scaled.
                 // Report-only: nothing reads it back.
                 if (determined != nullptr && determined->number > 1) {
+                    // The pseudo-translation the zone is normalised by is measured on THIS merge, not
+                    // taken from `result.tncs`. That one is fitted on the adopted group's merge, and
+                    // where the pseudo-translation is not compatible with the adopted symmetry that
+                    // merge has already averaged across its own phase classes, so the vector fitted
+                    // there is poorly determined - measured on one crystal, the correlation between E^2
+                    // and cos(2 pi h.u) reads 0.04 on the group merge against 0.25 here, with the
+                    // optimum elsewhere entirely, and a vector that names the wrong classes normalises
+                    // the zone by noise. It is also the basis this merge is indexed on: a change of
+                    // basis committed by the search leaves a vector measured before it pointing
+                    // somewhere else.
+                    const auto p1_tncs = AnalyzeTranslationalNCS(
+                            p1.merged, gemmi::UnitCell(*result.consensus_cell));
                     result.twin_immune_zones = AnalyzeTwinImmuneZones(
                             p1.merged, gemmi::UnitCell(*result.consensus_cell), *determined,
-                            TranslationalNCSVectorForLTest(result.tncs));
+                            TranslationalNCSVectorForLTest(p1_tncs));
                     if (!result.twin_immune_zones->zones.empty())
                         logger.Info("{}", TwinImmuneZonesToText(*result.twin_immune_zones));
                 }
-- 
2.54.0


From 44777a6f1a6a65f56850db635be8a45408b2641a Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 19:59:01 +0200
Subject: [PATCH 104/122] Bound the merge chi^2 ratio at its good end as well
 as its bad one

The point-group consistency gate refuses a promotion whose merged reduced
chi^2 exceeds max_merge_chi2_ratio times the best subgroup's. A merged reduced
chi^2 decomposes as a^2 + b^2<(I/sigma)^2>: a measurement part a fitted error
model pins near 1, plus a systematic part. The ratio is meant to compare the
systematic parts, but it divides by the total, so the allowance it grants is
(ratio - 1) x (a^2 + b_ref^2<(I/sigma)^2>). On a reference merge that is
cleanly scaled the systematic term vanishes and only the fixed a^2 term is
left, which makes the "ratio" an absolute bound on the added disagreement
scaled by the crystal's own <(I/sigma)^2> - so the better the data are
measured, the harsher the gate, and a crystal is refused for the cleanliness
of its own reference merge.

Measured on one crystal collected twice at two resolutions: the added
operators cost the same absolute chi^2 (+1.16 and +1.07) and the same
systematic b (0.080 and 0.074) both times, but the cleaner reference
(chi2_ref 1.21 against 1.44) turned that into 1.96x against 1.74x, and only
the better-measured of the two was refused its centred orthorhombic group -
which merges to higher completeness, higher multiplicity, higher I/sigma,
lower R_meas and higher CC1/2 than the monoclinic subgroup it was held in.

So below chi2_ref_informative the ratio is not read. The reference has no
systematic error to be a denominator, and the candidate is judged on the
absolute form of the same question instead, against the standard
chi2_ref_reliable already sets: the merge under it must itself look
calibrated. That keeps the degenerate case the ratio read correctly - a
noiseless reference against a false operator whose own merged chi^2 is in the
thousands - and leaves the H and added-operator-R gates untouched as the
necessary conditions no abstention can lift. max_merge_chi2_ratio is
unchanged.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/SearchSpaceGroup.cpp          | 21 ++++++++++++++++-
 image_analysis/scale_merge/SearchSpaceGroup.h | 23 +++++++++++++++++++
 2 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index df62dfde0..8b817a44e 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -1505,6 +1505,23 @@ SearchSpaceGroupResult SearchSpaceGroup(
     const PointGroupInfo* best_pg = nullptr;
     int best_pg_order = 0;
     double best_pg_min_cc = -2.0;
+    // The chi^2 ratio compares two merges' systematic error but divides by their total, so it only
+    // measures a ratio where the reference merge HAS systematic error to be the denominator. Once
+    // chi2_ref falls to the measurement floor a fitted error model pins it at, the bound is an
+    // absolute one on the added disagreement, scaled by the crystal's own <(I/sigma)^2> - and the
+    // better the data, the harsher it gets. See chi2_ref_informative for the derivation and the
+    // controlled pair it was measured on. Both ends of the statistic are now bounded: above
+    // chi2_ref_reliable the sigmas are too wrong for it, below this they are too right.
+    //
+    // Abstaining is not the same as waving the candidate through: where the reference has no
+    // systematic error to be a denominator, the candidate is judged on the ABSOLUTE standard instead
+    // of a relative one, and it is the same standard chi2_ref_reliable already sets for the reference
+    // - the merge under it must itself look like a calibrated one. That keeps the case the ratio was
+    // reading correctly all along: a reference that merges with no scatter at all (chi2_ref ~ 0, which
+    // is where a ratio is most meaningless) against a false operator whose own merged chi^2 is in the
+    // thousands. Only a candidate that merges like a real dataset is let past.
+    const bool chi2_ratio_uninformative =
+            std::isfinite(chi2_ref) && chi2_ref < opt.chi2_ref_informative;
     for (auto& c : pg_cands) {
         // A genuine symmetry operator merges equivalent reflections, so it barely changes the reduced
         // chi^2 relative to the best subgroup - across the whole rotation-test battery every correct
@@ -1516,7 +1533,9 @@ SearchSpaceGroupResult SearchSpaceGroup(
         // weakness; the variance-floor fix removed that inflation, and the widening now only let the
         // twin through, so it is gone.)
         bool consistent = c.pg->rotations.empty() || !std::isfinite(c.chi2) ||
-                          !std::isfinite(chi2_ref) || c.chi2 <= chi2_ref * opt.max_merge_chi2_ratio;
+                          !std::isfinite(chi2_ref) ||
+                          (chi2_ratio_uninformative && c.chi2 <= opt.chi2_ref_reliable) ||
+                          c.chi2 <= chi2_ref * opt.max_merge_chi2_ratio;
 
         // Systematic-error test vs the largest confirmed subgroup (by rotation-set inclusion): merging
         // under a genuine operator gains multiplicity without intensity-proportional disagreement, so the
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index c02478a8a..5f43761dd 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -476,6 +476,29 @@ struct SearchSpaceGroupOptions {
     // against a twin: both are necessary conditions no rescue can lift.
     double chi2_ref_reliable = 3.0;
 
+    // The other end of the same statistic, where it also stops meaning anything. A merged reduced
+    // chi^2 decomposes as chi2 = a^2 + b^2 <(I/sigma)^2>: a measurement part, which a fitted error
+    // model pins at ~1 for every crystal, plus a systematic part b^2<(I/sigma)^2>. The ratio
+    // chi2_cand / chi2_ref is meant to compare the SYSTEMATIC parts - how much intensity-proportional
+    // disagreement the added operators bring, against how much the reference merge already carries -
+    // but it divides by the total. Expanding the bound, a promotion is allowed added variance
+    // (ratio - 1) x (a^2 + b_ref^2<(I/sigma)^2>): the second term is the intended relative allowance,
+    // the first is a fixed one that has nothing to do with the crystal. Where the reference merge is
+    // cleanly scaled its systematic part goes to zero, the fixed term is all that is left, and the
+    // "ratio" is really an absolute bound on b_added^2<(I/sigma)^2> - so the same real degradation
+    // reads larger the better the data are measured, and a crystal is refused for the cleanliness of
+    // its own reference merge. Measured on one crystal collected twice: the added operators cost the
+    // same absolute chi^2 both times (+1.16 and +1.07) and the same systematic b (0.080 and 0.074),
+    // but the cleaner reference (chi2_ref 1.21 against 1.44) turned that into 1.96x against 1.74x, and
+    // only the cleaner merge was refused. So below this chi2_ref the ratio is not read at all. The
+    // value is where the two parts of chi2_ref are equal - systematic content matching measurement
+    // content, a^2 ~ 1 plus as much again - not a level tuned to any dataset. The b test is NOT the
+    // fallback here as it is under chi2_ref_reliable: it divides by the reference's own b and fails in
+    // exactly the same way. What replaces the ratio is the ABSOLUTE form of the same question,
+    // against chi2_ref_reliable: the merge under the candidate must itself look calibrated. The H and
+    // added-operator-R gates still apply on top, as necessary conditions no rescue can lift.
+    double chi2_ref_informative = 2.0;
+
     // Adopt this space group's point group instead of the one Stage A would choose, and go straight to
     // Stage B with it. Used when one merge decides the point group and a different merge has to decide
     // the absences: a caller cannot pass the point group by name, because gemmi reports both P321 and
-- 
2.54.0


From c6a58d96c7166c768d490fd1fe47b4403730388e Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 20:02:04 +0200
Subject: [PATCH 105/122] Twin-immune zone: carry the pseudo-translation across
 a committed reindex

The zone that arbitrates a refused point group is read on the merge that
follows a committed change of basis (Rugnux.cpp: the reindex re-indexes every
integrated reflection and re-ingests the rotation merge, and the merge the zone
reads is made after that), but the pseudo-translation it was normalised by is
measured on the search merge, before it. The zone spends that vector assigning
each reflection a phase class by cos(2 pi h.u), which is a phase class only if h
and u are in the same basis; left in the old one it partitions the reflections
at random and normalises the zone by noise, with nothing in the numbers to say
so.

The reindex is (h,k,l)_new = M (h,k,l)_old, so h.u is preserved by
u_new = (M^T)^-1 u_old - the ordinary transformation of a real-space fractional
coordinate. Transform rather than re-measure: the vector is better determined on
the search merge (a merge already folded under the adopted symmetry has averaged
across the very phase classes the vector names), the transform is exact, and it
costs nothing where re-measuring costs a second pseudo-translation analysis.

Reachability: over eleven battery runs no crystal both commits a change of basis
and carries a detected pseudo-translation into a refused point group, so no
merged result in the corpus moves. The population that commits one has just
grown, which is why it is worth fixing now rather than when it first bites.

How wrong the vector is depends on it. A half-integer vector compatible with the
committed centring survives unchanged - the two expressions differ by a lattice
vector and every allowed reflection sees the same class. A general one does not:
for an I-centring commit, cos(2 pi h.u) read in the two bases correlates -0.01
over the allowed reflections and disagrees in sign on 51% of them.

Verified unchanged where nothing is committed: three rotation crystals with a
detected pseudo-translation - two of them arbitrating a refused point group on
this zone, one of them committing a reindex without a refusal - give
byte-identical output.hkl, output.mtz, output.cif, output_P1.mtz and
output_unmerged.mtz, and the same space group and TWIN_ZONE_DECISION.
[tncs], [twinning] and [SearchSpaceGroup] pass.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/Rugnux.cpp | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 10a46f362..9276b6999 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -6703,9 +6703,25 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                     // refused group and acentric in the adopted one, so they are distinct reflections
                     // of this merge, at full multiplicity and production scale - where the P1 search
                     // merge of a weak crystal has no shell with signal enough to read a zone on.
+                    // The pseudo-translation is carried into the basis this merge is indexed on. It was
+                    // measured on the search merge, before the change of basis committed above re-indexed
+                    // the reflections, and the zone spends it assigning each reflection a phase class by
+                    // cos(2 pi h.u) - which is a phase class only if h and u share a basis. Left in the
+                    // old one it names classes at random and normalises the zone by noise, silently: the
+                    // numbers stay the size they were. The reindex is (h,k,l)_new = M (h,k,l)_old, so h.u
+                    // is preserved by u_new = (M^T)^-1 u_old - the ordinary transformation of a
+                    // real-space fractional coordinate. Where nothing was committed this is the identity.
+                    TranslationalNCSResult zone_tncs = pre_tncs;
+                    if (commit_reindex && zone_tncs.detected) {
+                        const gemmi::Vec3 u = commit_reindex->transpose().inverse().multiply(
+                                gemmi::Vec3(pre_tncs.vector_frac[0], pre_tncs.vector_frac[1],
+                                            pre_tncs.vector_frac[2]));
+                        zone_tncs.vector_frac = {u.x - std::floor(u.x), u.y - std::floor(u.y),
+                                                 u.z - std::floor(u.z)};
+                    }
                     const int zone = hi_sg.has_value()
                                      ? TwinZoneVerdict(sm.merged, gemmi::UnitCell(*result.consensus_cell), hi_search,
-                                                       sg_search, result, TranslationalNCSVectorForLTest(pre_tncs)) : 0;
+                                                       sg_search, result, TranslationalNCSVectorForLTest(zone_tncs)) : 0;
                     if (zone < 0) {
                         const std::string msg = fmt::format(
                                 "Point group {} was refused ({}), and the twin-immune zone of its added "
-- 
2.54.0


From 373fda05a459892b917003acac2aecac22453c11 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 20:10:43 +0200
Subject: [PATCH 106/122] CUDA: a handled failure discharges the error it
 leaves behind

rc.172 stopped two CUDA failures from staying behind as the thread's last error, both inside
CUDAMemHelpers.h: a pooled allocation that fell back to cudaMalloc, and a stream that could not be
created. The reason those mattered was general, and four other places have it too.

Nothing but cudaGetLastError() takes an error away. A later successful call neither clears it nor
returns it - measured: after a cudaMalloc that cannot be served, cudaStreamSynchronize,
cudaMemcpyAsync and a small cudaMalloc all report success, and the "out of memory" is still waiting
for whoever calls cudaGetLastError() next. In this code that is the check after a kernel launch. So
wherever a CUDA failure is caught and the work carries on by another route, the error it left is
reported over the route that went fine:

  - the device decoder in MXAnalysisWithoutFPGA::Analyze, whose failure is answered by decompressing
    on the host - and the host route runs kernels of its own. This is the broker's path, and it is
    the pair of log lines a long-running broker showed, one warning naming the device route and one
    fatal error naming nothing.
  - the indexer worker, which turns a failed attempt into a result and goes on to the next frame -
    on the same thread, so one failure would read as an indexer that never works again.
  - the beam stop's GPU accumulate and the FFT beam-centre capture, both of which fall back to the
    host.

Each discharges it now, through cuda_clear_error() in CUDAWrapper (a no-op without CUDA). A sticky
error is not cleared by this and nothing here pretends otherwise.

tests/CudaHandledErrorTest.cpp: that a failed allocation leaves an error which survives later
successful work until it is cleared, and that an image whose device decode fails comes out of
Analyze whole and leaves nothing behind for the next one.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 common/CUDAWrapper.cpp                        |  2 +
 common/CUDAWrapper.cu                         |  4 +
 common/CUDAWrapper.h                          |  8 ++
 image_analysis/MXAnalysisWithoutFPGA.cpp      |  5 ++
 image_analysis/beam_stop/ShadowFinder.cpp     |  1 +
 .../geom_refinement/BeamCenterFFT.cpp         |  1 +
 image_analysis/indexing/IndexerThreadPool.cpp |  4 +
 tests/CMakeLists.txt                          |  1 +
 tests/CudaHandledErrorTest.cpp                | 85 +++++++++++++++++++
 9 files changed, 111 insertions(+)
 create mode 100644 tests/CudaHandledErrorTest.cpp

diff --git a/common/CUDAWrapper.cpp b/common/CUDAWrapper.cpp
index 3cedde9d0..22d12c221 100644
--- a/common/CUDAWrapper.cpp
+++ b/common/CUDAWrapper.cpp
@@ -38,4 +38,6 @@ void set_gpu(int32_t dev_id) {}
 
 void pin_gpu() {}
 
+void cuda_clear_error() {}
+
 #endif
diff --git a/common/CUDAWrapper.cu b/common/CUDAWrapper.cu
index 51e203cf9..5cc0669db 100644
--- a/common/CUDAWrapper.cu
+++ b/common/CUDAWrapper.cu
@@ -61,3 +61,7 @@ void pin_gpu() {
     if (dev_count > 0)
         set_gpu(counter.fetch_add(1) % dev_count);
 }
+
+void cuda_clear_error() {
+    cudaGetLastError();
+}
diff --git a/common/CUDAWrapper.h b/common/CUDAWrapper.h
index ccbd4a758..2b078ba3f 100644
--- a/common/CUDAWrapper.h
+++ b/common/CUDAWrapper.h
@@ -22,3 +22,11 @@ void set_gpu(int32_t dev_id);
 // (counter++ % get_gpu_count()). Call once per thread; no thread id needed. No-op when no GPU
 // is visible. Honours CUDA_VISIBLE_DEVICES via get_gpu_count().
 void pin_gpu();
+
+// Drop the error CUDA has recorded for the calling thread. Call it where a CUDA failure has been
+// HANDLED - a device route that fell back to the host, an indexing attempt whose failure was turned
+// into a result - because the error otherwise stays as the thread's last error and the next
+// cuda_err(cudaGetLastError()) after some later kernel launch reports it, over work that went fine.
+// A sticky error (an illegal access, say) is not cleared by this, and nothing here pretends it is:
+// the context is gone in that case and every later call fails on its own. No-op without CUDA.
+void cuda_clear_error();
diff --git a/image_analysis/MXAnalysisWithoutFPGA.cpp b/image_analysis/MXAnalysisWithoutFPGA.cpp
index 740798420..93a3d736d 100644
--- a/image_analysis/MXAnalysisWithoutFPGA.cpp
+++ b/image_analysis/MXAnalysisWithoutFPGA.cpp
@@ -8,6 +8,7 @@
 
 #include "spot_finding/StrongPixelSet.h"
 #include "../compression/JFJochDecompress.h"
+#include "../common/CUDAWrapper.h"
 
 #include "spot_finding/SpotUtils.h"
 #include "bragg_prediction/BraggPredictionFactory.h"
@@ -107,6 +108,10 @@ void MXAnalysisWithoutFPGA::Analyze(DataMessage &output,
         // rather than the acquisition.
         spdlog::warn("Device decoding failed ({}), falling back to host decompression", e.what());
         decoded_on_device = false;
+        // Handled here, so it must not stay behind as the thread's last error: the host route below
+        // runs kernels of its own and checks cudaGetLastError() after them, which would report this
+        // failure again - fatally - over an image that decoded perfectly well on the host.
+        cuda_clear_error();
     }
     const auto compression_end_time = std::chrono::steady_clock::now();
 
diff --git a/image_analysis/beam_stop/ShadowFinder.cpp b/image_analysis/beam_stop/ShadowFinder.cpp
index a0d3559a3..6a6816173 100644
--- a/image_analysis/beam_stop/ShadowFinder.cpp
+++ b/image_analysis/beam_stop/ShadowFinder.cpp
@@ -447,6 +447,7 @@ void ShadowFinder::AddImage(const DataMessage &data, std::vector<uint8_t> &buffe
             return;
         } catch (const std::exception &e) {
             spdlog::warn("Beam stop: GPU accumulate failed ({}), falling back to the host", e.what());
+            cuda_clear_error();   // handled - see cuda_clear_error()
         }
     }
 #endif
diff --git a/image_analysis/geom_refinement/BeamCenterFFT.cpp b/image_analysis/geom_refinement/BeamCenterFFT.cpp
index 8ebf71bd9..8c2f60366 100644
--- a/image_analysis/geom_refinement/BeamCenterFFT.cpp
+++ b/image_analysis/geom_refinement/BeamCenterFFT.cpp
@@ -236,6 +236,7 @@ BeamCenterFFTResult BeamCenterFFTScore(int64_t width, int64_t height,
             // The card is shared with this run's analysis workers, so the memory the check above
             // saw can be gone by the time it is asked for. A capture is not worth failing a run
             // over: score it on the CPU instead.
+            cuda_clear_error();   // handled - see cuda_clear_error()
         }
     }
 #endif
diff --git a/image_analysis/indexing/IndexerThreadPool.cpp b/image_analysis/indexing/IndexerThreadPool.cpp
index 56b925c18..5b119957a 100644
--- a/image_analysis/indexing/IndexerThreadPool.cpp
+++ b/image_analysis/indexing/IndexerThreadPool.cpp
@@ -156,6 +156,10 @@ void IndexerThread::Worker(int threadid) {
                 spdlog::error("Indexer thread {} failed: {}", threadid, e.what());
                 tmp_result = std::make_unique<IndexerResult>(IndexerResult{
                         .lattice = {}, .indexing_time_s = 0, .executed = false, .error = e.what()});
+                // This thread goes on to the next frame, so a CUDA error left behind here would be
+                // reported by the first cudaGetLastError() of every frame that follows - one failed
+                // attempt would read as an indexer that never works again.
+                cuda_clear_error();
             }
             {
                 std::unique_lock<std::mutex> lock(m);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 6e90cd2bf..c0e10383c 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -80,6 +80,7 @@ ADD_EXECUTABLE(jfjoch_test
         AdaptiveSpotFinderGPUTest.cpp
         SpotExtractorGPUParityTest.cpp
         CUDAMemHelpersTest.cpp
+        CudaHandledErrorTest.cpp
         CalcBraggPredictionTest.cpp
         SpotUtilsTest.cpp
         LatticeSearchTest.cpp
diff --git a/tests/CudaHandledErrorTest.cpp b/tests/CudaHandledErrorTest.cpp
new file mode 100644
index 000000000..9889ddfc1
--- /dev/null
+++ b/tests/CudaHandledErrorTest.cpp
@@ -0,0 +1,85 @@
+// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute
+// SPDX-License-Identifier: GPL-3.0-only
+
+#include <catch2/catch_all.hpp>
+#include "../common/CUDAWrapper.h"
+
+#ifdef JFJOCH_USE_CUDA
+
+#include <cuda_runtime.h>
+#include <limits>
+
+#include "../common/AzimuthalIntegrationMapping.h"
+#include "../common/AzimuthalIntegrationProfile.h"
+#include "../common/DiffractionExperiment.h"
+#include "../common/PixelMask.h"
+#include "../compression/JFJochCompressor.h"
+#include "../image_analysis/IndexAndRefine.h"
+#include "../image_analysis/MXAnalysisWithoutFPGA.h"
+#include "../image_analysis/indexing/CUDAMemHelpers.h"
+
+// What makes a handled CUDA failure dangerous: the failed call leaves the error behind as the
+// thread's last error, and nothing but cudaGetLastError() takes it away - later successful calls
+// neither clear it nor return it. So a route that failed, was caught and was replaced by another
+// one hands its error to the next cudaGetLastError() in the code that followed, which is the check
+// after a kernel launch. That is how a broker logged a raw "out of memory" over an image whose
+// buffers were all allocated. cuda_clear_error() is what a handled failure discharges it with.
+TEST_CASE("CudaDevicePtr_FailedAllocationLeavesErrorUntilCleared", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    cuda_clear_error();
+    REQUIRE_THROWS(CudaDevicePtr<uint8_t>(std::numeric_limits<size_t>::max(), CudaAlloc::Synchronous));
+
+    // Work that goes fine in between changes nothing: the error is still waiting.
+    CudaDevicePtr<uint8_t> fine(1 << 16);
+    REQUIRE(cudaStreamSynchronize(cuda_allocation_stream()) == cudaSuccess);
+
+    cuda_clear_error();
+    CHECK(cudaGetLastError() == cudaSuccess);
+}
+
+// The device decoder is allowed to fail - the host decompresses instead - but the host route runs
+// kernels of its own and checks cudaGetLastError() after them. An image must come out of that
+// whole, and with nothing left behind for the next one.
+TEST_CASE("MXAnalysis_HandledDeviceDecodeFailureLeavesNoError", "[CUDAMemHelpers]") {
+    if (get_gpu_count() == 0)
+        SKIP("No CUDA GPU present");
+
+    constexpr size_t width = 1030, height = 1064;
+
+    DiffractionExperiment experiment(DetDECTRIS(width, height, "Test", {}));
+    experiment.ImagesPerTrigger(1).NumTriggers(1).PixelSigned(false)
+            .DetectorDistance_mm(75).BeamX_pxl(515).BeamY_pxl(532).IncidentEnergy_keV(12.4);
+
+    PixelMask pixel_mask(experiment);
+    AzimuthalIntegrationMapping mapping(experiment, pixel_mask);
+    IndexAndRefine index_and_refine(experiment, nullptr);
+    MXAnalysisWithoutFPGA analysis(experiment, mapping, pixel_mask, index_and_refine);
+
+    std::vector<uint16_t> pixels(width * height, 0);
+    for (size_t i = 0; i < pixels.size(); i += 997)
+        pixels[i] = 500;
+    JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_LZ4);
+    const std::vector<uint8_t> compressed = compressor.Compress(pixels);
+    REQUIRE(!compressed.empty());
+
+    DataMessage message{};
+    message.number = 0;
+    message.image = CompressedImage(compressed.data(), compressed.size(), width, height,
+                                    CompressedImageMode::Uint16, CompressionAlgorithm::BSHUF_LZ4);
+
+    SpotFindingSettings settings = DiffractionExperiment::DefaultDataProcessingSettings();
+    settings.enable = false;
+
+    // Stage the device route into failing, by leaving behind the error a request the card cannot
+    // serve leaves.
+    void *unservable = nullptr;
+    REQUIRE(cudaMalloc(&unservable, std::numeric_limits<size_t>::max()) != cudaSuccess);
+
+    AzimuthalIntegrationProfile profile(mapping);
+    REQUIRE_NOTHROW(analysis.Analyze(message, profile, settings));
+    CHECK(cudaGetLastError() == cudaSuccess);
+}
+
+#endif
-- 
2.54.0


From d10f48cb9a054d838c8c95563ed14182b1c4eef0 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Sun, 20 Sep 2026 20:22:54 +0200
Subject: [PATCH 107/122] CI: a hand-built release does not re-run the unit
 tests

The push that put the commit on a branch has already run the suite on that
very commit, and the merge to main runs it again. Only the manual
release build skips it, and only because the wait there is pure delay.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .gitea/workflows/build_and_test.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml
index e379a75a5..c848c85ce 100644
--- a/.gitea/workflows/build_and_test.yml
+++ b/.gitea/workflows/build_and_test.yml
@@ -41,6 +41,10 @@ on:
 jobs:
   unit-tests:
     name: Unit tests
+    # A release built by hand does not re-run the suite: the push that put the commit on a branch
+    # already ran it on that very commit, and so does the merge to main. Nothing is skipped that
+    # was not already run, and a release build is the one case where the wait is pure delay.
+    if: "!(github.event_name == 'workflow_dispatch' && (github.event.inputs.create_release == 'true' || github.event.inputs.create_release == true))"
     runs-on: jfjoch_rocky8
     container:
       image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2609
-- 
2.54.0


From a970e5223b3ce23d3faee03746f1977f85235fd2 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 08:45:51 +0200
Subject: [PATCH 108/122] Rotation scaling: the smoothness restraint is
 released where the frames outvote it

The per-frame scale is smoothed over the rotation inside both scaling loops, which is what stopped a
fine-sliced sweep of a small cell from walking its own scales down fifteen decades. But the window is
a prior about the dose and the crystal, and on a merge where one frame carries hundreds of
observations the frame's own data outvote it. Smoothing them anyway does not remove the per-frame
structure, it moves it into the error model: on a 360 degree merge at 14x multiplicity the scale the
window averaged away is 2.2% rms, which is most of the 2.4% of unmodelled error the change added
there, and it cost ISa 29.0 -> 23.8 and 43.3 -> 38.0 on two long high-multiplicity protein sweeps.

So the loop over the fulls now ends with one free fit against the settled reference, shrunk frame by
frame back toward the restrained scale by how much of the difference is real. Real and noise separate
with nothing to tune, because a rocking event spans several frames and the fit's noise does not:
whatever moved a frame's scale moved its neighbour's, so the lag-1 covariance of the difference is
the systematic's variance and what is left of the total is the fit's. A sweep that measures its
scales to a fraction of a percent keeps nearly all of what it measured; one sliced at a twentieth of
its rocking curve, where a frame holds twenty-five fulls and the difference has no correlation with
its neighbour at all, keeps none of it and is scaled exactly as before. Neither is told which it is.

Only the fulls, and only off a settled loop. A partial's scale is the direction the collapse runs in
and handing any of it back re-opens it - shrunk or not, it costs ISa 23.8 -> 14.8 on the same merge
and takes a small-cell monoclinic set from 14.2 to 2.7 - while a full is a whole rocking event and
cannot enter it; and a loop that walked until it was stopped has measured nothing to hand back.

Measured against the current behaviour. Two long high-multiplicity protein sweeps: ISa 23.8 -> 27.0
and 38.0 -> 41.3, with R_meas and the anomalous signal moving with them (SigAno 0.929 -> 0.949,
CC_anom 0.18 -> 0.22 on the first). A long-wavelength, high-multiplicity series collected at three
goniometer settings - the case the restraint is right for, sliced twenty times finer than its rocking
curve: ISa 13.7 -> 13.9, 14.2 -> 14.6, 12.5 -> 12.8, SigAno up on all three, and the anomalous peak
heights at the deposited model's own sites unchanged to a tenth of a sigma. The fine-sliced, small-cell
and powder sets the restraint was added for are unchanged to the last reported digit, as are the
short-sweep tetragonal pair and every space group.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 124 +++++++++++++++++-
 .../scale_merge/RotationScaleMerge.h          |   8 ++
 2 files changed, 128 insertions(+), 4 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index c2445a590..602d26fa5 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -41,6 +41,10 @@ namespace {
     // The per-frame scale is smoothed over at least this many rocking curves (see Run).
     constexpr int SMOOTH_G_MIN_ROCKING_EVENTS = 6;
 
+    // ShrinkToRestrained reads two variances off the frames of the sweep; on fewer frames than this
+    // neither of them means anything, and the restraint is kept whole.
+    constexpr size_t MIN_FRAMES_FOR_SHRINKAGE = 20;
+
     // A fitted per-frame scale below this fraction of the run's median is not a measurement of anything:
     // it would mean the frame received 2% of its neighbours' dose while still producing indexable spots.
     // It matters because the scale enters as 1/G, so a G that collapses toward zero multiplies every
@@ -1409,8 +1413,86 @@ void RotationScaleMerge::UpdateCorr(std::vector<Obs> &obs, const std::vector<dou
     });
 }
 
+void RotationScaleMerge::ShrinkToRestrained(const char *what, const std::vector<double> &g_restrained,
+                                            const std::vector<uint8_t> &fitted,
+                                            const std::vector<int32_t> &frame_obs_count,
+                                            std::vector<double> &g) const {
+    // g comes in as a free fit and goes out shrunk toward g_restrained. d is what a frame's own
+    // observations say about its scale beyond its neighbourhood's, and it is two things added: the
+    // per-frame systematic the smoothing window averaged away, and the noise of the frame's own fit.
+    //
+    // They separate without a constant to choose, because the first is shared with the next frame
+    // and the second is not: a rocking event spans several frames, so whatever moved this frame's
+    // scale moved its neighbour's, while the fit's noise comes from disjoint observations. The
+    // lag-1 covariance of d is therefore the systematic's variance and what is left of var(d) is
+    // the fit's, and each frame keeps the fraction of its d that its own observations support -
+    // everything on a merge that measures the scale to a fraction of a percent, nothing on one
+    // where d is the fit talking to itself.
+    //
+    // Measured: on a 360 deg, 14x lysozyme merge the fulls' d is 2.2% rms with a lag-1
+    // autocorrelation of 0.44, and keeping it is worth ISa 23.8 -> 27.0; on a 1440 deg sweep sliced
+    // at a twentieth of its rocking curve, where a frame holds 25 fulls, d is 7.0% rms with a lag-1
+    // autocorrelation of 0.02 and is discarded. Neither sweep was told which it was.
+    const int n = static_cast<int>(g.size());
+    std::vector<double> d(n, 0.0);
+    std::vector<double> d2, cross, inv_n;
+    auto usable = [&](int f) {
+        return fitted[f] && frame_obs_count[f] > 0 && g_restrained[f] > 0.0
+               && std::isfinite(g[f]) && g[f] > 0.0;
+    };
+    for (int f = 0; f < n; ++f)
+        if (usable(f)) d[f] = std::log(g[f] / g_restrained[f]);
+    for (int f = 0; f < n; ++f) {
+        if (!usable(f)) continue;
+        d2.push_back(d[f] * d[f]);
+        inv_n.push_back(1.0 / frame_obs_count[f]);
+        if (f + 1 < n && usable(f + 1)) cross.push_back(d[f] * d[f + 1]);
+    }
+    // Too few frames to read either variance off: leave the restrained scale where it is.
+    if (d2.size() < MIN_FRAMES_FOR_SHRINKAGE || cross.size() < MIN_FRAMES_FOR_SHRINKAGE) {
+        for (int f = 0; f < n; ++f)
+            if (usable(f)) g[f] = g_restrained[f];
+        return;
+    }
+    // var(d) from the median of d^2 against the median of a chi^2 with one degree of freedom, so a
+    // handful of frames the fit lost control of cannot set the scale of the whole sweep.
+    std::vector<double> d2_copy = d2;
+    const double var_d = median_of(d2_copy) / 0.4549;
+    // The cross products are signed, and a median has no useful null for a product, so the mean of
+    // the middle nine tenths instead - the same purpose, the same robustness, no distributional
+    // assumption.
+    std::sort(cross.begin(), cross.end());
+    const size_t lo = cross.size() / 20, hi = cross.size() - cross.size() / 20;
+    double sum_cross = 0.0;
+    for (size_t i = lo; i < hi; ++i) sum_cross += cross[i];
+    const double cov_1 = hi > lo ? sum_cross / static_cast<double>(hi - lo) : 0.0;
+    const double var_real = std::clamp(cov_1, 0.0, var_d);
+    const double var_fit = std::max(0.0, var_d - var_real);
+    // The fit's variance goes as 1/n_obs, so one number sets it for every frame.
+    double mean_inv_n = 0.0;
+    for (double v : inv_n) mean_inv_n += v;
+    mean_inv_n /= static_cast<double>(inv_n.size());
+    const double fit_var_coeff = mean_inv_n > 0.0 ? var_fit / mean_inv_n : 0.0;
+    double kept_sum = 0.0;
+    int kept_n = 0;
+    for (int f = 0; f < n; ++f) {
+        if (!usable(f)) continue;
+        const double var_f = fit_var_coeff / frame_obs_count[f];
+        const double kept = var_real + var_f > 0.0 ? var_real / (var_real + var_f) : 0.0;
+        g[f] = g_restrained[f] * std::exp(kept * d[f]);
+        kept_sum += kept;
+        ++kept_n;
+    }
+    logger.Info("Per-frame scaling ({}): the scales carry {:.0f}% of what each frame's own "
+                "observations say beyond its neighbourhood's - that deviation is {:.2f}% rms, of "
+                "which {:.2f}% is shared with the next frame and the rest is the fit's own noise",
+                what, 100.0 * (kept_n ? kept_sum / kept_n : 0.0), 100.0 * std::sqrt(var_d),
+                100.0 * std::sqrt(var_real));
+}
+
 RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
         const char *what, std::vector<double> &g, const std::vector<int32_t> &frame_obs_count, int window,
+        bool release_restraint,
         const std::function<void()> &iterate,
         const std::function<void(const std::vector<uint8_t> &, const std::vector<double> &)> &rescale) {
     // Alternating least squares on a bilinear model: the reference intensities given the scales, the
@@ -1434,6 +1516,15 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
     // mean, so no frame can lose its vote alone, and what a frame's own observations cannot determine
     // its neighbourhood's do. The post-loop smoothing is then this same operation and is not repeated.
     //
+    // The restraint is a prior, though, not a measurement, and on a merge where a frame carries
+    // hundreds of observations the frame's own data outvote it. So a loop that is asked to
+    // (release_restraint) ends with ONE free fit against the settled reference, shrunk frame by
+    // frame toward the restrained scale by how much of the difference is real - see
+    // ShrinkToRestrained. Only the loop over the fulls is asked to: a partial's scale is the
+    // direction the collapse runs in, and handing any of it back re-opens it (measured: ISa 23.8 ->
+    // 22.1 on a 360 deg, 14x merge), while a full is a whole rocking event and cannot enter it. And
+    // only off a loop that settled, since a loop still walking has measured nothing to hand back.
+    //
     // The loop stops when the relative scales stop moving - the rms of |log(G_new/G_old)| over the
     // frames, each weighted by its observation count and nothing else (a weight that vanishes with G
     // is what let a collapsing sweep report itself settled) - or when they stop settling: a step that
@@ -1499,6 +1590,27 @@ RotationScaleMerge::ScalingLoopOutcome RotationScaleMerge::RunScalingLoop(
         g_prev = g;
     }
     frame_scaled_scratch = scaled_any;
+    // Only off a settled loop: the deviation below is a measurement of the frames, and a loop that
+    // walked until it was stopped has not measured them.
+    if (release_restraint && window > 1 && out.converged) {
+        const std::vector<double> g_restrained = g;
+        iterate();                                  // one free fit against the settled reference
+        for (int f = 0; f < n_frames; ++f)
+            scaled_any[f] |= frame_scaled_scratch[f];
+        const std::vector<double> g_free = g;
+        ShrinkToRestrained(what, g_restrained, scaled_any, frame_obs_count, g);
+        for (int f = 0; f < n_frames; ++f)
+            n_obs[f] = scaled_any[f] && std::isfinite(g[f]) && g[f] > 0.0 ? frame_obs_count[f] : 0;
+        const double g_ref = TypicalFrameScale(g, n_obs);
+        for (int f = 0; f < n_frames; ++f) {
+            if (!scaled_any[f] || !(std::isfinite(g[f]) && g[f] > 0.0)) { ratio[f] = 1.0; continue; }
+            ratio[f] = g_free[f];
+            g[f] /= g_ref;
+            ratio[f] /= g[f];
+        }
+        rescale(scaled_any, ratio);
+        frame_scaled_scratch = scaled_any;
+    }
     if (out.converged)
         logger.Info("Per-frame scaling ({}): settled after {} iterations (rms |dlogG| {:.1e})", what,
                     out.iterations, out.step);
@@ -4791,7 +4903,8 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
         // fit this iteration keeps the G it had (its corr was left where it was).
         std::vector<double> g_dev(n_frames);
         std::vector<uint8_t> scaled_dev(n_frames);
-        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window, [&] {
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window,
+                                      /*release_restraint=*/false, [&] {
             gpu_->ScalePartials(1, min_partiality, d_min_limit.has_value());
             gpu_->GetG(g_dev.data(), scaled_dev.data());
             for (int f = 0; f < n_frames; ++f)
@@ -4804,7 +4917,8 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     }
 #endif
     if (!scaled_on_gpu) {
-        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window, [&] {
+        partial_loop = RunScalingLoop("partials", g_partial, frame_count, smooth_window,
+                                      /*release_restraint=*/false, [&] {
             ReduceGroupMeans(partials, n_groups, partial_mean);
             FitPerFrameG(partials, frame_start, frame_count, partial_mean, /*unity=*/false, g_partial);
             UpdateCorr(partials, g_partial, frame_scaled_scratch);
@@ -5026,7 +5140,8 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
             if (static_cast<int>(g_full.size()) != n_frames) g_full.assign(n_frames, 1.0);
             std::vector<double> g_dev(n_frames);
             std::vector<uint8_t> scaled_dev(n_frames);
-            fulls_loop = RunScalingLoop("fulls", g_full, f_count, smooth_window, [&] {
+            fulls_loop = RunScalingLoop("fulls", g_full, f_count, smooth_window,
+                                          /*release_restraint=*/true, [&] {
                 gpu_->ScaleFulls(1, min_partiality);
                 gpu_->GetG(g_dev.data(), scaled_dev.data());
                 for (int f = 0; f < n_frames; ++f)
@@ -5086,7 +5201,8 @@ RotationScaleMerge::Result RotationScaleMerge::Run(bool for_search, bool full_st
     // --- 4. Scale the fulls (XDS order, Unity model). ---
     if (scale_fulls && !scaled_fulls_on_gpu) {
         std::vector<double> full_mean;
-        fulls_loop = RunScalingLoop("fulls", g_full, fulls_frame_count, smooth_window, [&] {
+        fulls_loop = RunScalingLoop("fulls", g_full, fulls_frame_count, smooth_window,
+                                      /*release_restraint=*/true, [&] {
             ReduceGroupMeans(fulls, n_groups, full_mean);
             FitPerFrameG(fulls, fulls_frame_start, fulls_frame_count, full_mean, /*unity=*/true, g_full);
             UpdateCorr(fulls, g_full, frame_scaled_scratch);
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index a07017460..68fa1bf83 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -452,10 +452,18 @@ private:
     struct ScalingLoopOutcome { int iterations = 0; bool converged = false; bool stalled = false; double step = 0.0; };
     ScalingLoopOutcome RunScalingLoop(const char *what, std::vector<double> &g,
                                       const std::vector<int32_t> &frame_obs_count, int window,
+                                      bool release_restraint,
                                       const std::function<void()> &iterate,
                                       const std::function<void(const std::vector<uint8_t> &,
                                                                const std::vector<double> &)> &rescale);
 
+    // Shrink a free per-frame scale back toward the restrained one, frame by frame, by how much of
+    // the difference between them is real (see ShrinkToRestrained in the .cpp).
+    void ShrinkToRestrained(const char *what, const std::vector<double> &g_restrained,
+                            const std::vector<uint8_t> &fitted,
+                            const std::vector<int32_t> &frame_obs_count,
+                            std::vector<double> &g) const;
+
     // corr = prescaling_corr / (partiality * G[frame]); leaves corr unchanged for frames that could not be fit.
     void UpdateCorr(std::vector<Obs> &obs, const std::vector<double> &g,
                     const std::vector<uint8_t> &frame_scaled) const;
-- 
2.54.0


From a29a5194d7069e6b7b37064f109e68408d89dc5c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 08:49:07 +0200
Subject: [PATCH 109/122] Space-group search: a point group's own operators
 must agree with each other

The added-operator gates read a MEAN over the operators a promotion adds, so they are
blind to an added set that MIXES real operators with false ones: the mean sits between
the two populations and passes. A pseudo-symmetric metric produces exactly that. On open
set 5ebi - a monoclinic crystal whose lattice is exactly hexagonal (a = c, beta = 120) -
the eight operators the 622 promotion adds over 6 include two genuine 2-folds at the
noise floor (R 0.067, 0.069, against a merge floor of 0.067) and four false ones at
0.227-0.263; the mean of 0.187 reads contrast 0.74 against the 0.72 bound and the group
is admitted. The run merged in P 6(1)22 where the deposition is P 1 2(1) 1, at R_meas
0.319 and ISa 2.3 instead of 0.101 and 10.8.

POINTLESS on our own P1 cross-check merge is unambiguous: P 6/m m m likelihood 0.051
against 0.854 for the true Laue class, with the 3-fold and 6-fold reading Rmeas 0.40-0.42
where the identity reads 0.098 and the three genuine 2-folds 0.113-0.126. Our own operator
table says the same thing; only the summary over it does not.

So ask instead that the candidate's operators agree with EACH OTHER - a point group is
the claim that all of its operators are symmetries of one crystal, so none of them may
reproduce the merge several times worse than another does. Measured over the 129 rotation
datasets of one battery run that adopted a group of order 3 or more, as the worst-agreeing
over the best-agreeing operator within the adopted group: every correct adoption sits at
1.0-2.64 (the highest being the weak cubic crystal whose near-spindle 3-fold is unusually
clean - the one that motivated the contrast gate), and the single over-called group reads
4.87. The bound is 3.2, with 0.56 of headroom below and 1.67 above, and deliberately well
clear of the 2.0-2.6 spread a genuine group reaches - which is where the retired
ratio-to-best gate's bound of 2.0 sat, and why that gate had to go.

This refuses 622, both 32 rungs and 6 on that crystal and adopts 2, restoring the
P 1 1 2(1) the search gave before the contrast gate landed. The statistic is read within
one candidate, never across candidates, so it adds no new normalisation by a reference
measured on the same crystal. It is reported in the refusal text and as a ledger column.

Controls, all at -N 32 against the same-commit baseline binary: the ten sets with the
largest operator spread in that run are unchanged and still correct, including the two
nearest the bound at 2.64 and 2.30. Two of them differ from the stored battery row only
in the screw hand, which the baseline binary reproduces at the same thread count.
SearchSpaceGroup, MergeStats, HKLKey and ResolutionCutoff test cases pass.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/SearchSpaceGroup.cpp          | 48 +++++++++++++++++--
 image_analysis/scale_merge/SearchSpaceGroup.h | 21 ++++++++
 2 files changed, 65 insertions(+), 4 deletions(-)

diff --git a/image_analysis/scale_merge/SearchSpaceGroup.cpp b/image_analysis/scale_merge/SearchSpaceGroup.cpp
index 8b817a44e..3b99f6e3e 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.cpp
+++ b/image_analysis/scale_merge/SearchSpaceGroup.cpp
@@ -1377,6 +1377,8 @@ SearchSpaceGroupResult SearchSpaceGroup(
                     // reason as h_ratio: to report the adopted candidate's whether or not it decided.
                     double r_added = std::numeric_limits<double>::quiet_NaN();
                     double r_over_floor = std::numeric_limits<double>::quiet_NaN();
+                    // The candidate's OWN operators, worst R over best R (see max_operator_r_spread).
+                    double r_spread = std::numeric_limits<double>::quiet_NaN();
                     // Report-only, for the finalist ledger: the subgroup b the tests below compared
                     // this candidate against, whether it survived every consistency test, and - when
                     // it was the highest refusal - why it did not. The selection loop computes all
@@ -1629,6 +1631,23 @@ SearchSpaceGroupResult SearchSpaceGroup(
             if (n_new > 0 && pairs_new >= opt.min_pairs_for_h)
                 r_added = r_new / n_new;
         }
+        // Homogeneity of the candidate's OWN operators: the worst-agreeing over the best-agreeing,
+        // over all of them, parent and added alike (see max_operator_r_spread).
+        {
+            double r_lo = std::numeric_limits<double>::infinity(), r_hi = 0.0;
+            int n_op = 0;
+            for (const auto &rot : c.pg->rotations) {
+                if (rot.rot == gemmi::Op::identity().rot)
+                    continue;
+                const auto &os = operator_score(rot);
+                if (os.n_pairs < opt.min_pairs_per_operator || !std::isfinite(os.r_stat)
+                    || os.r_stat <= 0.0)
+                    continue;
+                r_lo = std::min(r_lo, os.r_stat); r_hi = std::max(r_hi, os.r_stat); ++n_op;
+            }
+            if (n_op >= 2)
+                c.r_spread = r_hi / r_lo;
+        }
         c.parent_b_used = parent_b;
         c.r_added = r_added;
         c.r_over_floor = (std::isfinite(r_added) && std::isfinite(result.merge_r_floor)
@@ -1686,16 +1705,28 @@ SearchSpaceGroupResult SearchSpaceGroup(
         if (r_refused)
             consistent = false;
 
+        // Operator-homogeneity test. A necessary condition like H and the contrast, and the one that
+        // catches what a MEAN over the added operators cannot: a candidate whose added set mixes real
+        // operators with false ones. The gates above read summaries - mean H, mean R - so a promotion
+        // that adds two operators at the noise floor together with four several times worse reads a
+        // mean between them and passes, while the group it names is a mixture that cannot be a
+        // symmetry of one crystal. Asking instead that the candidate's operators agree with EACH OTHER
+        // sees the mixture directly (see max_operator_r_spread).
+        const bool spread_refused = std::isfinite(c.r_spread) && c.r_spread > opt.max_operator_r_spread;
+        if (spread_refused)
+            consistent = false;
+
         if (!consistent) {
             // Same three sentences the highest refusal gets below, but kept per candidate for the
             // ledger: short, because the long form is written once for the group the user is told about.
-            c.why = h_refused ? "H ratio" : r_refused ? "added-operator R" : "merge chi^2";
+            c.why = h_refused ? "H ratio" : r_refused ? "added-operator R"
+                  : spread_refused ? "operator spread" : "merge chi^2";
             // Record the highest-order refusal so the caller can say WHY it is processing lower.
             if (c.order > refused_order && c.pg->representative) {
                 refused_order = c.order;
                 refused_pg_hm = c.pg->representative->point_group_hm();
                 refused_pg_rep = c.pg->representative;
-                refused_twin_gate = h_refused || r_refused;
+                refused_twin_gate = h_refused || r_refused || spread_refused;
                 refused_fraction = h_refused ? std::max(0.0, 0.5 - h_added)
                                              : std::numeric_limits<double>::quiet_NaN();
                 if (h_refused)
@@ -1727,6 +1758,13 @@ SearchSpaceGroupResult SearchSpaceGroup(
                               + FormatDouble(opt.max_operator_r_over_floor, 1)
                               + "x) - at full resolution the added operator relates reflections that "
                                 "disagree far beyond measurement error, i.e. it is not a real symmetry";
+                else if (spread_refused)
+                    refused_why = "its own operators disagree among themselves - the worst-agreeing "
+                                  "reads " + FormatDouble(c.r_spread, 1)
+                                + "x the intensity-weighted R of the best-agreeing one in the SAME "
+                                  "group (bound " + FormatDouble(opt.max_operator_r_spread, 1)
+                                + "x) - so the group pools operators the data support with operators "
+                                  "they do not, and cannot be a symmetry of one crystal";
                 else if (std::isfinite(c.chi2) && std::isfinite(chi2_ref))
                     refused_why = "merge chi^2 is " + FormatDouble(c.chi2 / chi2_ref, 2)
                                 + "x the subgroup's (bound " + FormatDouble(opt.max_merge_chi2_ratio, 2) + ")";
@@ -1822,6 +1860,7 @@ SearchSpaceGroupResult SearchSpaceGroup(
                                / (result.random_pairing_r - global_best_r);
         }
         e.r_over_floor = c.r_over_floor;
+        e.r_spread = c.r_spread;
         e.adopted = (c.pg == best_pg);
         e.eligible = c.eligible;
         e.refused_reason = c.why;
@@ -2589,14 +2628,15 @@ std::string FinalistLedgerToText(const SearchSpaceGroupResult& result) {
         os << "  Unrelated reflections (shell-matched random pairing) R "
            << FormatDouble(result.random_pairing_r, 4)
            << " - the far end of the contrast scale.\n";
-    os << "\n  PG      ord  minCC   R_add contrast R/best R/floor  |  H     chi2/best   b     b/par  verdict\n"
-          "                 <---- calibrated evidence ---->        |  <--- diagnostic only, NOT evidence --->\n";
+    os << "\n  PG      ord  minCC   R_add contrast spread R/best R/floor  |  H     chi2/best   b     b/par  verdict\n"
+          "                 <------- calibrated evidence ------->        |  <--- diagnostic only, NOT evidence --->\n";
     for (const auto& e : result.point_group_ledger) {
         os << "  " << std::left << std::setw(8) << e.point_group_hm << std::right << std::setw(3)
            << e.order
            << std::setw(8) << LedgerCell(e.min_class_cc, 3)
            << std::setw(8) << LedgerCell(e.r_added, 4)
            << std::setw(9) << LedgerCell(e.r_contrast, 2)
+           << std::setw(7) << LedgerCell(e.r_spread, 2)
            << std::setw(7) << LedgerCell(e.r_over_best, 2)
            << std::setw(8) << LedgerCell(e.r_over_floor, 2)
            << "  |" << std::setw(6) << LedgerCell(e.h_ratio, 2)
diff --git a/image_analysis/scale_merge/SearchSpaceGroup.h b/image_analysis/scale_merge/SearchSpaceGroup.h
index 4aba23e2d..1c7bd85f6 100644
--- a/image_analysis/scale_merge/SearchSpaceGroup.h
+++ b/image_analysis/scale_merge/SearchSpaceGroup.h
@@ -471,6 +471,26 @@ struct SearchSpaceGroupOptions {
     //    the floor is a noisier reference than a confirmed operator (it can also be inflated by an
     //    indexing ambiguity that mixes hands), and the safe direction here is to stay in P1.
     double max_operator_r_over_floor = 3.5;
+    //
+    //  - max_operator_r_spread: the two tests above read a MEAN over the operators a promotion adds,
+    //    so they are blind to an added set that MIXES real operators with false ones - the mean sits
+    //    between the two populations and passes. That is what a pseudo-symmetric metric produces: a
+    //    monoclinic crystal whose lattice is exactly hexagonal (a = c, beta = 120) carries two genuine
+    //    horizontal 2-folds among the six a 622 promotion adds, and their R at the noise floor buys
+    //    the other four a mean well inside the contrast bound. The mixture is invisible to any summary
+    //    of the added set and obvious the moment the candidate's operators are compared with EACH
+    //    OTHER: a point group is the claim that all of its operators are symmetries of one crystal, so
+    //    they must agree with the merge about equally well.
+    //
+    //    Measured over the 129 rotation datasets of one battery run that adopted a group of order 3 or
+    //    more, as worst-agreeing over best-agreeing operator WITHIN the adopted group: every correct
+    //    adoption sits at 1.0-2.64, the highest being the weak cubic crystal whose near-spindle 3-fold
+    //    is unusually clean (the same crystal that motivated the contrast above), then 2.30 for a
+    //    fine-sliced tetragonal one. The one over-called point group on that run reads 4.87. 3.2 sits
+    //    in that gap with 0.56 of headroom below and 1.67 above - deliberately well clear of the
+    //    2.0-2.6 spread a genuine group reaches, which is exactly where the old ratio-to-best gate's
+    //    bound of 2.0 sat and why that gate had to go.
+    double max_operator_r_spread = 3.2;
 
     // Above this reduced chi^2 for the best subgroup (chi2_ref), the merged error model is treated as
     // badly miscalibrated (weak, low-resolution data whose sigmas are far too small): the fixed-sigma
@@ -680,6 +700,7 @@ struct PointGroupLedgerEntry {
     double r_over_best = std::numeric_limits<double>::quiet_NaN();     // ... over the best-agreeing operator anywhere
     double r_contrast = std::numeric_limits<double>::quiet_NaN();      // ... 0 = unrelated reflections, 1 = that best operator
     double r_over_floor = std::numeric_limits<double>::quiet_NaN();    // ... over the merge's random-noise R floor
+    double r_spread = std::numeric_limits<double>::quiet_NaN();        // this group's own worst operator R over its best
     bool adopted = false;         // this is the group the search took
     bool eligible = false;        // it passed every consistency test (so it COULD have been taken)
     std::string refused_reason;   // why it did not, when it was the highest refusal
-- 
2.54.0


From cb508503c3a424d3580f9cf3ee4c60e847e2549c Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 08:03:02 +0200
Subject: [PATCH 110/122] rugnux: the error model is fitted on the Bijvoet
 hands

The scatter of a Friedel-merged reflection contains the anomalous difference, so
an error model fitted on it books that difference as instrument error. Measured
on a native-sulfur set at 6 keV: sqrt(ab) reads 0.0565 pooled against 0.0531 on
the hands, an absorbed term of 1.9% - the textbook Bijvoet ratio of that crystal
at that energy, reported as detector noise - and ISa 17.7 instead of 18.9.

An error-model sample is now the residual about its own HAND's mean wherever the
hand has two usable observations of its own, about the pooled pair where it has
not. A hand's own scatter never contains dI whatever its size, so this needs no
"is the anomalous signal strong?" gate and holds in either mode; it is what
dials.scale does, which builds its error-model table Friedel-separated
unconditionally. A centric has I(+) = I(-) by symmetry and is not split, and a
merge that already separates the hands has its group AS the hand and splits
nothing, so nothing outside a rotation merge moves.

Only the (a, b) fit reads the hands. The merge weights, the per-frame scaling,
the half-sets and every decision keep the one Friedel-merged grouping of the
previous step.

Measured bare on nine sets, ordered by their own CCanom. The absorbed term falls
with the anomalous signal - 2.4%, 2.3%, 1.9% on three low-energy sets, 1.4% and
1.1% on two long-wavelength ones - and on the three sets with no anomalous signal
there is nothing to remove: sqrt(ab) comes out marginally larger, ISa 1-2% lower.
ISa rises by 11.5%, 9.3% and 6.4% where the signal is strongest. Space group,
resolution, completeness and anomalous multiplicity are unchanged everywhere.

What this does NOT do is add anomalous signal, and the claim should not be read
that way. The anomalous difference map read at the deposited model's own sulfurs
moves by at most 0.05 sigma on eight sets, and CCanom - a correlation, which no
error model can move - by less than 0.01. This makes the reported uncertainty
honest, so a downstream program that weights by sigma is given an honest one; the
differences themselves are the same differences.

Merged intensities therefore change on every set - the fit changes, so the sigmas
and the weights do - and there is no set on which this is bit-identical. There
cannot be one without the strength gate the design rules out. The runs are
bit-reproducible, so none of the above is scatter.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 56 +++++++++++++++++--
 .../scale_merge/RotationScaleMergeGPU.cu      | 49 ++++++++++++++--
 .../scale_merge/RotationScaleMergeGPU.h       |  3 +
 3 files changed, 97 insertions(+), 11 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 602d26fa5..f3e5cfbac 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3833,6 +3833,36 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
         }
     });
 
+    // ---- The Bijvoet hand of every full, and which groups hold two of them. ----
+    // Every DECISION a rotation run takes is made with Friedel's law on (see the Rugnux constructor),
+    // but two estimators inside the merge are formed on the HAND instead: the error model below, and
+    // the outlier test after it. The scatter of a pooled Friedel pair contains the anomalous
+    // difference, so an error model fitted on it books that difference as instrument error - measured
+    // on a native-sulfur set at 6 keV, sqrt(ab) reads 0.0491 against 0.0450 fitted on the hands, an
+    // absorbed 2.0% and ISa 9% low. A hand's own scatter never contains dI, whatever its size, so this
+    // needs no "is the signal strong?" gate and is right in either mode.
+    // Following Beilsten-Edmands et al. (2020) Acta Cryst. D76, 385-399, whose error model is fitted on
+    // a Friedel-separated table unconditionally.
+    // A centric has I(+) = I(-) by symmetry and nothing to split; a merge that already separates the
+    // hands has its group AS the hand, and splits nothing.
+    std::vector<uint8_t> obs_hand(fulls.size(), 0);        // per-full, 0 = I(+), 1 = I(-)
+    std::vector<uint8_t> group_has_hands(n_groups, 0);
+    if (merge_friedel) {
+        const HKLKeyGenerator anom_keygen(/*merge_friedel=*/false, x.GetSpaceGroupOrP1());
+        const gemmi::GroupOps gops = x.GetSpaceGroupOrP1().operations();
+        ParallelChunks(n_groups, ThreadsForWork(n_groups, nthreads), [&](int lo, int hi) {
+            for (int g = lo; g < hi; ++g)
+                group_has_hands[g] = gops.is_reflection_centric(
+                        gemmi::Op::Miller{group_h[g], group_k[g], group_l[g]}) ? 0 : 1;
+        });
+        ParallelChunks(n_full, ThreadsForWork(fulls.size(), nthreads), [&](int lo, int hi) {
+            for (int i = lo; i < hi; ++i) {
+                const Obs &o = fulls[i];
+                obs_hand[i] = anom_keygen(o.h, o.k, o.l).plus ? 0 : 1;
+            }
+        });
+    }
+
     // ---- Error model: fit dev2 = a*sigma^2 + b^2*<I>^2 from symmetry-equivalent scatter. ----
     std::vector<double> em_mean(n_groups, NAN);
     std::vector<float> reject_median(n_groups, NAN);
@@ -4010,7 +4040,10 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             const int nf = static_cast<int>(fulls.size());
             std::vector<double> gs2(nf), gI2(nf), gdev2(nf);
             std::vector<uint8_t> gvalid(nf);
-            gpu_->MergeEmSamples(for_search, min_partiality, em_mean.data(), cnt.data(),
+            gpu_->MergeEmSamples(for_search, min_partiality,
+                                 merge_friedel ? obs_hand.data() : nullptr,
+                                 merge_friedel ? group_has_hands.data() : nullptr,
+                                 em_mean.data(), cnt.data(),
                                  gs2.data(), gI2.data(), gdev2.data(), gvalid.data());
             samples.reserve(nf);
             for (int i = 0; i < nf; ++i)
@@ -4019,13 +4052,24 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
         }
 #endif
         if (!did_gpu) {
-            // Per-group inverse-variance mean over usable fulls (>=2 obs), and the leverage-corrected samples.
+            // Per-group inverse-variance mean over usable fulls (>=2 obs), and the leverage-corrected
+            // samples - the samples about the HAND's own mean where the hand has two of its own, about
+            // the pooled pair where it has not (see obs_hand above). The pooled mean itself is not
+            // touched: em_mean is what the merge weights read, and only the (a,b) fit moves.
             std::vector<double> sw(n_groups, 0.0), swI(n_groups, 0.0);
+            const size_t n_hand = merge_friedel ? 2 * static_cast<size_t>(n_groups) : 0;
+            std::vector<double> swh(n_hand, 0.0), swIh(n_hand, 0.0);
+            std::vector<int32_t> cnth(n_hand, 0);
             for (const auto &o : fulls) {
                 if (!usable_merge(o)) continue;
                 const double sigma_corr = static_cast<double>(o.sigma) * o.corr;
                 const double w = 1.0 / (sigma_corr * sigma_corr);
-                sw[o.group] += w; swI[o.group] += w * (static_cast<double>(o.I) * o.corr); cnt[o.group]++;
+                const double wI = w * (static_cast<double>(o.I) * o.corr);
+                sw[o.group] += w; swI[o.group] += wI; cnt[o.group]++;
+                if (n_hand && group_has_hands[o.group]) {
+                    const size_t s = 2 * static_cast<size_t>(o.group) + obs_hand[&o - fulls.data()];
+                    swh[s] += w; swIh[s] += wI; cnth[s]++;
+                }
             }
             for (int g = 0; g < n_groups; ++g)
                 if (cnt[g] >= 2 && sw[g] > 0.0) em_mean[g] = swI[g] / sw[g];
@@ -4033,12 +4077,14 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
             samples.reserve(fulls.size());
             for (const auto &o : fulls) {
                 if (!usable_merge(o) || cnt[o.group] < 2) continue;
-                const double mean = em_mean[o.group];
+                const size_t s = n_hand ? 2 * static_cast<size_t>(o.group) + obs_hand[&o - fulls.data()] : 0;
+                const bool on_hand = n_hand && group_has_hands[o.group] && cnth[s] >= 2 && swh[s] > 0.0;
+                const double mean = on_hand ? swIh[s] / swh[s] : em_mean[o.group];
                 if (!std::isfinite(mean)) continue;
                 const double sigma_corr = static_cast<double>(o.sigma) * o.corr;
                 const double s2 = sigma_corr * sigma_corr;
                 const double w = 1.0 / s2;
-                const double factor = 1.0 - w / sw[o.group];
+                const double factor = 1.0 - w / (on_hand ? swh[s] : sw[o.group]);
                 if (factor < 0.05) continue;
                 const double resid = static_cast<double>(o.I) * o.corr - mean;
                 samples.push_back({s2, mean * mean, resid * resid / factor, o.d});
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.cu b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
index 09b1bbd88..cacd1a52a 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.cu
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
@@ -434,11 +434,13 @@ namespace {
         const float *I, *sigma, *corr, *partiality, *d, *reject_median, *var_bkg, *var_per_I;
         const int32_t *group, *frame;
         const uint8_t *on_ice, *frame_cell_ok, *half;
+        const uint8_t *hand, *has_hands;   // per-full Bijvoet hand; per-group "two hands to split"
         const int32_t *gperm, *gstart, *gcount;
         const double *em_mean, *merged_I, *cc_factor;
         // outputs
         double *sw, *swI, *em_mean_out;
-        int32_t *cnt;
+        double *swh, *swIh;      // per (group, hand), indexed 2*g + hand
+        int32_t *cnt, *cnth;
         double *s2, *I2, *dev2;
         uint8_t *valid;
         double *a_swI, *a_sw, *a_swIh0, *a_swIh1, *a_swh0, *a_swh1, *a_swht0, *a_swht1, *a_d;
@@ -478,14 +480,25 @@ namespace {
     __global__ void MergeEmStatsKernel(MergeParams p) {
         for (int g = blockIdx.x * blockDim.x + threadIdx.x; g < p.n_groups; g += gridDim.x * blockDim.x) {
             const int lo = p.gstart[g], hi = lo + p.gcount[g];
-            double sw = 0.0, swI = 0.0;
-            int cnt = 0;
+            double sw = 0.0, swI = 0.0, swh[2] = {0.0, 0.0}, swIh[2] = {0.0, 0.0};
+            int cnt = 0, cnth[2] = {0, 0};
+            const bool split = p.has_hands && p.has_hands[g];
             for (int q = lo; q < hi; ++q) {
                 const int i = p.gperm[q];
                 if (!MergeUsable(i, p)) continue;
                 const double sigma_corr = double(p.sigma[i]) * p.corr[i];
                 const double w = 1.0 / (sigma_corr * sigma_corr);
-                sw += w; swI += w * (double(p.I[i]) * p.corr[i]); ++cnt;
+                const double wI = w * (double(p.I[i]) * p.corr[i]);
+                sw += w; swI += wI; ++cnt;
+                if (split) {
+                    const int hh = p.hand[i];
+                    swh[hh] += w; swIh[hh] += wI; ++cnth[hh];
+                }
+            }
+            if (p.swh) {
+                p.swh[2 * g] = swh[0]; p.swh[2 * g + 1] = swh[1];
+                p.swIh[2 * g] = swIh[0]; p.swIh[2 * g + 1] = swIh[1];
+                p.cnth[2 * g] = cnth[0]; p.cnth[2 * g + 1] = cnth[1];
             }
             p.sw[g] = sw; p.swI[g] = swI; p.cnt[g] = cnt;
             p.em_mean_out[g] = (cnt >= 2 && sw > 0.0) ? swI / sw : NAN;
@@ -499,11 +512,15 @@ namespace {
             if (!MergeUsable(i, p)) continue;
             const int g = p.group[i];
             if (p.cnt[g] < 2) continue;
-            const double mean = p.em_mean[g];
+            // The hand's own mean where the hand has two of its own, the pooled pair where it has
+            // not - see the host obs_hand block. em_mean (the merge weights) is untouched.
+            const int sub = 2 * g + (p.hand ? p.hand[i] : 0);
+            const bool on_hand = p.swh && p.has_hands[g] && p.cnth[sub] >= 2 && p.swh[sub] > 0.0;
+            const double mean = on_hand ? p.swIh[sub] / p.swh[sub] : p.em_mean[g];
             if (!isfinite(mean)) continue;
             const double sigma_corr = double(p.sigma[i]) * p.corr[i];
             const double s2 = sigma_corr * sigma_corr;
-            const double factor = 1.0 - (1.0 / s2) / p.sw[g];
+            const double factor = 1.0 - (1.0 / s2) / (on_hand ? p.swh[sub] : p.sw[g]);
             if (factor < 0.05) continue;
             const double resid = double(p.I[i]) * p.corr[i] - mean;
             p.s2[i] = s2; p.I2[i] = mean * mean; p.dev2[i] = resid * resid / factor; p.valid[i] = 1;
@@ -627,6 +644,10 @@ struct RotationScaleMergeGPU::Impl {
     CudaDevicePtr<uint8_t> frame_cell_ok;
     CudaDevicePtr<double> m_sw, m_swI, m_em_mean;   // per group (n_groups)
     CudaDevicePtr<int32_t> m_cnt;
+    CudaDevicePtr<double> m_swh, m_swIh;            // per (group, hand), 2 * n_groups
+    CudaDevicePtr<int32_t> m_cnth;
+    CudaDevicePtr<uint8_t> m_hand;                  // per full: Bijvoet hand (0 = I(+))
+    CudaDevicePtr<uint8_t> m_has_hands;             // per group: acentric, and the merge pools the hands
     CudaDevicePtr<double> m_s2, m_I2, m_dev2;        // per full (n_fulls)
     CudaDevicePtr<uint8_t> m_valid;
     CudaDevicePtr<uint8_t> m_rejected;   // per-full outlier-rejected flag (MergeAccum -> MergeRmeas)
@@ -835,6 +856,7 @@ void RotationScaleMergeGPU::SetFrameCellOk(const uint8_t *frame_cell_ok) {
 // The per-group inv-var mean (em_mean) + the per-full leverage-corrected error-model samples over the
 // resident+scaled fulls. Stashes the filter context for the later MergeAccum/MergeRmeas calls.
 void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partiality,
+                                           const uint8_t *hand, const uint8_t *has_hands,
                                            double *em_mean_out, int32_t *cnt_out, double *s2_out,
                                            double *I2_out, double *dev2_out, uint8_t *valid_out) {
     DeviceGuard guard(impl_->device, impl_->available);
@@ -843,6 +865,19 @@ void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partialit
     d.merge_for_search = for_search ? 1 : 0; d.merge_min_part = min_partiality;
     d.m_sw = CudaDevicePtr<double>(std::max(1, ng)); d.m_swI = CudaDevicePtr<double>(std::max(1, ng));
     d.m_em_mean = CudaDevicePtr<double>(std::max(1, ng)); d.m_cnt = CudaDevicePtr<int32_t>(std::max(1, ng));
+    // The error model is fitted on the Bijvoet hands (see the host obs_hand block). Absent - a merge
+    // that already separates them - the hand sums are not allocated and the kernels take the pooled
+    // group, which is what they did before.
+    if (hand && has_hands) {
+        d.m_swh = CudaDevicePtr<double>(std::max(1, 2 * ng)); d.m_swIh = CudaDevicePtr<double>(std::max(1, 2 * ng));
+        d.m_cnth = CudaDevicePtr<int32_t>(std::max(1, 2 * ng));
+        if (nf > 0) Upload(d.m_hand, hand, nf);
+        if (ng > 0) Upload(d.m_has_hands, has_hands, ng);
+    } else {
+        d.m_swh = CudaDevicePtr<double>(); d.m_swIh = CudaDevicePtr<double>();
+        d.m_cnth = CudaDevicePtr<int32_t>();
+        d.m_hand = CudaDevicePtr<uint8_t>(); d.m_has_hands = CudaDevicePtr<uint8_t>();
+    }
     d.m_s2 = CudaDevicePtr<double>(std::max(1, nf)); d.m_I2 = CudaDevicePtr<double>(std::max(1, nf));
     d.m_dev2 = CudaDevicePtr<double>(std::max(1, nf)); d.m_valid = CudaDevicePtr<uint8_t>(std::max(1, nf));
 
@@ -856,6 +891,8 @@ void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partialit
     p.gperm = d.f_gperm.get(); p.gstart = d.f_gstart.get(); p.gcount = d.f_gcount.get();
     p.em_mean = d.m_em_mean.get(); p.sw = d.m_sw.get(); p.swI = d.m_swI.get();
     p.em_mean_out = d.m_em_mean.get(); p.cnt = d.m_cnt.get();
+    p.swh = d.m_swh.get(); p.swIh = d.m_swIh.get(); p.cnth = d.m_cnth.get();
+    p.hand = d.m_hand.get(); p.has_hands = d.m_has_hands.get();
     p.s2 = d.m_s2.get(); p.I2 = d.m_I2.get(); p.dev2 = d.m_dev2.get(); p.valid = d.m_valid.get();
 
     const int grp_blocks = std::min(65535, (ng + BLK - 1) / BLK);
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.h b/image_analysis/scale_merge/RotationScaleMergeGPU.h
index d1be12791..b3f625f02 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.h
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.h
@@ -84,7 +84,10 @@ public:
     // Per-group inv-var mean (em_mean, length n_groups) + per-full leverage-corrected error-model samples
     // (s2/I2/dev2 + valid flag, length n_fulls), mirroring MergeAndStats' first two error-model loops.
     // Stashes (for_search, min_partiality) for the MergeAccum/MergeRmeas calls that follow.
+    // hand / has_hands are the per-full Bijvoet hand and the per-group "this group pools two hands",
+    // which the error-model samples are formed on; both null leaves the fit on the pooled group.
     void MergeEmSamples(bool for_search, double min_partiality,
+                        const uint8_t *hand, const uint8_t *has_hands,
                         double *em_mean_out, int32_t *cnt_out, double *s2_out, double *I2_out,
                         double *dev2_out, uint8_t *valid_out);
 
-- 
2.54.0


From 92451b64f7f471ce926f46a758c8540bbb9d8edd Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 09:25:52 +0200
Subject: [PATCH 111/122] rugnux: the outlier cut widens by the shell's own
 Bijvoet variance

A flat n-sigma test against a pooled Friedel pair's median deletes a hand of
every reflection whose anomalous significance |dI|/sigma(dI) exceeds n sqrt(m):
S > 12 at multiplicity 4, S > 24 at 16. On native sulfur nothing is lost; on a
Se-peak or derivative set it is the top of the difference distribution that
goes, which is the part a substructure search ranks first.

The cut becomes n * sqrt(sigma^2 + v_anom), where v_anom is one observation's
share of the shell's own measured Bijvoet variance - the MEDIAN over the shell's
pairs of dI^2 - sigma^2(dI), clamped at zero and quartered, because an
observation of one hand sits dI/2 from the pooled mean. A median and not a mean:
a mean would let the one wild pair the test exists to catch inflate its own
tolerance. Where a shell has no anomalous signal this is the plain n sigma, so
there is no "is the signal strong?" gate anywhere in it.

v_anom is measured inside the pass that uses it, from the same quantity the
SigAno accumulator reads and with the error model's own sigmas. The design took
it from the previous pass; that would have made the written merge depend on how
many merges the pipeline happened to run before it, which is not a property of
the data.

Measured bare on nine sets. Rejections fall exactly where the anomalous signal
is: -60% on a 3.3 A long-wavelength set, -31% on a 6 keV one, -28% on a 5 keV
lysozyme set, and by nothing at all on the three sets with no anomalous signal.
Nothing else moves: space group, resolution, completeness, anomalous
multiplicity and ISa are unchanged everywhere, R_meas and CC1/2 in the fourth
digit. The anomalous difference map at the deposited model's own sulfurs is
unchanged or very slightly better on all four sets it was read on (mean peak
+0.05, +0.01, -0.06, -0.02 sigma), so nothing that was signal is being thrown
away and nothing that was noise is being kept.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 82 +++++++++++++++++--
 .../scale_merge/RotationScaleMergeGPU.cu      | 16 +++-
 .../scale_merge/RotationScaleMergeGPU.h       |  3 +
 3 files changed, 92 insertions(+), 9 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index f3e5cfbac..79a4ffe76 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3866,6 +3866,7 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
     // ---- Error model: fit dev2 = a*sigma^2 + b^2*<I>^2 from symmetry-equivalent scatter. ----
     std::vector<double> em_mean(n_groups, NAN);
     std::vector<float> reject_median(n_groups, NAN);
+    std::vector<float> reject_var_add;       // per group: the shell's measured share of dI^2/4
     double error_model_a = 1.0, error_model_b = 0.0;
     bool error_model_active = false;
     // What the reported chi2 is taken from, below: the pool the LAST successful fit was handed, with
@@ -4208,6 +4209,69 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                          + (error_model_b * I_for_b) * (error_model_b * I_for_b);
         return v > 0.0 ? static_cast<float>(std::sqrt(v)) : sigma_corr;
     };
+    // ---- What the pooled outlier test's tolerance gains from the shell's own Bijvoet variance. ----
+    // An observation of one hand sits dI/2 from the pooled pair's mean, so its share of the pair's
+    // anomalous variance is dI^2/4 and the cut becomes n * sqrt(sigma^2 + v_anom). That is the plain
+    // n sigma where a shell has no anomalous signal, and widens by exactly the measured amount where
+    // it has - no "is the signal strong?" gate. Without it a flat n-sigma test on a pooled pair
+    // deletes a hand of every reflection whose |dI|/sigma(dI) exceeds n sqrt(m): S > 12 at
+    // multiplicity 4, S > 24 at 16, which is nothing on native sulfur and the top of the difference
+    // distribution on a Se-peak or derivative set - the reflections SHELXD ranks first.
+    // The MEDIAN excess over the shell's pairs, not the mean: a mean would let one wild pair inflate
+    // the very tolerance that is meant to test it. Measured on this pass, from the same quantity the
+    // SigAno accumulator reads, with the error model's own sigmas - taking it from the previous pass
+    // would make the written merge depend on how many merges the pipeline happened to run first.
+    if (reject_outliers && error_model_active && merge_friedel && n_groups > 0) {
+        std::vector<double> sw_h(2 * static_cast<size_t>(n_groups), 0.0), swI_h(2 * static_cast<size_t>(n_groups), 0.0);
+        float d_lo = INFINITY, d_hi = 0.0f;
+        for (int i = 0; i < n_full; ++i) {
+            const int g = mf.group[i];
+            if (g < 0 || !group_has_hands[g]) continue;
+            const Obs &o = fulls[i];
+            const float I_corr = o.I * o.corr;
+            const float sigma_corr = corrected_sigma(o, I_corr, o.sigma * o.corr);
+            if (!(sigma_corr > 0.0f) || !std::isfinite(sigma_corr)) continue;
+            const double w = 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
+            const size_t t = 2 * static_cast<size_t>(g) + obs_hand[i];
+            sw_h[t] += w; swI_h[t] += w * I_corr;
+            if (std::isfinite(mf.d[i]) && mf.d[i] > 0.0f) {
+                d_lo = std::min(d_lo, mf.d[i]); d_hi = std::max(d_hi, mf.d[i]);
+            }
+        }
+        if (std::isfinite(d_lo) && d_hi > d_lo) {
+            const ResolutionShells v_shells(d_lo * 0.999f, d_hi, report_shell_count);
+            std::vector<std::vector<double>> excess(report_shell_count);
+            std::vector<float> group_d(n_groups, NAN);
+            for (int i = 0; i < n_full; ++i) {
+                const int g = mf.group[i];
+                if (g >= 0 && !std::isfinite(group_d[g])) group_d[g] = mf.d[i];
+            }
+            for (int g = 0; g < n_groups; ++g) {
+                const double swp = sw_h[2 * static_cast<size_t>(g)], swm = sw_h[2 * static_cast<size_t>(g) + 1];
+                if (!(swp > 0.0) || !(swm > 0.0) || !std::isfinite(group_d[g])) continue;
+                const auto sh = v_shells.GetShell(group_d[g]);
+                if (!sh || *sh < 0 || *sh >= report_shell_count) continue;
+                const double di = swI_h[2 * static_cast<size_t>(g)] / swp - swI_h[2 * static_cast<size_t>(g) + 1] / swm;
+                excess[*sh].push_back(di * di - (1.0 / swp + 1.0 / swm));
+            }
+            std::vector<double> v_anom(report_shell_count, 0.0);
+            for (int sh = 0; sh < report_shell_count; ++sh) {
+                auto &v = excess[sh];
+                if (v.empty()) continue;
+                const size_t mid = v.size() / 2;
+                std::nth_element(v.begin(), v.begin() + mid, v.end());
+                v_anom[sh] = std::max(0.0, v[mid]) / 4.0;
+            }
+            reject_var_add.assign(n_groups, 0.0f);
+            for (int g = 0; g < n_groups; ++g) {
+                if (!std::isfinite(group_d[g])) continue;
+                const auto sh = v_shells.GetShell(group_d[g]);
+                if (sh && *sh >= 0 && *sh < report_shell_count)
+                    reject_var_add[g] = static_cast<float>(v_anom[*sh]);
+            }
+        }
+    }
+
     // The CC1/2 half-sets, assigned once for the whole pass: which reflection an observation belongs to
     // and whether it is usable at all are fixed here, and neither depends on the error model that the
     // merge below refits. Rank parity within the reflection - see AssignHalvesByRank - so the halves are
@@ -4265,7 +4329,8 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
 #ifdef JFJOCH_USE_CUDA
         if (use_gpu_merge) {
             gpu_->MergeAccum(error_model_a, error_model_b, error_model_active,
-                             reject_outliers, reject_nsigma, reject_median.data(), merge_half.data(),
+                             reject_outliers, reject_nsigma, reject_median.data(),
+                             reject_var_add.empty() ? nullptr : reject_var_add.data(), merge_half.data(),
                              frame_cc_factor.data(), rejected_obs.data());
             // Downloaded a slice of groups at a time and unpacked straight into acc, so the host never
             // holds a second full-length copy of the accumulators - on a large cell that is most of a
@@ -4308,11 +4373,16 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                 const float I_corr = o.I * o.corr;
                 float sigma_corr = o.sigma * o.corr;
                 sigma_corr = corrected_sigma(o, I_corr, sigma_corr);
-                if (reject_outliers && error_model_active && std::isfinite(reject_median[o.group])
-                    && std::fabs(I_corr - reject_median[o.group]) > reject_nsigma * sigma_corr) {
-                    ++reject_count;
-                    rejected_obs[&o - fulls.data()] = 1;
-                    continue;
+                if (reject_outliers && error_model_active && std::isfinite(reject_median[o.group])) {
+                    // The pooled pair, widened by the shell's measured anomalous variance.
+                    const double v_add = reject_var_add.empty() ? 0.0 : reject_var_add[o.group];
+                    const double tol = reject_nsigma
+                                       * std::sqrt(static_cast<double>(sigma_corr) * sigma_corr + v_add);
+                    if (std::fabs(I_corr - reject_median[o.group]) > tol) {
+                        ++reject_count;
+                        rejected_obs[&o - fulls.data()] = 1;
+                        continue;
+                    }
                 }
                 const double w = 1.0 / (static_cast<double>(sigma_corr) * sigma_corr);
                 const double wI = w * I_corr;
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.cu b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
index cacd1a52a..302017845 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.cu
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.cu
@@ -432,6 +432,7 @@ namespace {
         double min_partiality, error_model_a, error_model_b, reject_nsigma;
         int for_search, error_model_active, reject_outliers;
         const float *I, *sigma, *corr, *partiality, *d, *reject_median, *var_bkg, *var_per_I;
+        const float *reject_var_add;   // per group: the shell's measured share of dI^2/4
         const int32_t *group, *frame;
         const uint8_t *on_ice, *frame_cell_ok, *half;
         const uint8_t *hand, *has_hands;   // per-full Bijvoet hand; per-group "two hands to split"
@@ -535,6 +536,8 @@ namespace {
             double swI = 0, sw = 0, swIh0 = 0, swIh1 = 0, swh0 = 0, swh1 = 0, swht0 = 0, swht1 = 0, dd = NAN;
             int nh0 = 0, nh1 = 0, rejected = 0, onice = 0;
             const float rmed = p.reject_median[g];
+            // The pooled cut, widened by the shell's measured Bijvoet variance - see the host loop.
+            const double v_add = p.reject_var_add ? p.reject_var_add[g] : 0.0;
             for (int q = lo; q < hi; ++q) {
                 const int i = p.gperm[q];
                 if (!MergeUsable(i, p)) continue;
@@ -552,9 +555,11 @@ namespace {
                     const double v = p.error_model_a * a_var + bi * bi;
                     if (v > 0.0) sigma_corr = float(sqrt(v));
                 }
-                if (p.reject_outliers && p.error_model_active && isfinite(rmed)
-                    && fabsf(I_corr - rmed) > p.reject_nsigma * sigma_corr) {
-                    ++rejected; p.rejected_obs[i] = 1; continue;
+                if (p.reject_outliers && p.error_model_active && isfinite(rmed)) {
+                    const double tol = p.reject_nsigma * sqrt(double(sigma_corr) * sigma_corr + v_add);
+                    if (fabs(double(I_corr) - rmed) > tol) {
+                        ++rejected; p.rejected_obs[i] = 1; continue;
+                    }
                 }
                 const double w = 1.0 / (double(sigma_corr) * sigma_corr);
                 const double wI = w * I_corr;
@@ -657,6 +662,7 @@ struct RotationScaleMergeGPU::Impl {
     CudaDevicePtr<int32_t> a_nh0, a_nh1, a_rejected;
     CudaDevicePtr<uint8_t> a_on_ice;     // per group: any contributing full on an ice ring
     CudaDevicePtr<float> reject_median;
+    CudaDevicePtr<float> reject_var_add;   // the pooled test's widening
     CudaDevicePtr<double> merged_I, r_absdev, r_sumI;   // R_meas per group (merged_I uploaded)
     CudaDevicePtr<int32_t> r_n, r_nusable;
     int merge_for_search = 0;   // filter context for one MergeAndStats call
@@ -915,6 +921,7 @@ void RotationScaleMergeGPU::MergeEmSamples(bool for_search, double min_partialit
 
 void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                                        bool reject_outliers, double reject_nsigma, const float *reject_median,
+                                       const float *reject_var_add,
                                        const uint8_t *half, const double *frame_cc_factor,
                                        uint8_t *rejected_obs) {
     DeviceGuard guard(impl_->device, impl_->available);
@@ -931,6 +938,8 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     CudaCheck(cudaMemset(d.m_rejected.get(), 0, size_t(std::max(1, d.n_fulls)) * sizeof(uint8_t)),
               "zero m_rejected");
     Upload(d.reject_median, reject_median, ng);
+    if (reject_var_add && ng > 0) Upload(d.reject_var_add, reject_var_add, ng);
+    else d.reject_var_add = CudaDevicePtr<float>();
     Upload(d.m_half, half, d.n_fulls);
     Upload(d.cc_factor, frame_cc_factor, d.n_frames);
 
@@ -941,6 +950,7 @@ void RotationScaleMergeGPU::MergeAccum(double error_model_a, double error_model_
     p.error_model_active = error_model_active ? 1 : 0;
     p.reject_outliers = reject_outliers ? 1 : 0; p.reject_nsigma = reject_nsigma;
     p.reject_median = d.reject_median.get();
+    p.reject_var_add = d.reject_var_add.get();
     p.I = d.f_I.get(); p.sigma = d.f_sigma.get(); p.corr = d.f_corr.get(); p.partiality = d.f_partiality.get();
     p.d = d.f_d.get(); p.group = d.f_group.get(); p.frame = d.f_frame.get();
     p.on_ice = d.f_on_ice.get(); p.frame_cell_ok = d.frame_cell_ok.get();
diff --git a/image_analysis/scale_merge/RotationScaleMergeGPU.h b/image_analysis/scale_merge/RotationScaleMergeGPU.h
index b3f625f02..bc96945a8 100644
--- a/image_analysis/scale_merge/RotationScaleMergeGPU.h
+++ b/image_analysis/scale_merge/RotationScaleMergeGPU.h
@@ -99,8 +99,11 @@ public:
     // for the reductions it still does itself, above all the anomalous I(+)/I(-) split.
     // frame_cc_factor (length n_frames) is each frame's (G_ref/G)^2 floored at 1; swh_typ0/1 are the
     // half-set weights multiplied by it. Requires MergeEmSamples first (em_mean resident).
+    // reject_var_add (n_groups) widens the pooled cut by the shell's own measured Bijvoet
+    // variance; null leaves the plain n-sigma test.
     void MergeAccum(double error_model_a, double error_model_b, bool error_model_active,
                     bool reject_outliers, double reject_nsigma, const float *reject_median,
+                    const float *reject_var_add,
                     const uint8_t *half, const double *frame_cc_factor, uint8_t *rejected_obs);
     // Download groups [g0, g0 + n) of what MergeAccum left on the device; every output has length n.
     // rejected[g] counts the outliers dropped from the group.
-- 
2.54.0


From 14b7fce816b603f84f4eed37a685af5c723545f3 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 08:09:08 +0200
Subject: [PATCH 112/122] rugnux: one run reports the merge both ways, and -A
 only says which

Since a rotation run decides with Friedel's law on, -A changed nothing at all -
not even the table, which stayed the Friedel-merged one. That made the report
unreadable against an anomalous CORRECT.LP: XDS with FRIEDEL'S_LAW=FALSE counts
its uniques, multiplicity, completeness, R_meas and CC1/2 per hand, and a
Friedel-merged table has roughly twice the multiplicity of one.

The merge now also reports itself counted with Friedel's law OFF - an acentric
reflection as two reflections, one per Bijvoet hand, a centric as one - as
ANOM_* and ANOM_REFRES_* keys and a shell table beside the run's own. It costs
no second merge: the per-hand accumulator that SigAno, CCanom and the I(+)/I(-)
export are already formed on carries every number in it, and the completeness
denominator is the same enumeration counted two per acentric. The intensities,
the scaling, the error model and every decision behind both tables are the
Friedel-merged ones, so this is a second way of counting one merge.

-A is therefore presentation only: it selects FRIEDELS_LAW, which says which of
the two tables was asked for. Both are printed either way. On a 6 keV set the
per-hand table reads 15.54 multiplicity and 95.1% completeness over the
reference range against the Friedel-merged 28.65 and 97.5%, where the XDS
reference is 12.42 and 92.4%.

Report-only: the written reflections, the MTZ and the mmCIF are byte-identical
to the run before it, and an -A run is byte-identical to a bare one but for the
FRIEDELS_LAW line.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/scale_merge/Merge.h            |  13 ++
 .../scale_merge/RotationScaleMerge.cpp        | 115 +++++++++++++++++-
 rugnux/ResultReport.cpp                       |  54 ++++++++
 3 files changed, 181 insertions(+), 1 deletion(-)

diff --git a/image_analysis/scale_merge/Merge.h b/image_analysis/scale_merge/Merge.h
index 447a532ee..bd80bf972 100644
--- a/image_analysis/scale_merge/Merge.h
+++ b/image_analysis/scale_merge/Merge.h
@@ -127,9 +127,22 @@ struct SweepQuality {
     float delta_cc_half_batch_deg = 0.0f;
 };
 
+// The same merge counted with Friedel's law OFF: an acentric reflection is two rows, one per Bijvoet
+// hand, and a centric is one. XDS's FRIEDEL'S_LAW=FALSE table, and what an anomalous CORRECT.LP is to
+// be read against. Formed from the same per-hand accumulators as SigAno and the I(+)/I(-) export, so
+// it is a second PRESENTATION of one merge and not a second merge: the intensities, the scaling, the
+// error model and every decision behind it are the Friedel-merged ones. `measured` is false when the
+// merge carried no anomalous split to count (the stills path, or a pass that writes nothing).
+struct AnomalousMergeStatistics {
+    std::vector<MergeStatisticsShell> shells;
+    MergeStatisticsShell overall;
+    bool measured = false;
+};
+
 struct MergeStatistics {
     std::vector<MergeStatisticsShell> shells;
     MergeStatisticsShell overall;
+    AnomalousMergeStatistics per_hand;
 
     // Dataset-wide isotropic Wilson B-factor estimate (A^2) from the log-linear fit of the shell-mean
     // merged intensity against 1/d^2 (CalcGlobalWilsonB) - the analogue of XDS's "WILSON LINE ... B=".
diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 79a4ffe76..96f46f46b 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -4733,6 +4733,17 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
         std::vector<CorrelationCoefficient> cc_anom_shell(n_shells);
         CorrelationCoefficient cc_anom_overall;
         size_t cc_anom_n = 0;
+        // The per-hand (FRIEDEL'S_LAW=FALSE) table, counted off the same accumulator: one row per
+        // Bijvoet hand of an acentric reflection, one for a centric.
+        struct HandAcc {
+            int unique = 0, total_obs = 0, possible = 0;
+            double sum_i_over_sigma = 0.0; int n_i_over_sigma = 0;
+            double rmeas_num = 0.0, rmeas_den = 0.0;
+            CorrelationCoefficient cc_half;
+        };
+        std::vector<HandAcc> ha(n_shells);
+        CorrelationCoefficient ha_cc_overall;
+        bool ha_measured = false;
         if (!for_search && full_stats) {
             const HKLKeyGenerator anom_keygen(/*merge_friedel=*/false, x.GetSpaceGroupOrP1());
             const gemmi::GroupOps gops = x.GetSpaceGroupOrP1().operations();
@@ -4794,12 +4805,54 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                 a.sw[cell & 1][anom_half[i]] += w;
                 a.nh[cell & 1][anom_half[i]]++;
             }
+            // The per-hand table's rows: one mean per (pair, hand), or one per centric pair. Filled in
+            // the pair walk below and read back by the R_meas walk after it; row_of_cell folds a
+            // centric's two cells onto its single row.
+            std::vector<float> row_mean(anom.size() * 2, NAN);
+            std::vector<int32_t> row_shell(anom.size() * 2, -1), row_of_cell(anom.size() * 2);
+            for (size_t c = 0; c < row_of_cell.size(); ++c) row_of_cell[c] = static_cast<int32_t>(c);
             for (size_t p = 0; p < anom.size(); ++p) {
                 AnomAcc a = anom[p];
                 a.h = pair_hkl[p].h; a.k = pair_hkl[p].k; a.l = pair_hkl[p].l;
                 const uint64_t fkey = pair_hkl[p].pack();
+                const bool centric = gops.is_reflection_centric(gemmi::Op::Miller{a.h, a.k, a.l});
+                {
+                    const auto hshell = shells.GetShell(a.d);
+                    if (hshell && *hshell >= 0 && *hshell < n_shells) {
+                        // One row of the per-hand table: its two CC1/2 halves put together. The halves
+                        // are the anomalous ones - balanced within the MATE, as CCanom needs - so this
+                        // CC1/2 is over the same halves as CCanom and is unweighted, where the
+                        // Friedel-merged table above weights by the frame's scale factor.
+                        auto add_row = [&](double sw0, double sw1, double swI0, double swI1,
+                                           int n0, int n1, size_t row) {
+                            const double sw = sw0 + sw1, swI = swI0 + swI1;
+                            if (!(sw > 0.0)) return;
+                            HandAcc &h = ha[*hshell];
+                            h.unique++; h.total_obs += n0 + n1;
+                            h.sum_i_over_sigma += (swI / sw) * std::sqrt(sw); h.n_i_over_sigma++;
+                            if (sw0 > 0.0 && sw1 > 0.0) {
+                                h.cc_half.Add(swI0 / sw0, swI1 / sw1);
+                                ha_cc_overall.Add(swI0 / sw0, swI1 / sw1);
+                            }
+                            row_mean[row] = static_cast<float>(swI / sw);
+                            row_shell[row] = *hshell;
+                            ha_measured = true;
+                        };
+                        if (centric) {
+                            add_row(a.sw[0][0] + a.sw[1][0], a.sw[0][1] + a.sw[1][1],
+                                    a.swI[0][0] + a.swI[1][0], a.swI[0][1] + a.swI[1][1],
+                                    a.nh[0][0] + a.nh[1][0], a.nh[0][1] + a.nh[1][1], 2 * p);
+                            row_of_cell[2 * p + 1] = static_cast<int32_t>(2 * p);
+                        } else {
+                            add_row(a.sw[0][0], a.sw[0][1], a.swI[0][0], a.swI[0][1],
+                                    a.nh[0][0], a.nh[0][1], 2 * p);
+                            add_row(a.sw[1][0], a.sw[1][1], a.swI[1][0], a.swI[1][1],
+                                    a.nh[1][0], a.nh[1][1], 2 * p + 1);
+                        }
+                    }
+                }
                 // Centrics have I(+)=I(-) by symmetry; leave them without an anomalous split.
-                if (gops.is_reflection_centric(gemmi::Op::Miller{a.h, a.k, a.l})) continue;
+                if (centric) continue;
                 // Whole-mate sums: the two halves put back together. I(+)/I(-) and SigAno are read off
                 // these, so splitting the accumulation above changed neither.
                 const double swp = a.sw[0][0] + a.sw[0][1], swm = a.sw[1][0] + a.sw[1][1];
@@ -4830,6 +4883,35 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
                     ++cc_anom_n;
                 }
             }
+            // R_meas of the per-hand table: |I_i - <I>| against the row's own mean, over exactly the
+            // observations the merge kept (anom_cell carries that filter), so an over-rejecting run
+            // looks better here for the same reason it does in the table above.
+            if (ha_measured) {
+                std::vector<double> row_absdev(row_mean.size(), 0.0), row_sumI(row_mean.size(), 0.0);
+                std::vector<int32_t> row_n(row_mean.size(), 0);
+                for (size_t i = 0; i < fulls.size(); ++i) {
+                    const int cell = anom_cell[i];
+                    if (cell < 0) continue;
+                    const int row = row_of_cell[cell];
+                    if (!std::isfinite(row_mean[row])) continue;
+                    const float I_corr = fulls[i].I * fulls[i].corr;
+                    row_absdev[row] += std::fabs(static_cast<double>(I_corr) - row_mean[row]);
+                    row_sumI[row] += I_corr; row_n[row]++;
+                }
+                for (size_t row = 0; row < row_mean.size(); ++row) {
+                    if (row_n[row] < 2 || row_shell[row] < 0) continue;
+                    const double factor = std::sqrt(static_cast<double>(row_n[row]) / (row_n[row] - 1));
+                    ha[row_shell[row]].rmeas_num += factor * row_absdev[row];
+                    ha[row_shell[row]].rmeas_den += row_sumI[row];
+                }
+                // The completeness denominator counted the same way: two per acentric, one per centric.
+                if (reference_cell) {
+                    std::vector<int> possible_hand(n_shells, 0);
+                    PossiblePerShell(x.GetSpaceGroupOrP1(), *reference_cell, grid_d_min, grid_d_max,
+                                     shells, /*merge_friedel=*/false, possible_hand, nthreads);
+                    for (int sh = 0; sh < n_shells; ++sh) ha[sh].possible = possible_hand[sh];
+                }
+            }
         }
 
         MergeStatistics out;
@@ -4863,6 +4945,37 @@ RotationScaleMerge::Result RotationScaleMerge::MergeAndStats(int n_groups, bool
         overall.r_meas = rmeas_den_all > 0.0 ? rmeas_num_all / rmeas_den_all : NAN;
         overall.abs_diff_over_sigma_anomalous = sig_den_all > 0.0 ? sig_num_all / sig_den_all : NAN;
         overall.cc_anom = cc_anom_overall.GetCC();
+
+        // The per-hand presentation of the same merge (see AnomalousMergeStatistics). SigAno and
+        // CCanom are pair quantities and read the same in either table, so they are carried over.
+        if (ha_measured) {
+            out.per_hand.measured = true;
+            out.per_hand.shells.resize(n_shells);
+            double ha_ios = 0.0, ha_rn = 0.0, ha_rd = 0.0; int ha_nios = 0;
+            for (int sh = 0; sh < n_shells; ++sh) {
+                MergeStatisticsShell &hs = out.per_hand.shells[sh];
+                hs = out.shells[sh];   // the shell bounds, SigAno and CCanom of this same shell
+                hs.total_observations = ha[sh].total_obs;
+                hs.unique_reflections = ha[sh].unique;
+                hs.possible_unique_reflections = ha[sh].possible;
+                hs.mean_i_over_sigma = ha[sh].n_i_over_sigma > 0
+                                       ? ha[sh].sum_i_over_sigma / ha[sh].n_i_over_sigma : 0.0;
+                hs.cc_half = ha[sh].cc_half.GetCC();
+                hs.r_meas = ha[sh].rmeas_den > 0.0 ? ha[sh].rmeas_num / ha[sh].rmeas_den : NAN;
+                out.per_hand.overall.total_observations += ha[sh].total_obs;
+                out.per_hand.overall.unique_reflections += ha[sh].unique;
+                out.per_hand.overall.possible_unique_reflections += ha[sh].possible;
+                ha_ios += ha[sh].sum_i_over_sigma; ha_nios += ha[sh].n_i_over_sigma;
+                ha_rn += ha[sh].rmeas_num; ha_rd += ha[sh].rmeas_den;
+            }
+            MergeStatisticsShell &ho = out.per_hand.overall;
+            ho.d_min = overall.d_min; ho.d_max = overall.d_max;
+            ho.mean_i_over_sigma = ha_nios > 0 ? ha_ios / ha_nios : 0.0;
+            ho.cc_half = ha_cc_overall.GetCC();
+            ho.r_meas = ha_rd > 0.0 ? ha_rn / ha_rd : NAN;
+            ho.abs_diff_over_sigma_anomalous = overall.abs_diff_over_sigma_anomalous;
+            ho.cc_anom = overall.cc_anom;
+        }
         if (own_table && std::isfinite(overall.abs_diff_over_sigma_anomalous))
             logger.Info("Anomalous signal SigAno = {:.2f} ({} acentric pairs), CCanom = {:.3f} ({} pairs "
                         "split in both hands)",
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index ee1d83a79..9e9960675 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -204,6 +204,38 @@ namespace {
         return o.str();
     }
 
+    // The per-hand (FRIEDEL'S_LAW=FALSE) table, in the columns of the run's own.
+    std::string PerHandShellTable(const AnomalousMergeStatistics &ph) {
+        std::ostringstream o;
+        o << "\n" << ShellTableHeader() << "\n" << ShellTableRule() << "\n";
+        for (const auto &sh : ph.shells) {
+            if (sh.unique_reflections == 0) continue;
+            o << fmt::format("  {:8.2f} ", sh.d_min) << sh << "\n";
+        }
+        o << ShellTableRule() << "\n";
+        o << fmt::format("  {:>8s} ", "Overall") << ph.overall << "\n";
+        return o.str();
+    }
+
+    // The ANOM_* / ANOM_REFRES_* keys of one per-hand table.
+    void AddPerHandKeys(ReportSection &s, const AnomalousMergeStatistics &ph, const std::string &prefix) {
+        const auto &po = ph.overall;
+        Add(s, KeyInt((prefix + "UNIQUE_REFLECTIONS").c_str(), po.unique_reflections));
+        Add(s, KeyInt((prefix + "TOTAL_OBSERVATIONS").c_str(), po.total_observations));
+        if (po.possible_unique_reflections > 0)
+            Add(s, KeyReal((prefix + "COMPLETENESS").c_str(),
+                           100.0 * po.unique_reflections / po.possible_unique_reflections, "{:.1f}"));
+        if (po.unique_reflections > 0) {
+            Add(s, KeyReal((prefix + "MULTIPLICITY").c_str(),
+                           static_cast<double>(po.total_observations) / po.unique_reflections, "{:.2f}"));
+            Add(s, KeyReal((prefix + "I_OVER_SIGMA").c_str(), po.mean_i_over_sigma, "{:.2f}"));
+        }
+        if (std::isfinite(po.r_meas))
+            Add(s, KeyReal((prefix + "R_MEAS").c_str(), po.r_meas, "{:.4f}"));
+        if (std::isfinite(po.cc_half))
+            Add(s, KeyReal((prefix + "CC_HALF").c_str(), po.cc_half, "{:.4f}"));
+    }
+
     // The finest shell whose CC1/2 still reaches the cut's own target: where the table says the signal
     // is, for the completeness quoted beside the written range.
     double FinestSupportedShell(const MergeStatistics &ms, double target) {
@@ -898,6 +930,28 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                 Add(s, Prose(ReferenceShellTable(rs, o.d_min)));
             }
 
+            // The same merge counted with Friedel's law OFF, from the Bijvoet split the merge always
+            // keeps. Both tables come out of ONE run: the intensities, the scaling, the error model
+            // and every decision above are the Friedel-merged ones in either mode, and -A chooses
+            // only which of the two a reader is asking for (FRIEDELS_LAW). This is the table to read
+            // an anomalous CORRECT.LP against - XDS with FRIEDEL'S_LAW=FALSE counts its uniques,
+            // multiplicity, completeness, R_meas and CC1/2 per hand, and the table above does not.
+            if (ms.per_hand.measured) {
+                Add(s, Blank());
+                AddPerHandKeys(s, ms.per_hand, "ANOM_");
+                if (result.reference_merge_statistics && result.reference_merge_statistics->per_hand.measured)
+                    AddPerHandKeys(s, result.reference_merge_statistics->per_hand, "ANOM_REFRES_");
+                Add(s, Blank());
+                Add(s, Prose(
+                        " ANOM_* is this same merge counted with Friedel's law OFF: an acentric reflection is\n"
+                        " two reflections, one per Bijvoet hand, and a centric is one. Nothing was processed\n"
+                        " differently for it and no reflection moved - it is a second way of counting one\n"
+                        " merge, the way an anomalous XDS run counts. ANOM_REFRES_* is the same over the\n"
+                        " --report-resolution range. FRIEDELS_LAW says which table was asked for (-A), not\n"
+                        " how the data were merged: every decision is taken with the mates merged either way."));
+                Add(s, Prose(PerHandShellTable(ms.per_hand)));
+            }
+
             // A merge with no signal in it. Neither of these is caught anywhere else: CC1/2 near zero
             // beside a healthy I/sigma is the signature of observations of DIFFERENT reflections being
             // averaged together (mixed indexing hands, a wrong point group), and a rejection count
-- 
2.54.0


From 29b5d7cce15a4c0fa13230ca5565d398c653ce82 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 08:14:52 +0200
Subject: [PATCH 113/122] tools/battery: every set runs bare, and an anomalous
 reference reads the per-hand table

The XDS arms passed -A wherever the reference had been measured with
FRIEDEL'S_LAW=FALSE, so that the merging statistics would be comparable. That
reason is gone: a rotation run decides with Friedel's mates merged whatever -A
says, and now reports itself counted both ways out of that one run, so -A is
presentation only and passing it changes nothing a battery reads. Verified on a
6 keV set: the reflections, the MTZ and the mmCIF of an -A run are byte-identical
to a bare one, and the reports differ in the FRIEDELS_LAW line alone.

Comparability now comes from the report instead. Where a reference kept the
mates apart, the scorer takes uniques, completeness, multiplicity, <I/sigma>,
R_meas and CC1/2 from the run's ANOM_REFRES_* block - the same merge counted
per Bijvoet hand, which is how XDS counted. ISa is not among them: there is one
error model, it is fitted on the hands, and REFRES_ISA is it.

The report reader also learns the third shell table, so it stops taking the
per-hand table's first row for the reference range's low-resolution shell.

Re-scored on six sets. The anomalous rows stop comparing a Friedel-merged
multiplicity against a per-hand one (28.65 against XDS's 12.42 becomes 15.54;
19.69 against 8.85 becomes 11.09), completeness moves 1-2 points onto the
reference's own footing, R_meas ratios move a few percent and the CC1/2 noise
ratio rises, as it must when CC1/2 is read at the reference's multiplicity. No
verdict moves: pass and fail are decided on the lattice, the space group and the
resolution, none of which these numbers reach. The two non-anomalous rows score
exactly as before.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/battery.py | 15 ++++++++-------
 tools/battery/score.py   | 19 ++++++++++++++++++-
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/tools/battery/battery.py b/tools/battery/battery.py
index 72ed37663..84c75a0d7 100644
--- a/tools/battery/battery.py
+++ b/tools/battery/battery.py
@@ -26,7 +26,7 @@ The site config (data roots, runs root, lock, gpulock, private manifest, baselin
 $JFJOCH_BATTERY_SITE, else site.json beside this script (not committed; site.example.json is).
 
 Every set runs once, with one command per arm (COMMAND_DOC): the open arm with the deposited model
-(--model), the XDS arms with -A where XDS was anomalous and XDS's range as a report-only second
+(--model), the XDS arms with XDS's range as a report-only second
 table (--report-resolution). Neither option changes the processing, so the one run is both what a
 user gets and the like-for-like comparison.
 
@@ -68,8 +68,9 @@ PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")
 COMMAND_DOC = {
     "deposition": "`rugnux --model <deposited coordinates> <input>` (without --model where there is no "
                   "deposited model: small molecules, unpublished sets)",
-    "xds": "`rugnux [-A] --report-resolution <XDS d_min>,<XDS d_max> <input>`: -A where XDS kept "
-           "Friedel mates apart; the second statistics table at XDS's range is report-only",
+    "xds": "`rugnux --report-resolution <XDS d_min>,<XDS d_max> <input>`: the second statistics "
+           "table at XDS's range is report-only; where XDS kept Friedel mates apart the scorer "
+           "reads the run's own per-hand table, which needs no flag",
 }
 
 LOCAL_SITE = os.path.join(HERE, "site.json")
@@ -174,10 +175,10 @@ def command(binary, e, opts, model=None):
         cmd += ["-N", str(opts["threads"])]
     ref = e.get("ref") or {}
     if e["reference"] == "xds":
-        # XDS merged with FRIEDEL'S_LAW=FALSE: merge Friedel mates separately too, or the merging
-        # statistics are not comparable
-        if ref.get("anomalous"):
-            cmd.append("-A")
+        # No -A, whatever the reference did. A rotation run decides with Friedel's mates merged
+        # either way, and reports the merge counted BOTH ways from that one run; -A only says which
+        # of the two tables was asked for. Where XDS merged with FRIEDEL'S_LAW=FALSE the scorer
+        # reads rugnux's per-hand block (ANOM_REFRES_*) instead, which is the like-for-like table.
         # a second statistics table over XDS's own range, from the same merge (report only). XDS's
         # own limit, not the derived reference d_min: the manifest's XDS totals are over XDS's range,
         # so only that makes the table like for like. Shells past rugnux's own cut print as not
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 6d213c039..8742d1bab 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -38,7 +38,10 @@ def read_report(path):
         if f[:2] == ["d_min", "N_obs"]:
             header = f
         elif header and f and re.match(r"^\d+\.\d+$", f[0]):
-            prefix = "REFRES_" if "REFRES_RANGE" in out else ""
+            # Three tables in report order: the run's own, the --report-resolution one, and the
+            # per-hand (FRIEDEL'S_LAW=FALSE) one, whose keys are written just above it.
+            prefix = ("ANOM_" if "ANOM_UNIQUE_REFLECTIONS" in out
+                      else "REFRES_" if "REFRES_RANGE" in out else "")
             out[prefix + "LOWRES_D"] = f[0]
             r_meas = f[header.index("R_meas")].rstrip("%")          # "3.7%", or "-" for none
             out[prefix + "LOWRES_R_MEAS"] = "" if r_meas == "-" else str(round(float(r_meas) / 100, 4))
@@ -199,6 +202,20 @@ def judge(entry, rep, run_note):
     # the same merge binned over the reference's range (--report-resolution, XDS arms)
     r.update({k: fnum(rep.get(k.upper())) for k in REFRES_KEYS})
     r["refres_range"] = rep.get("REFRES_RANGE")
+    # An XDS reference measured with FRIEDEL'S_LAW=FALSE counts its uniques, completeness,
+    # multiplicity, R_meas and CC1/2 per Bijvoet hand, so what is like for like is the per-hand
+    # table of the same rugnux merge - the Friedel-merged one has about twice the multiplicity.
+    # Both tables come out of one bare run: -A is presentation only and changes nothing that is
+    # compared here. ISa is not among them - there is one error model, fitted on the hands, and
+    # REFRES_ISA is it.
+    r["per_hand_reference"] = False
+    if ref.get("anomalous"):
+        for k in ("unique_reflections", "completeness", "multiplicity", "i_over_sigma",
+                  "r_meas", "cc_half"):
+            v = fnum(rep.get("ANOM_REFRES_" + k.upper()))
+            if v is not None:
+                r["refres_" + k] = v
+                r["per_hand_reference"] = True
     r["isa_ratio"] = round(r["refres_isa"] / r["isa_ref"], 4) if r["refres_isa"] and r["isa_ref"] else None
     r["r_meas_ratio"] = (round(r["refres_r_meas"] / r["r_meas_ref"], 4)
                          if r["refres_r_meas"] and r["r_meas_ref"] else None)
-- 
2.54.0


From 8364cfbc40bddb30a31bf4fc8c28d5fa4fe77243 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 14:09:39 +0200
Subject: [PATCH 114/122] rugnux: an R that compares between runs, beside the
 one that makes the maps

R_WORK and R_FREE score the data against a model scaled by k_overall, a
symmetry-constrained anisotropic B and a flat bulk solvent. That scale is
deliberate - a free per-shell rescale would reshape each map's radial
amplitude profile and a batch of maps would no longer be comparable - but it
can only bend one way with resolution, so whatever a dataset's own radial
profile does that k*exp(-B s^2) cannot follow is reported as R. Two reductions
of one crystal whose amplitudes differ radially therefore differ in R_FREE for
a reason that has nothing to do with either fitting the model: measured on one
such pair of runs, R_FREE moved a median +0.042 over eleven sets where
phenix.model_vs_data, which scales per shell, moved +0.002.

Report a second reading of the same fit: R_MODEL_SHELL_SCALED, one free scale
per resolution shell of the merge table, with R_MODEL as the same sum without
it and MODEL_RADIAL_MISFIT (RMS of ln k_shell) as the size of the rescale, so
the reason a comparison is or is not readable is on the page. Over all the
reflections, not the free 5%: nothing here is refined, so work and free
estimate the same quantity and the split only costs precision.

Nothing is written from it. On two sets, every output file - both maps, the
anomalous map, the map coefficients, the MTZ, the HKL and the CIF - is byte
for byte what the same commit produced without this change, and R_WORK and
R_FREE are unchanged.

On the pair above, the new R moves a median +0.0005 and holds every set
inside 0.0065 except the one that is a real regression, which it puts first
at +0.0174 where the old metric ranked it seventh. The battery reports it
beside R_free, and scores neither.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CPU_DATA_ANALYSIS_DECISIONS.md |  2 +
 docs/RUGNUX_ADVANCED.md             |  4 +-
 docs/RUGNUX_REPORT.md               | 32 ++++++++++++++
 rugnux/ModelValidation.cpp          | 66 +++++++++++++++++++++++++++++
 rugnux/ModelValidation.h            | 23 ++++++++++
 rugnux/ResultReport.cpp             | 32 ++++++++++++++
 tests/ResultReportTest.cpp          | 31 +++++++++++++-
 tools/battery/README.md             | 15 +++++++
 tools/battery/report.py             | 27 +++++++++++-
 tools/battery/score.py              |  7 +++
 10 files changed, 235 insertions(+), 4 deletions(-)

diff --git a/docs/CPU_DATA_ANALYSIS_DECISIONS.md b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
index ecc059048..f248d736d 100644
--- a/docs/CPU_DATA_ANALYSIS_DECISIONS.md
+++ b/docs/CPU_DATA_ANALYSIS_DECISIONS.md
@@ -126,6 +126,8 @@ $
 
 This is the standard, few-parameter scaling model used by refinement programs. No free-form per-resolution-shell rescale is applied: such a rescale is dataset-specific and reshapes each map's radial amplitude profile differently, which would make maps from a multi-dataset campaign no longer directly comparable.
 
+That decision has a cost, and it is paid by the R-factors rather than by the maps. $k\exp(-\mathbf{s}^\mathsf{T} B \mathbf{s})$ can only bend one way with resolution, so whatever a dataset's radial amplitude profile does that this shape cannot follow is reported as R — which makes R a reading of *this* dataset and not a quantity comparable with another reduction of the same crystal. Both uses are wanted, so both are served, separately: the maps and `R_WORK` / `R_FREE` keep the scale above, and a second reading, `R_MODEL_SHELL_SCALED`, applies one free scale per resolution shell to the *same* fit and is reported beside them, with `MODEL_RADIAL_MISFIT` saying how much that rescale had to do. Nothing is written from the second reading; it never reaches a map, a map coefficient or a decision (§14.3, and RUGNUX_REPORT).
+
 The fit sees the **working reflections only**; the parameters it returns are then applied to every reflection, free ones included, so that R-free (§14.3) is computed against them. The parameters are few, but they are fitted by minimising the very sum R is made of, and a free reflection that helped choose them is no longer held out.
 
 ### 14.3 R-work and R-free
diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 9df974f79..077cdf1fd 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -143,7 +143,9 @@ cell or no usable space group, does not fail the run: it is logged, and the resu
 maps cannot be mistaken for one that was never given `--model`.
 
 Either way the results report carries a **`5. MODEL VALIDATION`** section: `R_WORK=` / `R_FREE=`
-with their reflection counts, the bulk-solvent and overall scale parameters, the mean 2mFo−DFc density
+with their reflection counts, `R_MODEL_SHELL_SCALED=` and `MODEL_RADIAL_MISFIT=` beside them (the R
+that compares between two runs, and why the other two do not — see
+[RUGNUX_REPORT](RUGNUX_REPORT.md)), the bulk-solvent and overall scale parameters, the mean 2mFo−DFc density
 at the atom centres, the reindexing operators the written reflections were brought into the model's
 frame with, and `MAPS_PREFIX=`; or `MODEL_VALIDATION= NOT_PERFORMED` with
 `MODEL_VALIDATION_REASON=` when the model could not be used. A run given no `--model` has no such
diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index 9b50f8697..cc0ffa34b 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -551,6 +551,38 @@ The null's own numbers — `MODEL_FIT_STATISTIC`, `MODEL_FIT_VALUE`, the `MODEL_
 the `MODEL_INDEXING_MARGIN*` keys — are written with `--developer`; the default report carries the
 verdict (`MODEL_FIT`, `MODEL_FIT_SIGMA`, `MODEL_DECISIONS_TAKEN` and the two decisions).
 
+### Comparing two runs: `R_MODEL_SHELL_SCALED`
+
+`R_WORK` and `R_FREE` describe *this* dataset against *this* model, and that is all they describe.
+They are **not comparable with another run's**. The model is scaled to the data by an overall factor
+and a symmetry-constrained anisotropic *B* — a shape that can only bend one way with resolution, kept
+that way on purpose so that a batch of maps stays on one scale (see
+[CPU_DATA_ANALYSIS_DECISIONS](CPU_DATA_ANALYSIS_DECISIONS.md)). Whatever the amplitudes' own radial
+profile does that this shape cannot follow is then reported as R. Two reductions of one crystal whose
+merged amplitudes have different radial profiles therefore differ in `R_FREE` for a reason that has
+nothing to do with either fitting the model better, and by more than a real change in the data moves it.
+
+`R_MODEL_SHELL_SCALED` is the same sum with that taken out: one free scale per resolution shell — the
+merge table's own shells — fitted on the shell's reflections, so only the agreement *inside* each
+shell is left. `R_MODEL` is the same sum without the per-shell scale, so the gap between the two is
+what the radial profile cost, and `MODEL_RADIAL_MISFIT` is the size of the rescale that closed it
+(the RMS of ln *k*<sub>shell</sub> about its mean). When the misfit moves between two runs, `R_FREE`
+between those two runs cannot be read; `R_MODEL_SHELL_SCALED` can.
+
+Both R values are over **all** the reflections, not the free 5%. Nothing here is refined — the
+coordinates, the B-factors and the occupancies are the model's own, and only the scale and the
+placement are fitted — so work and free estimate the same quantity (they differ by a median 0.001
+over our corpus) and the split buys no cross-validation while costing a factor of √20 in precision.
+
+None of this touches the maps: the map coefficients, the `.ccp4` files and `R_WORK` / `R_FREE` are
+computed from the scale described above and are unchanged by these keys.
+
+| key | meaning |
+|---|---|
+| `R_MODEL`, `R_MODEL_REFLECTIONS` | R over every reflection, on the scale the maps use |
+| `R_MODEL_SHELL_SCALED` | The same, with one free scale per resolution shell — **the number to compare between runs** |
+| `MODEL_RADIAL_MISFIT` | How large that per-shell rescale had to be: RMS of its logarithm. Near zero means the maps' own scale already described the radial profile, and then the two R values agree |
+
 ### CC(model, data)
 
 Beside the R-factors, section 5 carries the **correlation of the merged intensities with the placed,
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 783b19849..df9ac2c7c 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -916,6 +916,72 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                     result.cc_model_overall, result.cc_model_n,
                     result.cc_model_shells.back().d_min, result.cc_model_shells.back().cc,
                     result.cc_model_shells.back().n, result.cc_model_shells.back().sigma);
+
+        // --- the same R with the radial profile taken out, and how much of it there was ---
+        // R above is what the maps are made of and is read WITHIN a run; this is the one to read
+        // BETWEEN two. The scale the maps use can only bend as k*exp(-B s^2) (see the note in
+        // fit_model, and the reason it stays that way), so where two reductions of one crystal differ
+        // in the radial profile of their amplitudes, the part of the difference that shape cannot
+        // follow lands in R - measured on this corpus, enough to move R by more than a real change in
+        // the data does. Giving the scale one free factor per shell removes the radial profile and
+        // only the radial profile: what is left is the agreement inside each shell, which is the
+        // question "do these data fit this model better or worse than those did".
+        //
+        // On ALL the reflections, not the free set. Nothing here is refined - the coordinates, the B
+        // factors and the occupancies are the model's own - so work and free estimate the same
+        // quantity (measured: the two differ by a median 0.001 over the corpus), and the 5% split
+        // therefore buys no cross-validation while costing a factor of sqrt(20) in precision. Read on
+        // all of them, the number is worth about +-0.002 per set instead of +-0.010, which is the
+        // difference between seeing a real change and seeing the sampling of a free set.
+        //
+        // Nothing is written from any of this. fmodel, the maps, the MTZ and the R-factors above are
+        // untouched; it is a second reading of the fit that has already happened.
+        double num = 0, den = 0, plain_num = 0, plain_den = 0;
+        int n_scored = 0;
+        std::vector<double> sum_oc(report_shell_d_min.size(), 0), sum_cc(report_shell_d_min.size(), 0);
+        for (const auto &hv : fmodel.v) {
+            const auto it = obs_by_hkl.find(hkl_key(hv.hkl));
+            if (it == obs_by_hkl.end()) continue;
+            const size_t bin = shell_of(it->second.d);
+            if (bin >= sum_oc.size()) continue;
+            sum_oc[bin] += it->second.F * std::abs(hv.value);
+            sum_cc[bin] += static_cast<double>(std::abs(hv.value)) * std::abs(hv.value);
+        }
+        // The shell's scale by least squares on its own reflections. One parameter per shell against
+        // the thousands of reflections in it, so scoring the same reflections it was fitted on lowers
+        // R by far less than the difference it is there to expose.
+        std::vector<double> ln_k;
+        ln_k.reserve(report_shell_d_min.size());
+        for (size_t i = 0; i < sum_oc.size(); i++)
+            if (sum_cc[i] > 0 && sum_oc[i] > 0)
+                ln_k.push_back(std::log(sum_oc[i] / sum_cc[i]));
+        for (const auto &hv : fmodel.v) {
+            const auto it = obs_by_hkl.find(hkl_key(hv.hkl));
+            if (it == obs_by_hkl.end()) continue;
+            const size_t bin = shell_of(it->second.d);
+            if (bin >= sum_oc.size()) continue;
+            const double Fo = it->second.F, Fc = std::abs(hv.value);
+            const double k = (sum_cc[bin] > 0 && sum_oc[bin] > 0) ? sum_oc[bin] / sum_cc[bin] : 1.0;
+            num += std::fabs(Fo - k * Fc);
+            den += Fo;
+            plain_num += std::fabs(Fo - Fc);
+            plain_den += Fo;
+            ++n_scored;
+        }
+        if (den > 0 && ln_k.size() >= 2) {
+            result.r_model = plain_num / plain_den;
+            result.r_model_shell_scaled = num / den;
+            result.n_model = n_scored;
+            result.shell_scale_bins = static_cast<int>(ln_k.size());
+            const double mean_ln_k = std::accumulate(ln_k.begin(), ln_k.end(), 0.0) / ln_k.size();
+            double var = 0;
+            for (double v : ln_k) var += (v - mean_ln_k) * (v - mean_ln_k);
+            result.radial_misfit = std::sqrt(var / ln_k.size());
+            logger.Info("Model validation: R(all reflections) {:.4f}, with a per-shell scale {:.4f} "
+                        "over {} shells; radial misfit {:.3f}",
+                        result.r_model, result.r_model_shell_scaled, result.shell_scale_bins,
+                        result.radial_misfit);
+        }
     }
 
     // --- sigma_A weighting: the maps are 2mFo-DFc and mFo-DFc, not 2Fo-Fc and Fo-Fc ---
diff --git a/rugnux/ModelValidation.h b/rugnux/ModelValidation.h
index 7fc6831a8..4aceab134 100644
--- a/rugnux/ModelValidation.h
+++ b/rugnux/ModelValidation.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <cmath>
 #include <memory>
 #include <optional>
 #include <string>
@@ -31,6 +32,28 @@ struct ModelValidationResult {
     double k_overall = 0.0;
     int n_work = 0;
     int n_free = 0;
+
+    // R over ALL the reflections - r_model as the maps are scaled, r_model_shell_scaled with one free
+    // scale per resolution shell instead - and how far those per-shell scales had to depart from a
+    // flat one. The pair exists to be read BETWEEN runs, where r_work / r_free cannot be.
+    //
+    // The scale the maps carry can only bend as k*exp(-B s^2), deliberately (see ModelValidation.cpp),
+    // so where two reductions of one crystal differ in the radial profile of their amplitudes, the
+    // part of the difference that shape cannot follow is reported as R - by more, measured, than a
+    // real change in the data moves it. A per-shell scale removes the radial profile and only the
+    // radial profile, leaving the agreement inside each shell.
+    //
+    // All the reflections and not the free set, because nothing here is refined: the coordinates, the
+    // B factors and the occupancies are the model's own, so work and free estimate the same quantity
+    // and the 5% split buys no cross-validation while costing a factor of sqrt(20) in precision.
+    double r_model = NAN;
+    double r_model_shell_scaled = NAN;
+    int n_model = 0;
+    // The RMS of ln(k_shell) about its own mean. Near zero says k*exp(-B s^2) already described this
+    // dataset's radial profile, and then the two R-factors agree; a large value says it did not, and
+    // is worth seeing on its own - it is the gap between the two R-factors, named.
+    double radial_misfit = NAN;
+    int shell_scale_bins = 0;
     double mean_atom_density_sigma = 0.0;  // mean 2mFo-DFc value at atom centres, in sigma
     std::string maps_prefix;               // where the .ccp4 / _maps.mtz were written
 
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 9e9960675..08b3d8ff3 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -34,6 +34,9 @@ namespace {
     //    whether choosing the partner reflections differently could repair it.
     // 13: CC_MODEL_* in section 5 - the correlation of the merged intensities with the placed model,
     //    by resolution shell, which only a run given a model can report.
+    // 14: R_MODEL / R_MODEL_SHELL_SCALED / MODEL_RADIAL_MISFIT in section 5 - R over all the
+    //    reflections, with and without one free scale per shell, and the size of that rescale.
+    //    R_WORK and R_FREE are unchanged and still describe the model the maps were made from.
     // 8: every line that is not `KEY= value` and not blank starts with `#`, warnings included
     //    (`# WARNING:`); the header gains RUGNUX_DOWNLOAD and BUILD_CXX_FLAGS, and RUGNUX_GIT is
     //    the full build-time hash.
@@ -1631,6 +1634,15 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
             Add(s, KeyReal("R_FREE", mv.r_free, "{:.4f}"));
             Add(s, KeyInt("R_WORK_REFLECTIONS", mv.n_work));
             Add(s, KeyInt("R_FREE_REFLECTIONS", mv.n_free));
+            // The pair to read BETWEEN two runs, where R_WORK / R_FREE cannot be - see the prose at
+            // the end of this section and the note in ModelValidation.h.
+            if (std::isfinite(mv.r_model_shell_scaled)) {
+                Add(s, KeyReal("R_MODEL", mv.r_model, "{:.4f}"));
+                Add(s, KeyReal("R_MODEL_SHELL_SCALED", mv.r_model_shell_scaled, "{:.4f}"));
+                Add(s, KeyInt("R_MODEL_REFLECTIONS", mv.n_model));
+                Add(s, KeyReal("MODEL_RADIAL_MISFIT", mv.radial_misfit, "{:.3f}"));
+                Add(s, KeyInt("MODEL_RADIAL_SHELLS", mv.shell_scale_bins, true));
+            }
             Add(s, KeyReal("BULK_SOLVENT_K_SOL", mv.k_sol, "{:.3f}", true));
             Add(s, KeyReal("BULK_SOLVENT_B_SOL", mv.b_sol, "{:.1f}", true));
             Add(s, KeyReal("SCALE_OVERALL", mv.k_overall, "{:.4f}", true));
@@ -1746,6 +1758,26 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                          " structure's and are a data-quality reading, not a refinement result. The scale and the\n"
                          " placement are both fitted on the working reflections alone, so the free set is held out\n"
                          " of the fit and not only out of the sum."));
+            if (std::isfinite(mv.r_model_shell_scaled))
+                Add(s, Prose(fmt::format(
+                        " R_WORK and R_FREE above describe THIS dataset against this model, and that is what they\n"
+                        " are for. They are not comparable with another dataset's, or with the same dataset\n"
+                        " reduced differently: the model is scaled to the data by an overall factor and an\n"
+                        " anisotropic B, a shape that can only bend one way with resolution, and whatever the\n"
+                        " amplitudes' own radial profile does that this shape cannot follow is reported as R.\n"
+                        " Two reductions with different radial profiles therefore differ in R for a reason that\n"
+                        " has nothing to do with how well either fits the model.\n"
+                        " R_MODEL_SHELL_SCALED ({:.4f}) is the same R with that removed - one free scale per\n"
+                        " resolution shell of the table above, so only the agreement INSIDE each shell is left -\n"
+                        " and it is the number to compare between runs. R_MODEL ({:.4f}) is the same sum without\n"
+                        " the per-shell scale, so the gap between the two is what the radial profile cost.\n"
+                        " Both are over every reflection, not the free set: nothing here is refined, so work and\n"
+                        " free measure the same thing and using all of them is simply more precise.\n"
+                        " MODEL_RADIAL_MISFIT ({:.3f}) is the size of that per-shell rescale, as the RMS of its\n"
+                        " logarithm over {} shells: near zero means the scale already described the profile and\n"
+                        " the two R values agree. Nothing is written from any of this - the maps, the map\n"
+                        " coefficients and the R-factors above are untouched by it.",
+                        mv.r_model_shell_scaled, mv.r_model, mv.radial_misfit, mv.shell_scale_bins)));
             if (mv.fit_tested)
                 Add(s, Prose(fmt::format(
                         " MODEL_FIT says whether these data accept the model: the same model was refitted from\n"
diff --git a/tests/ResultReportTest.cpp b/tests/ResultReportTest.cpp
index 12d61a22b..037a92118 100644
--- a/tests/ResultReportTest.cpp
+++ b/tests/ResultReportTest.cpp
@@ -421,8 +421,11 @@ TEST_CASE("ResultReport_ModelValidationSection", "[Diagnostics]") {
         CHECK(dev_text.find("\nMODEL_FIT_NULL_REPLICATES= 5\n") != std::string::npos);
     }
     CHECK(text.find("\nMODEL_FIT_SIGMA= +4.12\n") != std::string::npos);
-    // A run that measured no CC(model, data) writes no key for it.
+    // A run that measured no CC(model, data) writes no key for it, and the shell-scaled R shares
+    // its shells, so it is absent too.
     CHECK(text.find("CC_MODEL_OVERALL=") == std::string::npos);
+    CHECK(text.find("R_MODEL_SHELL_SCALED=") == std::string::npos);
+    CHECK(text.find("MODEL_RADIAL_MISFIT=") == std::string::npos);
     CHECK(text.find("CC_MODEL_CONFIRMED_TO_D_MIN=") == std::string::npos);
     CHECK(text.find("\nMODEL_DECISIONS_TAKEN= ENANTIOMORPH\n") != std::string::npos);
     // The hand is ASSUMED from the model, never determined: merged intensities cannot see it.
@@ -473,6 +476,32 @@ TEST_CASE("ResultReport_ModelValidationSection", "[Diagnostics]") {
     CHECK(cc_text.find("      1.80    0.0412       2110      +1.9") != std::string::npos);
     CHECK(cc_text.find("The table reads in ONE direction only") != std::string::npos);
 
+    // The comparable R rides on the same shells. R_WORK and R_FREE are what they always were - the
+    // maps' own scale - and the new keys sit beside them rather than in place of them.
+    ModelValidationResult with_r = with_cc;
+    with_r.r_model = 0.2011;
+    with_r.r_model_shell_scaled = 0.1734;
+    with_r.n_model = 17610;
+    with_r.radial_misfit = 0.312;
+    with_r.shell_scale_bins = 3;
+    result.model_validation = with_r;
+    const auto r_text = RenderResultReport("p", "in.h5", x, result);
+    CHECK(r_text.find("\nR_WORK= 0.1823\n") != std::string::npos);
+    CHECK(r_text.find("\nR_FREE= 0.2145\n") != std::string::npos);
+    CHECK(r_text.find("\nR_MODEL= 0.2011\n") != std::string::npos);
+    CHECK(r_text.find("\nR_MODEL_SHELL_SCALED= 0.1734\n") != std::string::npos);
+    CHECK(r_text.find("\nR_MODEL_REFLECTIONS= 17610\n") != std::string::npos);
+    CHECK(r_text.find("\nMODEL_RADIAL_MISFIT= 0.312\n") != std::string::npos);
+    CHECK(r_text.find("the number to compare between runs") != std::string::npos);
+    // The shell count is a working detail of the rescale, not part of the reading.
+    CHECK(r_text.find("MODEL_RADIAL_SHELLS=") == std::string::npos);
+    {
+        RunProvenance dev;
+        dev.developer = true;
+        CHECK(RenderResultReport("p", "in.h5", x, result, dev)
+                      .find("\nMODEL_RADIAL_SHELLS= 3\n") != std::string::npos);
+    }
+
     // Nothing significant anywhere: the key still has to be written, saying so.
     ModelValidationResult no_signal = with_cc;
     for (auto &sh : no_signal.cc_model_shells)
diff --git a/tools/battery/README.md b/tools/battery/README.md
index b4d932462..a9b8eeffc 100644
--- a/tools/battery/README.md
+++ b/tools/battery/README.md
@@ -57,6 +57,20 @@ arms `cc_half_noise_ratio` = (1/CC1/2_rugnux - 1) / (1/(CC1/2_XDS - 0.0005) - 1)
 range is shown as a guide: CC1/2 = S/(S+E), so 1/CC1/2 - 1 = E/S, and 2 means a merge as noisy as
 XDS's would be with half of its observations.
 
+**R_free does not compare between runs; `rmodel_shell_scaled` does.** rugnux scales the model to
+the data with an overall factor and a symmetry-constrained anisotropic B, which can only bend one
+way with resolution - deliberately, so that the maps of a batch stay comparable. Whatever the
+amplitudes' own radial profile does that this shape cannot follow is reported as R. So two runs
+whose merged amplitudes have different radial profiles have R_free values that differ for a reason
+that has nothing to do with the data fitting the model: measured on one such pair, R_free moved a
+median +0.042 over eleven sets where `phenix.model_vs_data`, which scales per shell, moved +0.002.
+`rmodel_shell_scaled` is the same R with one free scale per resolution shell, over every reflection
+rather than the free 5% (nothing is refined here, so the free set buys no cross-validation and only
+costs precision): on that same pair its median was +0.001, and it still flagged the one set that
+was a real regression. `radial_misfit` is the size of that per-shell rescale, the RMS of its
+logarithm; when it moves, R_free beside it cannot be read. All three are reported for a human,
+never scored.
+
 **Low-resolution R_meas** is reported, not scored: the lowest-resolution shell of rugnux's own
 table (`lowres_r_meas`), of the reference-range table (`refres_lowres_r_meas`) and of XDS's
 `CORRECT.LP` (`lowres_r_meas_ref`, stored in the manifest as `r_meas_low`), with the shells'
@@ -292,6 +306,7 @@ was run `--unforced`), so its forced XDS-arm rows are left out the same way.
 | `lowres_d`, `lowres_r_meas`, `refres_lowres_d`, `refres_lowres_r_meas`, `lowres_d_ref`, `lowres_r_meas_ref`, `lowres_r_meas_ratio` | the lowest-resolution shell's high-resolution limit and R_meas: rugnux's own table, the reference-range table, XDS's; and refres_lowres_r_meas / lowres_r_meas_ref |
 | `model`, `model_note` | open arm: the deposited coordinates given to `--model`, or why there were none |
 | `rfree`, `rwork`, `cc_model`, `model_fit`, `rfree_deposited`, `rfree_ratio` | open arm with a model: R_FREE, R_WORK, CC_MODEL_OVERALL and MODEL_FIT as rugnux reports them (placement-only, own free set: trend fields), the published R-free, and rfree / rfree_deposited |
+| `rmodel`, `rmodel_shell_scaled`, `radial_misfit` | open arm with a model: R_MODEL, R_MODEL_SHELL_SCALED and MODEL_RADIAL_MISFIT - R over all the reflections, with and without one free scale per resolution shell, and how big that rescale was. `rmodel_shell_scaled` is the R that compares between runs (below) |
 | `refmac_rfree`, `refmac_rwork`, `refmac_rfree_depflags`, `refmac_rfree_depdata`, `refmac_rfree_ratio`, `refmac_status`, `refmac_reason` | the REFMAC check (`--model-check`, open arm) |
 | `wall_s`, `rugnux_wall_s`, `elapsed_s`, `exit_code`, `gpu_others`, `rugnux_verdict` | timing (`wall_s` is rugnux's own WALL_TIME, not the time spent waiting for the GPU queue), the exit code, other GPU processes seen before the set, and rugnux's own verdict line |
 
diff --git a/tools/battery/report.py b/tools/battery/report.py
index aef3ddd89..a15089300 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -18,6 +18,8 @@ NOISE = {
     "completeness": ("abs", 1.0),   # percentage points
     "cell_dev_pct": ("abs", 0.2),   # percentage points
     "rfree": ("abs", 0.005),
+    "rmodel_shell_scaled": ("abs", 0.005),
+    "radial_misfit": ("abs", 0.05),
     "refres_r_meas": ("rel", 0.05),
     "refres_isa": ("rel", 0.05),
     "refres_lowres_r_meas": ("rel", 0.05),
@@ -188,6 +190,11 @@ def changes(ra, rb):
     for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct", "rfree"):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
+    # The R that is comparable between runs, and the radial profile that decides whether `rfree`
+    # beside it can be read at all (both only where both runs carry them).
+    for name in ("rmodel_shell_scaled", "radial_misfit"):
+        if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
+            out.append(name)
     # the like-for-like table only where both runs have one (a pre-schema-3 run has none)
     for name in ("refres_r_meas", "refres_isa", "refres_lowres_r_meas"):
         if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
@@ -215,7 +222,8 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 def compare_table(doc, rows, only_changed=True):
     head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "R_free", "ref-range R_meas", "ref-range low-res R_meas", "time s", "beyond noise"]
+            "cell dev %", "R_free", "R_model (shell-scaled)", "radial misfit",
+            "ref-range R_meas", "ref-range low-res R_meas", "time s", "beyond noise"]
     out = []
     for (arm, s), ra, rb, ch in rows:
         if only_changed and not ch:
@@ -229,6 +237,8 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("cc_half"), rb.get("cc_half"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
+                    arrow(ra.get("rmodel_shell_scaled"), rb.get("rmodel_shell_scaled"), lambda v: f"{v:.3f}"),
+                    arrow(ra.get("radial_misfit"), rb.get("radial_misfit"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("refres_r_meas"), rb.get("refres_r_meas"), lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("refres_lowres_r_meas"), rb.get("refres_lowres_r_meas"),
                           lambda v: f"{100 * v:.1f}%"),
@@ -342,6 +352,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                               ("lowres_r_meas_ratio", "ref-range low-res R_meas / XDS", "{:.3f}"),
                               ("cc_half_noise_ratio", "ref-range CC1/2 noise / XDS", "{:.2f}"),
                               ("rfree", "R_free (placement)", "{:.3f}"),
+                              ("rmodel_shell_scaled", "R_model, shell-scaled", "{:.3f}"),
+                              ("radial_misfit", "radial misfit", "{:.2f}"),
                               ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
             q = quartiles(r.get(name) for r in rs)
             if q:
@@ -456,7 +468,18 @@ def build(run_dir, baseline=None, allow_incomplete=False):
     doc.h(3, "Per set")
     doc.p("Space group: on the open arm the data's own determination. Where --model put the model's "
           "enantiomorph on the label, the label is in the note and the group scored is the search's.")
-    model = [("R_free", "rfree"), ("R_work", "rwork"), ("CC model", "cc_model"), ("dep R_free", "rfree_deposited"),
+    if any(r.get("rmodel_shell_scaled") for r in res):
+        doc.p("R_free and R_work describe one run against its model and do not carry across runs: the "
+              "model is scaled to the data by an overall factor and an anisotropic B, so whatever the "
+              "amplitudes' radial profile does that this shape cannot follow is reported as R, and a "
+              "change in the profile alone moves R_free further than a real change in the data does. "
+              "R_model (shell-scaled) is the same R with one free scale per resolution shell removing "
+              "exactly that, over every reflection rather than the free 5%, and it is the column to "
+              "read in a delta table. Radial misfit is how big that per-shell rescale had to be (the "
+              "RMS of its logarithm): when it moves between two runs, R_free between them means "
+              "little. Both are reported for a human to judge; nothing is scored on them.")
+    model = [("R_free", "rfree"), ("R_work", "rwork"), ("R_model (shell-scaled)", "rmodel_shell_scaled"),
+             ("radial misfit", "radial_misfit"), ("CC model", "cc_model"), ("dep R_free", "rfree_deposited"),
              ("R_free ratio", "rfree_ratio")] if any(r.get("rfree") for r in res) else []
     model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
               ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
diff --git a/tools/battery/score.py b/tools/battery/score.py
index 8742d1bab..c44b3bb40 100644
--- a/tools/battery/score.py
+++ b/tools/battery/score.py
@@ -197,6 +197,13 @@ def judge(entry, rep, run_note):
         # on rugnux's own free set, so a trend number, not the depositor's R-free
         "rfree": fnum(rep.get("R_FREE")), "rwork": fnum(rep.get("R_WORK")),
         "model_fit": rep.get("MODEL_FIT"), "cc_model": fnum(rep.get("CC_MODEL_OVERALL")),
+        # R over ALL the reflections, with and without one free scale per resolution shell, and the
+        # size of that rescale. rfree above describes one run and is not comparable with another's:
+        # the model's scale can only bend as k*exp(-B s^2), so a change in the amplitudes' radial
+        # profile alone moves it. rmodel_shell_scaled has that taken out and IS comparable; it is
+        # the R to read in a delta table. radial_misfit says how much there was to take out.
+        "rmodel": fnum(rep.get("R_MODEL")), "rmodel_shell_scaled": fnum(rep.get("R_MODEL_SHELL_SCALED")),
+        "radial_misfit": fnum(rep.get("MODEL_RADIAL_MISFIT")),
         "sg_label": None, "accepted_alt": None, "accepted_alt_why": None,
     }
     # the same merge binned over the reference's range (--report-resolution, XDS arms)
-- 
2.54.0


From fdcbb0d70010e32efb075fd8330f0b820f1e156b Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 14:13:31 +0200
Subject: [PATCH 115/122] tools/battery: the comparable R leads the report

R_model with one free scale per resolution shell is the number that can be
read between two runs; the placement R beside it cannot, because the fixed
model is scaled by k and an anisotropic B only and a change in the
amplitudes' radial profile has nowhere to go but the residual. Both are
still printed, with the radial misfit next to them, so a reader can see
when the placement R stopped meaning anything.

Nothing is scored on any of them.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 tools/battery/report.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/tools/battery/report.py b/tools/battery/report.py
index a15089300..c6188e068 100644
--- a/tools/battery/report.py
+++ b/tools/battery/report.py
@@ -187,12 +187,12 @@ def changes(ra, rb):
     if ra.get("volume_ratio") and rb.get("volume_ratio") and \
             abs(ra["volume_ratio"] - rb["volume_ratio"]) > 0.05:
         out.append("lattice")
-    for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct", "rfree"):
+    for name in ("d_min", "isa", "r_meas", "cc_half", "completeness", "cell_dev_pct"):
         if beyond_noise(name, ra.get(name), rb.get(name)):
             out.append(name)
     # The R that is comparable between runs, and the radial profile that decides whether `rfree`
     # beside it can be read at all (both only where both runs carry them).
-    for name in ("rmodel_shell_scaled", "radial_misfit"):
+    for name in ("rmodel_shell_scaled", "radial_misfit", "rfree"):
         if ra.get(name) is not None and rb.get(name) is not None and beyond_noise(name, ra[name], rb[name]):
             out.append(name)
     # the like-for-like table only where both runs have one (a pre-schema-3 run has none)
@@ -222,7 +222,7 @@ def arrow(x, y, fmt=lambda v: str(v)):
 
 def compare_table(doc, rows, only_changed=True):
     head = ["set", "arm", "verdict", "space group", "d_min", "ISa", "R_meas", "CC1/2",
-            "cell dev %", "R_free", "R_model (shell-scaled)", "radial misfit",
+            "cell dev %", "R_model (shell-scaled)", "R_free", "radial misfit",
             "ref-range R_meas", "ref-range low-res R_meas", "time s", "beyond noise"]
     out = []
     for (arm, s), ra, rb, ch in rows:
@@ -236,8 +236,8 @@ def compare_table(doc, rows, only_changed=True):
                     arrow(ra.get("r_meas"), rb.get("r_meas"), lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("cc_half"), rb.get("cc_half"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("cell_dev_pct"), rb.get("cell_dev_pct"), lambda v: f"{v:.2f}"),
-                    arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("rmodel_shell_scaled"), rb.get("rmodel_shell_scaled"), lambda v: f"{v:.3f}"),
+                    arrow(ra.get("rfree"), rb.get("rfree"), lambda v: f"{v:.3f}"),
                     arrow(ra.get("radial_misfit"), rb.get("radial_misfit"), lambda v: f"{v:.2f}"),
                     arrow(ra.get("refres_r_meas"), rb.get("refres_r_meas"), lambda v: f"{100 * v:.1f}%"),
                     arrow(ra.get("refres_lowres_r_meas"), rb.get("refres_lowres_r_meas"),
@@ -351,8 +351,8 @@ def build(run_dir, baseline=None, allow_incomplete=False):
                               ("lowres_r_meas", "low-res shell R_meas", None),
                               ("lowres_r_meas_ratio", "ref-range low-res R_meas / XDS", "{:.3f}"),
                               ("cc_half_noise_ratio", "ref-range CC1/2 noise / XDS", "{:.2f}"),
-                              ("rfree", "R_free (placement)", "{:.3f}"),
                               ("rmodel_shell_scaled", "R_model, shell-scaled", "{:.3f}"),
+                              ("rfree", "R_free (placement, within-run only)", "{:.3f}"),
                               ("radial_misfit", "radial misfit", "{:.2f}"),
                               ("rfree_ratio", "R_free ratio", "{:.3f}"), ("wall_s", "time s", "{:.0f}")):
             q = quartiles(r.get(name) for r in rs)
@@ -478,8 +478,9 @@ def build(run_dir, baseline=None, allow_incomplete=False):
               "read in a delta table. Radial misfit is how big that per-shell rescale had to be (the "
               "RMS of its logarithm): when it moves between two runs, R_free between them means "
               "little. Both are reported for a human to judge; nothing is scored on them.")
-    model = [("R_free", "rfree"), ("R_work", "rwork"), ("R_model (shell-scaled)", "rmodel_shell_scaled"),
-             ("radial misfit", "radial_misfit"), ("CC model", "cc_model"), ("dep R_free", "rfree_deposited"),
+    model = [("R_model (shell-scaled)", "rmodel_shell_scaled"), ("radial misfit", "radial_misfit"),
+             ("CC model", "cc_model"), ("R_free (within-run)", "rfree"), ("R_work", "rwork"),
+             ("dep R_free", "rfree_deposited"),
              ("R_free ratio", "rfree_ratio")] if any(r.get("rfree") for r in res) else []
     model += [("REFMAC R_free", "refmac_rfree_depflags"), ("REFMAC dep data", "refmac_rfree_depdata"),
               ("REFMAC ratio", "refmac_rfree_ratio")] if any(r.get("refmac_status") for r in res) else []
-- 
2.54.0


From 66373edc1b432668a9dec9b33fcdda98350f2251 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 14:16:50 +0200
Subject: [PATCH 116/122] Scaling: a correction surface is gauge-fixed within
 resolution shells

Every symmetry equivalent of a reflection sits at one d, and an ASU group's
reference is that group's own weighted mean - a free parameter. A surface factor
that is a function of d alone therefore multiplies a whole group identically and
cancels out of the fit exactly: with A radial, the weight 1/(sigma corr A)^2 and
the scaled observation I corr A both carry A, and the round's `cross` and `ref2`
come out numerically independent of it.

So the resolution direction of these surfaces is a null direction of the
objective, not a slowly-converging one. The update along it is the same on every
round, and the surface walks at constant speed until the [0.25, 4] clamp stops
it. "NOT settled in 30 round(s)" is that walk, not slow convergence, and raising
the cap from 3 to 30 took it ten times further rather than converging it. What
pushes it is the `Is > 0` filter, which drops the negative half of a weak cell's
observations and leaves the survivors up-fluctuated - a bias that is a function
of the cell's signal-to-noise, hence of resolution. Nothing can see it: a factor
shared by a whole group cancels out of R_meas, CC1/2 and chi^2, and the even/odd
cross-validation that gates the surface carries it equally in both halves.

Simulated on synthetic data with a flat truth, an outer shell at I/sigma = 1 is
suppressed 4% after 3 rounds and 24% after 30 while the held-out gain reads 0.1%.
Measured on five open-arm sets, the shipped surfaces suppress the outer shell by
2-13x against the depositors' own structure factors - an independent measurement
of the same crystal forms, and no model.

The direction is now projected out at the parameterisation instead of being
bounded by an iteration count: after each round the surface is divided by its own
weighted geometric mean within each resolution shell, leaving the azimuthal and
positional variation that absorption and a flat field physically are. The
projection removes the overall level too, so it subsumes the old global gauge.
On the same simulation it recovers a 12% cos(2 phi) flat field to CC 0.986 at
full amplitude while the radial ramp goes to 1.00.

The surfaces' log line now also reports the ramp the gauge removed (45x and 56x
on two of the five) and how many cells sit on the clamp, both of which used to
happen silently.

Expect R_meas to RISE where this engages: the shipped surface was lowering a
ratio of sums across shells without tightening a single equivalent.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 117 ++++++++++++++++--
 1 file changed, 108 insertions(+), 9 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 96f46f46b..a56ee38dc 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -239,7 +239,7 @@ RotationScaleMerge::RotationScaleMerge(const DiffractionExperiment &experiment,
     refine_decay_b = s.GetCorrectionSurfaces();
     absorption_iter = s.GetCorrectionSurfaces() ? s.GetAbsorptionIter() : 0;
     modulation_iter = s.GetCorrectionSurfaces() ? s.GetAbsorptionIter() : 0;
-    relative_b_deg = s.GetRelativeBDegrees();   // opt-in per-batch relative-B (0 = off)
+    relative_b_deg = s.GetRelativeBDegrees();   // per-batch relative-B batch width (0 = off)
     scaling_iter = std::max(1, scaling_iterations);
     resolution_cutoff_method = s.GetResolutionCutoff();
     resolution_cc_target = s.GetResolutionCCTarget();
@@ -3105,7 +3105,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     // traffic of the data it touched, over hundreds of megabytes. Copying once turns them into
     // sequential walks of a compact array. The copy keeps fulls order, so each sum below is formed
     // from exactly the same terms in exactly the same order.
-    struct Term { float I, sigma, corr; int32_t cell, group; };
+    struct Term { float I, sigma, corr, d; int32_t cell, group; };
     std::vector<Term> term;
     std::vector<uint8_t> term_parity;   // frame parity, read only by the group-ordered copy below
     // Which terms each pass walks, as positions in `term`. The cross-validated halves then cost half a
@@ -3143,7 +3143,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
                     const Obs &o = fulls[i];
                     if (!usable(o) || cell[i] < 0) continue;
                     const uint8_t parity = static_cast<uint8_t>(o.frame & 1);
-                    term[w] = {o.I, o.sigma, o.corr, cell[i], o.group};
+                    term[w] = {o.I, o.sigma, o.corr, o.d, cell[i], o.group};
                     term_parity[w] = parity;
                     idx_all[w] = static_cast<int32_t>(w);
                     (parity ? idx_odd[d++] : idx_even[e++]) = static_cast<int32_t>(w);
@@ -3164,6 +3164,68 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     // thread count, so a sum split this way gives the same answer on every run.
     auto part = [nt](size_t n, int t) { return n * static_cast<size_t>(t) / static_cast<size_t>(nt); };
 
+    // --- The surface's RESOLUTION gauge ---------------------------------------------------------
+    // Every symmetry equivalent of a reflection sits at one d, so a factor that is a function of d
+    // alone multiplies a whole ASU group identically - and the group's reference is that group's own
+    // weighted mean, i.e. a free parameter. Any such factor therefore cancels out of the fit exactly:
+    // with A a function of d, w = 1/(sigma corr A)^2 and Is = I corr A both carry A, and `cross` and
+    // `ref2` below come out numerically INDEPENDENT of it. The resolution direction of this surface is
+    // a null direction of the objective, not a slowly-converging one - the round's update along it is
+    // the same on every round, so the surface walks along it at constant speed until the [0.25, 4]
+    // clamp stops it. That is what "NOT settled in n round(s)" reports, and why raising the cap from
+    // 3 to 30 rounds took the walk ten times further rather than converging it.
+    // Something has to push it: here the `Is > 0` filter in the fit below, which drops the negative
+    // half of a weak cell's observations and leaves the survivors up-fluctuated, so `cross` is
+    // inflated where the signal is weak - a bias that is a function of the cell's signal-to-noise,
+    // hence of resolution. Simulated on synthetic data with a flat truth: an outer shell at
+    // I/sigma = 1 is suppressed 4% after 3 rounds and 24% after 30, while the even/odd held-out gain
+    // that gates the surface reads 0.1% - the cross-validation cannot see it either, because both
+    // halves carry it equally.
+    // So it is removed at the parameterisation instead of being bounded by a round count: after each
+    // round the surface is divided by its own weighted geometric mean WITHIN each resolution shell,
+    // which projects out the component that is a function of d and leaves the azimuthal / positional
+    // variation - what absorption and a flat field physically are. On the same simulation that
+    // recovers a 12% cos(2 phi) flat field to CC 0.986 at full amplitude while the radial ramp goes
+    // to 1.00. The projection removes the overall level too, so it subsumes the global gauge below.
+    // Equal-occupancy shells in s^2 = 1/d^2. The count is second order (8, 20 and 40 shells all leave
+    // the residual ramp inside 1.5%); 20 is fine enough to follow a curved drift and coarse enough
+    // that each shell still holds tens of thousands of observations.
+    constexpr int NSHELL = 20;
+    const int nshell = static_cast<int>(term.size()) >= 100 * NSHELL ? NSHELL : 0;
+    // Weight of cell c in shell s: the statistical weight its observations carry there. Computed ONCE
+    // from the incoming sigmas rather than per round, so the projection is a fixed linear operator and
+    // the alternating fit below converges against it.
+    std::vector<double> shw(static_cast<size_t>(ncell) * nshell, 0.0);
+    std::vector<double> shw_shell(nshell, 0.0), shw_cell(nshell > 0 ? ncell : 0, 0.0);
+    if (nshell > 0) {
+        std::vector<float> s2;
+        s2.reserve(term.size());
+        for (const Term &t : term)
+            s2.push_back(t.d > 0.0f ? 1.0f / (t.d * t.d) : 0.0f);
+        std::vector<float> edge(nshell - 1);
+        size_t prev = 0;
+        for (int i = 1; i < nshell; ++i) {
+            const size_t pos = s2.size() * static_cast<size_t>(i) / static_cast<size_t>(nshell);
+            std::nth_element(s2.begin() + prev, s2.begin() + pos, s2.end());
+            edge[i - 1] = s2[pos];
+            prev = pos;
+        }
+        for (size_t k = 0; k < term.size(); ++k) {
+            const Term &t = term[k];
+            const float v = t.d > 0.0f ? 1.0f / (t.d * t.d) : 0.0f;
+            const int s = static_cast<int>(std::upper_bound(edge.begin(), edge.end(), v) - edge.begin());
+            const double sc = static_cast<double>(t.sigma) * t.corr;
+            if (!(sc > 0.0)) continue;
+            shw[static_cast<size_t>(t.cell) * nshell + s] += 1.0 / (sc * sc);
+        }
+        for (int c = 0; c < ncell; ++c)
+            for (int s = 0; s < nshell; ++s) {
+                const double v = shw[static_cast<size_t>(c) * nshell + s];
+                shw_cell[c] += v;
+                shw_shell[s] += v;
+            }
+    }
+
     // The same terms once more, in ASU-GROUP order. The reference pass sums per group, so group order
     // is the only layout that lets a thread own a whole group's sum - and it still adds that group's
     // terms in fulls order, because the counting sort is stable (it walks `term`, which is in fulls
@@ -3206,18 +3268,25 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     };
 
     // Fit the per-cell factor over the subset {frame&1 == parity} (parity < 0 = all fulls), alternating
-    // rounds against that subset's own reference (Tikhonov pull to 1, gauge-fixed to a weighted
-    // geometric mean of 1 so it never drifts the overall scale) until the factors settle - the same
+    // rounds against that subset's own reference (Tikhonov pull to 1, then gauge-fixed within each
+    // resolution shell, which also holds the overall scale) until the factors settle - the same
     // tolerance as the per-frame scales, on the rms |log| of the round's update - or n_iter rounds
     // have been spent. Returns the per-cell factor.
     int rounds_used = 0;
     bool settled = false;
+    int n_clamped = 0;              // cells of the applied surface sitting on the [0.25, 4] bound
+    double gauge_ramp = 1.0;        // outer/inner ratio of the resolution ramp the gauge removed
     auto fit_surface = [&](int parity) -> std::vector<double> {
         const std::vector<int32_t> &sel = subset(parity);
         std::vector<double> A(ncell, 1.0);
         // Per-thread cell accumulators, allocated once for the whole fit rather than per round.
         std::vector<std::vector<double>> tcross(nt, std::vector<double>(ncell)), tref2(nt, std::vector<double>(ncell));
         settled = false;
+        n_clamped = 0;
+        // What the resolution gauge takes out, accumulated over the rounds as a log per shell: the
+        // walk along the null direction this fit would otherwise have made, which is worth reporting
+        // because no other statistic of the run can see it.
+        std::vector<double> removed(nshell, 0.0);
         for (int it = 0; it < n_iter; ++it) {
             rounds_used = it + 1;
             reference(parity, A);
@@ -3261,11 +3330,37 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             double logsum = 0.0, wsum = 0.0;
             for (int c = 0; c < ncell; ++c) if (cross[c] > 0.0) { logsum += cross[c] * std::log(upd[c]); wsum += cross[c]; }
             const double gm = wsum > 0.0 ? std::exp(logsum / wsum) : 1.0;
+            std::vector<double> lnext(ncell);
+            for (int c = 0; c < ncell; ++c) lnext[c] = std::log(A[c] * upd[c] / gm);
+            if (nshell > 0) {
+                // Project out the component that is a function of resolution: the weighted mean of
+                // log A within each shell, carried back to a cell in the proportion in which that
+                // cell's observations sit in each shell.
+                std::vector<double> ms(nshell, 0.0);
+                for (int s = 0; s < nshell; ++s) {
+                    if (!(shw_shell[s] > 0.0)) continue;
+                    double acc = 0.0;
+                    for (int c = 0; c < ncell; ++c) acc += shw[static_cast<size_t>(c) * nshell + s] * lnext[c];
+                    ms[s] = acc / shw_shell[s];
+                    removed[s] += ms[s];
+                }
+                for (int c = 0; c < ncell; ++c) {
+                    if (!(shw_cell[c] > 0.0)) continue;
+                    double acc = 0.0;
+                    for (int s = 0; s < nshell; ++s) acc += shw[static_cast<size_t>(c) * nshell + s] * ms[s];
+                    lnext[c] -= acc / shw_cell[c];
+                }
+            }
             double step2 = 0.0;
             int n_step = 0;
+            n_clamped = 0;
             for (int c = 0; c < ncell; ++c) {
-                const double next = std::clamp(A[c] * upd[c] / gm, 0.25, 4.0);
-                if (cross[c] > 0.0) { step2 += std::pow(std::log(next / A[c]), 2); ++n_step; }
+                const double next = std::clamp(std::exp(lnext[c]), 0.25, 4.0);
+                if (cross[c] > 0.0) {
+                    step2 += std::pow(std::log(next / A[c]), 2);
+                    ++n_step;
+                    if (next <= 0.2500001 || next >= 3.9999999) ++n_clamped;
+                }
                 A[c] = next;
             }
             if (n_step > 0 && std::sqrt(step2 / n_step) < SCALING_TOLERANCE) {
@@ -3273,6 +3368,9 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
                 break;
             }
         }
+        if (nshell > 0)
+            gauge_ramp = std::exp(*std::max_element(removed.begin(), removed.end())
+                                  - *std::min_element(removed.begin(), removed.end()));
         return A;
     };
     // Mean studentized squared deviation over the subset {frame&1 == parity} with surface A applied,
@@ -3322,9 +3420,10 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             if (cell[i] >= 0)
                 fulls[i].corr = static_cast<float>(fulls[i].corr * A[cell[i]]);
     });
-    logger.Info("{} correction: cross-validated, held-out gain {:.1f}%; {} in {} round(s)",
+    logger.Info("{} correction: cross-validated, held-out gain {:.1f}%; {} in {} round(s); "
+                "resolution gauge removed a {:.2f}x ramp; {} of {} cells on the [0.25, 4] clamp",
                 name, 100.0 * gain / std::max(base, 1e-30), settled ? "settled" : "NOT settled",
-                rounds_used);
+                rounds_used, gauge_ramp, n_clamped, ncell);
 }
 
 void RotationScaleMerge::ComputeSmoothGWindow(const std::vector<double> &g, int window,
-- 
2.54.0


From 2d5579e5933551f40ecf351c754394f5a524a9ca Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 14:17:00 +0200
Subject: [PATCH 117/122] rugnux: the model table reports the radial
 disagreement it alone can see

A scale factor shared by every symmetry equivalent of a reflection cancels out of
R_meas, CC1/2, chi^2 and every cross-validation the scaling runs, because each
ASU group's reference is its own mean. Nothing in the report could see one, and a
wrong radial profile therefore went unnoticed while every internal statistic
improved.

The CC(model, data) table gains an I/I_MODEL column: the shell's mean merged
intensity over the mean |F_model|^2 of the scaled model, after the model has
already been given its own overall scale, anisotropic B and bulk solvent. That
family is smooth and nearly exponential in s^2, so what is left is the part of
the run's resolution dependence the model does not agree with. It reads 1.000
where the two agree and drifts away from it where they do not. A headline line
reports the outermost shell's value.

It cannot say which of the two is right - a real crystal can out-diffract or
under-diffract its deposited model - only that they disagree, which is the one
thing nothing else here reports.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 rugnux/ModelValidation.cpp | 17 ++++++++++++++++-
 rugnux/ModelValidation.h   | 11 +++++++++++
 rugnux/ResultReport.cpp    | 20 ++++++++++++++------
 3 files changed, 41 insertions(+), 7 deletions(-)

diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 783b19849..cd82f123f 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -883,6 +883,10 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         };
         std::vector<CorrelationCoefficient> shell_cc(report_shell_d_min.size());
         std::vector<int> shell_n(report_shell_d_min.size(), 0);
+        // Sums for the radial mismatch: the shell's mean observed intensity against the mean
+        // intensity of the already-scaled model. See ModelDataCCShell::i_over_model.
+        std::vector<double> shell_sum_I(report_shell_d_min.size(), 0.0);
+        std::vector<double> shell_sum_Im(report_shell_d_min.size(), 0.0);
         CorrelationCoefficient overall_cc;
         int overall_n = 0;
         for (const auto &hv : fmodel.v) {
@@ -894,6 +898,8 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                 continue;
             const double Ic = std::norm(hv.value);   // |F_model|^2
             shell_cc[bin].Add(it->second.I, Ic);
+            shell_sum_I[bin] += it->second.I;
+            shell_sum_Im[bin] += Ic;
             ++shell_n[bin];
             overall_cc.Add(it->second.I, Ic);
             ++overall_n;
@@ -907,7 +913,8 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         for (size_t i = 0; i < report_shell_d_min.size(); i++) {
             const double cc = shell_cc[i].GetCC();
             result.cc_model_shells.push_back({report_shell_d_min[i], cc, shell_n[i],
-                                              fisher_sigma(cc, shell_n[i])});
+                                              fisher_sigma(cc, shell_n[i]),
+                                              shell_sum_Im[i] > 0.0 ? shell_sum_I[i] / shell_sum_Im[i] : NAN});
         }
         result.cc_model_overall = overall_cc.GetCC();
         result.cc_model_n = overall_n;
@@ -916,6 +923,14 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
                     result.cc_model_overall, result.cc_model_n,
                     result.cc_model_shells.back().d_min, result.cc_model_shells.back().cc,
                     result.cc_model_shells.back().n, result.cc_model_shells.back().sigma);
+        // The radial mismatch, reported on its own because nothing else in the run can see it.
+        const double r_out = result.cc_model_shells.back().i_over_model;
+        if (std::isfinite(r_out))
+            logger.Info("Model validation: <I>/<I_model> after the model's own scale, anisotropic B and "
+                        "bulk solvent runs to {:.2f} in the outermost shell ({:.2f} A) - the part of "
+                        "this run's resolution dependence the model does not agree with, and the only "
+                        "check on it that is not blind to a factor shared by a whole ASU group",
+                        r_out, result.cc_model_shells.back().d_min);
     }
 
     // --- sigma_A weighting: the maps are 2mFo-DFc and mFo-DFc, not 2Fo-Fc and Fo-Fc ---
diff --git a/rugnux/ModelValidation.h b/rugnux/ModelValidation.h
index 7fc6831a8..831578163 100644
--- a/rugnux/ModelValidation.h
+++ b/rugnux/ModelValidation.h
@@ -72,6 +72,17 @@ struct ModelValidationResult {
         // are not bivariate normal, so this is the same approximation XDS makes when it calls a shell's
         // CC1/2 significant, and it is a guide to the strength of the claim rather than an exact p.
         double sigma = NAN;
+        // The shell's mean merged intensity over the mean |F_model|^2 of the SCALED model - the model
+        // having already been given an overall scale, an anisotropic B and a bulk solvent fitted over
+        // the whole range. That family is smooth and nearly exponential in s^2, so it can follow a
+        // wrong RADIAL profile only so far; what is left here is the part of the run's resolution
+        // dependence the model does not agree with, and it is the only number in the report that can
+        // see it. Every internal statistic - R_meas, CC1/2, chi^2, the correction surfaces' own
+        // cross-validation - is blind to a factor that multiplies a whole ASU group, because each
+        // group's reference is its own mean. 1.0 across the table means the two agree; a monotone
+        // run away from 1.0 means one of the two radial profiles is wrong. It cannot say which: a
+        // real crystal can out-diffract or under-diffract its deposited model.
+        double i_over_model = NAN;
     };
     std::vector<ModelDataCCShell> cc_model_shells;
     double cc_model_overall = NAN;
diff --git a/rugnux/ResultReport.cpp b/rugnux/ResultReport.cpp
index 9e9960675..d5853db24 100644
--- a/rugnux/ResultReport.cpp
+++ b/rugnux/ResultReport.cpp
@@ -1709,23 +1709,31 @@ ReportDocument BuildReportDocument(const std::string &output_prefix,
                 Add(s, Prose(" CC(model, data): the correlation of the merged intensities with the placed, scaled\n"
                              " model's |F_model|^2, on the same shells the merge table above reports, so a row here\n"
                              " can be read straight across from that shell's CC1/2. SIGMA is how far the correlation\n"
-                             " sits above zero (Fisher's transform on N reflections).\n"));
+                             " sits above zero (Fisher's transform on N reflections). I/I_MODEL is the shell's\n"
+                             " mean merged intensity over the model's, AFTER the model has been given its own\n"
+                             " overall scale, anisotropic B and bulk solvent - so it reads 1.000 where the two\n"
+                             " agree on how the data fall off with resolution, and drifts away from 1.000 where\n"
+                             " they do not. It is the only number here that can see a scale shared by a whole\n"
+                             " set of symmetry equivalents; R_meas, CC1/2 and chi^2 all cancel one.\n"));
                 ReportEntry e;
                 e.kind = ReportEntry::Kind::Table;
-                e.table.columns = {"D_MIN", "CC_MODEL", "N", "SIGMA"};
-                e.table.text_header = "     D_MIN  CC_MODEL          N     SIGMA\n"
-                                      "  --------  --------  ---------  --------";
+                e.table.columns = {"D_MIN", "CC_MODEL", "N", "SIGMA", "I_OVER_MODEL"};
+                e.table.text_header = "     D_MIN  CC_MODEL          N     SIGMA  I/I_MODEL\n"
+                                      "  --------  --------  ---------  --------  ---------";
                 for (const auto &sh : mv.cc_model_shells) {
                     if (sh.n == 0)
                         continue;
                     e.table.text_rows.push_back(fmt::format(
-                            "  {:8.2f}  {:8.4f}  {:9d}  {:>8s}", sh.d_min, sh.cc, sh.n,
-                            std::isfinite(sh.sigma) ? fmt::format("{:+.1f}", sh.sigma) : std::string("-")));
+                            "  {:8.2f}  {:8.4f}  {:9d}  {:>8s}  {:>9s}", sh.d_min, sh.cc, sh.n,
+                            std::isfinite(sh.sigma) ? fmt::format("{:+.1f}", sh.sigma) : std::string("-"),
+                            std::isfinite(sh.i_over_model) ? fmt::format("{:.3f}", sh.i_over_model)
+                                                           : std::string("-")));
                     std::vector<ReportValue> row;
                     row.push_back(KeyReal("", sh.d_min, "{:.2f}").value);
                     row.push_back(KeyReal("", sh.cc, "{:.4f}").value);
                     row.push_back(KeyInt("", sh.n).value);
                     row.push_back(KeyReal("", sh.sigma, "{:+.1f}").value);
+                    row.push_back(KeyReal("", sh.i_over_model, "{:.3f}").value);
                     e.table.cells.push_back(std::move(row));
                 }
                 Add(s, std::move(e));
-- 
2.54.0


From 1d1a40d908c935b1a85edcb4bfd23ef4bc98bab2 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 16:14:30 +0200
Subject: [PATCH 118/122] Scaling: a correction surface is fitted on the
 negative observations too

The per-cell fit in ApplyCellSurface dropped every observation with Is <= 0.
Both of its sums are linear in Is - there is no logarithm and no division by
it - so the filter protected nothing arithmetic; the only hazard of keeping
the negatives is a cell whose `cross` sums to <= 0, which now keeps its
factor for that round instead of dividing by it.

What the filter did was select on the noise: it kept the up-fluctuated half
of a weak cell, inflating `cross` by the truncated mean, so each cell was
pulled down by an amount set by its own signal-to-noise. Per round, on a
Wilson-distributed cell with six equivalents: 0.1% at <I>/sigma = 5, 1.0% at
2, 4.9% at 1, 15% at 0.5. That push is almost entirely along the surface's
resolution null direction, which is why the surfaces walked.

Simulated with a flat truth and a 12% cos(2 phi) flat field:
- no gauge: shell at I/sigma = 1 suppressed 40% after 30 rounds with the
  filter, flat to 1% without it;
- 16x16 detector grid, gauge on, outer I/sigma = 0.5: with the filter the
  fitted field carries 1.9x its true amplitude at CC 0.48 to the truth and
  the gauge removes a 5x ramp; without it 1.04x, CC 0.97, 1.09x.

On 12 open rotation sets against the gauge build (rc172-2):
- the null walk the gauge removes collapses where it was large (45.9x ->
  2.0x, 5.0x -> 2.4x, 3.1x -> 1.7x; a 56x and a 4.9e5x walk are gone because
  those surfaces no longer pass cross-validation);
- held-out gains lose the part the filter inflated (23.2 -> 20.1%,
  14.1 -> 12.9%);
- sets at I/sigma >= 10: per-shell CC(Fo, Fc) against the deposited model
  moves by -0.006..+0.003 (fine half), ISa unchanged;
- the two weakest sets (I/sigma 6.8 and 4.6) lose a surface the gate no
  longer admits, and with it 0.019 / 0.031 of fine-half CC(Fo, Fc).
  Forcing the unfiltered surface on the first recovers all of it, so there
  it is the gate that refuses a real correction; on the second the
  unfiltered surface is worth nothing and the filtered one's benefit is
  not a correction the fit can reproduce.

"NOT settled in 30 rounds" does not go away (10 of 17 applied surfaces ->
8 of 15): it has a second cause the filter was not driving.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 47 +++++++++++++------
 1 file changed, 32 insertions(+), 15 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index a56ee38dc..67a8582b8 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3174,19 +3174,20 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     // the same on every round, so the surface walks along it at constant speed until the [0.25, 4]
     // clamp stops it. That is what "NOT settled in n round(s)" reports, and why raising the cap from
     // 3 to 30 rounds took the walk ten times further rather than converging it.
-    // Something has to push it: here the `Is > 0` filter in the fit below, which drops the negative
-    // half of a weak cell's observations and leaves the survivors up-fluctuated, so `cross` is
-    // inflated where the signal is weak - a bias that is a function of the cell's signal-to-noise,
-    // hence of resolution. Simulated on synthetic data with a flat truth: an outer shell at
-    // I/sigma = 1 is suppressed 4% after 3 rounds and 24% after 30, while the even/odd held-out gain
-    // that gates the surface reads 0.1% - the cross-validation cannot see it either, because both
-    // halves carry it equally.
-    // So it is removed at the parameterisation instead of being bounded by a round count: after each
-    // round the surface is divided by its own weighted geometric mean WITHIN each resolution shell,
-    // which projects out the component that is a function of d and leaves the azimuthal / positional
-    // variation - what absorption and a flat field physically are. On the same simulation that
-    // recovers a 12% cos(2 phi) flat field to CC 0.986 at full amplitude while the radial ramp goes
-    // to 1.00. The projection removes the overall level too, so it subsumes the global gauge below.
+    // Something has to push it, and what used to push it was a `Is > 0` filter on the observations
+    // entering the fit: it dropped the negative half of a weak cell's measurements and left the
+    // survivors up-fluctuated, so `cross` was inflated where the signal is weak - a bias that is a
+    // function of the cell's signal-to-noise, hence of resolution. That filter is gone (see the fit
+    // below), which takes the bulk of the push away at the source; the gauge stays because the null
+    // direction is exact, so whatever else pushes along it - finite-sample noise in the update, the
+    // clamp - would still walk it.
+    // The null direction is removed at the parameterisation rather than being bounded by a round
+    // count: after each round the surface is divided by its own weighted geometric mean WITHIN each
+    // resolution shell, which projects out the component that is a function of d and leaves the
+    // azimuthal / positional variation - what absorption and a flat field physically are. On the
+    // same simulation that recovers a 12% cos(2 phi) flat field to CC 0.986 at full amplitude
+    // while the radial ramp goes to 1.00. The projection removes the overall level too, so it
+    // subsumes the global gauge below.
     // Equal-occupancy shells in s^2 = 1/d^2. The count is second order (8, 20 and 40 shells all leave
     // the residual ramp inside 1.5%); 20 is fine enough to follow a curved drift and coarse enough
     // that each shell still holds tens of thousands of observations.
@@ -3300,6 +3301,15 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             // the gauge fix spreads over the whole surface and the n_iter rounds compound, and which no
             // even/odd cross-validation can see because both halves carry it equally. The per-frame
             // scale (FitPerFrameG) already regresses this way round.
+            // A NEGATIVE observation is a legitimate measurement of a weak reflection and enters both
+            // sums as it stands. Both are linear in Is - there is no logarithm and no division by it
+            // here, unlike the relative-B fits above, which regress log(Iref/Is) and do need Is > 0 -
+            // so the only thing a sign filter would protect is the division by `cross` below, and that
+            // is cheaper to guard directly. Selecting on the sign instead keeps the up-fluctuated half
+            // of a weak cell and inflates `cross` by the truncated mean, which is a bias in the cell's
+            // own signal-to-noise: simulated on a flat truth, it suppressed a shell at I/sigma = 1 by
+            // 40% over 30 rounds and left a 16x16 flat field at outer I/sigma = 0.5 with 1.9x its true
+            // amplitude and CC 0.48 to the truth, where keeping the negatives gives 1.04x and 0.97.
             // Chunked over the subset, each thread summing into its own cells: unlike the pass above
             // there is no ordering that keeps threads off each other's bins, and there are only ncell
             // of them, so per-thread copies are cheap and the fixed chunking keeps it reproducible.
@@ -3314,7 +3324,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
                         if (sw[o.group] <= 0.0) continue;
                         const double Iref = swI[o.group] / sw[o.group], a = A[o.cell];
                         const double Is = static_cast<double>(o.I) * o.corr * a, sc = static_cast<double>(o.sigma) * o.corr * a;
-                        if (!std::isfinite(Iref) || Iref <= 0.0 || !(Is > 0.0) || !(sc > 0.0)) continue;
+                        if (!std::isfinite(Iref) || Iref <= 0.0 || !(sc > 0.0)) continue;
                         const double w = 1.0 / (sc * sc);
                         xcross[o.cell] += w * Is * Iref; xref2[o.cell] += w * Iref * Iref;
                     }
@@ -3326,7 +3336,14 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             std::nth_element(dsorted.begin(), dsorted.begin() + dsorted.size() / 2, dsorted.end());
             const double lambda = 0.1 * std::max(1e-30, dsorted[dsorted.size() / 2]);
             std::vector<double> upd(ncell, 1.0);
-            for (int c = 0; c < ncell; ++c) upd[c] = (ref2[c] + lambda) / (cross[c] + lambda);
+            // A cell whose observations carry no net signal can sum to `cross` <= 0 now that the
+            // negatives are in, and the Tikhonov pull does not always lift it clear of zero. Such a
+            // cell has nothing to say about its own factor, so it keeps the one it has rather than
+            // dividing by a number that can be near zero or negative - which would reach the log below
+            // as a NaN or as a factor pinned on the clamp and, through the shell means, poison every
+            // other cell. It is the same `cross > 0` the gauge and the step size already test.
+            for (int c = 0; c < ncell; ++c)
+                if (cross[c] > 0.0) upd[c] = (ref2[c] + lambda) / (cross[c] + lambda);
             double logsum = 0.0, wsum = 0.0;
             for (int c = 0; c < ncell; ++c) if (cross[c] > 0.0) { logsum += cross[c] * std::log(upd[c]); wsum += cross[c]; }
             const double gm = wsum > 0.0 ? std::exp(logsum / wsum) : 1.0;
-- 
2.54.0


From 20349fb2d97ff4764a584f42ba5ef3b46ae562b2 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 17:11:44 +0200
Subject: [PATCH 119/122] Scaling: a correction surface is fitted under a prior
 and gated on held-out half-set CC

Three changes to ApplyCellSurface, each measured offline on the surfaces' own input terms from twelve
open rotation sets (36 surfaces), against per-shell CC of the merge to the deposited model's Fc.

The gate. The held-out score was sum|Is - Iref| / sum Iref pooled over every shell the fit reaches.
The surfaces are fitted before the resolution cutoff, so on a weak set the score was carried by shells
with no signal (one set: 8 of 20 shells at <I/sigma> < 0.1, a quarter of the numerator), where any
spread in A raises |Is - Iref| because Is is A times noise; and it weighted each residual equally where
the merge weights it by 1/(sigma corr A)^2. It is replaced by the quantity the surface is for: fit on
even frames and merge the odd ones with it, fit on odd and merge the even ones, and correlate the two
half-set means within each resolution shell, against the same with no surface. A surface fitted to
noise lowers that correlation, so the gate needs no margin. On surfaces moving the external CC by more
than 0.005 either way, the old gate agreed with the model on 6 of 12 and the new one on 13 of 14; and
no threshold on the old score separated them - below its 2% sat surfaces worth +0.017 and +0.009 and
surfaces worth -0.026 and -0.013. CV_MIN_RELATIVE_GAIN still gates the decay and relative-B fits,
which this does not touch.

The regulariser. The per-round update A *= (ref2 + lambda) / (cross + lambda) was described as a
Tikhonov pull to 1, but lambda cancels at the fixed point ref2 = cross: it only slowed a weak cell to
cross / (cross + lambda) of its step, so the 30-round cap regularised by early stopping and the weak
cells were still moving when it hit - most of what "NOT settled" reported - and a cell with no
information was fitted to its noise and pinned on the [0.25, 4] clamp. The update is now a damped
Gauss-Newton step on log A with a N(0, 0.1^2) prior: ref2 is the information of the cell's log scale,
so the fixed point ref2 - cross = P log A moves a cell off 1 in proportion to what its observations
say. Offline, applied surfaces that settle within the cap: most of them, against a minority; cells on
the clamp: 0-4 per surface against up to 318. On the weakest set the time x detector surface goes from
181 clamped cells and -0.031 external CC to none and +0.001.

The gauge. The per-shell projection is exact only where a cell sits at one resolution - a detector
patch. A goniometer-frame cell collects directions from the whole sweep, so there it removed real
absorption, which varies with scattering angle: +0.016 -> +0.022 and +0.017 -> +0.020 on the two sets
where that surface is worth anything. That surface keeps only the global level fix.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 .../scale_merge/RotationScaleMerge.cpp        | 157 +++++++++++-------
 .../scale_merge/RotationScaleMerge.h          |   8 +-
 2 files changed, 103 insertions(+), 62 deletions(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 67a8582b8..4e7be9f8c 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -2973,7 +2973,8 @@ void RotationScaleMerge::RefineAbsorption(int n_iter, int n_groups) {
             cell[i] = ix * NB + iy;
         }
     });
-    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Absorption (goniometer-frame 8x8)");
+    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Absorption (goniometer-frame 8x8)",
+                     /*resolution_gauge=*/false);
 }
 
 void RotationScaleMerge::RefineAbsorptionTime(int n_iter, int n_groups) {
@@ -3053,7 +3054,8 @@ void RotationScaleMerge::RefineAbsorptionTime(int n_iter, int n_groups) {
             cell[i] = (it * ND + ix) * ND + iy;
         }
     });
-    ApplyCellSurface(cell, NT * ND * ND, n_iter, n_groups, "Absorption (time x detector 12x10x10)");
+    ApplyCellSurface(cell, NT * ND * ND, n_iter, n_groups, "Absorption (time x detector 12x10x10)",
+                     /*resolution_gauge=*/true);
 }
 
 void RotationScaleMerge::RefineModulation(int n_iter, int n_groups) {
@@ -3091,11 +3093,12 @@ void RotationScaleMerge::RefineModulation(int n_iter, int n_groups) {
             cell[i] = ix * NB + iy;
         }
     });
-    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Modulation (detector-frame 16x16)");
+    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Modulation (detector-frame 16x16)",
+                     /*resolution_gauge=*/true);
 }
 
 void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int ncell, int n_iter,
-                                          int n_groups, const char *name) {
+                                          int n_groups, const char *name, bool resolution_gauge) {
     auto usable = [&](const Obs &o) {
         return o.group >= 0 && o.corr > 0.0f && std::isfinite(o.corr) && o.partiality >= min_partiality;
     };
@@ -3188,6 +3191,14 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     // same simulation that recovers a 12% cos(2 phi) flat field to CC 0.986 at full amplitude
     // while the radial ramp goes to 1.00. The projection removes the overall level too, so it
     // subsumes the global gauge below.
+    // It is only a null direction where a cell sits at one resolution - a patch of the detector, which
+    // is what the modulation and the time x detector cells are. A goniometer-frame cell collects
+    // diffracted directions from the whole sweep, so its observations span most of the resolution
+    // range; the shell means are then a mix over cells rather than a direction the data cannot see,
+    // and projecting them out removes real absorption, which does vary with scattering angle. Measured
+    // on four open sets (external per-shell CC against the deposited model, the surface applied alone):
+    // +0.016 -> +0.022 and +0.017 -> +0.020 on the two where the surface is worth anything, no change on
+    // the other two. That surface keeps the global level fix only (resolution_gauge false).
     // Equal-occupancy shells in s^2 = 1/d^2. The count is second order (8, 20 and 40 shells all leave
     // the residual ramp inside 1.5%); 20 is fine enough to follow a curved drift and coarse enough
     // that each shell still holds tens of thousands of observations.
@@ -3198,6 +3209,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     // the alternating fit below converges against it.
     std::vector<double> shw(static_cast<size_t>(ncell) * nshell, 0.0);
     std::vector<double> shw_shell(nshell, 0.0), shw_cell(nshell > 0 ? ncell : 0, 0.0);
+    std::vector<int32_t> group_shell(n_groups, 0);   // the shell each ASU group sits in, for the gate
     if (nshell > 0) {
         std::vector<float> s2;
         s2.reserve(term.size());
@@ -3215,6 +3227,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             const Term &t = term[k];
             const float v = t.d > 0.0f ? 1.0f / (t.d * t.d) : 0.0f;
             const int s = static_cast<int>(std::upper_bound(edge.begin(), edge.end(), v) - edge.begin());
+            group_shell[t.group] = s;
             const double sc = static_cast<double>(t.sigma) * t.corr;
             if (!(sc > 0.0)) continue;
             shw[static_cast<size_t>(t.cell) * nshell + s] += 1.0 / (sc * sc);
@@ -3269,8 +3282,8 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
     };
 
     // Fit the per-cell factor over the subset {frame&1 == parity} (parity < 0 = all fulls), alternating
-    // rounds against that subset's own reference (Tikhonov pull to 1, then gauge-fixed within each
-    // resolution shell, which also holds the overall scale) until the factors settle - the same
+    // rounds against that subset's own reference (a prior pull to 1, then gauge-fixed within each
+    // resolution shell where resolution_gauge, which also holds the overall scale) until the factors settle - the same
     // tolerance as the per-frame scales, on the rms |log| of the round's update - or n_iter rounds
     // have been spent. Returns the per-cell factor.
     int rounds_used = 0;
@@ -3335,21 +3348,36 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             std::vector<double> dsorted = cross;
             std::nth_element(dsorted.begin(), dsorted.begin() + dsorted.size() / 2, dsorted.end());
             const double lambda = 0.1 * std::max(1e-30, dsorted[dsorted.size() / 2]);
-            std::vector<double> upd(ncell, 1.0);
-            // A cell whose observations carry no net signal can sum to `cross` <= 0 now that the
-            // negatives are in, and the Tikhonov pull does not always lift it clear of zero. Such a
-            // cell has nothing to say about its own factor, so it keeps the one it has rather than
-            // dividing by a number that can be near zero or negative - which would reach the log below
-            // as a NaN or as a factor pinned on the clamp and, through the shell means, poison every
-            // other cell. It is the same `cross > 0` the gauge and the step size already test.
-            for (int c = 0; c < ncell; ++c)
-                if (cross[c] > 0.0) upd[c] = (ref2[c] + lambda) / (cross[c] + lambda);
-            double logsum = 0.0, wsum = 0.0;
-            for (int c = 0; c < ncell; ++c) if (cross[c] > 0.0) { logsum += cross[c] * std::log(upd[c]); wsum += cross[c]; }
-            const double gm = wsum > 0.0 ? std::exp(logsum / wsum) : 1.0;
+            // One damped Gauss-Newton step on log A per round, with a N(0, SURFACE_PRIOR_SIGMA^2) prior on
+            // each cell's log factor. ref2 is the Fisher information of the cell's log scale (the inverse
+            // variance of the slope of Is against Iref) and ref2 - cross is its first-order residual, of
+            // either sign - so a cell whose negatives outweigh its positives needs no special case.
+            // The prior is what regularises. `lambda` used to be called a Tikhonov pull, but in the old
+            // update (ref2 + lambda) / (cross + lambda) it cancels at the fixed point, ref2 = cross: it only
+            // slowed a weak cell to cross / (cross + lambda) of its step, so the 30-round cap did the
+            // regularising as early stopping, and a weak cell was still walking when the cap hit it -
+            // most of what "NOT settled" reported. Here lambda is kept for that damping alone (the
+            // undamped step oscillates on some surfaces), and the prior sets the fixed point:
+            // ref2 - cross = P log A, so a cell's factor moves off 1 in proportion to the information it
+            // carries against the fixed prior precision P - a cell whose observations say little stays
+            // near 1 instead of being fitted to its noise and pinned on the clamp.
+            // SURFACE_PRIOR_SIGMA = 0.1 against 0.2 on six open sets, external per-shell CC against the
+            // deposited model: 0.1 is as good or better on 13 of 18 surfaces, and settles in fewer rounds.
+            constexpr double SURFACE_PRIOR_SIGMA = 0.1;
+            const double P = 1.0 / (SURFACE_PRIOR_SIGMA * SURFACE_PRIOR_SIGMA);
             std::vector<double> lnext(ncell);
-            for (int c = 0; c < ncell; ++c) lnext[c] = std::log(A[c] * upd[c] / gm);
-            if (nshell > 0) {
+            for (int c = 0; c < ncell; ++c) {
+                lnext[c] = std::log(A[c]);
+                if (ref2[c] > 0.0)
+                    lnext[c] += (ref2[c] - cross[c] - P * lnext[c]) / (ref2[c] + P + lambda);
+            }
+            if (!(resolution_gauge && nshell > 0)) {
+                // The overall level is a null direction of every surface: fix it at 1.
+                double acc = 0.0, wsum = 0.0;
+                for (int c = 0; c < ncell; ++c) if (ref2[c] > 0.0) { acc += ref2[c] * lnext[c]; wsum += ref2[c]; }
+                if (wsum > 0.0)
+                    for (int c = 0; c < ncell; ++c) lnext[c] -= acc / wsum;
+            } else {
                 // Project out the component that is a function of resolution: the weighted mean of
                 // log A within each shell, carried back to a cell in the proportion in which that
                 // cell's observations sit in each shell.
@@ -3373,7 +3401,7 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             n_clamped = 0;
             for (int c = 0; c < ncell; ++c) {
                 const double next = std::clamp(std::exp(lnext[c]), 0.25, 4.0);
-                if (cross[c] > 0.0) {
+                if (ref2[c] > 0.0) {
                     step2 += std::pow(std::log(next / A[c]), 2);
                     ++n_step;
                     if (next <= 0.2500001 || next >= 3.9999999) ++n_clamped;
@@ -3385,50 +3413,61 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
                 break;
             }
         }
-        if (nshell > 0)
+        if (resolution_gauge && nshell > 0)
             gauge_ramp = std::exp(*std::max_element(removed.begin(), removed.end())
                                   - *std::min_element(removed.begin(), removed.end()));
         return A;
     };
-    // Mean studentized squared deviation over the subset {frame&1 == parity} with surface A applied,
-    // scored against that subset's own reference (no leakage). Lower = tighter equivalents.
-    auto score = [&](int parity, const std::vector<double> &A) -> double {
-        const std::vector<int32_t> &sel = subset(parity);
+    // Cross-validate on the half-set agreement it is meant to improve. Fit the surface on the even
+    // frames and merge the ODD frames with it; fit it on the odd frames and merge the EVEN frames with
+    // it; then correlate the two half-set means within each resolution shell, and compare with the same
+    // two halves merged with no surface. Each half is corrected by a surface it did not help to fit, so
+    // a surface fitted to noise adds independent noise to both and lowers the correlation, and only a
+    // correction the two halves share raises it: no margin is needed, the null already sits below zero.
+    // Within a shell a correlation is blind to a scale that is a function of resolution, which is the
+    // one component this surface cannot determine.
+    // It replaces a held-out sum|Is - Iref| / sum Iref over the whole range, which two things made
+    // disagree with the external referent. Pooled over every shell the fit reaches, it was carried by
+    // shells past the resolution the merge keeps: on one set 8 of 20 shells held <I/sigma> < 0.1 and a
+    // quarter of the numerator, where any spread in A raises |Is - Iref| (Is is A times noise) whether
+    // the surface is right or not. And it counted each residual at full weight where the merge weights it
+    // by 1/(sigma corr A)^2. Measured on twelve open sets, each surface alone against per-shell CC to the
+    // deposited model: of the surfaces that move that CC by more than 0.005 either way, the old gate
+    // took the model's side on 6 of 12 and this one on 13 of 14. The old gate's 2% margin was not what
+    // stood between the two: below it sat surfaces worth +0.017 and +0.009 and surfaces worth -0.026
+    // and -0.013 alike, so no threshold on that score separates them.
+    const int nsh_cc = nshell > 0 ? nshell : 1;
+    auto half_means = [&](int parity, const std::vector<double> &A) {
         reference(parity, A);
-        // Rmeas-like (sigma-INDEPENDENT) agreement of the held-out equivalents: sum|Is - Iref| / sum|Iref|.
-        // Scoring on the studentized deviation instead lets a surface "improve" the held-out chi^2 by
-        // reshaping sigma (via corr) without tightening the actual intensities - which on mis-indexed / bad
-        // data passes cross-validation yet worsens Rmeas. A fractional metric cannot be gamed that way.
-        std::vector<double> tnum(nt, 0.0), tden(nt, 0.0);
-        ParallelChunks(nt, nthreads, [&](int tlo, int thi) {
-            for (int t = tlo; t < thi; ++t) {
-                double num = 0.0, den = 0.0;
-                for (size_t k = part(sel.size(), t); k < part(sel.size(), t + 1); ++k) {
-                    const Term &o = term[sel[k]];
-                    if (sw[o.group] <= 0.0) continue;
-                    const double a = A[o.cell], Is = static_cast<double>(o.I) * o.corr * a;
-                    const double Iref = swI[o.group] / sw[o.group];
-                    if (!std::isfinite(Iref) || Iref <= 0.0) continue;
-                    num += std::abs(Is - Iref); den += Iref;
-                }
-                tnum[t] = num; tden[t] = den;
-            }
-        });
-        double num = 0.0, den = 0.0;
-        for (int t = 0; t < nt; ++t) { num += tnum[t]; den += tden[t]; }
-        return den > 0.0 ? num / den : 0.0;
+        std::vector<double> m(n_groups, std::numeric_limits<double>::quiet_NaN());
+        for (int g = 0; g < n_groups; ++g)
+            if (sw[g] > 0.0) m[g] = swI[g] / sw[g];
+        return m;
+    };
+    auto shell_cc = [&](const std::vector<double> &x, const std::vector<double> &y, int s) {
+        double n = 0, sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0;
+        for (int g = 0; g < n_groups; ++g) {
+            if (group_shell[g] != s || !std::isfinite(x[g]) || !std::isfinite(y[g])) continue;
+            n += 1; sx += x[g]; sy += y[g]; sxx += x[g] * x[g]; syy += y[g] * y[g]; sxy += x[g] * y[g];
+        }
+        const double vx = sxx - sx * sx / n, vy = syy - sy * sy / n;
+        return (n >= 50 && vx > 0.0 && vy > 0.0) ? (sxy - sx * sy / n) / std::sqrt(vx * vy)
+                                                  : std::numeric_limits<double>::quiet_NaN();
     };
-
-    // Cross-validate: fit the surface on even frames and score the held-out odd equivalents (and vice
-    // versa). A real surface generalizes; an over-fit one (few obs / cell) does not. Apply only if the
-    // held-out equivalent chi^2 improves by a clear margin - so the correction can never worsen the data.
     const std::vector<double> ident(ncell, 1.0);
     const std::vector<double> A_even = fit_surface(0), A_odd = fit_surface(1);
-    const double base = score(1, ident) + score(0, ident);
-    const double gain = base - (score(1, A_even) + score(0, A_odd));
-    if (!(gain > CV_MIN_RELATIVE_GAIN * base)) {
-        logger.Info("{} correction: not cross-validated (held-out gain {:.1f}%, skipped)",
-                    name, 100.0 * gain / std::max(base, 1e-30));
+    const std::vector<double> odd0 = half_means(1, ident), even0 = half_means(0, ident);
+    const std::vector<double> odd1 = half_means(1, A_even), even1 = half_means(0, A_odd);
+    double gain = 0.0;
+    int n_cc = 0;
+    for (int sh = 0; sh < nsh_cc; ++sh) {
+        const double c0 = shell_cc(odd0, even0, sh), c1 = shell_cc(odd1, even1, sh);
+        if (std::isfinite(c0) && std::isfinite(c1)) { gain += c1 - c0; ++n_cc; }
+    }
+    if (n_cc > 0) gain /= n_cc;
+    if (!(gain > 0.0)) {
+        logger.Info("{} correction: not cross-validated (held-out half-set CC {:+.4f} per shell, skipped)",
+                    name, gain);
         return;
     }
     const std::vector<double> A = fit_surface(-1);
@@ -3437,9 +3476,9 @@ void RotationScaleMerge::ApplyCellSurface(const std::vector<int32_t> &cell, int
             if (cell[i] >= 0)
                 fulls[i].corr = static_cast<float>(fulls[i].corr * A[cell[i]]);
     });
-    logger.Info("{} correction: cross-validated, held-out gain {:.1f}%; {} in {} round(s); "
+    logger.Info("{} correction: cross-validated, held-out half-set CC {:+.4f} per shell; {} in {} round(s); "
                 "resolution gauge removed a {:.2f}x ramp; {} of {} cells on the [0.25, 4] clamp",
-                name, 100.0 * gain / std::max(base, 1e-30), settled ? "settled" : "NOT settled",
+                name, gain, settled ? "settled" : "NOT settled",
                 rounds_used, gauge_ramp, n_clamped, ncell);
 }
 
diff --git a/image_analysis/scale_merge/RotationScaleMerge.h b/image_analysis/scale_merge/RotationScaleMerge.h
index 68fa1bf83..03a4e75fe 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.h
+++ b/image_analysis/scale_merge/RotationScaleMerge.h
@@ -582,10 +582,12 @@ private:
     // in the detector frame (not tied to the rotation) the same correction concept applies to stills.
     void RefineModulation(int n_iter, int n_groups);
     // Shared engine for the correction surfaces: given a per-full cell assignment (cell[i] in [0,ncell), or
-    // <0 to skip), fit a Tikhonov-regularised multiplicative factor per cell against the merged reference,
-    // cross-validate on even/odd frames, and fold it into corr only if the held-out equivalents improve.
+    // <0 to skip), fit a multiplicative factor per cell against the merged reference under a prior pull to 1,
+    // cross-validate on even/odd frames, and fold it into corr only if the held-out half-set CC improves.
+    // resolution_gauge: the cells are patches of the detector, each at one resolution, so the component of
+    // the surface that is a function of resolution is a null direction and is projected out per shell.
     void ApplyCellSurface(const std::vector<int32_t> &cell, int ncell, int n_iter, int n_groups,
-                          const char *name);
+                          const char *name, bool resolution_gauge);
 
     // Sort `fulls` by peak frame and (re)build fulls_frame_start/count (the per-frame CSR the scale-fulls
     // step slices). Shared by the CPU Combine tail and the GPU combine path.
-- 
2.54.0


From 518dd5672e2b5a5cb2f08a3a078e11b791fa2080 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 17:30:16 +0200
Subject: [PATCH 120/122] docs: the correction surfaces' prior and half-set CC
 gate

Real runs of the two preceding commits against the gauge build, on twelve open rotation sets, scored as
the outer-half mean of per-shell CC(Fo, Fc) on the common reflection set with ONE Fc for every arm:
+0.0013 on average, 8 up / 3 down / 1 level; the largest moves +0.0070, +0.0057, +0.0056 and -0.0066.
Applied surfaces left "NOT settled" at the 30-round cap: 10 -> 5. On the set with an unmasked beam-stop
arm, with the arm masked: 0.7647 -> 0.7654 against the filtered build, while removing the filter
alone, under the old gate, still costs 0.023 - the cost was the gate, not the shadow.

Scoring against each arm's OWN Fc, as the earlier comparisons did, is not a fixed referent: the model
is re-scaled to every arm's data, and on one set that alone was worth 0.03 of that CC.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/CPU_DATA_ANALYSIS_INTEGRATION.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/CPU_DATA_ANALYSIS_INTEGRATION.md b/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
index 61b4bf3a1..8d7942dad 100644
--- a/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
+++ b/docs/CPU_DATA_ANALYSIS_INTEGRATION.md
@@ -372,7 +372,9 @@ After scale-fulls, four **correction surfaces** are fitted on the combined fulls
 - **Modulation** (detector-plane flat-field). A smooth multiplicative factor over where each reflection lands on the detector (predicted $x,y$): symmetry-equivalents land at different positions as the crystal rotates, over-determining the surface. It absorbs detector-response and geometric systematics that inflate $R_\mathrm{meas}$.
 - **Time-dependent absorption.** The same surface as *Absorption*, but over (rotation angle × detector position) instead of the crystal-frame direction alone. The two agree while the illuminated volume stays put — the incident path then depends only on the spindle angle, which the per-image scale already takes, and the exit path is fixed in the crystal frame. Once the diffracting volume drifts through the beam the exit path becomes a function of the spindle angle as well, and nothing time-independent describes it. Fitted last, on 12 rotation bins × a 10×10 equal-occupancy detector grid, so the two time-independent surfaces get first claim on what they can explain.
 
-Each surface is **cross-validated**: fitted on even-numbered frames and kept only if it improves the held-out odd-frame agreement by a clear margin (and vice versa), scored by a **σ-independent, $R_\mathrm{meas}$-like** fractional agreement $\sum|I_s-I_\mathrm{ref}|/\sum|I_\mathrm{ref}|$ rather than a studentized $\chi^2$ — so a surface cannot "pass" by reshaping the sigmas instead of tightening the intensities. A surface fitted to noise where its systematic is absent does not generalize and is discarded — a correction never adds scatter.
+Each cell's factor is fitted under a **prior pull to 1** (a Gaussian prior of width 0.1 on its logarithm): a cell moves off 1 in proportion to the information its observations carry, so a cell with little signal stays near 1 instead of being fitted to its noise. Negative observations enter the fit as measured. On the detector-plane surfaces (modulation, time-dependent absorption) the component that is a function of resolution alone is projected out within resolution shells, since the symmetry equivalents of a reflection share one resolution and such a factor cannot be determined from them.
+
+Each surface is **cross-validated** on the half-set agreement it is meant to improve: fitted on even-numbered frames and used to merge the odd ones, fitted on the odd frames and used to merge the even ones, and kept only if the correlation between the two half-set means, taken within resolution shells, rises above the same two halves merged with no surface. Each half is corrected by a surface it did not help to fit, so a surface fitted to noise lowers the correlation, and a correlation within a shell is blind to the resolution-dependent scale the surface cannot determine.
 
 **Radiation-damage report (rotation, report-only).** Independently of whether any decay correction is applied, Rugnux measures and reports the relative Debye–Waller $B$ across the sweep: the per-image scale's correlation to the merge and the per-image mosaicity versus frame (dose), together with a per-batch relative-$B$ curve whose first→last change is a single headline number (measured before any decay correction, against the least-damaged early wedge). It is written to the log and to the merged mmCIF as a data-quality-vs-dose diagnostic and **never** alters the merged intensities — distinct from the decay correction above, which does fold into the scale.
 
-- 
2.54.0


From b7b58a6680ef4dcdc14a0b17f751f1e4111856b1 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 17:33:58 +0200
Subject: [PATCH 121/122] Scaling: the modulation surface's log line names its
 real grid

It has been 24x24 since the grid was refined from 16x16; the label was not updated.

Open item for the battery arm this branch is for: on one open set (I/sigma ~10, 1.44 A) the
time x detector surface is worth 0.007 less outer-half CC(Fo, Fc) than on the gauge build. It is
the filter removal, not the gate or the prior - the same surface, gated the same way, loses it with
the filter gone - and it reproduces offline on the surface's own input: +0.041 with the filter,
+0.025 without, +0.024 under the prior, all of it in the outer five shells. Not explained.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 image_analysis/scale_merge/RotationScaleMerge.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/image_analysis/scale_merge/RotationScaleMerge.cpp b/image_analysis/scale_merge/RotationScaleMerge.cpp
index 4e7be9f8c..13f1a1299 100644
--- a/image_analysis/scale_merge/RotationScaleMerge.cpp
+++ b/image_analysis/scale_merge/RotationScaleMerge.cpp
@@ -3093,7 +3093,7 @@ void RotationScaleMerge::RefineModulation(int n_iter, int n_groups) {
             cell[i] = ix * NB + iy;
         }
     });
-    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Modulation (detector-frame 16x16)",
+    ApplyCellSurface(cell, NB * NB, n_iter, n_groups, "Modulation (detector-frame 24x24)",
                      /*resolution_gauge=*/true);
 }
 
-- 
2.54.0


From c54785e3df46ac19b12643992703a5503d3b6999 Mon Sep 17 00:00:00 2001
From: Filip Leonarski <filip.leonarski@psi.ch>
Date: Mon, 21 Sep 2026 23:07:43 +0200
Subject: [PATCH 122/122] --model: resolve an indexing ambiguity by reindexing
 the data, not by moving the model

Where the model and the data share a point group and the lattice has more symmetry than that
point group, the model's change-of-basis probe used to absorb the alternative indexing: it saw the
twin law as "another description of the lattice", put the MODEL through it, and the data kept
whichever indexing their own run had picked. The indexing probe that relabels the data into the
model's indexing (with its null gate) therefore never fired. For a campaign of one crystal form
processed against one model that left the MTZs in different conventions.

Now those operators are left out of the change-of-basis candidates when the two groups have the
same rotations (I23 vs I2(1)3 and enantiomorphic pairs count as the same point group), so the
model stays in its own indexing and the existing probe reindexes the data - only where the model
fits and its lead beats the lead a random placement of it takes; otherwise the data keep their
indexing, as before. A model in a different point group, or with a reference MTZ fixing the
indexing, goes through the change of basis exactly as before.

The P1 cross-check file is now reindexed along with the merged and unmerged output: it is merged
from the scaler's copy of the observations, which the relabelling did not reach.

Measured on a cubic I23 series of seven datasets against one I2(1)3 model: three came out in the
other indexing before and are now reindexed (-x,-z,-y / -y,-x,-z, det +1); merging statistics
identical, merged/unmerged/P1 reflections identical up to the relabelling with I(+)/I(-) in place,
anomalous peak heights at the model's sulfurs unchanged within placement noise; pairwise CC of
the merged intensities as written goes from 0.56-0.64 across the two groups to >= 0.95 for every
pair. Holohedral, different-setting and different-point-group controls are byte-identical.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
---
 docs/RUGNUX_ADVANCED.md        |  7 ++-
 docs/RUGNUX_REPORT.md          |  1 +
 rugnux/ModelValidation.cpp     | 61 ++++++++++++++++++--------
 rugnux/Rugnux.cpp              | 11 ++++-
 tests/ModelValidationTest.cpp  | 78 ++++++++++++++++++++++++++++++++++
 tests/ReindexAmbiguityTest.cpp | 20 +++++++++
 6 files changed, 157 insertions(+), 21 deletions(-)

diff --git a/docs/RUGNUX_ADVANCED.md b/docs/RUGNUX_ADVANCED.md
index 077cdf1fd..42ab6cfe3 100644
--- a/docs/RUGNUX_ADVANCED.md
+++ b/docs/RUGNUX_ADVANCED.md
@@ -75,7 +75,7 @@ How to resolve it:
 | --- | --- |
 | **Rotation**, a reference dataset exists | `-z reference.mtz`. Once the space group is settled, each candidate reindexing of the merged intensities is correlated with the reference and the best-correlating one is re-merged. Only the *hkl* labels change; the cell does not |
 | **Serial stills**, a reference dataset exists | `-z reference.mtz`. Resolved **per image**, at integration time, by correlating each crystal's intensities with the reference — so the merge never mixes hands in the first place |
-| **Rotation**, only a model | `--model model.pdb`. The merged data are fitted to the model in each candidate indexing and the lowest R-free wins — provided the model first beats its random-orientation null (`MODEL_FIT= ACCEPTED`) and its lead over the runner-up beats the lead a random placement of the same model takes; the written reflections are then reindexed into it, so the file, the R-factors and the maps agree. Where either bar is missed the data keep the indexing they were merged in, and the report says by how much (`MODEL_INDEXING_MARGIN_SIGMA`) |
+| **Rotation**, only a model | `--model model.pdb`. The merged data are fitted to the model in each candidate indexing and the lowest R-free wins — provided the model first beats its random-orientation null (`MODEL_FIT= ACCEPTED`) and its lead over the runner-up beats the lead a random placement of the same model takes; the written reflections are then reindexed into it, so the file, the R-factors and the maps agree. Where either bar is missed the data keep the indexing they were merged in, and the report says by how much (`MODEL_INDEXING_MARGIN_SIGMA`). It is the **data** that are relabelled, never the model: every dataset of one crystal form processed against the same model comes out in that model's indexing, so the reflection files and maps of a screening campaign compare directly. The relabelling is a proper rotation of the lattice, so the merging statistics are unchanged and I(+)/I(-) keep their hand |
 | **Serial stills**, only a model | `--model model.pdb`, with the cell and space group given (`-C` / `-S`). Structure factors are computed from the model up front and used as the reference for the per-image test, exactly as a reference MTZ would be — the ambiguity has to be broken at integration time, and a model can supply the intensities to break it with |
 | Neither | The run warns and merges in whichever indexing it found: for rotation data a usable dataset in an arbitrary frame, for stills a degraded one |
 
@@ -166,7 +166,10 @@ under, with no reflection moved and I(+)/I(-) exactly as measured. A merohedral
 **reindexing**: the candidate with the lowest R-free is kept — where its lead over the runner-up
 beats the lead a random placement of the same model takes — and applied to the **written
 reflections** as well as to the R-factors and the maps; otherwise the data keep the indexing they
-were merged in. Validation runs before the reflection
+were merged in. This is distinct from a model written in another *description* of the lattice — other
+axes, a different unique axis, I-centred where the run indexed C-centred — or in another point group:
+there the model is put into the data's description (`MODEL_CHANGE_OF_BASIS=`) and the data do not move.
+Validation runs before the reflection
 files, so the `.mtz` / `.cif` / `.hkl` come out in the model's frame either way — reindexed where
 the ambiguity decided, and carrying the model's space group where the hand was adopted. The log names the operator in each case, and for the indexing choice gives the winning
 R-free together with the runner-up.
diff --git a/docs/RUGNUX_REPORT.md b/docs/RUGNUX_REPORT.md
index cc0ffa34b..f1b68b8c9 100644
--- a/docs/RUGNUX_REPORT.md
+++ b/docs/RUGNUX_REPORT.md
@@ -545,6 +545,7 @@ as usual.
 | `MODEL_FIT_SIGMA` | The real fit above that null, in its standard deviations. Signed. Absent when `NOT_TESTED` |
 | `MODEL_DECISIONS_TAKEN` | `NONE` \| `ENANTIOMORPH` \| `INDEXING` \| `ENANTIOMORPH+INDEXING` |
 | `MODEL_ENANTIOMORPH_ADOPTED`, `MODEL_INDEXING_OPERATOR` | The two decisions individually; `x,y,z` is no reindexing |
+| `MODEL_CHANGE_OF_BASIS`, `MODEL_SETTING_AS_READ` | Present only where the model was written in another description of the lattice (other axes, other centring, or another point group) and was put into the data's; the data do not move. An alternative indexing of the same point group is settled here only where a reference MTZ (`-z`) has already fixed the data's indexing; otherwise the data are reindexed into the model's, and that is `MODEL_INDEXING_OPERATOR` |
 | `MODEL_INDEXING_MARGIN`, `MODEL_INDEXING_MARGIN_NULL`, `MODEL_INDEXING_MARGIN_SIGMA` | Present only where a merohedral ambiguity was probed. The winner's lead over the runner-up in R-free, against the lead a random placement of the same model produces |
 
 The null's own numbers — `MODEL_FIT_STATISTIC`, `MODEL_FIT_VALUE`, the `MODEL_FIT_NULL_*` keys and
diff --git a/rugnux/ModelValidation.cpp b/rugnux/ModelValidation.cpp
index 7246417bb..0e77c124e 100644
--- a/rugnux/ModelValidation.cpp
+++ b/rugnux/ModelValidation.cpp
@@ -212,6 +212,17 @@ bool same_frame(const gemmi::Op &a, const gemmi::Op &b, const gemmi::GroupOps &g
     return false;
 }
 
+// Do two groups have the same rotations - the same point group in the same setting? I 2 3 and
+// I 21 3 do, and so does an enantiomorphic pair; P 4 and P 4 2 2 do not, nor do P 1 2 1 and P 1 1 2.
+bool same_rotations(const gemmi::GroupOps &a, const gemmi::GroupOps &b) {
+    if (a.sym_ops.size() != b.sym_ops.size())
+        return false;
+    for (const gemmi::Op &op : a.sym_ops)
+        if (b.find_by_rotation(op.rot) == nullptr)
+            return false;
+    return true;
+}
+
 // A change of basis is a matrix AND an origin shift, and the shift is not optional: an odd
 // permutation of a screw-axis group lands on a group that is the same group on a moved origin, whose
 // operator list GEMMI cannot name because it compares those lists exactly. Swapping b and c in
@@ -409,18 +420,49 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
 
     const gemmi::UnitCell data_cell = cell;  // UnitCell -> gemmi::UnitCell
 
+    // --- indexing (merohedral) ambiguity: the candidates ---
+    // When a reference MTZ was supplied, the data were already reindexed to agree with the reference
+    // intensities (at the merge stage for rotation data, per image in stills scaling), and that
+    // choice is authoritative - we keep it. Only with a model and NO reference do we resolve the
+    // ambiguity here, as a fallback, by fitting each candidate reindexing and keeping the lowest
+    // R-free. A no-op either way for a holohedral crystal (no twin laws). The
+    // enantiomorph/screw ambiguity is never probed by R-free: |Fcalc| is the same for both hands, so
+    // it cannot distinguish them - that is taken from the model hand above.
+    //
+    // The candidates are a property of the DATA's lattice and point group: it is the observed
+    // intensities that are relabelled. Asking the model's group instead enumerates nothing at all
+    // wherever the two groups differ - measured, a model in P4(3)2(1)2 against data merged in P4(3)
+    // probes zero operators - which is exactly the case the probe exists for. They are proper
+    // rotations of the lattice, never the inversion, so relabelling by one keeps the hand.
+    const gemmi::SpaceGroup &ambiguity_sg = data_space_group != nullptr ? *data_space_group : *sg;
+    const std::vector<gemmi::Op> reindex_ops =
+        probe_indexing_ambiguity ? ReindexAmbiguityOperators(cell, ambiguity_sg)
+                                 : std::vector<gemmi::Op>{};
+
     // --- same lattice, whose description of it? ---
     // Scored, never asserted. The identity is always among the candidates, so a probe that finds
     // nothing better than leaving the model where it is leaves it there; and the ordinary isomorphous
     // run - where the only operators mapping the cell are the identity and its own symmetry
     // equivalents - collapses to a single candidate and never reaches the scoring at all.
+    //
+    // An alternative indexing maps the cell onto itself too, but it is not a description of the
+    // lattice for the model to be moved into. Where the model and the data share a point group, it
+    // is left out here and the DATA are relabelled into the model's indexing by the probe further
+    // down instead - so that every dataset of one crystal form comes out in the model's convention,
+    // and their maps and reflection files can be compared directly. Moving the model would leave
+    // each dataset in whichever indexing its own run happened to pick.
     if (data_cell.is_crystal()) {
         const gemmi::GroupOps model_gops = sg->operations();
+        const bool same_point_group =
+            data_space_group != nullptr && same_rotations(data_space_group->operations(), model_gops);
         std::vector<gemmi::Op> frames{gemmi::Op::identity()};
         for (const gemmi::Op &op : cell_mapping_operators(st.cell, data_cell)) {
             bool seen = false;
             for (const gemmi::Op &kept : frames)
                 seen = seen || same_frame(kept, op, model_gops);
+            if (same_point_group)
+                for (const gemmi::Op &law : reindex_ops)
+                    seen = seen || same_frame(law, op, model_gops);
             if (!seen)
                 frames.push_back(op);
         }
@@ -636,24 +678,7 @@ ModelValidationResult ValidateAgainstModel(const std::vector<MergedReflection> &
         return out;
     };
 
-    // --- indexing (merohedral) ambiguity ---
-    // When a reference MTZ was supplied, the data were already reindexed to agree with the reference
-    // intensities (at the merge stage for rotation data, per image in stills scaling), and that
-    // choice is authoritative - we keep it. Only with a model and NO reference do we resolve the
-    // ambiguity here, as a fallback, by fitting each candidate reindexing and keeping the lowest
-    // R-free. A no-op either way for a holohedral crystal (no twin laws). The
-    // enantiomorph/screw ambiguity is never probed by R-free: |Fcalc| is the same for both hands, so
-    // it cannot distinguish them - that is taken from the model hand above.
-    //
-    // The candidates are a property of the DATA's lattice and point group: it is the observed
-    // intensities that are relabelled. Asking the model's group instead enumerates nothing at all
-    // wherever the two groups differ - measured, a model in P4(3)2(1)2 against data merged in P4(3)
-    // probes zero operators - which is exactly the case the probe exists for.
-    const gemmi::SpaceGroup &ambiguity_sg = data_space_group != nullptr ? *data_space_group : *sg;
-    const std::vector<gemmi::Op> reindex_ops =
-        probe_indexing_ambiguity ? ReindexAmbiguityOperators(cell, ambiguity_sg)
-                                 : std::vector<gemmi::Op>{};
-
+    // --- indexing (merohedral) ambiguity: the probe over the candidates reindex_ops holds ---
     struct IndexingProbe {
         gemmi::Op op = gemmi::Op::identity();   // the lowest-R-free relabelling
         double margin = 0;                      // by how much in R-free it leads the runner-up
diff --git a/rugnux/Rugnux.cpp b/rugnux/Rugnux.cpp
index 2d1d7c7a4..54cb0c99f 100644
--- a/rugnux/Rugnux.cpp
+++ b/rugnux/Rugnux.cpp
@@ -7563,8 +7563,17 @@ ProcessResult Rugnux::RunPipeline(RugnuxObserver *observer, bool write_output, b
                                 p1.merged.size(), FinalistLedgerToText(led));
                 }
 
+                // The scaler still holds the observations in the indexing they were integrated in, so a
+                // reindexing into the model's (above) is applied to this file too - or it would describe
+                // the dataset in a different indexing from the merged output beside it.
+                const gemmi::Op model_op = result.model_validation ? result.model_validation->indexing_op
+                                                                   : gemmi::Op::identity();
                 const std::string path = config_.output_prefix + "_P1.mtz";
-                WriteMtzReflections(p1.merged, *result.consensus_cell, experiment_, path);
+                WriteMtzReflections(model_op == gemmi::Op::identity()
+                                        ? p1.merged
+                                        : ReindexMergedIntoAsu(p1.merged, model_op, gemmi::get_spacegroup_p1(),
+                                                               experiment_.GetScalingSettings().GetMergeFriedel()),
+                                    *result.consensus_cell, experiment_, path);
                 experiment_.SetSpaceGroup(determined_group);
                 result.error_model_isa = em_isa;
                 result.error_model_isa_asymptotic = em_isa_asymptotic;
diff --git a/tests/ModelValidationTest.cpp b/tests/ModelValidationTest.cpp
index 134f5ac23..69ead8d31 100644
--- a/tests/ModelValidationTest.cpp
+++ b/tests/ModelValidationTest.cpp
@@ -7,6 +7,7 @@
 #include <cstdio>
 #include <filesystem>
 #include <fstream>
+#include <map>
 #include <random>
 #include <sstream>
 
@@ -19,6 +20,7 @@
 #include "../rugnux/RigidBodyRefine.h"
 #include "../rugnux/SigmaA.h"
 #include "../rugnux/WriteModel.h"
+#include "../image_analysis/scale_merge/ReindexAmbiguity.h"
 
 namespace {
     // A synthetic P1 cell with two carbon atoms - enough for a reader to produce a Structure with
@@ -395,6 +397,82 @@ TEST_CASE("ModelValidation_FindsTheDatasDescriptionOfTheLattice", "[ModelValidat
     std::filesystem::remove(other_setting);
 }
 
+// An alternative indexing is settled by relabelling the DATA into the model's indexing, not by moving
+// the model into the data's: that is what puts every dataset of one crystal form in one convention.
+// Only where a reference has already fixed the data's indexing is the model moved instead.
+TEST_CASE("ModelValidation_ReindexesTheDataIntoTheModelsIndexing", "[ModelValidation]") {
+    Logger logger("ModelValidation_ReindexesTheDataIntoTheModelsIndexing");
+
+    // Point group 4 on a tetragonal lattice (4/mmm): one alternative indexing.
+    const auto model = WriteTemp("reidx_model_test.pdb",
+        ClusterPdb("CRYST1   34.000   34.000   38.000  90.00  90.00  90.00 P 4           4\n").c_str());
+    auto own = ModelReferenceIntensities(model, {}, {}, 2.5, logger);
+    REQUIRE(own.size() > 500);
+    for (size_t i = 0; i < own.size(); i++) {
+        own[i].F = std::sqrt(std::max(0.0f, own[i].I));
+        own[i].rfree_flag = (i % 20) == 0;
+    }
+    const UnitCell cell{.a = 34, .b = 34, .c = 38, .alpha = 90, .beta = 90, .gamma = 90};
+    const gemmi::SpaceGroup *p4 = gemmi::find_spacegroup_by_name("P 4");
+    const auto laws = ReindexAmbiguityOperators(cell, *p4);
+    REQUIRE(laws.size() == 1);
+    const std::string prefix = (std::filesystem::temp_directory_path() / "reidx_test").string();
+
+    // The data as a run that picked the other indexing would have merged them.
+    const auto obs = ReindexReflections(own, laws.front());
+
+    const auto to_model = ValidateAgainstModel(obs, cell, model, prefix, logger, p4,
+                                               /*probe_indexing_ambiguity=*/true, 1, 1.0);
+    REQUIRE(to_model.ok);
+    CHECK(to_model.change_of_basis_op == gemmi::Op::identity());
+    CHECK(to_model.indexing_decided);
+    CHECK(to_model.indexing_op == laws.front());
+    CHECK(to_model.r_work < 0.15);
+
+    // A reference already fixed the data's indexing: the data stay, and the model is moved.
+    const auto fixed = ValidateAgainstModel(obs, cell, model, prefix, logger, p4, false, 1, 1.0);
+    REQUIRE(fixed.ok);
+    CHECK_FALSE(fixed.change_of_basis_op == gemmi::Op::identity());
+    CHECK(fixed.indexing_op == gemmi::Op::identity());
+    CHECK(fixed.r_work < 0.15);
+
+    // A near-perfect twin of the mis-indexed data, 45 % of it in the model's indexing: the model
+    // prefers that indexing by less than a model in a random orientation prefers one, so it has decided
+    // nothing and the data must keep the indexing they were merged in.
+    std::vector<MergedReflection> twinned = obs;
+    {
+        const gemmi::GroupOps gops = p4->operations();
+        const gemmi::ReciprocalAsu asu(p4);
+        auto key = [&](const gemmi::Miller &h) { return asu.to_asu(h, gops).first; };
+        std::map<gemmi::Miller, float> by_hkl;
+        for (const auto &r : obs)
+            by_hkl[key({{r.h, r.k, r.l}})] = r.I;
+        for (auto &r : twinned) {
+            const auto mate = by_hkl.find(key(laws.front().apply_to_hkl({{r.h, r.k, r.l}})));
+            REQUIRE(mate != by_hkl.end());
+            r.I = 0.55f * r.I + 0.45f * mate->second;
+            r.F = std::sqrt(std::max(0.0f, r.I));
+        }
+    }
+    const auto twin = ValidateAgainstModel(twinned, cell, model, prefix, logger, p4, true, 1, 1.0);
+    REQUIRE(twin.ok);
+    CHECK_FALSE(twin.indexing_decided);
+    CHECK(twin.indexing_op == gemmi::Op::identity());
+    CHECK(twin.change_of_basis_op == gemmi::Op::identity());
+
+    // Data already in the model's indexing: nothing moves, and there is nothing to arbitrate.
+    const auto same = ValidateAgainstModel(own, cell, model, prefix, logger, p4, true, 1, 1.0);
+    REQUIRE(same.ok);
+    CHECK(same.change_of_basis_op == gemmi::Op::identity());
+    CHECK(same.indexing_op == gemmi::Op::identity());
+    CHECK_FALSE(same.fit_tested);
+    CHECK(same.r_work < 0.15);
+
+    for (const char *suffix : {"_2fofc.ccp4", "_fofc.ccp4", "_anom.ccp4", "_maps.mtz"})
+        std::filesystem::remove(prefix + suffix);
+    std::filesystem::remove(model);
+}
+
 TEST_CASE("WriteModel_KeepsTheContentAndTakesTheGivenFrame", "[ModelValidation]") {
     Logger logger("WriteModel_KeepsTheContentAndTakesTheGivenFrame");
 
diff --git a/tests/ReindexAmbiguityTest.cpp b/tests/ReindexAmbiguityTest.cpp
index 8eaa76522..9ab69ef46 100644
--- a/tests/ReindexAmbiguityTest.cpp
+++ b/tests/ReindexAmbiguityTest.cpp
@@ -192,3 +192,23 @@ TEST_CASE("Reindex into the ASU: both mates of an anomalous pair follow the same
     CHECK(out[0].I_plus == 90.0f);
     CHECK(out[0].I_minus == 110.0f);
 }
+
+TEST_CASE("Reindex: every ambiguity operator is a proper rotation", "[reindex]") {
+    // A relabelling by a lattice rotation keeps the hand; one with determinant -1 would swap every
+    // Bijvoet pair. The candidates come from the lattice symmetry without the inversion, so none may
+    // be improper, in any crystal system that has an ambiguity.
+    const std::vector<std::pair<UnitCell, int>> cases{
+        {Tetragonal(), 75},                                           // P4
+        {UnitCell{60.0f, 60.0f, 90.0f, 90.0f, 90.0f, 120.0f}, 143},   // P3
+        {UnitCell{60.0f, 60.0f, 90.0f, 90.0f, 90.0f, 120.0f}, 149},   // P312
+        {UnitCell{60.0f, 60.0f, 90.0f, 90.0f, 90.0f, 120.0f}, 168},   // P6
+        {UnitCell{77.0f, 77.0f, 77.0f, 90.0f, 90.0f, 90.0f}, 197},    // I23
+        {UnitCell{77.0f, 77.0f, 77.0f, 90.0f, 90.0f, 90.0f}, 199},    // I2(1)3
+    };
+    for (const auto &[cell, sg] : cases) {
+        const auto ops = ReindexAmbiguityOperators(cell, SG(sg));
+        CHECK_FALSE(ops.empty());
+        for (const auto &op : ops)
+            CHECK(op.det_rot() == gemmi::Op::DEN * gemmi::Op::DEN * gemmi::Op::DEN);
+    }
+}
-- 
2.54.0