v1.0.0-rc.178 (#88)

* Rugnux: Processes serial crystallography data from XFELs - SACLA (MPCCD), PAL-XFEL and European XFEL (CXI), LCLS (XTC) and SwissFEL Alvra (JUNGFRAU with a CrystFEL module geometry) - with several files or Jungfraujoch master files merged in one run (`rugnux *_master.h5`).
* Rugnux: Stills processing takes a known unit cell and space group as a starting point, finds the beam centre (and, with a cell, the detector distance) from the images, detects the saturation level in other facilities' files and refines the placement of individual detector panels.
* Rugnux: The stills report gives R_split and CC1/2 from frame half-sets, comparable with CrystFEL.
* jfjoch_viewer: Opens the same XFEL file formats.
* Validation: A stills battery checks Rugnux against deposited structures from SACLA, PAL-XFEL, LCLS, European XFEL and SwissFEL.
* Rugnux: More reliable convergence of rotation scaling, and live molecular replacement starts as soon as the model is uploaded.
* jfjoch_broker: Initialize clears the previous dataset's bearer tokens, image buffer and live Rugnux status, and a slow CUDA JIT cache is reported at start.

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

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);