v1.0.0-rc.166 (#76)

* `rugnux --mode calibration` writes `<prefix>.json` beside the `.poni`, whose `dataset_settings` member is a `jfjoch_broker` `dataset_settings` body as it stands.
* `rugnux` and `jfjoch_viewer` read PILATUS miniCBF sweeps natively, without conversion.
* Masters written by other facilities open, including Eiger 1.x and third-party NXmx variants.
* `rugnux` measures the beam centre on every run, and indexes with it when the file's value indexes nothing.
* A detector swung out on a 2theta arm is placed where the file says it stands, and the calibration can hold the tilt fixed.
* `rugnux` writes the unmerged MTZ by default, and a P1 merge beside it, so a wrong space group can be re-merged without reprocessing.
* Significant improvements to symmetry handling in `rugnux`: the lattice, the point group, the setting and the systematic absences.
* The `rugnux` report gives the resolution the CC1/2 fit reached, beside the range the reflections were written to.
* The `rugnux` report gives the twinning statistics measured before the space group was decided, beside the ones measured after.
* The `rugnux` report gives the strong-direction diffraction limit, and warns when CC1/2 is not monotone with resolution.
* `rugnux` ranks screw axes on the evidence their absences carry, rather than on how many control reflections a candidate happens to have.
* Twinning is no longer reported when the L-test contradicts it.
* The `rugnux` report gives the detector tilt, the measured tilt and the direct beam beside the beam centre, and a post-refined beam centre is judged against the run's own measurement rather than the file's.
* `--no-refine-tilt` holds the detector tilt at the value in the file, instead of zeroing it, when the calibration starts from the spots.
* The `jfjoch_viewer` grid scan view draws the cells in the proportion of the scan steps, so the map has the shape of the scanned area.

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

tests/ReindexAmbiguityTest.cpp

@@ -11,6 +11,8 @@
 #include "../image_analysis/scale_merge/ReindexAmbiguity.h"
 
 namespace {
+    const gemmi::SpaceGroup &SG(int number) { return *gemmi::find_spacegroup_by_number(number); }
+
     UnitCell Tetragonal() { return UnitCell{78.0f, 78.0f, 37.0f, 90.0f, 90.0f, 90.0f}; }
 
     // A reference set: one distinct intensity per Laue-ASU reflection, so that reflections related by
@@ -38,28 +40,28 @@ namespace {
 
 TEST_CASE("Reindex: holohedral crystal has no indexing ambiguity", "[reindex]") {
     // P4(3)2(1)2 (422, holohedral for the tetragonal lattice) -> no twin laws.
-    CHECK(ReindexAmbiguityOperators(Tetragonal(), 96).empty());
+    CHECK(ReindexAmbiguityOperators(Tetragonal(), SG(96)).empty());
     // P422 likewise.
-    CHECK(ReindexAmbiguityOperators(Tetragonal(), 89).empty());
+    CHECK(ReindexAmbiguityOperators(Tetragonal(), SG(89)).empty());
 }
 
 TEST_CASE("Reindex: merohedral crystal exposes the ambiguity operators", "[reindex]") {
     // P4 (point group 4) in a tetragonal lattice (422) -> a non-trivial reindexing coset.
-    CHECK_FALSE(ReindexAmbiguityOperators(Tetragonal(), 75).empty());
+    CHECK_FALSE(ReindexAmbiguityOperators(Tetragonal(), SG(75)).empty());
 }
 
 TEST_CASE("Reindex: reference agreement recovers a misindexed dataset", "[reindex]") {
     const int sg = 75;   // P4
     const auto reference = DistinctReference(sg);
-    const auto laws = ReindexAmbiguityOperators(Tetragonal(), sg);
+    const auto laws = ReindexAmbiguityOperators(Tetragonal(), SG(sg));
     REQUIRE_FALSE(laws.empty());
 
     // Deliberately mis-index the data by one twin law.
     const auto data = ReindexReflections(reference, laws.front());
 
     const auto choice = ChooseReindex(
-        data, Tetragonal(), sg,
-        [&](const std::vector<MergedReflection> &m) { return ReferenceIntensityCC(m, reference, sg); });
+        data, Tetragonal(), SG(sg),
+        [&](const std::vector<MergedReflection> &m) { return ReferenceIntensityCC(m, reference, SG(sg)); });
 
     CHECK_FALSE(choice.is_identity);                 // a reindex was needed
     CHECK(choice.score > 0.99);                      // the winner realigns with the reference
@@ -71,8 +73,8 @@ TEST_CASE("Reindex: a correctly indexed dataset keeps identity", "[reindex]") {
     const int sg = 75;
     const auto reference = DistinctReference(sg);
     const auto choice = ChooseReindex(
-        reference, Tetragonal(), sg,
-        [&](const std::vector<MergedReflection> &m) { return ReferenceIntensityCC(m, reference, sg); });
+        reference, Tetragonal(), SG(sg),
+        [&](const std::vector<MergedReflection> &m) { return ReferenceIntensityCC(m, reference, SG(sg)); });
     CHECK(choice.is_identity);
     CHECK(choice.score > 0.99);
 }
@@ -80,13 +82,13 @@ TEST_CASE("Reindex: a correctly indexed dataset keeps identity", "[reindex]") {
 TEST_CASE("Reindex into the ASU: a twin law permutes the reflections without losing any", "[reindex]") {
     const int sg = 75;   // P4
     const auto reference = DistinctReference(sg);
-    const auto laws = ReindexAmbiguityOperators(Tetragonal(), sg);
+    const auto laws = ReindexAmbiguityOperators(Tetragonal(), SG(sg));
     REQUIRE_FALSE(laws.empty());
 
     // Mis-index by a twin law, then reindex back into the ASU: the labels must land where an export
     // needs them, and the reflection the label carries must be the one the reference has there.
     const auto misindexed = ReindexReflections(reference, laws.front());
-    const auto fixed = ReindexMergedIntoAsu(misindexed, laws.front(), sg, /*merge_friedel=*/true);
+    const auto fixed = ReindexMergedIntoAsu(misindexed, laws.front(), SG(sg), /*merge_friedel=*/true);
     REQUIRE(fixed.size() == reference.size());
 
     const HKLKeyGenerator key(true, *gemmi::find_spacegroup_by_number(sg));
@@ -121,7 +123,7 @@ TEST_CASE("Reindex into the ASU: the change of hand swaps the Bijvoet halves", "
     r.I_plus = 110.0f; r.sigma_plus = 2.0f; r.I_minus = 90.0f; r.sigma_minus = 3.0f;
     r.F_plus = 10.5f; r.F_minus = 9.5f;
 
-    const auto merged = ReindexMergedIntoAsu({r}, sg->change_of_hand_op(), 96, /*merge_friedel=*/true);
+    const auto merged = ReindexMergedIntoAsu({r}, sg->change_of_hand_op(), SG(96), /*merge_friedel=*/true);
     REQUIRE(merged.size() == 1);
     CHECK(merged[0].h == asu.h);
     CHECK(merged[0].k == asu.k);
@@ -135,7 +137,7 @@ TEST_CASE("Reindex into the ASU: the change of hand swaps the Bijvoet halves", "
     CHECK(merged[0].F_minus == 10.5f);
 
     // With the mates kept apart the merge stores the minus hand at -hkl, so the row moves there.
-    const auto anom = ReindexMergedIntoAsu({r}, sg->change_of_hand_op(), 96, /*merge_friedel=*/false);
+    const auto anom = ReindexMergedIntoAsu({r}, sg->change_of_hand_op(), SG(96), /*merge_friedel=*/false);
     REQUIRE(anom.size() == 1);
     CHECK(anom[0].h == -asu.h);
     CHECK(anom[0].k == -asu.k);
@@ -168,7 +170,7 @@ TEST_CASE("Reindex into the ASU: both mates of an anomalous pair follow the same
     MergedReflection minus = plus;                   // same anomalous split, stored at -hkl_asu
     minus.h = -asu.h; minus.k = -asu.k; minus.l = -asu.l;
 
-    const auto out = ReindexMergedIntoAsu({plus, minus}, op, 75, /*merge_friedel=*/false);
+    const auto out = ReindexMergedIntoAsu({plus, minus}, op, SG(75), /*merge_friedel=*/false);
     REQUIRE(out.size() == 2);
 
     // The two rows are still one pair: same Laue label up to the Friedel sign, opposite hands.