148 lines
4.6 KiB
C++
148 lines
4.6 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) {
|
|
check_min("ViableCellMinSpots", input, 6);
|
|
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;
|
|
}
|
|
|
|
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, 500);
|
|
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, 5);
|
|
check_max("FFT indexing min unit cell (A)", input, 40);
|
|
fft_min_unit_cell_A = input;
|
|
return *this;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
bool IndexingSettings::GetIndexIceRings() const {
|
|
return index_ice_rings;
|
|
}
|