Struct LagrangeElementFamily 

pub struct LagrangeElementFamily<T: RlstScalar + Getrf + Getri = f64, TGeo: RlstScalar = f64> { /* private fields */ }

Lagrange element family.

A family of Lagrange elements on multiple cell types with appropriate continuity across different cell types.

Implementations

impl<T: RlstScalar + Getrf + Getri, TGeo: RlstScalar> LagrangeElementFamily<T, TGeo>

pub fn new(degree: usize, continuity: Continuity) -> Self

Create new family with given degree and continuity.

Examples found in repository

ndfunctionspace/examples/test_parallel_space.rs (line 26)

fn test_parallel_function_space<C: Communicator>(comm: &C) {
    let grid = unit_cube_distributed::<f64, _>(
        comm,
        GraphPartitioner::None,
        4,
        4,
        4,
        ReferenceCellType::Tetrahedron,
    );

    let family = LagrangeElementFamily::<f64>::new(2, Continuity::Standard);
    let space = ParallelFunctionSpaceImpl::new(&grid, &family);
    let serial_grid = unit_cube::<f64>(4, 4, 4, ReferenceCellType::Tetrahedron);
    let serial_space = FunctionSpaceImpl::new(&serial_grid, &family);

    assert_eq!(space.global_size(), serial_space.global_size());
}

ndelement/examples/element_family.rs (line 8)

fn main() {
    // Create the degree 2 Lagrange element family. A family is a set of finite elements with the
    // same family type, degree, and continuity across a set of cells
    let family = LagrangeElementFamily::<f64, f64>::new(2, Continuity::Standard);

    // Get the element in the family on a triangle
    let element = family.element(ReferenceCellType::Triangle);
    println!("Cell: {:?}", element.cell_type());

    // Get the element in the family on a quadrilateral
    let element = family.element(ReferenceCellType::Quadrilateral);
    println!("Cell: {:?}", element.cell_type());
}

ndfunctionspace/examples/test_mass_matrix.rs (line 21)

fn test_lagrange_mass_matrix() {
    let grid = regular_sphere(0);

    let family = LagrangeElementFamily::<f64>::new(1, Continuity::Standard);
    let space = FunctionSpaceImpl::new(&grid, &family);

    let mut mass_matrix = rlst_dynamic_array!(f64, [space.local_size(), space.local_size()]);

    let element = &space.elements()[0];

    let (p, w) = single_integral_quadrature(
        QuadratureRule::XiaoGimbutas,
        Domain::Triangle,
        2 * element.lagrange_superdegree(),
    )
    .unwrap();
    let npts = w.len();
    let mut pts = rlst_dynamic_array!(f64, [2, npts]);
    for i in 0..w.len() {
        for j in 0..2 {
            *pts.get_mut([j, i]).unwrap() = p[3 * i + j];
        }
    }
    let wts = w.iter().map(|i| *i / 2.0).collect::<Vec<_>>();

    let mut table = DynArray::<f64, 4>::from_shape(element.tabulate_array_shape(0, npts));
    element.tabulate(&pts, 0, &mut table);

    let gmap = grid.geometry_map(ReferenceCellType::Triangle, 1, &pts);
    let mut jacobians = rlst_dynamic_array!(f64, [grid.geometry_dim(), grid.topology_dim(), npts]);
    let mut jinv = rlst_dynamic_array!(f64, [grid.topology_dim(), grid.geometry_dim(), npts]);
    let mut jdets = vec![0.0; npts];

    for cell in grid.entity_iter(ReferenceCellType::Triangle) {
        let dofs = space
            .entity_closure_dofs(ReferenceCellType::Triangle, cell.local_index())
            .unwrap();
        gmap.jacobians_inverses_dets(cell.local_index(), &mut jacobians, &mut jinv, &mut jdets);
        for (test_i, test_dof) in dofs.iter().enumerate() {
            for (trial_i, trial_dof) in dofs.iter().enumerate() {
                *mass_matrix.get_mut([*test_dof, *trial_dof]).unwrap() += wts
                    .iter()
                    .enumerate()
                    .map(|(i, w)| {
                        jdets[i]
                            * *w
                            * *table.get([0, i, test_i, 0]).unwrap()
                            * *table.get([0, i, trial_i, 0]).unwrap()
                    })
                    .sum::<f64>();
            }
        }
    }

    // Compare matrix entries to values from Bempp
    for i in 0..6 {
        assert_relative_eq!(mass_matrix[[i, i]], 0.5773502691896255, epsilon = 1e-10);
    }
    for i in 0..6 {
        for j in 0..6 {
            if i != j && mass_matrix[[i, j]].abs() > 0.001 {
                assert_relative_eq!(mass_matrix[[i, j]], 0.1443375672974061, epsilon = 1e-10);
            }
        }
    }
}

Trait Implementations

impl<T: RlstScalar + Getrf + Getri, TGeo: RlstScalar> ElementFamily for LagrangeElementFamily<T, TGeo>

type T = T

The scalar type

type FiniteElement = CiarletElement<T, IdentityMap, TGeo>

The finite element type

type CellType = ReferenceCellType

Cell type

fn element( &self, cell_type: ReferenceCellType, ) -> CiarletElement<T, IdentityMap, TGeo>

Create an element for the given cell type.