use crate::acquisition::{ChemicalShiftReference, NormalizationEvidence, PendingGroupDelay};
use crate::processing::contracts::state::{AxisState, ProcessingDelayState};
#[derive(Clone, Debug, PartialEq)]
pub struct SpectrumReference {
pub(crate) frequency_mhz: f64,
pub(crate) evidence: NormalizationEvidence,
}
impl SpectrumReference {
pub fn reference_frequency_mhz(&self) -> f64 {
self.frequency_mhz
}
pub fn evidence(&self) -> &NormalizationEvidence {
&self.evidence
}
}
#[non_exhaustive]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ProcessedGroupDelay<'a> {
NotApplicable,
Unknown,
Pending(&'a PendingGroupDelay),
Corrected {
delay_points: f64,
evidence: Option<&'a NormalizationEvidence>,
},
}
#[derive(Clone, Copy, Debug)]
pub struct ProcessedAxisEvidence<'a>(pub(crate) &'a AxisState);
impl<'a> ProcessedAxisEvidence<'a> {
pub fn observe_frequency_mhz(self) -> Option<f64> {
self.0
.axis
.frequency_evidence()
.and_then(|f| f.observe_frequency_mhz())
}
pub fn reference_frequency_mhz(self) -> Option<f64> {
self.chemical_shift_reference()
.map(ChemicalShiftReference::reference_frequency_mhz)
.or_else(|| {
self.0
.axis
.spectrum_reference()
.map(SpectrumReference::reference_frequency_mhz)
})
}
pub fn reference_evidence(self) -> Option<&'a NormalizationEvidence> {
self.chemical_shift_reference()
.map(ChemicalShiftReference::evidence)
.or_else(|| {
self.0
.axis
.spectrum_reference()
.map(SpectrumReference::evidence)
})
}
pub fn chemical_shift_reference(self) -> Option<&'a ChemicalShiftReference> {
self.0.chemical_shift_reference.as_ref()
}
pub fn group_delay(self) -> ProcessedGroupDelay<'a> {
match &self.0.group_delay {
ProcessingDelayState::NotApplicable => ProcessedGroupDelay::NotApplicable,
ProcessingDelayState::Unknown => ProcessedGroupDelay::Unknown,
ProcessingDelayState::Pending(value) => ProcessedGroupDelay::Pending(value),
ProcessingDelayState::Corrected { delay, evidence } => ProcessedGroupDelay::Corrected {
delay_points: *delay,
evidence: evidence.as_ref(),
},
}
}
}
impl SpectrumReference {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(&self) -> (&f64, &NormalizationEvidence) {
(&self.frequency_mhz, &self.evidence)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (f64, NormalizationEvidence),
) -> Result<Self, crate::internal::ModelError> {
let (frequency_mhz, evidence) = parts;
let value = Self {
frequency_mhz,
evidence,
};
if !value.frequency_mhz.is_finite() || value.frequency_mhz <= 0.0 {
return Err(crate::internal::ModelError::Structure);
}
Ok(value)
}
}