Struct MixedGridBuilder 

pub struct MixedGridBuilder<T: Scalar> { /* private fields */ }

Grid builder for a grid with a mixture of element types

Implementations

impl<T: Scalar> MixedGridBuilder<T>

pub fn new(gdim: usize) -> Self

Create a new grid builder

Examples found in repository

ndgrid/examples/mixed_grid.rs (line 11)

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");
}

Trait Implementations

impl<T: Scalar> Builder for MixedGridBuilder<T>

type Grid = MixedGrid<T, CiarletElement<T, IdentityMap, T>>

The type of the grid that the builder creates

type T = T

The floating point type used for coordinates

type CellData<'a> = (ReferenceCellType, usize, &'a [usize])

The type of the data that is input to add a cell

type EntityDescriptor = ReferenceCellType

Type used as identifier of different entity types

fn add_point(&mut self, id: usize, data: &[T])

Add a point to the grid

fn add_cell( &mut self, id: usize, cell_data: (ReferenceCellType, usize, &[usize]), )

Add a cell to the grid

fn add_cell_from_nodes_and_type( &mut self, id: usize, nodes: &[usize], cell_type: ReferenceCellType, cell_degree: usize, )

Add a cell to the grid

fn create_grid(&self) -> MixedGrid<T, CiarletElement<T, IdentityMap, T>>

Create the grid

fn point_count(&self) -> usize

Number of points

fn cell_count(&self) -> usize

Number of cells

fn point_indices_to_ids(&self) -> &[usize]

Get the insertion ids of each point

fn cell_indices_to_ids(&self) -> &[usize]

Get the insertion ids of each cell

fn cell_points(&self, index: usize) -> &[usize]

Get the indices of the points of a cell

fn cell_vertices(&self, index: usize) -> &[usize]

Get the indices of the points of a cell

fn point(&self, index: usize) -> &[T]

Get the coordinates of a point

fn points(&self) -> &[T]

Get all points

fn cell_type(&self, index: usize) -> ReferenceCellType

Get the type of a cell

fn cell_degree(&self, index: usize) -> usize

Get the degree of a cell’s geometry

fn gdim(&self) -> usize

Geometric dimension

fn tdim(&self) -> usize

Topoligical dimension

fn npts(&self, cell_type: Self::EntityDescriptor, degree: usize) -> usize

Number of points in a cell with the given type and degree

impl<T: Debug + Scalar> Debug for MixedGridBuilder<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.