141 lines
3.6 KiB
C++
141 lines
3.6 KiB
C++
// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
|
|
// SPDX-License-Identifier: GPL-3.0-only
|
|
|
|
|
|
#include "ScalingSettings.h"
|
|
|
|
|
|
ScalingSettings& ScalingSettings::SetPartialityModel(PartialityModel mode) {
|
|
partiality_mode = mode;
|
|
return *this;
|
|
}
|
|
|
|
ScalingSettings& ScalingSettings::RefineB(bool input) {
|
|
refine_b = input;
|
|
return *this;
|
|
}
|
|
|
|
ScalingSettings& ScalingSettings::MergeFriedel(bool input) {
|
|
merge_friedel = input;
|
|
return *this;
|
|
}
|
|
|
|
ScalingSettings& ScalingSettings::HighResolutionLimit_A(double limit) {
|
|
if (limit <= 0.0)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterBelowMin, "High resolution limit must be positive");
|
|
high_resolution_limit_A = limit;
|
|
return *this;
|
|
}
|
|
|
|
bool ScalingSettings::GetRefineB() const {
|
|
return refine_b;
|
|
}
|
|
|
|
bool ScalingSettings::GetMergeFriedel() const {
|
|
return merge_friedel;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::RefineRotationWedge(bool input) {
|
|
refine_wedge = input;
|
|
return *this;
|
|
}
|
|
|
|
bool ScalingSettings::GetRefineWedge() const {
|
|
return refine_wedge;
|
|
}
|
|
|
|
std::optional<PartialityModel> ScalingSettings::GetPartialityModel() const {
|
|
return partiality_mode;
|
|
}
|
|
|
|
std::optional<double> ScalingSettings::GetHighResolutionLimit_A() const {
|
|
return high_resolution_limit_A;
|
|
}
|
|
|
|
double ScalingSettings::GetMinB() const {
|
|
return min_b;
|
|
}
|
|
|
|
double ScalingSettings::GetMaxB() const {
|
|
return max_b;
|
|
}
|
|
|
|
double ScalingSettings::GetMinMosaicity() const {
|
|
return 0.001;
|
|
}
|
|
|
|
double ScalingSettings::GetMaxMosaicity() const {
|
|
return 1.0;
|
|
}
|
|
|
|
double ScalingSettings::GetMinWedge() const {
|
|
return 0.001;
|
|
|
|
}
|
|
|
|
double ScalingSettings::GetMaxWedge() const {
|
|
return 10.0;
|
|
}
|
|
|
|
double ScalingSettings::GetDefaultMosaicity() const {
|
|
return 0.1;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::RotationWedgeForScaling(std::optional<double> input) {
|
|
if (input) {
|
|
// TODO: Use fmt
|
|
if (input.value() < GetMinWedge() || input.value() > GetMaxWedge())
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
|
|
"Wedge for scaling must be between " + std::to_string(GetMinWedge()) +
|
|
" and " + std::to_string(GetMaxWedge()));
|
|
}
|
|
wedge_for_scaling = input;
|
|
return *this;
|
|
}
|
|
|
|
std::optional<double> ScalingSettings::GetRotationWedgeForScaling() const {
|
|
return wedge_for_scaling;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::MinPartiality(double input) {
|
|
if (min_partiality < 0.0 || min_partiality > 1.0)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Min partiality must be between 0 and 1");
|
|
min_partiality = input;
|
|
return *this;
|
|
}
|
|
|
|
double ScalingSettings::GetMinCCForImage() const {
|
|
return min_cc_for_image;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::MinCCForImage(double input) {
|
|
if (input < 0.0 || input > 1.0)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Min CC for image must be between 0 and 1");
|
|
min_cc_for_image = input;
|
|
return *this;
|
|
}
|
|
|
|
double ScalingSettings::GetMinPartiality() const {
|
|
return min_partiality;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::FileFormat(IntensityFormat input) {
|
|
intensity_format = input;
|
|
return *this;
|
|
}
|
|
|
|
IntensityFormat ScalingSettings::GetFileFormat() const {
|
|
return intensity_format;
|
|
}
|
|
|
|
ScalingSettings &ScalingSettings::RfreeFraction(double input) {
|
|
if (input < 0.0 || input > 1.0)
|
|
throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "R-free fraction must be between 0 and 1");
|
|
rfree_fraction = input;
|
|
return *this;
|
|
}
|
|
|
|
double ScalingSettings::GetRfreeFraction() const {
|
|
return rfree_fraction;
|
|
}
|