mesh-sieve 4.0.2

Modular, high-performance Rust library for mesh and data management, designed for scientific computing and PDE codes.
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

//! DMPLEX-like external mesh creation/refinement/remeshing workflows.
//!
//! Run with one or more backends enabled, for example:
//! `cargo run --example external_mesh_workflows --features triangle-support,gmsh-support`.

use mesh_sieve::algs::meshgen::{
    GmshInput, GmshOptions, MeshGenOptions, StructuredCellType, TetGenInput, TetGenOptions,
    TriangleInput, TriangleOptions, generate_with_gmsh, generate_with_tetgen,
    generate_with_triangle, remesh_with_gmsh, structured_box_2d,
};
use mesh_sieve::data::storage::VecStorage;
use mesh_sieve::io::MeshData;
use mesh_sieve::topology::cell_type::CellType;
use mesh_sieve::topology::point::PointId;
use mesh_sieve::topology::sieve::{InMemorySieve, Sieve};

fn count_cells(
    mesh: &MeshData<InMemorySieve<PointId, ()>, f64, VecStorage<f64>, VecStorage<CellType>>,
) -> usize {
    let Some(cell_types) = mesh.cell_types.as_ref() else {
        return 0;
    };
    cell_types
        .atlas()
        .points()
        .filter(|point| {
            cell_types
                .try_restrict(*point)
                .is_ok_and(|values| values[0] != CellType::Vertex)
        })
        .count()
}

fn report(name: &str, result: mesh_sieve::algs::meshgen::MeshGenResult) {
    match result {
        Ok(mesh) => println!(
            "{name}: {} cells, {} points",
            count_cells(&mesh),
            mesh.sieve.points().count()
        ),
        Err(err) => println!("{name}: unavailable ({err})"),
    }
}

fn main() {
    // Create: Triangle constrained triangulation of a square with a square hole.
    let triangle_domain = TriangleInput {
        vertices: vec![
            [0.0, 0.0],
            [1.0, 0.0],
            [1.0, 1.0],
            [0.0, 1.0],
            [0.4, 0.4],
            [0.6, 0.4],
            [0.6, 0.6],
            [0.4, 0.6],
        ],
        segments: vec![
            [0, 1],
            [1, 2],
            [2, 3],
            [3, 0],
            [4, 5],
            [5, 6],
            [6, 7],
            [7, 4],
        ],
        holes: vec![[0.5, 0.5]],
        ..TriangleInput::default()
    };
    let triangle_options = TriangleOptions {
        max_area: Some(0.02),
        ..TriangleOptions::default()
    };
    report(
        "triangle create",
        generate_with_triangle(&triangle_domain, &triangle_options),
    );

    // Refine: Gmsh creates a refined unit square from a simple geometry script.
    let gmsh_geo = r#"
        SetFactory("OpenCASCADE");
        Rectangle(1) = {0, 0, 0, 1, 1, 0};
        Mesh.CharacteristicLengthMin = 0.05;
        Mesh.CharacteristicLengthMax = 0.10;
    "#;
    let gmsh_input = GmshInput {
        geo: gmsh_geo.into(),
        dimension: 2,
    };
    report(
        "gmsh create/refine",
        generate_with_gmsh(&gmsh_input, &GmshOptions::default()),
    );

    // Remesh: start from mesh-sieve's structured triangles, then ask Gmsh to reprocess it.
    let coarse = structured_box_2d(
        2,
        2,
        [0.0, 0.0],
        [1.0, 1.0],
        StructuredCellType::Triangle,
        MeshGenOptions::default(),
    )
    .expect("structured seed mesh");
    report(
        "gmsh remesh",
        remesh_with_gmsh(&coarse, 2, &GmshOptions::default()),
    );

    // Create: TetGen tetrahedralizes a closed tetrahedral PLC.
    let tet_domain = TetGenInput {
        vertices: vec![
            [0.0, 0.0, 0.0],
            [1.0, 0.0, 0.0],
            [0.0, 1.0, 0.0],
            [0.0, 0.0, 1.0],
        ],
        facets: vec![vec![0, 2, 1], vec![0, 1, 3], vec![1, 2, 3], vec![2, 0, 3]],
        ..TetGenInput::default()
    };
    report(
        "tetgen create",
        generate_with_tetgen(&tet_domain, &TetGenOptions::default()),
    );
}