Files
Jungfraujoch/common/IndexingSettings.cpp
leonarski_fandClaude Opus 5.5 790005ab1e RotationIndexer: fixed lattice system held by value, not as a dangling reference
`const auto &fixed_system = experiment.GetIndexingSettings().GetFixedLatticeSystem()`
bound a reference into the IndexingSettings copy GetIndexingSettings() returns, which
dies at the end of that statement. Reading it afterwards is use-after-scope: built
without LTO the stack slot still held the empty optional, but with -flto=auto (the CI
build) it read as engaged, so every rotation run without -C/-S behaved as if the
crystal system were fixed - no triclinic pseudo-symmetry refinement beside a promoted
candidate (has_tri = false), hence no unconstrained alternative for the first pass's
false-promotion demotion. On a triclinic crystal whose metric is pseudo-monoclinic
the first pass then lost the true cell (0/60 validation frames on the promoted cell)
and the run merged an axis-doubled cell; the same build without LTO, on the same
machine, merged the deposited one.

GetFixedLatticeSystem() now returns the optional by value, so no caller can keep a
reference into the temporary settings, and the call site holds a copy.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UqXYdJDrM65gxsCn2PrbfK
2026-11-17 01:49:30 +01:00

245 lines
8.0 KiB
C++

// SPDX-FileCopyrightText: 2025 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only
#include "IndexingSettings.h"
#include "JFJochException.h"
#include "CUDAWrapper.h"
#include <cmath>
#define check_max(param, val, max) if ((val) > (max)) throw JFJochException(JFJochExceptionCategory::InputParameterAboveMax, param)
#define check_min(param, val, min) if ((val) < (min)) throw JFJochException(JFJochExceptionCategory::InputParameterBelowMin, param)
#define check_finite(param, val) if (!std::isfinite(val)) throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, param)
IndexingSettings::IndexingSettings() {
if (get_gpu_count() > 0)
algorithm = IndexingAlgorithmEnum::FFBIDX;
else
algorithm = IndexingAlgorithmEnum::None;
}
IndexingSettings &IndexingSettings::ViableCellMinSpots(int64_t input) {
// Four, not the default six: six is the stills frame gate's number, and a rotation run is no longer
// accepted or refused on it (the pooled spot test in the first pass decides that), so it has no
// business being a hard minimum. Four is where the number stops being a convention and becomes a
// fact - three spots fit any lattice at all (see MIN_SPOT_COUNT), and the cell and orientation
// refinements this same setting bounds need more observations than parameters.
check_min("ViableCellMinSpots", input, 4);
viable_cell_min_spots = input;
return *this;
}
int64_t IndexingSettings::GetViableCellMinSpots() const {
return viable_cell_min_spots;
}
IndexingSettings &IndexingSettings::Algorithm(IndexingAlgorithmEnum input) {
switch (input) {
case IndexingAlgorithmEnum::Auto:
case IndexingAlgorithmEnum::FFBIDX:
case IndexingAlgorithmEnum::FFT:
case IndexingAlgorithmEnum::FFTW:
case IndexingAlgorithmEnum::None:
algorithm = input;
break;
default:
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
"Invalid value for indexing algorithm enum parameter");
}
return *this;
}
// The accepted range, not the default (which stays 500 A - see IndexingSettings.h). The FFT can
// only recover a basis vector up to this length, so the ceiling is exactly the longest cell the
// indexer can ever find; at 500 it excluded 1091 of the PDB's 206950 X-ray entries (0.53%) outright.
// 1200 A leaves 8. Nothing pays for the wider range: the histogram is sized from the VALUE in use,
// and only a caller that asks for more - a given cell that needs it, or the long-axis hypothesis - gets
// a longer transform.
IndexingSettings &IndexingSettings::FFT_MaxUnitCell_A(float input) {
check_finite("FFT indexing max unit cell (A)", input);
check_min("FFT indexing max unit cell (A)", input, 50);
check_max("FFT indexing max unit cell (A)", input, fft_max_unit_cell_limit_A);
fft_max_unit_cell_A = input;
return *this;
}
IndexingSettings &IndexingSettings::FFT_MinUnitCell_A(float input) {
check_finite("FFT indexing min unit cell (A)", input);
check_min("FFT indexing min unit cell (A)", input, fft_min_unit_cell_limit_A);
check_max("FFT indexing min unit cell (A)", input, 40);
fft_min_unit_cell_A = input;
return *this;
}
IndexingSettings & IndexingSettings::FFT_MaxAngle_deg(float input) {
check_finite("FFT indexing max angle (deg)", input);
check_min("FFT indexing max angle (deg)", input, 0);
check_max("FFT indexing max angle (deg)", input, 180);
fft_max_angle_deg = input;
return *this;
}
IndexingSettings & IndexingSettings::FFT_MinAngle_deg(float input) {
check_finite("FFT indexing min angle (deg)", input);
check_min("FFT indexing min angle (deg)", input, 0);
check_max("FFT indexing min angle (deg)", input, 180);
fft_min_angle_deg = input;
return *this;
}
float IndexingSettings::GetFFT_MinAngle_deg() const {
return fft_min_angle_deg;
}
float IndexingSettings::GetFFT_MaxAngle_deg() const {
return fft_max_angle_deg;
}
IndexingSettings &IndexingSettings::FFT_NumVectors(int64_t input) {
check_min("FFT indexing number of search vectors", input, 128);
fft_num_vectors = input;
return *this;
}
IndexingSettings &IndexingSettings::FFT_HighResolution_A(float input) {
check_finite("FFT indexing high resolution (A)", input);
check_min("FFT indexing high resolution (A)", input, 0.5);
check_max("FFT indexing high resolution (A)", input, 6.0);
fft_high_resolution_A = input;
return *this;
}
IndexingAlgorithmEnum IndexingSettings::GetAlgorithm() const {
return algorithm;
}
float IndexingSettings::GetFFT_MaxUnitCell_A() const {
return fft_max_unit_cell_A;
}
float IndexingSettings::GetFFT_MinUnitCell_A() const {
return fft_min_unit_cell_A;
}
int64_t IndexingSettings::GetFFT_NumVectors() const {
return fft_num_vectors;
}
float IndexingSettings::GetFFT_HighResolution_A() const {
return fft_high_resolution_A;
}
IndexingSettings &IndexingSettings::Tolerance(float input) {
check_min("Indexing tolerance", input, 0.0);
check_max("Indexing tolerance", input, 0.5);
indexing_tolerance = input;
return *this;
}
float IndexingSettings::GetTolerance() const {
return indexing_tolerance;
}
int64_t IndexingSettings::GetIndexingThreads() const {
return indexing_threads;
}
IndexingSettings &IndexingSettings::IndexingThreads(int64_t input) {
check_min("Indexing thread count", input, 1);
check_max("Indexing thread count", input, 64);
indexing_threads = input;
return *this;
}
int64_t IndexingSettings::GetRefineThreads() const {
return refine_threads;
}
IndexingSettings &IndexingSettings::RefineThreads(int64_t input) {
check_min("Candidate-cell refinement thread count", input, 1);
check_max("Candidate-cell refinement thread count", input, MAX_REFINE_THREADS);
refine_threads = input;
return *this;
}
IndexingSettings &IndexingSettings::UnitCellDistTolerance(float input) {
check_min("Relative unit cell distance tolerance vs. reference", input, 0.0001);
check_max("Relative unit cell distance tolerance vs. reference", input, 0.2001);
unit_cell_dist_tolerance_vs_reference = input;
return *this;
}
float IndexingSettings::GetUnitCellDistTolerance() const {
return unit_cell_dist_tolerance_vs_reference;
}
float IndexingSettings::GetUnitCellAngleTolerance_deg() const {
return unit_cell_angle_tolerance_deg;
}
GeomRefinementAlgorithmEnum IndexingSettings::GetGeomRefinementAlgorithm() const {
return refinement;
}
IndexingSettings &IndexingSettings::GeomRefinementAlgorithm(GeomRefinementAlgorithmEnum input) {
refinement = input;
return *this;
}
IndexingSettings & IndexingSettings::IndexIceRings(bool input) {
index_ice_rings = input;
return *this;
}
IndexingSettings & IndexingSettings::RotationIndexing(bool input) {
enable_rotation_indexing = input;
return*this;
}
bool IndexingSettings::GetRotationIndexing() const {
return enable_rotation_indexing;
}
IndexingSettings & IndexingSettings::LatticeClassDemoted(bool input) {
lattice_class_demoted = input;
return *this;
}
bool IndexingSettings::GetLatticeClassDemoted() const {
return lattice_class_demoted;
}
bool IndexingSettings::GetIndexIceRings() const {
return index_ice_rings;
}
bool IndexingSettings::GetBlockingBehavior() const {
return blocking_behavior;
}
IndexingSettings &IndexingSettings::BlockingBehavior(bool input) {
blocking_behavior = input;
return *this;
}
int64_t IndexingSettings::GetMaxExtraLattices() const {
return max_extra_lattices;
}
IndexingSettings &IndexingSettings::MaxExtraLattices(int64_t input) {
check_min("Max extra lattices", input, 0);
check_max("Max extra lattices", input, 10);
max_extra_lattices = input;
return *this;
}
IndexingSettings &IndexingSettings::FixedLatticeSystem(const std::optional<gemmi::CrystalSystem> &input) {
fixed_lattice_system = input;
return *this;
}
std::optional<gemmi::CrystalSystem> IndexingSettings::GetFixedLatticeSystem() const {
return fixed_lattice_system;
}