caexfer 0.1.1

Transfer 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

//! Supported-subset validation without file output.

use std::path::{Path, PathBuf};

use crate::conversion::{self, Format, Omission, Options};
use crate::core::Result;

/// Supported-subset validation counts, omissions, and assumptions.
/// A passing report does not establish solver-model correctness.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ValidationReport {
    /// Validated source path.
    pub path: PathBuf,
    /// Detected or explicitly selected source format.
    pub format: Format,
    /// Whether strict omission checking was requested.
    pub strict: bool,
    /// Whether the supported-subset check passed under the chosen strictness.
    pub passed: bool,
    /// Projected point count.
    pub points: usize,
    /// Projected cell count.
    pub cells: usize,
    /// Projected numeric field count.
    pub fields: usize,
    /// Information omitted or assumed while reading the source.
    pub omissions: Vec<Omission>,
}

/// Validate one file against caexfer's supported mesh-and-fields subset.
///
/// Like `caexfer validate`, ordinary mode reports source omissions and
/// unverified assumptions. Strict mode marks the report as failed when any
/// notice is present. A non-BDF OP2/PCH companion is read under a reported
/// basic-frame assumption; validation does not accept it for conversion.
/// Parse and projection errors return [`crate::Error`] instead of a report.
///
/// # Errors
///
/// Returns a source format, I/O, size-limit, or projection error.
pub fn validate(path: impl AsRef<Path>, options: &Options) -> Result<ValidationReport> {
    let path = path.as_ref();
    let format = options
        .input_format
        .map_or_else(|| Format::from_input_path(path), Ok)?;
    let mut read_options = options.clone();
    if matches!(format, Format::Op2 | Format::Pch)
        && options.mesh.as_ref().is_some_and(|mesh| {
            Format::from_input_path(mesh).is_ok_and(|mesh_format| mesh_format != Format::Bdf)
        })
    {
        read_options.assume_basic_frame = true;
    }
    let read = conversion::read_path(path, &read_options)?;
    let passed = !options.strict || read.omissions.is_empty();
    Ok(ValidationReport {
        path: path.to_path_buf(),
        format: read.format,
        strict: options.strict,
        passed,
        points: read.dataset.mesh.points.len(),
        cells: read.dataset.mesh.cells.len(),
        fields: read.dataset.fields.len(),
        omissions: read.omissions,
    })
}