caexfer 0.2.0

Transfer finite-element meshes, voxel occupancy, 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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Adapter tests for VTK.

use super::{read, read_projection, write_data};
use crate::core::{CellKind, Dataset, Field, FieldLocation};
use crate::formats::bdf;

/// Round-trip legacy VTK topology, original IDs, and numeric arrays.
#[test]
fn all_linear_cells_ids_and_fields_roundtrip() {
    let mesh = bdf::mesh::read(include_bytes!(
        "../../../../tests/fixtures/mixed-linear.bdf"
    ))
    .unwrap()
    .mesh;
    let dataset = Dataset {
        fields: vec![
            Field {
                name: "velocity".into(),
                location: FieldLocation::Point,
                components: vec!["C1".into(), "C2".into(), "C3".into()],
                values: vec![0.5; mesh.points.len() * 3],
                step: None,
                time: None,
            },
            Field {
                name: "energy".into(),
                location: FieldLocation::Cell,
                components: vec!["C1".into()],
                values: (0..mesh.cells.len())
                    .map(|index| f64::from(u32::try_from(index).unwrap()))
                    .collect(),
                step: None,
                time: None,
            },
        ],
        mesh,
    };
    let mut bytes = Vec::new();
    write_data(&dataset, &mut bytes).unwrap();
    let read = read(std::str::from_utf8(&bytes).unwrap()).unwrap();
    assert_eq!(read, dataset);
}

/// Assign deterministic IDs and report the loss when legacy VTK omits them.
#[test]
fn missing_ids_are_reported_and_assigned() {
    let source = "# vtk DataFile Version 2.0\nexample\nASCII\nDATASET UNSTRUCTURED_GRID\nPOINTS 2 float\n0 0 0 1 0 0\nCELLS 1 3\n2 0 1\nCELL_TYPES 1\n3\nPOINT_DATA 2\nSCALARS temperature double 1\nLOOKUP_TABLE default\n1.5 2.5\n";
    let projection = read_projection(source).unwrap();
    assert!(projection.generated_point_ids);
    assert!(projection.generated_cell_ids);
    assert_eq!(projection.dataset.mesh.points[0].id, 1);
    assert_eq!(projection.dataset.fields[0].values, [1.5, 2.5]);
}

/// Read an independently written VTK offsets/connectivity fixture.
#[test]
fn vtk_written_offsets_fixture_preserves_ids_and_topology() {
    let dataset = read(include_str!("../../../../tests/fixtures/vtk-5.1-mixed.vtk")).unwrap();
    assert_eq!(dataset.mesh.points.len(), 9);
    assert_eq!(dataset.mesh.cells.len(), 7);
    assert_eq!(dataset.mesh.cells[0].id, 101);
    assert_eq!(dataset.mesh.cells[6].kind, CellKind::Pyramid5);
    assert_eq!(dataset.mesh.cells[6].connectivity, [0, 1, 2, 3, 8]);
}

/// Reject malformed legacy VTK sections and unsupported datasets.
#[test]
fn malformed_and_unsupported_inputs_fail() {
    let source = "# vtk DataFile Version 2.0\nexample\nASCII\nDATASET UNSTRUCTURED_GRID\nPOINTS 2 float\n0 0 0 1 0 0\nCELLS 1 3\n2 0 2\nCELL_TYPES 1\n3\n";
    assert!(read(source).is_err());
    assert!(read(&source.replace("ASCII", "BINARY")).is_err());
    assert!(read(&source.replace("CELL_TYPES 1\n3", "CELL_TYPES 1\n22")).is_err());
    assert!(read(&source.replace("POINTS 2", "POINTS 999999999")).is_err());
}

/// Preserve supported legacy VTK scalar, vector, and integer arrays.
#[test]
fn scalar_vector_and_integer_attributes_are_preserved() {
    let source = "# vtk DataFile Version 2.0\nattributes\nASCII\nDATASET UNSTRUCTURED_GRID\nPOINTS 2 double\n0 0 0 1 0 0\nCELLS 1 3\n2 0 1\nCELL_TYPES 1\n3\nPOINT_DATA 2\nSCALARS temperature int\nLOOKUP_TABLE default\n2 3\nVECTORS velocity float\n1 2 3 4 5 6\nCELL_DATA 1\nSCALARS pressure unsigned_short 1\nLOOKUP_TABLE default\n7\n";
    let dataset = read(source).unwrap();
    assert_eq!(dataset.fields.len(), 3);
    assert_eq!(dataset.fields[0].values, [2.0, 3.0]);
    assert_eq!(dataset.fields[1].values, [1., 2., 3., 4., 5., 6.]);
    assert_eq!(dataset.fields[2].location, FieldLocation::Cell);
    assert_eq!(dataset.fields[2].values, [7.]);
}

/// Reject incomplete attribute records and invalid cell offsets.
#[test]
fn malformed_legacy_attributes_and_offsets_are_rejected() {
    let base = "# vtk DataFile Version 2.0\nmalformed\nASCII\nDATASET UNSTRUCTURED_GRID\nPOINTS 2 float\n0 0 0 1 0 0\nCELLS 1 3\n2 0 1\nCELL_TYPES 1\n3\n";
    for suffix in [
        "POINT_DATA 2\nSCALARS bad int 1\nLOOKUP_TABLE default\n9007199254740993 1\n",
        "POINT_DATA 2\nSCALARS bad bit 1\nLOOKUP_TABLE default\n0 1\n",
        "POINT_DATA 2\nSCALARS bad double 0\nLOOKUP_TABLE default\n0 1\n",
        "POINT_DATA 2\nSCALARS bad double 1\nLOOKUP_TABLE rainbow\n0 1\n",
        "POINT_DATA 2\nFIELD FieldData 1\nnastran_node_id 1 2 double\n1 2\n",
        "POINT_DATA 2\nSCALARS same double 1\nLOOKUP_TABLE default\n0 1\nSCALARS same double 1\nLOOKUP_TABLE default\n0 1\n",
        "POINT_DATA 2\nFIELD FieldData 1\nnastran_node_id 1 2 int\n0 2\n",
        "CELL_DATA 2\nSCALARS bad double 1\nLOOKUP_TABLE default\n0 1\n",
        "POINT_DATA 2\nFIELD FieldData 1\nshort 2 3 float\n0 1 2 3 4 5\n",
        "POINT_DATA 2\nTEXTURE_COORDINATES uv 2 float\n0 0 1 0\n",
    ] {
        let error = read(&format!("{base}{suffix}")).unwrap_err();
        assert_eq!(error.code, "E_VTK", "{suffix}");
    }
    let offset_base = base.replace(
        "CELLS 1 3\n2 0 1",
        "CELLS 2 2\nOFFSETS vtktypeint64\n0 1\nCONNECTIVITY vtktypeint64\n0 1",
    );
    assert_eq!(read(&offset_base).unwrap_err().code, "E_VTK");
    let unsupported_type = base.replace(
        "CELLS 1 3\n2 0 1",
        "CELLS 2 2\nOFFSETS float\n0 2\nCONNECTIVITY vtktypeint64\n0 1",
    );
    assert_eq!(read(&unsupported_type).unwrap_err().code, "E_VTK");
}

/// Reject contradictory geometry metadata before exposing a partial grid.
#[test]
fn malformed_legacy_grid_metadata_has_specific_diagnostics() {
    let base = "# vtk DataFile Version 2.0\ngeometry\nASCII\nDATASET UNSTRUCTURED_GRID\nPOINTS 2 float\n0 0 0 1 0 0\nCELLS 1 3\n2 0 1\nCELL_TYPES 1\n3\n";
    for (old, new, expected) in [
        (
            "POINTS 2 float",
            "POINTS 2 int",
            "POINTS require float or double",
        ),
        ("0 0 0 1 0 0", "0 0 0 NaN 0 0", "nonfinite VTK value"),
        ("CELLS 1 3", "CELLS 1 2", "cell list exceeds declared size"),
        ("CELLS 1 3", "CELLS 1 4", "cell list size mismatch"),
        ("2 0 1", "9 0 1", "unsupported higher-order cell width"),
        ("CELL_TYPES 1", "CELL_TYPES 2", "cell type count mismatch"),
        (
            "CELL_TYPES 1\n3",
            "CELL_TYPES 1\n5",
            "cell arity does not match",
        ),
    ] {
        let changed = base.replacen(old, new, 1);
        let error = read_projection(&changed).unwrap_err();
        assert!(error.message.contains(expected), "{new}: {error}");
    }
    for source in [
        base.replace("# vtk", "# wrong"),
        base.replace("ASCII", "ASC\0II"),
        format!("{base}UNKNOWN 1\n"),
        format!("{base}POINT_DATA 2\nPOINT_DATA 2\n"),
    ] {
        assert_eq!(read_projection(&source).unwrap_err().code, "E_VTK");
    }
}