leonarski_fandClaude Opus 5
26fc4b02b3
The adopted space group travelled the pipeline as a bare int and was rebuilt downstream with find_spacegroup_by_number, which returns the reference setting. So every setting a number cannot name was destroyed one line after it was determined: P 1 1 2 came back as P 1 2 1, I 1 1 2 as C 1 2 1, R 3:R as R 3:H. DatasetSettings now holds the gemmi::SpaceGroup itself, DiffractionExperiment exposes it as GetGemmiSpaceGroup() / GetSpaceGroupOrP1(), and everything that used to take an int - HKLKeyGenerator (its int constructor is gone, so the compiler finds the callers), the merge, the R-free flags, French-Wilson, the reindexing ambiguity, the completeness enumeration, the MTZ and mmCIF exports, the model validation - takes the group. -S keeps the setting the symbol names rather than reducing it to a number. The end message carries both spellings and a reader prefers the name, since only the name keeps the setting while the number is what a reader written before the name understands. It carries them over CBOR too: the determined group was never serialised at all, so a group rugnux chose reached the master file only when the same process wrote it, and an online writer fell back to whatever the user had supplied at the start. Both keys are optional additions, so an older reader skips them and a newer one reads an older sender. On disk the master's /entry/sample/space_group carries the extended Hermann-Mauguin name and is what the reader takes the group from, so a setting survives a _process.h5 and the --mode scale that re-reads it; the number stays beside it and is the fallback for files written before. Every one of the 230 reference settings the old writer could produce reads back as itself, so older files are unaffected. Stage A and Stage B of the search still enumerate reference settings only, so this determines no group differently today - it is what the enumeration needs before it can be widened. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01EFEJG6WBQv8th4UJFNe53N
107 lines
3.3 KiB
C++
107 lines
3.3 KiB
C++
// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
#include <cmath>
|
|
|
|
#include "HKLKey.h"
|
|
#include "gemmi/symmetry.hpp"
|
|
|
|
uint64_t HKLKey::pack() const {
|
|
constexpr int bits = 21;
|
|
constexpr int bias = 1 << (bits - 1); // 1,048,576
|
|
constexpr int max_value = bias - 1;
|
|
constexpr int min_value = -bias;
|
|
constexpr std::uint64_t mask = (1ULL << bits) - 1ULL;
|
|
|
|
if (h < min_value || h > max_value ||
|
|
k < min_value || k > max_value ||
|
|
l < min_value || l > max_value) {
|
|
throw std::out_of_range("HKL index outside packable range");
|
|
}
|
|
|
|
const std::uint64_t hh = static_cast<std::uint64_t>(h + bias) & mask;
|
|
const std::uint64_t kk = static_cast<std::uint64_t>(k + bias) & mask;
|
|
const std::uint64_t ll = static_cast<std::uint64_t>(l + bias) & mask;
|
|
|
|
return (hh << 1) | (kk << (bits + 1)) | (ll << (2 * bits + 1)) | (plus ? 1ULL : 0ULL);
|
|
}
|
|
|
|
HKLKeyGenerator::HKLKeyGenerator(bool merge_friedel, const gemmi::SpaceGroup &sg)
|
|
: merge_friedel(merge_friedel),
|
|
sg(sg),
|
|
ops(sg.operations()),
|
|
asu(&sg) {
|
|
}
|
|
|
|
HKLKey HKLKeyGenerator::operator()(const MergedReflection &r) const {
|
|
return operator()(r.h, r.k, r.l);
|
|
}
|
|
|
|
HKLKey HKLKeyGenerator::operator()(const Reflection &r) const {
|
|
return operator()(r.h, r.k, r.l);
|
|
}
|
|
|
|
HKLKey HKLKeyGenerator::operator()(int32_t h, int32_t k, int32_t l) const {
|
|
HKLKey key{h, k, l, true};
|
|
|
|
if (sg.number == 1) {
|
|
const HKLKey neg{-h, -k, -l, true};
|
|
if (std::tie(key.h, key.k, key.l) < std::tie(neg.h, neg.k, neg.l)) {
|
|
key.h = -key.h;
|
|
key.k = -key.k;
|
|
key.l = -key.l;
|
|
key.plus = merge_friedel;
|
|
}
|
|
} else {
|
|
const gemmi::Op::Miller in{h, k, l};
|
|
const auto [hkl, sign_plus] = asu.to_asu_sign(in, ops);
|
|
|
|
key.h = hkl[0];
|
|
key.k = hkl[1];
|
|
key.l = hkl[2];
|
|
key.plus = merge_friedel ? true : sign_plus;
|
|
}
|
|
return key;
|
|
}
|
|
|
|
bool HKLKeyGenerator::IsSystematicallyAbsent(int32_t h, int32_t k, int32_t l) const {
|
|
return ops.is_systematically_absent(gemmi::Op::Miller{h, k, l});
|
|
}
|
|
|
|
bool HKLKeyGenerator::IsSystematicallyAbsent(const Reflection &r) const {
|
|
return IsSystematicallyAbsent(r.h, r.k, r.l);
|
|
}
|
|
|
|
bool AcceptReflection(const Reflection &r, std::optional<double> d_min_limit, std::optional<double> d_max_limit) {
|
|
if (!std::isfinite(r.I))
|
|
return false;
|
|
if (!std::isfinite(r.d) || r.d <= 0.0f)
|
|
return false;
|
|
if (d_min_limit && r.d < d_min_limit)
|
|
return false;
|
|
if (d_max_limit && r.d > d_max_limit)
|
|
return false;
|
|
if (!std::isfinite(r.rlp) || r.rlp == 0.0f)
|
|
return false;
|
|
if (!std::isfinite(r.sigma) || r.sigma <= 0.0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool AcceptReflection(const Reflection &r, double d_min_limit, double d_max_limit) {
|
|
if (!std::isfinite(r.I))
|
|
return false;
|
|
if (!std::isfinite(r.d) || r.d <= 0.0f)
|
|
return false;
|
|
if (d_min_limit > 0.0 && r.d < d_min_limit)
|
|
return false;
|
|
if (d_max_limit > 0.0 && r.d > d_max_limit)
|
|
return false;
|
|
if (!std::isfinite(r.rlp) || r.rlp == 0.0f)
|
|
return false;
|
|
if (!std::isfinite(r.sigma) || r.sigma <= 0.0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|