runmat-meshing 0.6.0

Topology-first meshing pipeline orchestration for RunMat
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
133
134
135
136
137

use runmat_meshing_core::contracts::AnalysisFieldTopologyLocation;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FieldMappingError {
    FieldTopologyMissing {
        topology_id: String,
        location: AnalysisFieldTopologyLocation,
        element_kind: Option<String>,
    },
    FieldTopologyCountMismatch {
        topology_id: String,
        location: AnalysisFieldTopologyLocation,
        expected_entity_count: usize,
        actual_entity_count: usize,
    },
    FieldTopologyElementKindMismatch {
        topology_id: String,
        location: AnalysisFieldTopologyLocation,
        expected_element_kind: String,
        actual_element_kind: Option<String>,
    },
    ElementFieldLengthMismatch {
        element_value_count: usize,
        volume_element_count: usize,
    },
    NodeVectorFieldLengthMismatch {
        node_value_count: usize,
        node_count: usize,
    },
    NonFiniteElementValue {
        element_index: usize,
    },
    NonFiniteNodeVectorValue {
        node_index: usize,
        component_index: usize,
    },
    BoundaryFaceMissingAdjacentVolume {
        face_id: String,
    },
    BoundaryFaceReferencesUnknownVolume {
        face_id: String,
        volume_element_id: String,
    },
    BoundaryFaceReferencesUnknownNode {
        face_id: String,
        node_id: u32,
    },
    BoundaryFaceHasNoNodes {
        face_id: String,
    },
    BoundaryEdgeReferencesUnknownNode {
        edge_id: String,
        node_id: u32,
    },
}

impl std::fmt::Display for FieldMappingError {
    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::FieldTopologyMissing {
                topology_id,
                location,
                element_kind,
            } => write!(
                formatter,
                "mesh field topology descriptor is missing: topology_id={topology_id} location={location:?} element_kind={}",
                element_kind.as_deref().unwrap_or("none")
            ),
            Self::FieldTopologyCountMismatch {
                topology_id,
                location,
                expected_entity_count,
                actual_entity_count,
            } => write!(
                formatter,
                "mesh field topology count mismatch: topology_id={topology_id} location={location:?} expected_entity_count={expected_entity_count} actual_entity_count={actual_entity_count}"
            ),
            Self::FieldTopologyElementKindMismatch {
                topology_id,
                location,
                expected_element_kind,
                actual_element_kind,
            } => write!(
                formatter,
                "mesh field topology element kind mismatch: topology_id={topology_id} location={location:?} expected_element_kind={expected_element_kind} actual_element_kind={}",
                actual_element_kind.as_deref().unwrap_or("none")
            ),
            Self::ElementFieldLengthMismatch {
                element_value_count,
                volume_element_count,
            } => write!(
                formatter,
                "element scalar field length {element_value_count} does not match volume element count {volume_element_count}"
            ),
            Self::NodeVectorFieldLengthMismatch {
                node_value_count,
                node_count,
            } => write!(
                formatter,
                "node vector field length {node_value_count} does not match mesh node count {node_count}"
            ),
            Self::NonFiniteElementValue { element_index } => {
                write!(formatter, "element scalar field value {element_index} is not finite")
            }
            Self::NonFiniteNodeVectorValue {
                node_index,
                component_index,
            } => write!(
                formatter,
                "node vector field value {node_index} component {component_index} is not finite"
            ),
            Self::BoundaryFaceMissingAdjacentVolume { face_id } => {
                write!(formatter, "boundary face {face_id} has no adjacent volume element")
            }
            Self::BoundaryFaceReferencesUnknownVolume {
                face_id,
                volume_element_id,
            } => write!(
                formatter,
                "boundary face {face_id} references unknown volume element {volume_element_id}"
            ),
            Self::BoundaryFaceReferencesUnknownNode { face_id, node_id } => write!(
                formatter,
                "boundary face {face_id} references unknown node {node_id}"
            ),
            Self::BoundaryFaceHasNoNodes { face_id } => {
                write!(formatter, "boundary face {face_id} has no nodes")
            }
            Self::BoundaryEdgeReferencesUnknownNode { edge_id, node_id } => write!(
                formatter,
                "boundary edge {edge_id} references unknown node {node_id}"
            ),
        }
    }
}

impl std::error::Error for FieldMappingError {}