nmr 0.1.2

NMR data tools for Rust
Documentation
use crate::MetadataField;
use crate::ReadWarning;
use crate::WarningImpact;
use crate::axis::AxisCoordinates;
use crate::axis::AxisDomain;
use crate::axis::AxisRole;
use crate::axis::AxisUnit;
use crate::processed::ComponentBasis;
use crate::processed::ProcessedAxis;
use crate::read_error::ReadError;
use std::path::Path;

use super::parameters::{Parameters, invalid_parameter};

#[allow(clippy::too_many_arguments)]
pub(super) fn axis(
    parameters: &Parameters,
    source: &Path,
    points: usize,
    label: &str,
    axis_index: usize,
    basis: ComponentBasis,
    warnings: &mut Vec<ReadWarning>,
) -> Result<ProcessedAxis, ReadError> {
    let sw = valid_positive(parameters.optional_f64("SW_P", source)?, source, "SW_p")?;
    let sf = valid_positive(parameters.optional_f64("SF", source)?, source, "SF")?;
    let offset = valid_finite(parameters.optional_f64("OFFSET", source)?, source, "OFFSET")?;
    for (present, field) in [
        (sw.is_some(), MetadataField::SpectralWidth),
        (sf.is_some(), MetadataField::ReferenceFrequency),
        (offset.is_some(), MetadataField::Offset),
    ] {
        if !present {
            warnings.push(ReadWarning::MissingMetadata {
                field,
                axis: Some(axis_index),
                impact: WarningImpact::AxisCalibration,
            });
        }
    }
    let calibrated = sw.zip(sf).zip(offset);
    let (domain, unit, coordinates) = if let Some(((sw, sf), offset)) = calibrated {
        let step = -sw / sf / points as f64;
        if !step.is_finite() || points > 1 && step == 0.0 {
            return Err(ReadError::corrupt(
                source.into(),
                "invalid Bruker processed axis calibration",
            ));
        }
        (
            AxisDomain::Frequency,
            Some(AxisUnit::Ppm),
            if points == 1 {
                AxisCoordinates::Explicit(vec![offset])
            } else {
                AxisCoordinates::Uniform {
                    start: offset,
                    step,
                }
            },
        )
    } else {
        (AxisDomain::Unknown, None, AxisCoordinates::Unknown)
    };
    let mut axis = ProcessedAxis::new(AxisRole::Signal, domain, unit, points, coordinates, basis)?
        .with_label(Some(label.to_owned()));
    let nucleus = parameters.text("AXNUC");
    if nucleus.is_none() {
        warnings.push(ReadWarning::MissingMetadata {
            field: MetadataField::Nucleus,
            axis: Some(axis_index),
            impact: WarningImpact::AxisAnnotation,
        });
    }
    axis = axis.with_nucleus(nucleus)?.with_spectral_width_hz(sw)?;
    if let Some(sf) = sf {
        use crate::acquisition::{
            DerivationStepId, NormalizationEvidence, NormalizationFact, RuleId,
        };
        axis = axis.with_spectrum_reference(crate::processed::SpectrumReference {
            frequency_mhz: sf,
            evidence: NormalizationEvidence::from_format(
                RuleId::registered("bruker.processed-sf.v1"),
                vec![NormalizationFact::ChemicalShiftReference],
                vec![DerivationStepId::registered("bruker.processed-sf.v1")],
            )
            .expect("fixed nonempty reference rule"),
        });
    }
    Ok(axis)
}

pub(super) fn valid_positive(
    value: Option<f64>,
    source: &Path,
    name: &str,
) -> Result<Option<f64>, ReadError> {
    if value.is_some_and(|value| !value.is_finite() || value <= 0.0) {
        return Err(invalid_parameter(source, name));
    }
    Ok(value)
}

pub(super) fn valid_finite(
    value: Option<f64>,
    source: &Path,
    name: &str,
) -> Result<Option<f64>, ReadError> {
    if value.is_some_and(|value| !value.is_finite()) {
        return Err(invalid_parameter(source, name));
    }
    Ok(value)
}