Trait GmshExport 

pub trait GmshExport: Grid {
    // Required method
    fn to_gmsh_string(&self) -> String;

    // Provided method
    fn export_as_gmsh(&self, filename: &str) { ... }
}

Grid export for Gmsh

Required Methods

fn to_gmsh_string(&self) -> String

Generate the Gmsh string for a grid

Provided Methods

fn export_as_gmsh(&self, filename: &str)

Export as Gmsh

Examples found in repository

ndgrid/examples/io.rs (line 50)

fn main() {
    // Create a grid using the shapes module: unit_cube_boundary will mesh the surface of a cube
    let g = shapes::unit_cube_boundary::<f64>(4, 5, 4, ReferenceCellType::Triangle);

    // If the serde option is used, the raw grid data can be exported in RON format
    g.export_as_ron("_unit_cube_boundary.ron");

    // A grid can be re-imported from raw RON data
    let g2 = SingleElementGrid::<f64, CiarletElement<f64, IdentityMap>>::import_from_ron(
        "_unit_cube_boundary.ron",
    );

    // Print the first 5 cells of each grid
    println!("The first 5 cells of the grids");
    for (cell, cell2) in izip!(
        g.entity_iter(ReferenceCellType::Triangle),
        g2.entity_iter(ReferenceCellType::Triangle)
    )
    .take(5)
    {
        println!(
            "{:?} {:?}",
            cell.topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>(),
            cell2
                .topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>(),
        );
    }

    println!();

    // Alternatively, grids can be exported and imported to/from Gmsh files

    // Export the grid as a Gmsh .msh file
    g.export_as_gmsh("_unit_cube_boundary.msh");

    // To import from a Gmsh .msh file, a builder is used
    let mut b = SingleElementGridBuilder::<f64>::new(3, (ReferenceCellType::Triangle, 1));
    b.import_from_gmsh("_unit_cube_boundary.msh");
    let g3 = b.create_grid();

    // Print the first 5 cells of each grid
    println!("The first 5 cells of the grids");
    for (cell, cell3) in izip!(
        g.entity_iter(ReferenceCellType::Triangle),
        g3.entity_iter(ReferenceCellType::Triangle)
    )
    .take(5)
    {
        println!(
            "{:?} {:?}",
            cell.topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>(),
            cell3
                .topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>(),
        );
    }
}

ndgrid/examples/mixed_grid.rs (line 67)

fn main() {
    // When creating the grid builder, we give the physical/geometric dimension (3)
    let mut b = MixedGridBuilder::<f64>::new(2);
    // Add nine points with ids 0 to 8
    b.add_point(0, &[0.0, 0.0]);
    b.add_point(1, &[0.5, -0.3]);
    b.add_point(2, &[1.0, 0.0]);
    b.add_point(3, &[2.0, 0.0]);
    b.add_point(4, &[-0.3, 0.5]);
    b.add_point(5, &[0.5, 0.5]);
    b.add_point(6, &[0.0, 1.0]);
    b.add_point(7, &[1.0, 1.0]);
    b.add_point(8, &[2.0, 1.0]);
    // Add a linear triangle cell. The inputs to add_cell are
    // (id, (cell type, cell degree, vertices))
    b.add_cell(0, (ReferenceCellType::Triangle, 1, &[2, 7, 6]));
    // Add a quadratic triangle cell. The edge that is shared with cell 0 is straight to ensure
    // that there are no discontinuities in the grid.
    b.add_cell(1, (ReferenceCellType::Triangle, 2, &[0, 2, 6, 5, 4, 1]));
    // Add a quadrilateral cell
    b.add_cell(2, (ReferenceCellType::Quadrilateral, 1, &[2, 3, 7, 8]));
    // Create the grid
    let grid = b.create_grid();

    // Print the vertices of each triangle cell: this will only include the three points
    // for each cell as these are the topological vertices (ie the 0-dimensional entities at
    // each corner of the cell), not the geometric points
    for cell in grid.entity_iter(ReferenceCellType::Triangle) {
        println!(
            "triangle cell {}: {:?}",
            cell.local_index(),
            cell.topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>(),
        );
    }
    // Print the geometric points that definie each cells position in space. Note that
    // The indexing of these points may differ from the indexing used for the topological vertices.
    let mut coords = vec![0.0; 2];
    for cell in grid.entity_iter(ReferenceCellType::Triangle) {
        println!("triangle cell {}:", cell.local_index());
        for p in cell.geometry().points() {
            p.coords(&mut coords);
            println!("  point {}: {:?}", p.index(), coords);
        }
    }
    // Print the vertices of each quadrilateral cell
    for cell in grid.entity_iter(ReferenceCellType::Quadrilateral) {
        println!(
            "quadrilateral cell {}: {:?} ",
            cell.local_index(),
            cell.topology()
                .sub_entity_iter(ReferenceCellType::Point)
                .collect::<Vec<_>>()
        );
    }

    // Export the mesh in Gmsh format
    grid.export_as_gmsh("_mixed.msh");
}

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<G: Grid<EntityDescriptor = ReferenceCellType>> GmshExport for G