rugnux stills: a given cell is matched in any setting, and per-image reindexing moves the lattice with the indices

Three defects that stopped known-cell stills runs:

- The consensus cell compared every frame's cell to -C axis by axis. A run whose frames index in another
  setting of the same lattice (axes in another order, another monoclinic choice) had no frame accepted, no
  consensus cell and no output ("No crystal lattice was determined"), although it merged fine. A frame
  whose lattice contains the given cell now counts on the given cell's axes (CellOnReference, the same
  FindSublatticeBases the merge-stage relabel uses).
- The per-image ambiguity resolver relabelled a frame's reflections but left its lattice on the old axes.
  Everything after it predicts from index and lattice: the sublattice relabel put such a frame through a
  second transformation, and on a monoclinic cell with a near-symmetry (a+c nearly as long as a) the
  merge came out at indices finer than anything measured, shells over 100% complete. The lattice now
  follows the indices (ReindexLattice, B' = R^-1 B).
- With -C/-S the stills path replaced the known-cell indexer's lattice, already on the given axes, by
  LatticeSearch's conventional choice, which on that near-symmetric cell is the other description on half
  the frames. The indexer's lattice is now kept when it is close to the given cell.

Measured (cell + space group given, dimple against the deposited model and free set):
- monoclinic MbCO-type still set: was over-complete/broken with --model; now 2.06 A, R/Rfree 0.233/0.314
  at 2.11 A (P1 merge before: 0.275/0.306).
- C-centred orthorhombic set: no MTZ before; now 3.27 A, R/Rfree 0.298/0.403 at 3.68 A (de novo 0.336/0.448).
- monoclinic two-form set, one form: cell P 1 21 1 with beta (was alpha); Rfree 0.310 -> 0.260, 3.05 -> 2.72 A.
- No change on seven other stills sets, nor on two rotation battery sets (5reo, lyso_x10sa_90deg_1).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

image_analysis/IndexAndRefine.cpp

@@ -16,6 +16,7 @@
 #include "lattice_search/LatticeSearch.h"
 #include "scale_merge/ReindexAmbiguity.h"
 #include "scale_merge/ScaleOnTheFly.h"
+#include "scale_merge/SublatticeRelabel.h"
 
 namespace {
     // Iterations the offline geometry refinement is allowed, standing in for the 40 ms the online path
@@ -339,8 +340,17 @@ IndexAndRefine::IndexingOutcome IndexAndRefine::DetermineLatticeAndSymmetry(Data
                 // niggli_class is left unassigned (0): it needs the primitive cell incl.
                 // centering, which LatticeSearch cannot recover from a (possibly centred, e.g.
                 // C2) user cell. A proper primitive-cell indexing path (CrystFEL-style) is deferred.
+                // A lattice FFBIDX returned on the given cell is already on its axes; LatticeSearch's
+                // conventional choice is only one of the descriptions of it, and on a cell with a
+                // near-symmetry (a monoclinic one whose a+c is nearly as long as a) it picks the other
+                // one on half the frames, which the merge then has to tell apart again.
+                const auto settings = experiment.GetIndexingSettings();
                 auto sym_result = LatticeSearch(latt);
-                if (sym_result.system == sg->crystal_system())
+                if (!de_novo && latt.GetUnitCell().is_close(*experiment.GetUnitCell(),
+                                                            settings.GetUnitCellDistTolerance(),
+                                                            settings.GetUnitCellAngleTolerance_deg()))
+                    outcome.lattice_candidate = latt;
+                else if (sym_result.system == sg->crystal_system())
                     outcome.lattice_candidate = sym_result.conventional;
                 else if (!de_novo)
                     outcome.lattice_candidate = latt;
@@ -938,7 +948,7 @@ void IndexAndRefine::ScaleImage(DataMessage &msg, IntegrationOutcome& outcome) {
         return;
 
     auto scaling_start_time = std::chrono::steady_clock::now();
-    reindex_resolver->Resolve(outcome.reflections);
+    reindex_resolver->Resolve(outcome.reflections, outcome.latt);
     auto scaling_end_time = std::chrono::steady_clock::now();
     msg.image_scale_time_s = std::chrono::duration<float>(scaling_end_time - scaling_start_time).count();
 }
@@ -990,9 +1000,16 @@ std::optional<UnitCell> IndexAndRefine::GetConsensusUnitCell() const {
         std::vector<UnitCell> accepted;
         accepted.reserve(cells.size());
 
+        // A frame whose lattice is the given cell in another setting (axes in another order, another
+        // monoclinic or centred choice) counts on the given cell's axes - the merge puts it there
+        // (RelabelOnSublattice) - rather than being left out. Compared axis by axis only, a run whose
+        // frames all index in another setting than the one typed after -C has no consensus at all.
         for (const auto &cell: cells) {
             if (cell.is_close(*experiment.GetUnitCell(), dist_tolerance, angle_tolerance))
                 accepted.emplace_back(cell);
+            else if (const auto on_ref = CellOnReference(cell, *experiment.GetUnitCell(),
+                                                         experiment.GetIndexingSettings()))
+                accepted.emplace_back(*on_ref);
         }
 
         return MeanUnitCell(accepted);