Basix
Enumerations | Functions
basix::element Namespace Reference

Interfaces for creating finite elements. More...

Enumerations

enum class  lagrange_variant {
  unset = -1 , equispaced = 0 , gll_warped = 1 , gll_isaac = 2 ,
  gll_centroid = 3 , chebyshev_warped = 4 , chebyshev_isaac = 5 , chebyshev_centroid = 6 ,
  gl_warped = 7 , gl_isaac = 8 , gl_centroid = 9 , legendre = 10 ,
  vtk = 20
}
 Variants of a Lagrange space that can be created.
 
enum class  dpc_variant {
  unset = -1 , simplex_equispaced = 0 , simplex_gll = 1 , horizontal_equispaced = 2 ,
  horizontal_gll = 3 , diagonal_equispaced = 4 , diagonal_gll = 5 , legendre = 6
}
 Variants of a DPC space that can be created.
 
enum class  family {
  custom = 0 , P = 1 , RT = 2 , N1E = 3 ,
  BDM = 4 , N2E = 5 , CR = 6 , Regge = 7 ,
  DPC = 8 , bubble = 9 , serendipity = 10 , HHJ = 11
}
 Available element families.
 

Functions

FiniteElement create_bdm (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_bubble (cell::type celltype, int degree, bool discontinuous)
 
FiniteElement create_cr (cell::type celltype, int degree, bool discontinuous)
 
FiniteElement create_hhj (cell::type celltype, int degree, bool discontinuous)
 
FiniteElement create_lagrange (cell::type celltype, int degree, element::lagrange_variant variant, bool discontinuous)
 
FiniteElement create_rtc (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_nce (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_nedelec (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_nedelec2 (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_rt (cell::type celltype, int degree, element::lagrange_variant lvariant, bool discontinuous)
 
FiniteElement create_regge (cell::type celltype, int degree, bool discontinuous)
 
FiniteElement create_serendipity (cell::type celltype, int degree, element::lagrange_variant lvariant, element::dpc_variant dvariant, bool discontinuous)
 
FiniteElement create_dpc (cell::type celltype, int degree, element::dpc_variant variant, bool discontinuous)
 
FiniteElement create_serendipity_div (cell::type celltype, int degree, element::lagrange_variant lvariant, element::dpc_variant dvariant, bool discontinuous)
 
FiniteElement create_serendipity_curl (cell::type celltype, int degree, element::lagrange_variant lvariant, element::dpc_variant dvariant, bool discontinuous)
 
std::tuple< std::array< std::vector< xt::xtensor< double, 2 > >, 4 >, std::array< std::vector< xt::xtensor< double, 3 > >, 4 > > make_discontinuous (const std::array< std::vector< xt::xtensor< double, 2 >>, 4 > &x, const std::array< std::vector< xt::xtensor< double, 3 >>, 4 > &M, int tdim, int value_size)
 

Detailed Description

Interfaces for creating finite elements.

Function Documentation

◆ create_bdm()

FiniteElement basix::element::create_bdm ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create BDM element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_bubble()

FiniteElement basix::element::create_bubble ( cell::type  celltype,
int  degree,
bool  discontinuous 
)

Create a bubble element on cell with given degree

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_cr()

FiniteElement basix::element::create_cr ( cell::type  celltype,
int  degree,
bool  discontinuous 
)

Crouzeix-Raviart element

Note
degree must be 1 for Crouzeix-Raviart
Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_dpc()

FiniteElement basix::element::create_dpc ( cell::type  celltype,
int  degree,
element::dpc_variant  variant,
bool  discontinuous 
)

Create a DPC element on cell with given degree

Note
DPC elements must be discontinuous
Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]variantThe variant of the element to be created
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_hhj()

FiniteElement basix::element::create_hhj ( cell::type  celltype,
int  degree,
bool  discontinuous 
)

Create Hellan-Herrmann-Johnson element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_lagrange()

FiniteElement basix::element::create_lagrange ( cell::type  celltype,
int  degree,
element::lagrange_variant  variant,
bool  discontinuous 
)

Create a Lagrange element on cell with given degree

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]variantThe variant of the element to be created
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_nce()

FiniteElement basix::element::create_nce ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create NC H(curl) element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_nedelec()

FiniteElement basix::element::create_nedelec ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create Nedelec element (first kind)

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_nedelec2()

FiniteElement basix::element::create_nedelec2 ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create Nedelec element (second kind)

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_regge()

FiniteElement basix::element::create_regge ( cell::type  celltype,
int  degree,
bool  discontinuous 
)

Create Regge element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_rt()

FiniteElement basix::element::create_rt ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create Raviart-Thomas element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_rtc()

FiniteElement basix::element::create_rtc ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
bool  discontinuous 
)

Create RTC H(div) element

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe Lagrange variant to use when defining the element to take integral moments against
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_serendipity()

FiniteElement basix::element::create_serendipity ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
element::dpc_variant  dvariant,
bool  discontinuous 
)

Create a serendipity element on cell with given degree

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe variant of the Lagrange element to be used for integral moments on the edges of the cell
[in]dvariantThe variant of the DPC element to be used for integral moments on the interior of the cell (for quads and hexes). For elements on an interval element::dpc_variant::unset can be passed in
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_serendipity_curl()

FiniteElement basix::element::create_serendipity_curl ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
element::dpc_variant  dvariant,
bool  discontinuous 
)

Create a serendipity H(curl) element on cell with given degree

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe variant of the Lagrange element to be used for integral moments
[in]dvariantThe variant of the DPC element to be used for integral moments
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ create_serendipity_div()

FiniteElement basix::element::create_serendipity_div ( cell::type  celltype,
int  degree,
element::lagrange_variant  lvariant,
element::dpc_variant  dvariant,
bool  discontinuous 
)

Create a serendipity H(div) element on cell with given degree

Parameters
[in]celltypeThe cell type
[in]degreeThe degree of the element
[in]lvariantThe variant of the Lagrange element to be used for integral moments
[in]dvariantThe variant of the DPC element to be used for integral moments
[in]discontinuousControls whether the element is continuous or discontinuous
Returns
A finite element

◆ make_discontinuous()

std::tuple< std::array< std::vector< xt::xtensor< double, 2 > >, 4 >, std::array< std::vector< xt::xtensor< double, 3 > >, 4 > > basix::element::make_discontinuous ( const std::array< std::vector< xt::xtensor< double, 2 >>, 4 > &  x,
const std::array< std::vector< xt::xtensor< double, 3 >>, 4 > &  M,
int  tdim,
int  value_size 
)

Creates a version of the interpolation points, interpolation matrices and entity transformation that represent a discontinuous version of the element. This discontinuous version will have the same DOFs but they will all be associated with the interior of the reference cell.

Parameters
[in]xInterpolation points. Shape is (tdim, entity index, point index, dim)
[in]MThe interpolation matrices. Indices are (tdim, entity index, dof, vs, point_index)
[in]tdimThe topological dimension of the cell the element is defined on
[in]value_sizeThe value size of the element