Jungfraujoch/common/ScalingSettings.cpp

// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute <filip.leonarski@psi.ch>
// SPDX-License-Identifier: GPL-3.0-only


#include "ScalingSettings.h"


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;
}

ScalingSettings& ScalingSettings::HighResolutionLimit_A(std::optional<double> limit) {
    if (limit.has_value() && limit.value() <= 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<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::GetOutlierRejectNsigma() const {
    return outlier_reject_nsigma;
}

ScalingSettings &ScalingSettings::OutlierRejectNsigma(double input) {
    outlier_reject_nsigma = input; // <= 0 disables; no upper bound (large = effectively off)
    return *this;
}

ScalingSettings &ScalingSettings::ScaleFulls(bool input) {
    scale_fulls = input;
    return *this;
}

bool ScalingSettings::GetScaleFulls() const {
    return scale_fulls;
}

ScalingSettings &ScalingSettings::AbsorptionIter(int input) {
    if (input < 0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Absorption iterations must be non-negative");
    absorption_iter = input;
    return *this;
}

int ScalingSettings::GetAbsorptionIter() const {
    return absorption_iter;
}

ScalingSettings &ScalingSettings::CorrectionSurfaces(bool input) {
    correction_surfaces = input;
    return *this;
}

bool ScalingSettings::GetCorrectionSurfaces() const {
    return correction_surfaces;
}

ScalingSettings &ScalingSettings::StillsModulation(bool input) {
    stills_modulation = input;
    return *this;
}

bool ScalingSettings::GetStillsModulation() const {
    return stills_modulation;
}

ScalingSettings &ScalingSettings::ExpectedVarianceMerge(bool input) {
    expected_variance_merge = input;
    return *this;
}

bool ScalingSettings::GetExpectedVarianceMerge() const {
    return expected_variance_merge;
}

ScalingSettings &ScalingSettings::SmoothGDegrees(double input) {
    if (input < 0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Smooth-G range must be non-negative");
    smooth_g_deg = input;
    return *this;
}

double ScalingSettings::GetSmoothGDegrees() const {
    return smooth_g_deg;
}

ScalingSettings &ScalingSettings::RelativeBDegrees(double input) {
    if (input < 0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "Relative-B batch width must be non-negative");
    relative_b_deg = input;
    return *this;
}

double ScalingSettings::GetRelativeBDegrees() const {
    return relative_b_deg;
}

double ScalingSettings::GetMinPartiality() const {
    return min_partiality;
}

ScalingSettings &ScalingSettings::ForcedMosaicity(std::optional<double> input) {
    if (input.has_value() && (input.value() < GetMinMosaicity() || input.value() > GetMaxMosaicity()))
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
            "Forced mosaicity must be between " + std::to_string(GetMinMosaicity()) +
            " and " + std::to_string(GetMaxMosaicity()));
    forced_mosaicity = input;
    return *this;
}

std::optional<double> ScalingSettings::GetForcedMosaicity() const {
    return forced_mosaicity;
}

ScalingSettings &ScalingSettings::CaptureUncertaintyCoeff(double input) {
    if (input < 0.0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Capture uncertainty coefficient must be non-negative");
    capture_uncertainty_coeff = input;
    return *this;
}

double ScalingSettings::GetCaptureUncertaintyCoeff() const {
    return capture_uncertainty_coeff;
}

ScalingSettings &ScalingSettings::PartialityUncertaintyCoeff(double input) {
    partiality_uncertainty_coeff = input;
    return *this;
}

double ScalingSettings::GetPartialityUncertaintyCoeff() const {
    return partiality_uncertainty_coeff;
}

ScalingSettings &ScalingSettings::MinCapturedFraction(double input) {
    if (input < 0.0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Minimum captured fraction must be non-negative");
    min_captured_fraction = input;
    return *this;
}

double ScalingSettings::GetMinCapturedFraction() const {
    return min_captured_fraction;
}

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;
}

ScalingSettings &ScalingSettings::ScalingRegularize(bool input) {
    scaling_regularize = input;
    return *this;
}

bool ScalingSettings::GetScalingRegularize() const {
    return scaling_regularize;
}

ScalingSettings &ScalingSettings::ResolutionCutoff(ResolutionCutoffMethod input) {
    resolution_cutoff = input;
    return *this;
}

ResolutionCutoffMethod ScalingSettings::GetResolutionCutoff() const {
    return resolution_cutoff;
}

ScalingSettings &ScalingSettings::ResolutionCCTarget(double input) {
    if (input <= 0.0 || input >= 1.0)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Resolution CC target must be between 0 and 1");
    resolution_cc_target = input;
    return *this;
}

double ScalingSettings::GetResolutionCCTarget() const {
    return resolution_cc_target;
}

ScalingSettings &ScalingSettings::ReportShellCount(int input) {
    if (input < 1)
        throw JFJochException(JFJochExceptionCategory::InputParameterInvalid,
                              "Number of report shells must be at least 1");
    report_shell_count = input;
    return *this;
}

int ScalingSettings::GetReportShellCount() const {
    return report_shell_count;
}