use super::*;
#[derive(Clone, Debug, PartialEq)]
pub struct RawDescriptor {
pub(super) axes: Vec<RawAxis>,
pub(super) acquisition: RawMetadata,
pub(super) layout: RawLayout,
pub(super) layout_evidence: crate::acquisition::NormalizationEvidence,
}
impl RawDescriptor {
pub(crate) fn new(
axes: Vec<RawAxis>,
acquisition: RawMetadata,
) -> Result<Self, ValidationError> {
let evidence = crate::acquisition::NormalizationEvidence::user_constructed(vec![
crate::acquisition::NormalizationFact::TraceMappingBijection,
])?;
Self::new_resolved(axes, acquisition, evidence)
}
pub(crate) fn new_resolved(
axes: Vec<RawAxis>,
acquisition: RawMetadata,
layout_evidence: crate::acquisition::NormalizationEvidence,
) -> Result<Self, ValidationError> {
let layout = RawLayout::from_axes(&axes)?;
let value = Self {
axes,
acquisition,
layout,
layout_evidence,
};
value.validate()?;
Ok(value)
}
pub fn axes(&self) -> &[RawAxis] {
&self.axes
}
pub fn acquisition(&self) -> &RawMetadata {
&self.acquisition
}
pub fn storage_order(&self) -> StorageOrder {
self.layout.storage_order()
}
pub fn layout(&self) -> &RawLayout {
&self.layout
}
pub fn layout_evidence(&self) -> &crate::acquisition::NormalizationEvidence {
&self.layout_evidence
}
pub fn logical_shape(&self) -> Vec<usize> {
self.layout.logical_shape().to_vec()
}
pub fn component_lanes(&self) -> Vec<usize> {
self.layout.lane_counts().to_vec()
}
pub fn validate(&self) -> Result<(), ValidationError> {
if self.axes.is_empty() {
return Err(ValidationError::EmptyAxes);
}
for axis in &self.axes {
axis.validate()?;
}
if self.axes.iter().any(|a| {
matches!(
a.kind(),
crate::acquisition::RawAxisKind::Indirect(
crate::acquisition::IndirectComponents::SharedComplex { .. }
)
)
}) && !self.axes.last().is_some_and(|a| {
matches!(
a.kind(),
crate::acquisition::RawAxisKind::Direct(crate::acquisition::DirectSamples::Complex)
)
}) {
return Err(ValidationError::DescriptorDataMismatch);
}
let mut points_product = 1usize;
let mut lanes_product = 1usize;
for axis in &self.axes {
axis.points()
.checked_mul(axis.component_lanes())
.ok_or(ValidationError::SizeOverflow)?;
points_product = points_product
.checked_mul(axis.points())
.ok_or(ValidationError::SizeOverflow)?;
lanes_product = lanes_product
.checked_mul(axis.component_lanes())
.ok_or(ValidationError::SizeOverflow)?;
}
if !self
.axes
.iter()
.map(RawAxis::points)
.eq(self.layout.logical_shape.iter().copied())
|| !self.axes.iter().map(RawAxis::component_lanes).eq(self
.layout
.lane_counts
.iter()
.copied())
|| self.layout.storage_order != StorageOrder::RowMajorDirectFastest
{
return Err(ValidationError::DescriptorDataMismatch);
}
self.acquisition.validate()?;
if let Some(diffusion) = self.acquisition.diffusion() {
let axis = self
.axes
.get(diffusion.gradient_axis())
.ok_or(ValidationError::DiffusionGradientAxisMismatch)?;
if axis.quantity() != Some(AxisQuantity::MagneticFieldGradientStrength) {
return Err(ValidationError::DiffusionGradientAxisMismatch);
}
}
if self
.axes
.last()
.is_some_and(|axis| axis.role() != AxisRole::DirectAcquisition)
|| self.axes[..self.axes.len() - 1]
.iter()
.any(|axis| axis.role() == AxisRole::DirectAcquisition)
{
return Err(ValidationError::DirectAxisNotFastest);
}
Ok(())
}
}
impl RawDescriptor {
#[allow(clippy::type_complexity)]
pub(crate) fn model_parts(
&self,
) -> (
&Vec<RawAxis>,
&RawMetadata,
&RawLayout,
&crate::acquisition::NormalizationEvidence,
) {
(
&self.axes,
&self.acquisition,
&self.layout,
&self.layout_evidence,
)
}
#[allow(clippy::type_complexity)]
pub(crate) fn from_model_parts(
parts: (
Vec<RawAxis>,
RawMetadata,
RawLayout,
crate::acquisition::NormalizationEvidence,
),
) -> Result<Self, crate::internal::ModelError> {
let (axes, acquisition, layout, layout_evidence) = parts;
let value = Self {
axes,
acquisition,
layout,
layout_evidence,
};
value
.validate()
.map_err(|e| crate::internal::ModelError::Validation(e.to_string()))?;
Ok(value)
}
}