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::ForceStillProcessing(bool input) {
    force_still_processing = input;
    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;
}

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

bool ScalingSettings::GetForceStillProcessing() const {
    return force_still_processing;
}

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::Combine3D(bool input) {
    combine_3d = input;
    return *this;
}

bool ScalingSettings::GetCombine3D() const {
    return combine_3d;
}

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

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

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

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