mx/Jungfraujoch
2
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 79 Wiki Activity
Files
508fcfb400aad5b01aee9f0af5e3ef95cbaffbd3
Jungfraujoch/tests/SearchSpaceGroupTest.cpp
T
leonarski_fandClaude Opus 5 7a6df3c24a Space group: say which axis a screw could not be decided on 
A screw axis whose row the sweep never recorded - it lies in the spindle's
blind cone, or outside the resolution range - is not a group the data refused,
it is a question nobody asked. The search already offered the whole set in
SPACE_GROUP_ALTERNATIVES, but the per-zone screw table that would say it in
words is printed for the SELECTED candidate only, and the selected candidate
in exactly this case is the one with no screw zones, so the run's account of
the open axis was a blank.

The search now names the axes on which two SELECTED candidates disagree about
whether the row carries screw absences at all, with why the row could not be
judged (never recorded / no control class). The report writes the axes as
SPACE_GROUP_SCREW_UNDETERMINED= beside SPACE_GROUP_ALTERNATIVES and explains
them in prose; the adoption logs a warning naming the axis and the set. An
enantiomorphic or origin-ambiguous pair predicts the same absences on every
row and is not named here - that ambiguity is the hand, or the origin.

Nothing about the decision moves: the group adopted, the alternatives and the
written .mtz/.cif/.hkl are exactly as before, because a reflection file cannot
hold "maybe a screw".

The battery scorer mirrors its existing "hand only" rule: a set differing from
its reference only by a screw the run reports as undeterminable, with the
reference among the groups it offered, scores unscored/screw_undetermined
instead of a sym_screw failure. All three conditions are necessary, so a screw
called wrongly where the row WAS measured stays a failure.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013nW6FNRP1bBJJ8pfHiByAT
2026-09-20 18:45:17 +02:00

703 lines
34 KiB
C++
Raw Blame History

#include <catch2/catch_all.hpp>
#include "../image_analysis/scale_merge/SearchSpaceGroup.h"
#include "gemmi/symmetry.hpp"
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <string>
#include <tuple>
#include <unordered_set>
#include <vector>
namespace {
struct HKL {
int h = 0;
int k = 0;
int l = 0;
bool operator==(const HKL& o) const noexcept {
return h == o.h && k == o.k && l == o.l;
}
};
struct HKLHash {
size_t operator()(const HKL& x) const noexcept {
auto mix = [](uint64_t v) {
v ^= v >> 33;
v *= 0xff51afd7ed558ccdULL;
v ^= v >> 33;
v *= 0xc4ceb9fe1a85ec53ULL;
v ^= v >> 33;
return v;
};
return static_cast<size_t>(
mix(static_cast<uint64_t>(x.h)) ^
(mix(static_cast<uint64_t>(x.k)) << 1) ^
(mix(static_cast<uint64_t>(x.l)) << 2));
}
};
double CalcSyntheticD(int h, int k, int l) {
const double q2 = static_cast<double>(h * h + k * k + l * l);
return 40.0 / std::sqrt(q2 + 1.0);
}
double SyntheticIntensityFromAsu(const gemmi::Op::Miller& asu) {
uint64_t x = static_cast<uint64_t>((asu[0] + 31) * 73856093u) ^
static_cast<uint64_t>((asu[1] + 37) * 19349663u) ^
static_cast<uint64_t>((asu[2] + 41) * 83492791u);
x ^= x >> 13;
x *= 0x9e3779b97f4a7c15ULL;
x ^= x >> 17;
return 100.0 + static_cast<double>(x % 500);
}
std::vector<MergedReflection> GenerateMergedReflectionsForSpaceGroup(
const gemmi::SpaceGroup& sg,
int hmax = 8) {
std::vector<MergedReflection> merged;
std::unordered_set<HKL, HKLHash> added;
const gemmi::GroupOps gops = sg.operations();
const gemmi::ReciprocalAsu rasu(&sg);
for (int h = -hmax; h <= hmax; ++h) {
for (int k = -hmax; k <= hmax; ++k) {
for (int l = -hmax; l <= hmax; ++l) {
if (h == 0 && k == 0 && l == 0)
continue;
bool absent = false;
gemmi::Op::Miller hkl{{h, k, l}};
if (gops.is_systematically_absent(hkl))
absent = true;
const auto [asu, sign_plus] = rasu.to_asu_sign(hkl, gops);
if (!sign_plus)
continue;
const HKL key{h, k, l};
if (added.find(key) != added.end())
continue;
added.insert(key);
merged.push_back(MergedReflection{
.h = h,
.k = k,
.l = l,
.I = static_cast<float>(absent ? 0.0 : SyntheticIntensityFromAsu(asu)),
.sigma = 1.0,
.d = static_cast<float>(CalcSyntheticD(h, k, l))
});
}
}
}
return merged;
}
}
TEST_CASE("SearchSpaceGroup detects synthetic space groups") {
struct Case {
std::string input_name;
std::string expected_short_name;
};
const std::vector<Case> cases = {
{"P 1", "P1"},
{"P 1 2 1", "P2"},
{"P 3 2 1", "P321"},
{"P 4 2 2", "P422"},
{"P 4 3 2", "P432"},
{"P 43 21 2", "P43212"},
{"P 6 2 2", "P622"},
{"C 1 2 1", "C2"},
{"C 2 2 2", "C222"},
{"I 4 3 2", "I432"},
{"I 21 21 21", "I212121"},
{"I 2 1 3", "I213"},
};
for (const auto& tc : cases) {
DYNAMIC_SECTION(tc.expected_short_name) {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name(tc.input_name);
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
const auto result = SearchSpaceGroup(merged, opt);
// Several inputs cannot be told apart from intensities alone: enantiomorphic partners
// (P4_3 vs P4_1) and origin-ambiguous pairs (I2_12_12_1 vs I222, I2_13 vs I2_3) share
// the same systematic absences. The search reports those as alternatives, so the
// expected group must appear among the best group and its alternatives.
std::vector<std::string> accepted;
if (result.best_space_group.has_value())
accepted.push_back(result.best_space_group->short_name());
for (const auto& alt : result.alternatives)
accepted.push_back(alt.short_name());
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(std::find(accepted.begin(), accepted.end(), tc.expected_short_name) != accepted.end());
}
}
}
// Regression: a real screw axis whose systematically-absent reflections carry a genuinely weak
// intensity but an UNDER-estimated sigma (so their I/sigma clears the "present" cut) must still be
// found. Reproduces a monoclinic 2_1 miss on weakly-diffracting monoclinic data, where the merged sigmas on
// the 0k0-odd reflections were ~2x too small and faked screw-axis violations. The E^2 intensity gate
// (present_e_squared) is what keeps those reflections classified absent.
TEST_CASE("SearchSpaceGroup finds a screw axis despite under-estimated sigmas on absent reflections") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 21 1");
auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 18);
// Every systematically-absent (0k0, k odd) reflection: small-but-nonzero intensity (~2% of a
// normal reflection) with a far-too-small sigma, so I/sigma ~ 27 fakes a "present" reflection.
const gemmi::GroupOps gops = sg.operations();
int absent_count = 0;
for (auto& r : merged) {
const gemmi::Op::Miller hkl{{r.h, r.k, r.l}};
if (gops.is_systematically_absent(hkl)) {
r.I = 8.0f;
r.sigma = 0.3f;
++absent_count;
}
}
REQUIRE(absent_count >= 8); // enough predicted-absent reflections to be trusted
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
SECTION("intensity gate on (default): screw recovered") {
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->short_name() == "P21");
}
SECTION("intensity gate off (I/sigma only): the deferral recovers the screw anyway") {
// This section used to document the failure the E^2 gate fixes - with I/sigma alone the
// too-small sigmas fake violations and the search fell back to the symmorphic group. There
// are now TWO independent defences and the second one holds here without the first: the
// fabricated violations are still counted, but the absent class sits at 2% of its own row,
// so the zone is dead per reflection and carries no measured pseudo-translation, which is
// what licenses the absence evidence to override the count.
//
// Kept rather than deleted, because it pins the two apart: if a future change makes this
// read P2 again, the deferral has stopped licensing a zone that is genuinely extinct.
opt.present_e_squared = 0.0;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->short_name() == "P21");
}
}
// Regression: the E^2 gate above compares a reflection to the mean of its RESOLUTION SHELL, which
// falls off with resolution, while a systematically-absent reflection keeps a small non-decaying
// residual (background / profile leakage). On a crystal whose axial rows are much stronger than an
// average reflection, that turns the high-resolution residuals into screw-axis violations and the
// screw is lost, although the reflections beside them in the same row are tens of times stronger.
// A tetragonal 42_12 case failed exactly this way (18 of 47 absent 00l over the cut, all beyond
// 3.7 A, at 1-2% of the l=4n reflections next to them). The threshold is therefore taken relative to
// the axial row the screw constrains, not to the shell.
TEST_CASE("SearchSpaceGroup finds a screw axis whose absent class is weak only within its own row") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 43 21 2");
auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 12);
// Axial rows 40x stronger than a general reflection, and an absent class carrying ~2% of its own
// row - but half of a general reflection, so a threshold set against the shell calls every one of
// them a violation while a threshold set against the row calls none.
const gemmi::GroupOps gops = sg.operations();
int absent_on_axis = 0;
for (auto& r : merged) {
const gemmi::Op::Miller hkl{{r.h, r.k, r.l}};
if (gops.epsilon_factor_without_centering(hkl) <= 1)
continue;
if (gops.is_systematically_absent(hkl)) {
r.I = 300.0f;
r.sigma = 1.0f;
++absent_on_axis;
} else {
r.I *= 40.0f;
}
}
REQUIRE(absent_on_axis >= 8);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
// P4_1 2_1 2 and P4_3 2_1 2 are enantiomorphs and indistinguishable from intensities.
std::vector<std::string> accepted{result.best_space_group->short_name()};
for (const auto& alt : result.alternatives)
accepted.push_back(alt.short_name());
CHECK(std::find(accepted.begin(), accepted.end(), "P43212") != accepted.end());
}
// Regression: a screw's predicted-absent class is one row of reciprocal space, and that row is often
// the one a rotation sweep records least - it lies near the spindle, where the blind cusp maps onto
// itself and symmetry cannot fill it in. Counting the class therefore measures the geometry of the
// sweep, not the strength of the evidence, and a count gate refused a monoclinic crystal its 2_1 for
// having six 0k0-odd reflections rather than eight, every one of them measured at a thousandth of the
// row beside them. The class is judged by ScrewZoneEvidence instead, which reads the contrast
// against the row - so few-but-decisive is accepted and many-but-marginal is not.
TEST_CASE("SearchSpaceGroup weighs a screw's absences by evidence, not by how many were recorded") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 21 1");
const gemmi::GroupOps gops = sg.operations();
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
SECTION("five decisive absences, below min_absent_observed: the screw is still found") {
auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 18);
// Keep five of the 0k0-odd reflections, at a thousandth of their row, and drop the rest - as a
// sweep along the 2-fold does, leaving too few to satisfy a count but plenty to decide.
int kept = 0;
std::erase_if(merged, [&](MergedReflection& r) {
if (!gops.is_systematically_absent(gemmi::Op::Miller{{r.h, r.k, r.l}}))
return false;
if (kept >= 5)
return true;
++kept;
r.I = 0.5;
return false;
});
REQUIRE(kept == 5);
REQUIRE(kept < opt.min_absent_observed);
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->short_name() == "P21");
}
SECTION("a uniformly weak axial row decides nothing, however many absences it holds") {
// The whole 0k0 row badly measured: the predicted-absent reflections are weak, but so is the
// rest of their row, so there is no contrast and no screw to claim. A violation count cannot
// see this - nothing on the row clears an absolute cut, so it reads zero violations and, with
// enough reflections to satisfy the count, would claim the 2_1 from no evidence at all.
auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 18);
int absent_on_row = 0;
for (auto& r : merged) {
if (r.h != 0 || r.l != 0)
continue;
const bool absent = gops.is_systematically_absent(gemmi::Op::Miller{{r.h, r.k, r.l}});
r.I = absent ? 4.0 : 5.0;
absent_on_row += absent ? 1 : 0;
}
REQUIRE(absent_on_row >= opt.min_absent_observed);
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->short_name() == "P2");
}
}
// The operator correlation is on resolution-normalised E^2, not on raw I (see SearchSpaceGroup.cpp).
// Both members of a symmetry pair sit at the same |s|, so on raw intensities the resolution fall-off
// is variance shared perfectly between the two arms of every pair and reads as a correlation for ANY
// pairing at all. These two cases pin that down from both sides.
TEST_CASE("SearchSpaceGroup operator correlation reads symmetry, not the resolution fall-off",
"[SearchSpaceGroup]") {
// Intensities that are a smooth function of resolution times an INDEPENDENT per-reflection
// factor: a Wilson-like fall-off with no symmetry in it whatsoever.
auto radial_only = [](int hmax) {
std::vector<MergedReflection> merged;
for (int h = -hmax; h <= hmax; ++h)
for (int k = -hmax; k <= hmax; ++k)
for (int l = -hmax; l <= hmax; ++l) {
if ((h == 0 && k == 0 && l == 0) || std::make_tuple(-h, -k, -l) < std::make_tuple(h, k, l))
continue;
const double d = CalcSyntheticD(h, k, l);
const double falloff = std::exp(-30.0 / (d * d));
// Deterministic, independent of any symmetry mate: reuse the hash on the raw index.
const double jitter = SyntheticIntensityFromAsu(gemmi::Op::Miller{{h, k, l}}) / 350.0;
const double I = 1.0e5 * falloff * jitter;
merged.push_back(MergedReflection{
.h = h, .k = k, .l = l, .I = static_cast<float>(I),
.sigma = static_cast<float>(I / 20.0), .d = static_cast<float>(d)});
}
return merged;
};
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
SECTION("a fall-off with no symmetry in it confirms no operator") {
const auto result = SearchSpaceGroup(radial_only(8), opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.operator_scores.size() > 1);
for (const auto& s : result.operator_scores) {
INFO("operator " << s.op_triplet_hkl);
CHECK(s.n_pairs >= opt.min_pairs_per_operator);
CHECK(s.cc < opt.min_operator_cc);
CHECK_FALSE(s.present);
}
CHECK(result.point_group_hm == "1");
}
SECTION("a real operator under the same fall-off is confirmed, and does not move with the cut") {
// Same fall-off, but the intensities now carry a genuine monoclinic 2-fold.
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 2 1");
const gemmi::ReciprocalAsu rasu(&sg);
const gemmi::GroupOps gops = sg.operations();
auto merged = radial_only(8);
for (auto& r : merged) {
const auto [asu, plus] = rasu.to_asu_sign(gemmi::Op::Miller{{r.h, r.k, r.l}}, gops);
const double falloff = std::exp(-30.0 / (r.d * r.d));
r.I = 1.0e5 * falloff * SyntheticIntensityFromAsu(asu) / 350.0;
r.sigma = r.I / 20.0;
}
auto two_fold_cc = [&](double d_min) {
SearchSpaceGroupOptions o = opt;
o.d_min_limit_A = d_min;
const auto result = SearchSpaceGroup(merged, o);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.point_group_hm == "2");
double cc = -2.0;
for (const auto& s : result.operator_scores)
if (s.present)
cc = s.cc;
REQUIRE(cc > opt.min_operator_cc);
return cc;
};
// The whole point of normalising: how much of the fall-off is inside the merge no longer
// moves the operator's score, so the search resolution cut cannot decide the symmetry.
CHECK(std::fabs(two_fold_cc(0.0) - two_fold_cc(6.0)) < 0.05);
}
}
// The enumeration reaches the settings gemmi does not call the reference one, and only when the cell
// has the axes they name. Both halves are pinned here: `P 1 1 2_1` puts its 2-fold and its screw on
// c, which no reference setting can express (Stage A never offers the rotation and Stage B never
// offers the group), so without the two options the answer is P1; with them, and with a cell whose
// unique axis IS c, it is named; and with a cell whose unique axis is b the same candidate is
// refused rather than adopted on axes the crystal does not have.
TEST_CASE("SearchSpaceGroup names a non-reference setting only on a cell that hosts it") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 1 21");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 12);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
SECTION("narrow enumeration cannot name it") {
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->number == 1);
}
SECTION("widened enumeration names it on a c-unique cell") {
opt.cell = gemmi::UnitCell(40.0, 50.0, 60.0, 90.0, 90.0, 100.0);
opt.enumerate_all_settings = true;
opt.enumerate_all_rotation_sets = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->xhm() == "P 1 1 21");
}
SECTION("a b-unique cell refuses it") {
opt.cell = gemmi::UnitCell(40.0, 50.0, 60.0, 90.0, 100.0, 90.0);
opt.enumerate_all_settings = true;
opt.enumerate_all_rotation_sets = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->number == 1);
}
}
// The screw axes of an orthorhombic crystal can lie on any pair of axes, and only one of the three
// namings of #18 is a reference setting. With the narrow enumeration the group that predicts a
// SUBSET of the real absences and nothing else wins on no evidence at all, so the reported group is
// wrong rather than low - the widening is what makes the correct one available.
TEST_CASE("SearchSpaceGroup names an orthorhombic screw pair on the axes it lies on") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 2 21 21");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 14);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.lattice_system = gemmi::CrystalSystem::Orthorhombic;
SECTION("narrow enumeration reports the wrong group") {
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->number != 18);
}
SECTION("widened enumeration reports it") {
opt.cell = gemmi::UnitCell(40.0, 50.0, 60.0, 90.0, 90.0, 90.0);
opt.enumerate_all_settings = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->xhm() == "P 2 21 21");
}
}
// A screw on a row the sweep never recorded is not a group the data refused, it is a question
// nobody asked: the run writes the member claiming no screw because a reflection file must carry
// one group, and without this the only trace of the ambiguity is a list of names that does not say
// which axis is open. Modelled on a real hexagonal set whose 00l row lies in the spindle's blind
// cone and which is reported as P 6 against a deposited P 63.
TEST_CASE("SearchSpaceGroup says which axis a missing row left the screw open on",
"[SearchSpaceGroup]") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 21 21 21");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 14);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.lattice_system = gemmi::CrystalSystem::Orthorhombic;
SECTION("every row measured - nothing is open") {
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->xhm() == "P 21 21 21");
CHECK(result.undetermined_screws.empty());
}
SECTION("the 00l row removed - the c screw is undetermined") {
std::vector<MergedReflection> without_00l;
for (const auto& r : merged)
if (r.h != 0 || r.k != 0)
without_00l.push_back(r);
const auto result = SearchSpaceGroup(without_00l, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
REQUIRE(result.undetermined_screws.size() == 1);
CHECK(result.undetermined_screws[0].axis == 'c');
CHECK(result.undetermined_screws[0].row_label == "00l");
CHECK(result.undetermined_screws[0].n_observed == 0);
// The a and b screws were measured and are unaffected: what the missing row costs is the
// third condition, not the two the data still carry.
CHECK(result.best_space_group->operations().is_systematically_absent({{1, 0, 0}}));
CHECK(result.best_space_group->operations().is_systematically_absent({{0, 1, 0}}));
// ...and the group the c row would have decided between is offered, not silently dropped.
bool offers_a_group_without_the_c_screw = false;
for (const auto& alt : result.alternatives)
if (!alt.operations().is_systematically_absent({{0, 0, 1}}))
offers_a_group_without_the_c_screw = true;
CHECK((offers_a_group_without_the_c_screw
|| !result.best_space_group->operations().is_systematically_absent({{0, 0, 1}})));
}
}
// The centring half of the same widening. A, B and C centring on one orthorhombic cell are three
// different lattices, and only C is a reference setting, so an A-centred crystal used to have its
// centring refused (its absent class is not the one C predicts) and came out primitive. The
// candidate is now offered, and it has to be adopted from its own absences rather than from the
// metric, which cannot tell A from C at all.
TEST_CASE("SearchSpaceGroup names an A-centred orthorhombic lattice") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("A 2 2 2");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 12);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.lattice_system = gemmi::CrystalSystem::Orthorhombic;
SECTION("narrow enumeration cannot name it") {
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->centring_type() != 'A');
}
SECTION("widened enumeration names it") {
opt.cell = gemmi::UnitCell(40.0, 50.0, 60.0, 90.0, 90.0, 90.0);
opt.enumerate_all_settings = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->xhm() == "A 2 2 2");
}
}
// The null the widening has to survive. Stage A's second pass offers the a- and c-unique 2-folds on
// any metric that could host them, which is every orthorhombic one - so a genuinely triclinic
// crystal sitting on a pseudo-orthorhombic cell is now offered three promotions where it used to be
// offered one. It must still be refused all three: the added candidates go through the same operator
// correlation as every other, and a rotation the intensities do not have scores nothing.
TEST_CASE("SearchSpaceGroup does not promote triclinic data on a pseudo-orthorhombic cell") {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 10);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.lattice_system = gemmi::CrystalSystem::Orthorhombic;
opt.cell = gemmi::UnitCell(40.0, 50.0, 60.0, 90.0, 90.0, 90.0);
opt.enumerate_all_settings = true;
opt.enumerate_all_rotation_sets = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->number == 1);
CHECK(result.point_group_order == 1);
}
// A screw zone is a handful of axial reflections and its evidence is a SUM over them, so it is
// decided by its largest member. Measured on a monoclinic crystal whose eight absent 0k0 are dead in
// every run: between two scaling passes that differed only in which weak frames were rejected, ONE
// of the eight moved from 14 +- 9 to 99 +- 10 (its two half-set merges reading 198 and 2.5, so it
// was never measured to the precision its sigma claimed) while the other seven did not move at all -
// and the zone went from 30.1 nats to 17.1 and lost the 2(1) under a bound of 20. Trimming the
// largest member and rescaling for the trim makes the two passes agree.
TEST_CASE("A screw zone's evidence does not hang on its largest absence", "[SearchSpaceGroup]") {
// Seven reflections at a hundredth of their row, and one that moved between the two passes.
const double dead_seven = 7 * 0.01;
const double before = ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.03, 0.03, 8), 8);
const double after = ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.39, 0.39, 8), 8);
CHECK(before == Catch::Approx(after).margin(0.01)); // the same seven reflections, the same verdict
CHECK(after > 20.0); // and the screw survives the move
// Untrimmed, that one reflection is the whole difference and it crosses the bound.
CHECK(ScrewZoneEvidence(dead_seven + 0.03, 8) > 20.0);
CHECK(ScrewZoneEvidence(dead_seven + 0.39, 8) < 20.0);
// Only ONE member is trimmed, whatever the zone holds: a zone with two strong absences is not a
// zone with a bad reflection in it, it is a zone that is not extinct.
CHECK(ScrewZoneEvidence(TrimmedZoneSum(dead_seven + 0.39 + 0.39, 0.39, 8), 8) < 20.0);
// On a uniform zone the rescale under-states rather than over-states - the safe direction.
CHECK(ScrewZoneEvidence(TrimmedZoneSum(8 * 0.01, 0.01, 8), 8) <
ScrewZoneEvidence(8 * 0.01, 8));
// A class that merged non-positive throughout is unchanged: sum and max are both zero, so the
// floor in ScrewZoneEvidence is what answers, exactly as before.
CHECK(TrimmedZoneSum(0.0, 0.0, 8) == 0.0);
}
// A zone whose predicted absences were never measurable must not outscore a zone that is genuinely
// dead. sum_u is a sum of max(0, E^2)/row_mean, so it is EXACTLY zero when every absent reflection in
// the zone merged non-positive - and the Beta tail then diverges, worth ~690 nats per reflection. That
// was harmless while the number only had to clear a bound; it is now summed across zones and ranks the
// candidates, so it made a candidate claiming a screw on an UNMEASURED row beat one whose rows are
// actually dead. The evidence is scored through the same entry point for both kinds of absence.
TEST_CASE("AbsenceEvidence does not reward a zone that was never measurable", "[SearchSpaceGroup]") {
// 2 absences that all merged non-positive, against a control of 8...
const double unmeasurable = AbsenceEvidence(0.0, 2, 8);
// ...against a genuinely dead zone: 6 absences at 1% of their row's mean, same control.
const double genuine = AbsenceEvidence(0.06, 6, 8);
CHECK(std::isfinite(unmeasurable));
CHECK(unmeasurable < genuine); // the ordering that was inverted
CHECK(unmeasurable < 20.0); // and it does not clear min_screw_absence_evidence
// The floor is far below any real measurement, so a genuine zone is untouched by it.
CHECK(genuine == Catch::Approx(22.0).margin(0.2));
CHECK(AbsenceEvidence(0.22, 22, 8) == Catch::Approx(65.4).margin(0.3));
// More dead reflections still means more evidence, which is the property the sum relies on.
CHECK(AbsenceEvidence(0.0, 6, 8) > AbsenceEvidence(0.0, 2, 8));
}
// ---------------------------------------------------------------------------------------------
// Glide planes (small-molecule space groups).
//
// A glide extinguishes a two-dimensional ZONE where a screw extinguishes a row, so it is the same
// absence test on a plane. What these cases pin is not that the test works - it is the two places
// it must NOT act: on a Sohncke group (a chiral crystal has no glide, and the corpus measurement
// that licensed this feature is a zero false-positive rate on 140 protein datasets), and on an
// inversion centre (Friedel's law makes it unmeasurable, so it must never be claimed).
// ---------------------------------------------------------------------------------------------
TEST_CASE("SearchSpaceGroup names a glide plane") {
struct Case {
std::string input_name;
std::string expected_xhm;
gemmi::UnitCell cell;
};
const gemmi::UnitCell monoclinic(11.0, 13.0, 17.0, 90.0, 101.0, 90.0);
const gemmi::UnitCell orthorhombic(11.0, 13.0, 17.0, 90.0, 90.0, 90.0);
const std::vector<Case> cases = {
// The reference setting, and the non-reference one the same group takes when the data are
// indexed with the glide on a: a setting names the mirror by AXIS, so both have to be
// reachable or a crystal indexed the other way round is named wrongly or not at all.
{"P 1 21/c 1", "P 1 21/c 1", monoclinic},
{"P 1 21/a 1", "P 1 21/a 1", monoclinic},
{"C 1 2/c 1", "C 1 2/c 1", monoclinic},
// Three glide planes at once: every zone must be dead, not just the best one.
{"P b c a", "P b c a", orthorhombic},
};
for (const auto& tc : cases) {
DYNAMIC_SECTION(tc.expected_xhm) {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name(tc.input_name);
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 10);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.cell = tc.cell;
opt.enumerate_all_settings = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->xhm() == tc.expected_xhm);
// The Sohncke answer is reported alongside on the same run, so a reader who knows the
// sample is chiral never has to process the images again to see it.
CHECK(result.sohncke_space_group.has_value());
CHECK(result.sohncke_space_group->is_sohncke());
REQUIRE_FALSE(result.glide_zones.empty());
for (const auto& z : result.glide_zones)
CHECK(z.evidence_per_reflection >= opt.min_glide_evidence_per_reflection);
}
}
}
// The inert direction, which is the one that matters: a chiral crystal has no glide plane, so on
// Sohncke data the glide machinery must add nothing at all - not a different group, not a zone.
TEST_CASE("SearchSpaceGroup claims no glide on Sohncke data") {
const gemmi::UnitCell monoclinic(11.0, 13.0, 17.0, 90.0, 101.0, 90.0);
for (const std::string name : {"P 1 21 1", "P 1 2 1", "C 1 2 1"}) {
DYNAMIC_SECTION(name) {
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name(name);
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 10);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.cell = monoclinic;
opt.enumerate_all_settings = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->is_sohncke());
CHECK_FALSE(result.glide_space_group.has_value());
CHECK(result.glide_zones.empty());
}
}
}
// The centre of symmetry is NOT determinable and must never be claimed: Friedel's law makes the
// diffraction pattern centrosymmetric whether or not the crystal is, so P 1 2/m 1 predicts exactly
// what P 1 2 1 predicts. Data generated in the centrosymmetric group must still come out Sohncke -
// which is the enumeration refusing any non-Sohncke group whose absences a Sohncke one already has.
TEST_CASE("SearchSpaceGroup never claims an inversion centre") {
const gemmi::UnitCell monoclinic(11.0, 13.0, 17.0, 90.0, 101.0, 90.0);
const gemmi::SpaceGroup& sg = gemmi::get_spacegroup_by_name("P 1 2/m 1");
const auto merged = GenerateMergedReflectionsForSpaceGroup(sg, 10);
SearchSpaceGroupOptions opt;
opt.merge_friedel = true;
opt.cell = monoclinic;
opt.enumerate_all_settings = true;
const auto result = SearchSpaceGroup(merged, opt);
INFO(SearchSpaceGroupResultToText(result));
REQUIRE(result.best_space_group.has_value());
CHECK(result.best_space_group->is_sohncke());
CHECK_FALSE(result.glide_space_group.has_value());
}
Reference in New Issue View Git Blame Copy Permalink