runmat-meshing-core 0.6.0

Deterministic meshing preparation contracts 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

use crate::contracts::MeshingStage;

use super::{MeshingStageArtifacts, MeshingStageContractError};

pub fn validate_meshing_stage_order(
    artifacts: &MeshingStageArtifacts,
) -> Result<(), MeshingStageContractError> {
    if artifacts.sizing_field.is_some() {
        require(
            artifacts.cad_model.is_some(),
            MeshingStage::Sizing,
            MeshingStage::CadTopology,
        )?;
    }
    if artifacts.curve_mesh.is_some() {
        require(
            artifacts.cad_model.is_some(),
            MeshingStage::CurveMesh,
            MeshingStage::CadTopology,
        )?;
        require(
            artifacts.sizing_field.is_some(),
            MeshingStage::CurveMesh,
            MeshingStage::Sizing,
        )?;
    }
    if artifacts.surface_mesh.is_some() {
        require(
            artifacts.curve_mesh.is_some(),
            MeshingStage::SurfaceMesh,
            MeshingStage::CurveMesh,
        )?;
    }
    if artifacts.protected_boundary_complex.is_some() {
        require(
            artifacts.surface_mesh.is_some(),
            MeshingStage::ProtectedBoundaryComplex,
            MeshingStage::SurfaceMesh,
        )?;
    }
    if artifacts.initial_tetrahedron_mesh.is_some() {
        require(
            artifacts.protected_boundary_complex.is_some(),
            MeshingStage::TetrahedronMesh,
            MeshingStage::ProtectedBoundaryComplex,
        )?;
        let plc = artifacts
            .protected_boundary_complex
            .as_ref()
            .expect("PLC presence was checked");
        if !plc.validation.valid_for_volume_meshing() {
            return Err(MeshingStageContractError::InvalidProtectedBoundaryComplex);
        }
    }
    if let Some(mesh) = &artifacts.recovered_tetrahedron_mesh {
        require(
            artifacts.initial_tetrahedron_mesh.is_some(),
            MeshingStage::ConstraintRecovery,
            MeshingStage::TetrahedronMesh,
        )?;
        if !mesh.recovery_complete {
            return Err(MeshingStageContractError::UnrecoveredTetrahedronMesh);
        }
    }
    if let Some(mesh) = &artifacts.optimized_tetrahedron_mesh {
        require(
            artifacts.recovered_tetrahedron_mesh.is_some(),
            MeshingStage::Optimization,
            MeshingStage::ConstraintRecovery,
        )?;
        if !mesh.recovery_complete {
            return Err(MeshingStageContractError::UnrecoveredTetrahedronMesh);
        }
    }
    if let Some(report) = &artifacts.solve_readiness {
        require(
            artifacts.optimized_tetrahedron_mesh.is_some(),
            MeshingStage::SolveReadiness,
            MeshingStage::Optimization,
        )?;
        let mesh = artifacts
            .optimized_tetrahedron_mesh
            .as_ref()
            .expect("optimized mesh presence was checked");
        if !mesh.quality_optimized {
            return Err(MeshingStageContractError::UnoptimizedTetrahedronMesh);
        }
        if !report.ready {
            return Err(MeshingStageContractError::SolveReadinessFailed);
        }
    }
    Ok(())
}

fn require(
    condition: bool,
    stage: MeshingStage,
    prerequisite: MeshingStage,
) -> Result<(), MeshingStageContractError> {
    if condition {
        Ok(())
    } else {
        Err(MeshingStageContractError::MissingPrerequisite {
            stage,
            prerequisite,
        })
    }
}