nmr 0.1.3

NMR data tools for Rust
Documentation
use crate::acquisition::DirectSamples;
use crate::acquisition::IndirectComponents;
use crate::acquisition::RawAxisKind;
use crate::processed::ComponentBasis;
use crate::processed::ProcessedAxis;
use crate::processed::ProcessedDescriptor;

use super::{AxisState, PlanState, ProcessingDelayState, StateError, validate_auto_phase_axis};

#[cfg(test)]
thread_local! {
    pub(crate) static STATE_CONSTRUCTIONS: std::cell::Cell<usize> = const { std::cell::Cell::new(0) };
}

impl PlanState {
    pub(crate) fn from_descriptor(descriptor: &ProcessedDescriptor) -> Self {
        #[cfg(test)]
        STATE_CONSTRUCTIONS.with(|count| count.set(count.get() + 1));
        Self {
            axes: descriptor
                .axes()
                .iter()
                .cloned()
                .map(|axis| AxisState {
                    group_delay: if axis.role().is_signal() {
                        ProcessingDelayState::Unknown
                    } else {
                        ProcessingDelayState::NotApplicable
                    },
                    axis,
                    chemical_shift_reference: None,
                    latest_fft: None,
                    operation_count: 0,
                    phase_applied: false,
                    phase_attempt_failed: false,
                })
                .collect(),
            observation_ordinals: None,
            absolute_origin: vec![0; descriptor.axes().len()].into(),
        }
    }

    pub(crate) fn from_raw(
        descriptor: &ProcessedDescriptor,
        raw_axes: &[crate::raw::RawAxis],
        sampling: Option<&crate::raw::SamplingSchedule>,
        absolute_origin: &[usize],
    ) -> Result<Self, StateError> {
        Self::from_raw_with_cancellation(descriptor, raw_axes, sampling, absolute_origin, None)
    }

    pub(crate) fn from_raw_with_cancellation(
        descriptor: &ProcessedDescriptor,
        raw_axes: &[crate::raw::RawAxis],
        sampling: Option<&crate::raw::SamplingSchedule>,
        absolute_origin: &[usize],
        token: Option<&crate::CancellationToken>,
    ) -> Result<Self, StateError> {
        let check = || {
            if token.is_some_and(crate::CancellationToken::is_cancelled) {
                Err(StateError::Cancelled)
            } else {
                Ok(())
            }
        };
        check()?;
        if descriptor.axes().len() != raw_axes.len() || raw_axes.len() != absolute_origin.len() {
            return Err(StateError::Mapping("raw and processed axis ranks disagree"));
        }
        #[cfg(test)]
        STATE_CONSTRUCTIONS.with(|count| count.set(count.get() + 1));
        let observation_ordinals = sampling
            .map(|schedule| -> Result<_, StateError> {
                let points = raw_axes.first().map_or(0, crate::raw::RawAxis::points);
                check()?;
                let mut mapping = vec![usize::MAX; points];
                check()?;
                for (ordinal, coordinate) in schedule.coordinates().iter().enumerate() {
                    if ordinal % 4096 == 0 {
                        check()?;
                    }
                    if let Some(&point) = coordinate.as_slice().first() {
                        if point < mapping.len() {
                            mapping[point] = ordinal;
                        }
                    }
                }
                check()?;
                Ok(std::sync::Arc::from(mapping))
            })
            .transpose()?;
        Ok(Self {
            axes: descriptor
                .axes()
                .iter()
                .cloned()
                .zip(raw_axes)
                .map(|(axis, raw)| AxisState {
                    axis,
                    group_delay: raw.group_delay().into(),
                    chemical_shift_reference: raw.chemical_shift_reference().cloned(),
                    latest_fft: None,
                    operation_count: 0,
                    phase_applied: false,
                    phase_attempt_failed: false,
                })
                .collect(),
            observation_ordinals,
            absolute_origin: absolute_origin.into(),
        })
    }

    pub(crate) fn descriptor(&self) -> Result<ProcessedDescriptor, StateError> {
        ProcessedDescriptor::new(self.axes.iter().map(|state| state.axis.clone()).collect())
            .map_err(Into::into)
    }

    pub(crate) fn record_phase_failure(&mut self, axis: usize) -> Result<(), StateError> {
        validate_auto_phase_axis(self, axis)?;
        self.axes[axis].phase_attempt_failed = true;
        Ok(())
    }
}
pub(crate) fn expand_raw_descriptor(
    raw_axes: &[crate::raw::RawAxis],
) -> Result<ProcessedDescriptor, StateError> {
    if !(1..=3).contains(&raw_axes.len()) {
        return Err(StateError::Mapping(
            "only rank-1 through rank-3 raw data is supported",
        ));
    }
    let mut axes = Vec::new();
    axes.try_reserve_exact(raw_axes.len())
        .map_err(|_| StateError::AllocationFailure)?;
    for raw in raw_axes {
        let basis = match raw.kind() {
            RawAxisKind::Direct(DirectSamples::Real) | RawAxisKind::Parameter => {
                ComponentBasis::Scalar
            }
            RawAxisKind::Direct(DirectSamples::Complex) => ComponentBasis::Cartesian,
            RawAxisKind::Indirect(IndirectComponents::Scalar) => ComponentBasis::Scalar,
            RawAxisKind::Indirect(IndirectComponents::SharedComplex { conjugated, .. }) => {
                ComponentBasis::SharedComplex {
                    axis: crate::AxisIndex::new(raw_axes.len() - 1),
                    conjugated: *conjugated,
                }
            }
            RawAxisKind::Indirect(IndirectComponents::Cartesian(_)) => ComponentBasis::Cartesian,
            RawAxisKind::Indirect(IndirectComponents::Encoded(transform)) => {
                ComponentBasis::Encoded(transform.clone())
            }
        };
        let axis = ProcessedAxis::from_raw_axis(raw, basis)?;
        axes.push(axis);
    }
    ProcessedDescriptor::new(axes).map_err(Into::into)
}