Serial stills: the indexing ambiguity resolved from the data when no reference or model is given

Where the space group is given (-S) and its lattice admits alternative indexings, a stills run without
-z or --model used to merge the crystals' random indexings together (and warned). The crystals are now
made consistent with each other before anything is scaled (ReferenceFreeReindex): each takes the
indexing in which it agrees best with all the others (Brehm & Diederichs 2014), agreement being the
sum over shared reflections of the products of shell-normalised, per-crystal standardised intensities,
weighted by 1/(1+(sigma/sd)^2). The sum over all pairs is (|M|^2 - const)/2 for M the running sum, so a
pass over the crystals is one pass over the reflections rather than over all pairs: coordinate ascent,
four seeded starts, stop when <= 1 crystal in 1000 moves, the overall relabel that moves the fewest
crystals. Deterministic (fixed summation order, sequential passes).

A twin law of a pseudo-merohedral cell whose axes differ by a few per cent is decided by the crystals'
own refined cells, which the indexer has already used: where >= 90% of the crystals' cells fit better as
indexed, those crystals are anchors and only the others are decided by the intensities. Without this,
two public sets got worse (pal90 R-free 0.183 -> 0.207, lcls242_t 0.296 -> 0.350).

With a reference or model the per-image choice stands; the same resolution runs as a check, reported as
AMBIGUITY_DATA_DISAGREES. New report keys (section 2): INDEXING_AMBIGUITY_RESOLVED, AMBIGUITY_CRYSTALS,
AMBIGUITY_REINDEXED, AMBIGUITY_SEPARATION_SIGMA, AMBIGUITY_DECIDED_FRACTION (+ AMBIGUITY_TIME_S, dev).
--mode scale is not changed.

Still battery, no --model (R-free, REFMAC 0-cycle against the deposited model; before -> after; with
--model for comparison): euxfel83 0.321 -> 0.207 (0.204), euxfel152 0.346 -> 0.257 (0.245), alvra213
0.209 -> 0.201 (0.207), alvra213_int16 0.210 -> 0.202 (0.208), pal90 0.183 -> 0.183 (0.188), lcls242_t
0.296 -> 0.294 (0.285); controls sacla237 / lcls222 unchanged (no ambiguity, no-op). The step takes
0.2-1.6 s on 2.7k-54k crystals; synthetic 64k crystals x 200 reflections 0.5 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015CeEGgpKdfkCTJb3YNMJcu
(cherry picked from commit 80d378a1fe92364fd5b99a17f5c9ee8498412d36)

docs/ACKNOWLEDGEMENT.md

@@ -367,6 +367,16 @@ S. C. Abrahams, H. D. Flack, E. Prince and A. J. C. Wilson, "Statistical descrip
 crystallography. II. Report of a Working Group on Expression of Uncertainty in Measurement" (1995),
 Acta Cryst. A51, 565-569 [doi:10.1107/S0108767395002340](https://doi.org/10.1107/S0108767395002340).
 
+**Indexing ambiguity of serial data without a reference** — where a serial run's lattice is more
+symmetric than its crystals and no reference or model is given, each crystal is put into the indexing in
+which its intensities agree best with those of all the other crystals, crystal by crystal until none
+changes. The objective - the summed agreement between every pair of crystals - and the iteration that
+maximises it are taken from Brehm and Diederichs, whose method CrystFEL's `ambigator` also implements;
+rugnux measures the agreement as a product of standardised intensities rather than a correlation, which
+lets the sum over all partners be taken against one running sum instead of pair by pair.
+W. Brehm and K. Diederichs, "Breaking the indexing ambiguity in serial crystallography" (2014),
+Acta Cryst. D70, 101-109 [doi:10.1107/S1399004713025431](https://doi.org/10.1107/S1399004713025431).
+
 ### Physical corrections and calibration
 
 **Sensor absorption at oblique incidence, and the flight path** — the angle-dependent quantum

docs/CPU_DATA_ANALYSIS.md

@@ -87,6 +87,7 @@ The methods draw on, and in places reimplement, solutions from:
 - C. Vonrhein, C. Flensburg, P. Keller et al., "Data processing and analysis with the autoPROC toolbox", *Acta Cryst.* **D67** (2011), 293-302 (the inspiration for not trusting header geometry and for finding the beam centre from the images, §1.4).
 - P. R. Evans & G. N. Murshudov, "How good are my data and what is the resolution?", *Acta Cryst.* **D69** (2013), 1204-1214 (AIMLESS: the anisotropic deltaB as the range of the principal components, and diffraction limits from a cone about each principal direction).
 - G. Assmann, W. Brehm & K. Diederichs, "Identification of rogue datasets in serial crystallography", *J. Appl. Cryst.* **49** (2016), 1021-1028, and G. M. Assmann, M. Wang & K. Diederichs, *Acta Cryst.* **D76** (2020), 636-652 (XDSCC12: sigma-tau CC1/2, delta-CC1/2, the Fisher transformation and the rejection discipline the frame disposition follows).
+- W. Brehm & K. Diederichs, "Breaking the indexing ambiguity in serial crystallography", *Acta Cryst.* **D70** (2014), 101-109 (serial stills without a reference: each crystal put into the indexing in which it agrees best with all the others).
 - K. Diederichs & P. A. Karplus, *Nat. Struct. Biol.* **4** (1997), 269-275, and P. A. Karplus & K. Diederichs, *Science* **336** (2012), 1030-1033 (R_meas / R_pim, CC1/2 and CC\*).
 - M. S. Weiss, "Global indicators of X-ray data quality", *J. Appl. Cryst.* **34** (2001), 130-135 (R_pim).
 - IUCr Commission on Crystallographic Nomenclature, "Statistical descriptors in crystallography", *Acta Cryst.* **A45** (1989), 63-75, and *Acta Cryst.* **A51** (1995), 565-569 (uncertainty conventions).

docs/CPU_DATA_ANALYSIS_INTEGRATION.md

@@ -471,7 +471,11 @@ A reference dataset (`--reference`, MTZ or SF-mmCIF) supplies known intensities
 
 **Fix the space group and cell.** Unless overridden on the command line (`-S` for the space group, `-C` for the cell), the reference's space group is adopted and its cell is used as the soft reference cell — indexing may still drift the cell within tolerance, so a small mismatch between reference and data is absorbed rather than rejected. This applies to both stills and rotation data.
 
-**Resolve the indexing (merohedral) ambiguity.** When the lattice symmetry is higher than the crystal's Laue symmetry (e.g. $P3$, $P4$, $P6$, $C2$), more than one indexing of the same lattice is geometrically valid, and the two solutions produce *different* merged intensities that a self-consistent scale cannot tell apart — only an external reference can. The candidate reindexings are the identity together with the twin-law cosets of the metric symmetry (from the unit-cell metric and the Laue group); each is scored by the intensity correlation $\mathrm{CC}_\mathrm{ref}$ of the reindexed merge against the reference, and the data are re-merged in the best-correlating indexing. The reindex is **metric-preserving** — only the $hkl$ labels change, the cell is unchanged — and it is a no-op for a holohedral crystal, which has no twin laws (the lattice and Laue symmetry coincide). For rotation data this is done once, after the space group is determined, and the whole merge is then repeated in the chosen indexing. For stills it has to be done **per image**, at integration time: each crystal is indexed independently, so a run resolves the ambiguity image by image (the image's partiality/Lorentz-corrected intensities are correlated with the reference under each candidate operator, which is scale-invariant, and the best-correlating one is adopted once and for good) — otherwise the merge would average reflections that are not symmetry mates. In neither workflow is the reference a **scale** target: both scale against their own data (§10.2), so $\mathrm{ISa}$ and the merging statistics come from the data alone and no cross-dataset systematic is imported. Because the stills choice is made at integration time, a later re-merge of stored reflections cannot repair a dataset integrated without a reference. Where there is no reference dataset but there is a **model** (`--model`), the reference intensities are computed from it instead - $|F_\mathrm{model}|^2$ from the atomic structure factors with a flat bulk-solvent contribution at the standard constants ($k_\mathrm{sol}=0.35$, $B_\mathrm{sol}=46$ Å$^2$), which are not fitted because there are no observations yet. Nothing is scaled against them; they serve only to rank the candidate indexings, and the correlation that does the ranking is scale-invariant. This needs the cell and space group up front (`-C` / `-S`, as serial indexing wants anyway); on rotation data the same job is done after the merge, in §14.5, where a merge exists to fit the model to properly.
+**Resolve the indexing (merohedral) ambiguity.** When the lattice symmetry is higher than the crystal's Laue symmetry (e.g. $P3$, $P4$, $P6$, $C2$), more than one indexing of the same lattice is geometrically valid, and the two solutions produce *different* merged intensities that a self-consistent scale cannot tell apart — only an external reference can. The candidate reindexings are the identity together with the twin-law cosets of the metric symmetry (from the unit-cell metric and the Laue group); each is scored by the intensity correlation $\mathrm{CC}_\mathrm{ref}$ of the reindexed merge against the reference, and the data are re-merged in the best-correlating indexing. The reindex is **metric-preserving** — only the $hkl$ labels change, the cell is unchanged — and it is a no-op for a holohedral crystal, which has no twin laws (the lattice and Laue symmetry coincide). For rotation data this is done once, after the space group is determined, and the whole merge is then repeated in the chosen indexing. For stills it has to be done **per image**, at integration time: each crystal is indexed independently, so a run resolves the ambiguity image by image (the image's partiality/Lorentz-corrected intensities are correlated with the reference under each candidate operator, which is scale-invariant, and the best-correlating one is adopted once and for good) — otherwise the merge would average reflections that are not symmetry mates. In neither workflow is the reference a **scale** target: both scale against their own data (§10.2), so $\mathrm{ISa}$ and the merging statistics come from the data alone and no cross-dataset systematic is imported. Because the stills choice is made at integration time, a later re-merge of stored reflections (`--mode scale`) cannot repair a dataset integrated without a reference; the data-only resolution below runs in the full pipeline only. Where there is no reference dataset but there is a **model** (`--model`), the reference intensities are computed from it instead - $|F_\mathrm{model}|^2$ from the atomic structure factors with a flat bulk-solvent contribution at the standard constants ($k_\mathrm{sol}=0.35$, $B_\mathrm{sol}=46$ Å$^2$), which are not fitted because there are no observations yet. Nothing is scaled against them; they serve only to rank the candidate indexings, and the correlation that does the ranking is scale-invariant. This needs the cell and space group up front (`-C` / `-S`, as serial indexing wants anyway); on rotation data the same job is done after the merge, in §14.5, where a merge exists to fit the model to properly.
+
+**Serial stills without a reference or model.** The data cannot say which indexing is the *true* one, but they can say which crystals are in the *same* one, and that is all a merge needs. Where the space group is fixed (`-S`) and its lattice admits alternative indexings, the crystals are made consistent with each other before anything is scaled, following Brehm & Diederichs (2014). Each crystal's partiality- and Lorentz-corrected intensities are divided by the run's mean intensity in their resolution shell (20 shells of equal reciprocal volume), standardised within the crystal so that its unknown scale and offset drop out, and weighted by $1/(1+(\sigma/s)^2)$, $s$ being the crystal's spread, so that a weak or barely recorded reflection counts for little. The agreement of two crystals is the sum of the products of these values over the reflections they share, and the objective is that agreement summed over every pair of crystals, each in the indexing assigned to it. That sum is $(|M|^2 - \mathrm{const})/2$ with $M$ the per-reflection sum over all crystals, so a crystal's agreement with all the others is one dot product with $M$ less its own contribution: each crystal in turn takes the indexing in which that dot product is largest, $M$ is updated, and the passes repeat until no more than one crystal in a thousand moves. A pass costs one read of the reflections, not one per pair of crystals, which is what keeps tens of thousands of crystals to seconds. The objective only grows, so it converges; it is started four times (once from the indexing as found, three times from a seeded random assignment) and the start that ends highest is kept, and of the equally consistent answers related by an overall relabelling the one that moves the fewest crystals is taken. The order of every floating-point sum is fixed (crystals in image order, sequential passes), so the result does not depend on the thread count. The run reports how clearly the crystals separated: for each crystal the correlation with the mean of all the others in its chosen indexing and in the best other one, compared by Fisher's $z$ in units of its standard error ($\sqrt{2/(n-3)}$ for $n$ shared reflections) — the median of that margin and the share of crystals above $3\sigma$.
+
+A twin law is only an ambiguity for crystals whose own lattice cannot tell the indexings apart. On a pseudo-merohedral cell whose axes differ by a few per cent, each crystal's refined cell already says which axis is which, and the indexer has used that; letting the intensities overrule it there moves crystals that were right. So for each law the share of crystals whose refined cell fits the run's cell better as indexed than after the law is measured (a tie counting half — on an exactly merohedral lattice the share is about one half). Where it is at least 0.9 the law is decided by the cells: a crystal whose cell prefers its indexing stays there, as an anchor, and only the crystals whose cell does not are decided by the intensities, against the anchors. With a reference or a model the per-image choice above stands, and the same resolution is run only to measure it: the report gives the number of crystals on which the data alone would have chosen otherwise.
 
 ### 10.10 Ice rings at the scale and merge stages
 

docs/RUGNUX_ADVANCED.md

@@ -31,7 +31,7 @@ the status marks no test set. It is read once, before processing starts, and use
   already on the reference's axes), `REFERENCE_CC=` and `REFERENCE_MATCHED_FRACTION=` how well the
   result matches.
 - **It resolves the indexing ambiguity** (below) — the one thing the data cannot settle for
-  themselves.
+  themselves: which of the equivalent indexings is the reference's own.
 - **It hands over its R-free test set**, where the file carries one, so every dataset of a campaign
   is scored on the same free reflections - in the reference's frame, and only where the merge
   matches the reference (CC at least 0.5 over at least half of the merged reflections in its
@@ -59,8 +59,8 @@ cell is metrically more symmetric than the Laue class by accident (*pseudo-meroh
 obliquity). The alternatives are related by the crystal's **twin laws** — reindexing operators such
 as `k,h,-l`.
 
-Nothing in the data breaks the tie: the merge is equally self-consistent either way, so which
-solution comes out is arbitrary. What that costs depends on the workflow:
+Nothing in the data says which solution is the *true* one: the merge is equally self-consistent
+either way, so which comes out is arbitrary. What that costs depends on the workflow:
 
 - **Rotation.** The whole sweep is one lattice, so the whole dataset lands in one indexing, picked
   at random. The merge itself is sound; it may simply be the *other* solution from an earlier
@@ -68,20 +68,31 @@ solution comes out is arbitrary. What that costs depends on the workflow:
   same model.
 - **Serial stills.** Every crystal is indexed independently, so a run mixes both indexings into one
   merge. That is not a labelling matter — reflections that are not symmetry mates get averaged
-  together, and CC1/2, R<sub>meas</sub> and the anomalous signal all degrade.
+  together, and CC1/2, R<sub>meas</sub> and the anomalous signal all degrade. The data *can* say
+  which crystals are in the same indexing, though, and that is what a merge needs: with the space
+  group given (`-S`) and no reference, Rugnux puts each crystal into the indexing in which it agrees
+  best with all the others, before anything is scaled. This takes seconds for tens of thousands of
+  crystals, and the report says how clearly the crystals separated (`AMBIGUITY_SEPARATION_SIGMA=`,
+  `AMBIGUITY_DECIDED_FRACTION=`) and how many were moved (`AMBIGUITY_REINDEXED=`). The indexing the
+  whole merge ends up in is still arbitrary against other data sets, exactly as on rotation data.
+  On a pseudo-merohedral cell whose axes differ by a few per cent, each crystal's own refined cell
+  already says which axis is which; there only the crystals whose cell does not are decided by the
+  intensities, and the others keep their indexing.
 
-Every run that merges tests for the ambiguity, and where it exists and nothing resolves it, says so
-in the log and in the report's warnings:
+Every run that merges tests for the ambiguity, and where it exists and nothing resolves it (serial
+stills whose space group was determined by the run rather than given), says so in the log and in the
+report's warnings:
 
 ```
 Indexing ambiguity: this cell / space group admits alternative indexing (reindex operator(s):
--h,-k,l). Serial-stills crystals are indexed in one hand at random, and rugnux can only break this
-against an external reference. WITHOUT one the merge mixes the hands and CC1/2 is degraded - supply
-a reference MTZ (-z) or a model (--model, which needs -C and -S here) to resolve it.
+-h,-k,l). Serial-stills crystals are indexed in one hand at random, and rugnux makes them consistent
+from the data only where the space group is given: here it was determined by the run, so the merge
+mixes the hands and CC1/2 is degraded. Giving the space group (-S) resolves it from the data; a
+reference MTZ (-z) or a model (--model, which needs -C and -S here) resolves it against them.
 ```
 
 Where something does resolve it, the run says so instead — `Indexing ambiguity present (reindex
-operator(s): -h,-k,l); resolved against the supplied model`.
+operator(s): -h,-k,l); resolved against the supplied reference` or `...; resolved from the data`.
 
 How to resolve it:
 
@@ -90,14 +101,16 @@ 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`). 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 |
+| **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 data-only resolution below is then run only as a check: `AMBIGUITY_DATA_DISAGREES=` counts the crystals on which it would have chosen otherwise |
+| **Serial stills**, neither, space group given (`-S`) | Nothing to do: the crystals are made consistent with each other from the data alone (`INDEXING_AMBIGUITY_RESOLVED= data`), in an indexing that is arbitrary against other data sets. A model or reference still settles the weakest crystals more reliably than the other crystals can, and puts the merge in its own indexing |
+| Neither | The run warns and merges in whichever indexing it found: for rotation data a usable dataset in an arbitrary frame, for stills whose space group the run determined a degraded one |
 
 Two things to know about where the choice lands:
 
 - **`--mode scale` cannot repair a stills run after the fact.** The per-image test happens at
   integration time, so a `_process.h5` whose images were integrated without a reference — an MTZ or a
-  model — has already lost the distinction, and no re-merge brings it back. On rotation data, where
+  model — has already lost the distinction, and no re-merge brings it back; the data-only resolution
+  runs in the full pipeline, not in `--mode scale`. On rotation data, where
   the ambiguity is one choice for the whole dataset, `--mode scale --model model.pdb` does resolve it.
 - **The choice reaches the written reflections**, not only the R-factors and the maps: the merged
   `.mtz` / `.cif` / `.hkl` (and `_unmerged.mtz`, where it is asked for) are written in the indexing

docs/RUGNUX_MODEL_AND_REFERENCE.md

@@ -39,9 +39,9 @@ the rest walks through a run step by step.
   [Serial stills](#serial-stills-the-one-place-a-model-acts-before-the-merge)). Nothing else is
   taken from it before the merge. This is deliberate: a structure of the same protein (often a cryo
   structure) usually exists, and it settles the choice reliably. Where the lattice has no ambiguity
-  the model changes nothing. Without a model the result is still a valid one, only with the
-  crystals' indexings mixed - unless chance happens to sort them, which is very unlikely - so its
-  merged intensities average each reflection with its alternative.
+  the model changes nothing. Without a model the crystals are made consistent with each other from
+  the data alone (with `-S` given), which recovers most of what the model gives; the model still
+  decides the weakest crystals better than the other crystals can.
 
 ## Every option that brings in a model or reference data
 
@@ -103,7 +103,7 @@ these letters.
 | Point group, Laue class, centring | data (space-group search) | `-S` fixes it | the reference's | — | (a) |
 | Screw axes (space group within the point group) | data | `-S` | the reference's | a different choice → `<prefix>_mr.*` only | (a) in `p.mtz`, (c) beside it |
 | Hand (enantiomorph) | not decidable: `SPACE_GROUP_ENANTIOMORPH= UNDETERMINED` | `GIVEN` | `GIVEN` | relabelled to the model's where it fits, past the anomalous veto: `ASSUMED_FROM_MODEL` | (b) |
-| Indexing ambiguity (merohedral reindex) | arbitrary on rotation (`INDEXING_AMBIGUITY_OPERATORS=`); mixed on stills (warning) | — | resolved against the reference | resolved by the rigid-body model where its lead beats its null, rotation; per image on stills with `-C`/`-S`. Never by molecular replacement | (b) |
+| Indexing ambiguity (merohedral reindex) | arbitrary on rotation (`INDEXING_AMBIGUITY_OPERATORS=`); on stills with `-S` the crystals made consistent from the data, otherwise mixed (warning) | — | resolved against the reference | resolved by the rigid-body model where its lead beats its null, rotation; per image on stills with `-C`/`-S`. Never by molecular replacement | (b) |
 | Setting (which axis is a, b, c) | standard setting | `-C`'s axis order; `-S`'s symbol | the reference's | the model's, where it fits and there is no `-z` (`SETTING_SOURCE= MODEL`) | (b) |
 | Twinning check (L-test, twin laws) | data | — | — | — | (a) |
 | Twin hypothesis `<prefix>_twin_<SG>.*` | data (when the group may have absorbed a twin law) | — | — | the model may also *ask* for this merge; written then only where the model chooses it | (a) / (c) |
@@ -189,6 +189,12 @@ carries no information to choose with, so the crystals stay mixed, as they would
 After the merge, the model is validated as in the steps above. Without `-C` and `-S`, or on rotation
 data, the model is not used before the merge at all.
 
+Without a model or reference, a stills run given `-S` settles the same question from the data: it
+cannot say which indexing is the true one, but it can say which crystals share one, and puts each
+crystal into the indexing in which it agrees best with all the others. With a model, that resolution
+still runs, as a check only: `AMBIGUITY_DATA_DISAGREES=` in the report counts the crystals on which
+the data alone would have chosen differently from the model.
+
 ## Where a model can touch the space group
 
 Spelled out, because this is the question that matters most:

docs/RUGNUX_REPORT.md

@@ -238,7 +238,16 @@ and a run that produced a textbook data set read identically for their first thr
   correct cells show, an arbitrary indexing choice (`Indexing choice`, a rotation sweep whose cell
   admits alternative indexing: one sweep is indexed consistently, so it matters only against other data;
   the operators are **`INDEXING_AMBIGUITY_OPERATORS=`** in section 2). On serial stills the same ambiguity
-  mixes the hands in the merge, and is an `INDEXING_AMBIGUITY` warning. `INDEXING_RATE=` - the share of
+  mixes the hands in the merge. Where the space group was given (`-S`), the crystals are made
+  consistent from the data alone and section 2 says so: **`INDEXING_AMBIGUITY_RESOLVED= data`**,
+  **`AMBIGUITY_CRYSTALS=`** (the crystals that took part), **`AMBIGUITY_REINDEXED=`** (of them, the ones
+  moved), **`AMBIGUITY_SEPARATION_SIGMA=`** (per crystal, how far its chosen indexing beats the best other
+  one in correlation with all the other crystals, in sigma; the median) and
+  **`AMBIGUITY_DECIDED_FRACTION=`** (the share of crystals decided at over 3 sigma). With a reference or
+  a model the choice is theirs (`INDEXING_AMBIGUITY_RESOLVED= reference`), and
+  **`AMBIGUITY_DATA_DISAGREES=`** counts the crystals on which the data alone would have chosen
+  otherwise. Where the space group was determined by the run instead, the mixed merge is an
+  `INDEXING_AMBIGUITY` warning. `INDEXING_RATE=` - the share of
   frames the per-image indexer took - is a stills measure: a rotation run indexes the sweep as a whole, so
   there it is written only with `--developer`, and `NO_LATTICE` rests on whether the sweep was indexed.
 - **`WARNING_COUNT=`** and the **`WARNING:`** lines follow, in the same section. They are what they