v1.0.0-rc.175 (#85)

* Rugnux: Processes a collection live while jfjoch_broker writes it (`rugnux <master.h5> <broker URL>`).
* Rugnux: Processing starts on the first images and confirms its choices once all are in, so analysis can begin during collection.
* Rugnux: Faster processing, especially on servers with several GPUs and CPU sockets and on computers without a GPU (`--no-gpu`, macOS).
* Rugnux: Uses much less GPU memory, so large data sets stay on the GPU of smaller cards, and a data set too large for the card is processed on the CPU instead.
* Rugnux: On macOS, Bragg integration runs on the Apple GPU.
* Rugnux: Better handling of twinning and pseudo-symmetry, with the twin hypothesis written as `<prefix>_twin_<SG>.mtz`, and a wrong `--model` no longer confirms the data or decides the hand.
* Rugnux: `--model` accepts predicted (AlphaFold) models and falls back to molecular replacement when the model is not placed as a rigid body (experimental `--mr` forces it), settling space group, hand and twinning and writing a different answer as `<prefix>_mr.mtz`.
* Rugnux: Molecular replacement is faster and settles the space group in more cases with several copies in the asymmetric unit.
* Rugnux: Deposition-ready mmCIF, a richer report, and numbered steps on the terminal with the full log in `<prefix>_log.txt`; `_P1.mtz`, `--estimate-beam-center` and `--beam-center-search` are removed.
* Rugnux: The beam-stop shadow is found correctly on tilted detectors.
* Rugnux: Stills files that record a stationary goniometer axis get the default stills geometry refinement.
* jfjoch_viewer: "Analyze dataset" uses the same defaults as a bare `rugnux <file>`, and shows the results of processed CBF, marCCD and SMV sweeps.
* jfjoch_viewer: The Files panel refreshes on F5 and every few seconds, and the plot type and other selections stay put during live collection.
* jfjoch_writer: Memory stays bounded and old data files are closed efficiently on long runs, any failure ends the run in an error state the broker is told about, and the master file appears only after its data files; the ZeroMQ pusher logs when a stalled writer makes it drop images.
* Fixes: The TCP image pusher no longer blocks the broker's receiver, GPU out-of-memory failures stop with a clear message, and the XDS plugin masks module and chip edges.

---------

Co-authored-by: Filip Leonarski <jungfrau@filips-mac-mini.home>
Reviewed-on: #85
Co-authored-by: Filip Leonarski <filip.leonarski@psi.ch>

tests/IndexingUnitTest.cpp

@@ -249,6 +249,37 @@ TEST_CASE("FFTIndexer","[Indexing]") {
     logger.Info("Time: {} ms", std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count());
 }
 
+TEST_CASE("FFTIndexer_AxisLongerThanTheBound","[Indexing]") {
+    // The projected histogram is sampled at 1/(2*max length), so an axis between the bound and twice it
+    // folds back to 2*bound - L: a 360 A axis searched to 250 A peaks at 140 A. The fold must be undone,
+    // not built into a cell.
+    UnitCell uc(39, 45, 360, 90, 90, 90);
+    CrystalLattice cl(uc);
+
+    DiffractionExperiment experiment;
+    IndexingSettings settings;
+    settings.Algorithm(IndexingAlgorithmEnum::FFT)
+            .FFT_MaxUnitCell_A(250.0).FFT_HighResolution_A(2 * M_PI / 3.0);
+    experiment.ImportIndexingSettings(settings);
+    std::unique_ptr<Indexer> indexer = CreateIndexer(experiment);
+    REQUIRE(indexer);
+
+    std::vector<Coord> vec;
+    for (int h = -2; h < 8; h++)
+        for (int k = -4; k < 8; k++)
+            for (int l = -3; l < 60; l++)
+                vec.push_back(h * cl.Astar() + k * cl.Bstar() + l * cl.Cstar());
+
+    auto result = indexer->Run(vec);
+    REQUIRE(!result.lattice.empty());
+    const auto uc_out = result.lattice[0].GetUnitCell();
+    std::array<float, 3> out = {uc_out.a, uc_out.b, uc_out.c};
+    std::sort(out.begin(), out.end());
+    CHECK(out[0] == Catch::Approx(39.0f).epsilon(0.01));
+    CHECK(out[1] == Catch::Approx(45.0f).epsilon(0.01));
+    CHECK(out[2] == Catch::Approx(360.0f).epsilon(0.01));
+}
+
 TEST_CASE("FFTIndexer_CentredReferenceCell","[Indexing]") {
     // A reference cell is quoted the way a deposit states it, which for a centred lattice is the
     // conventional cell - and the indexer's candidates are Niggli-reduced primitive cells, whose
@@ -785,3 +816,60 @@ TEST_CASE("FitSupercellProbe", "[SupercellProbe]") {
     // Too few reflections to fit a line: nothing.
     CHECK(FitSupercellProbe(SupercellProbeClass{}).b == 0.0);
 }
+
+TEST_CASE("DoubledLattice", "[SupercellProbe]") {
+    const CrystalLattice prim(Coord(40, 0, 0), Coord(0, 50, 0), Coord(0, 0, 60));
+    // Class 0 0 1: the c axis doubled, the others kept.
+    const CrystalLattice c2 = DoubledLattice(prim, {0, 0, 1});
+    CHECK(c2.Vec0().x == Catch::Approx(40.0));
+    CHECK(c2.Vec1().y == Catch::Approx(50.0));
+    CHECK(c2.Vec2().z == Catch::Approx(120.0));
+    // Class 1 1 0: a centred doubling of the ab plane - twice a, and b plus a - so every vector of the
+    // supercell has h + k even, at twice the volume.
+    const CrystalLattice ab = DoubledLattice(prim, {1, 1, 0});
+    CHECK(std::fabs(ab.CalcVolume()) == Catch::Approx(2.0 * 40 * 50 * 60));
+    CHECK(ab.Vec0().x == Catch::Approx(80.0));
+    CHECK(ab.Vec1().x == Catch::Approx(40.0));
+    CHECK(ab.Vec1().y == Catch::Approx(50.0));
+    CHECK(ab.Vec2().z == Catch::Approx(60.0));
+}
+
+TEST_CASE("PostIndexingRefinement_CoplanarCandidateIsRejected", "[Indexing]") {
+    // A candidate whose three rows lie in one plane passes every length and angle test - three rows
+    // 120 deg apart in a plane meet the 30-150 deg window - and every spot along the plane normal
+    // indexes as (0,0,0), so the spot count passes too. Such a cell has no reciprocal basis; handed
+    // on, it made the online analysis throw "Crystal lattice is coplanar" for the frame instead of
+    // leaving the frame unindexed.
+    const Coord a(50, 0, 0);
+    const Coord b(-25, 25.0f * std::sqrt(3.0f), 0);
+    const Coord c(-25, -25.0f * std::sqrt(3.0f), 0);
+    REQUIRE(CrystalLattice(a, b, c).VolumeFraction() < MIN_BASIS_VOLUME_FRACTION);
+
+    std::vector<Coord> spots;
+    for (int i = 1; i <= 40; i++)
+        spots.emplace_back(0.0f, 0.0f, 0.01f * static_cast<float>(i));
+
+    Eigen::MatrixX3<float> cells(3, 3);
+    cells << a.x, a.y, a.z,
+             b.x, b.y, b.z,
+             c.x, c.y, c.z;
+    // A score below the refinement's distance floor, so the candidate reaches the filters as given.
+    Eigen::VectorX<float> scores(1);
+    scores << -10.99f;
+
+    RefineParameters parameters{
+        .viable_cell_min_spots = 9,
+        .dist_tolerance_vs_reference = 0.05,
+        .reference_unit_cell = std::nullopt,
+        .min_length_A = 5,
+        .max_length_A = 500,
+        .min_angle_deg = 30,
+        .max_angle_deg = 150,
+        .indexing_tolerance = 0.1
+    };
+
+    const auto lattices = Refine(spots, spots.size(), cells, scores, parameters);
+    CHECK(lattices.empty());
+    for (const auto &l: lattices)
+        CHECK_NOTHROW(l.GetUBMatrix());
+}