caexfer 0.1.0

Exchange linear finite-element meshes and results across CAE formats
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::path::PathBuf;

use crate::core::Dataset;

use super::Format;

/// Where an omission or assumption enters a conversion.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Stage {
    /// Information not represented when reading the source.
    Source,

    /// Information not representable by the destination.
    Destination,

    /// A value or frame assumed by the projection.
    Assumption,
}

impl Stage {
    /// Stable lowercase name for machine-readable reports.
    #[must_use]
    pub fn name(self) -> &'static str {
        match self {
            Self::Source => "source",
            Self::Destination => "destination",
            Self::Assumption => "assumption",
        }
    }
}

/// A caller decision that supplies or accepts a value absent from the source.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AssumptionKind {
    /// Treat a companion mesh and Nastran result as using the basic frame.
    BasicFrame,

    /// Fill absent rotational displacement components with numeric zero.
    ZeroRotations,

    /// Treat a synthetic all-zero displacement table as intended output.
    SyntheticZero,
}

/// One piece of information omitted or explicitly assumed.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Omission {
    /// Origin of the omission or assumption.
    pub stage: Stage,

    /// Specific caller assumption, when this notice supplies missing data.
    pub assumption: Option<AssumptionKind>,

    /// Human-readable detail; wording is not a stable API.
    pub detail: String,
}

impl Omission {
    /// Retain the origin of one omission for machine-readable reports.
    pub(super) fn new(stage: Stage, detail: impl Into<String>) -> Self {
        Self {
            stage,
            assumption: None,
            detail: detail.into(),
        }
    }

    /// Record one specifically identified projection assumption.
    pub fn assumed(kind: AssumptionKind, detail: impl Into<String>) -> Self {
        Self {
            stage: Stage::Assumption,
            assumption: Some(kind),
            detail: detail.into(),
        }
    }
}

/// Supported source data and its read-side omissions or assumptions.
/// The `dataset` is a projection; `omissions` explains what was not carried
/// or verified from the source format. Retain the original file when those
/// details matter.
#[derive(Debug, Clone, PartialEq)]
pub struct ReadResult {
    /// Detected or explicitly selected source format.
    pub format: Format,

    /// Projected mesh and fields.
    pub dataset: Dataset,

    /// Source information omitted or assumed in the projected dataset.
    pub omissions: Vec<Omission>,

    /// True when source point IDs were assigned because the file did not carry them.
    /// Such a mesh cannot verify Nastran result node identity.
    pub generated_point_ids: bool,

    /// Whether an OP2 title marks its result as synthetic all-zero data.
    pub assumed_zero: bool,
}

/// Counts and omissions for one conversion.
/// `fields` counts fields before destination filtering, while `omissions`
/// records source losses, destination losses, and explicit assumptions.
/// The default is an empty report with zero counts.
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct ConversionReport {
    /// Number of source mesh points.
    pub points: usize,

    /// Number of source mesh cells.
    pub cells: usize,

    /// Number of source numeric fields before destination filtering.
    pub fields: usize,

    /// Source and destination omissions, including explicit assumptions.
    pub omissions: Vec<Omission>,

    /// Separate receipt when an OP2 companion mesh is written.
    pub mesh_output: Option<CompanionReport>,
}

/// Receipt for a separately written OP2 companion mesh.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct CompanionReport {
    /// Installed companion path.
    pub path: PathBuf,
    /// Companion mesh format.
    pub format: Format,
    /// Source and destination omissions for the companion.
    pub omissions: Vec<Omission>,
}