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)
}
}
impl super::ProcessedDataset {
pub fn has_magnitude_history(&self) -> bool {
use crate::processing::{Projection, ResolvedOperation, SpectrumOperation};
use crate::{derivation::DerivationInput, processed::ProcessedOrigin};
let mut pending = vec![self.provenance()];
while let Some(provenance) = pending.pop() {
if provenance.history().is_some_and(|history| {
history.records().iter().any(|record| {
matches!(
record.resolved(),
Some(ResolvedOperation::Spectrum(SpectrumOperation::Magnitude))
| Some(ResolvedOperation::Projection {
projection: Projection::Magnitude,
..
})
)
})
}) {
return true;
}
match provenance.origin() {
ProcessedOrigin::Library(boundary) => {
for input in boundary.inputs() {
if let DerivationInput::Processed(parent) = input {
pending.push(parent.provenance());
}
}
}
ProcessedOrigin::External(boundary) => pending.push(boundary.parent().provenance()),
_ => {}
}
}
false
}
}