Implementations of the GlobalBasis concept. More...

Collaboration diagram for Function space basis implementations:

Classes
class	Dune::Functions::ArgyrisPreBasis< GV, R >
	A pre-basis for a Argyrisbasis. More...
class	Dune::Functions::BSplineLocalBasis< GV, R >
	LocalBasis class in the sense of dune-localfunctions, presenting the restriction of a B-spline patch to a knot span. More...
class	Dune::Functions::BSplineLocalCoefficients< dim >
	Attaches a shape function to an entity. More...
class	Dune::Functions::BSplineLocalInterpolation< dim, LB >
	Local interpolation in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids. More...
class	Dune::Functions::BSplineLocalFiniteElement< GV, R >
	LocalFiniteElement in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids. More...
class	Dune::Functions::BSplinePreBasis< GV >
	Pre-basis for B-spline basis. More...
class	Dune::Functions::CompositePreBasis< IMS, SPB >
	A pre-basis for composite bases. More...
class	Dune::Functions::CubicHermitePreBasis< GV, R, reduced >
	A pre-basis for a Hermitebasis. More...
class	Dune::Functions::HierarchicalLagrangePreBasis< GV, k, R >
	A pre-basis for a hierarchical Lagrange basis. More...
class	Dune::Functions::HierarchicalLagrangeWithElementBubblePreBasis< GV, k, R >
	A pre-basis for a hierarchical basis. More...
class	Dune::Functions::LagrangePreBasis< GV, k, R >
	A pre-basis for a PQ-lagrange bases with given order. More...
class	Dune::Functions::LagrangeDGPreBasis< GV, k, R >
	PreBasis implementation for a Lagrangean-DG finite element space. More...
class	Dune::Functions::LFEPreBasisMixin< GV, LFE >
	A pre-basis mixin class parametrized with a local finite-element and a DOF layout. More...
class	Dune::Functions::MorleyPreBasis< GV, R >
	A pre-basis for a Morleybasis. More...
class	Dune::Functions::RannacherTurekPreBasis< GV >
	Pre-basis for a Rannacher-Turek basis. More...
class	Dune::Functions::RefinedLagrangePreBasis< GV, k, R >
	A pre-basis for a refined Lagrange bases. More...
class	Dune::Functions::Experimental::RestrictedPreBasis< GV, SDPB, SD >
	A pre-basis restricted to a sub-domain. More...
class	Dune::Functions::TaylorHoodPreBasis< GV, HI >
	Pre-basis for lowest order Taylor-Hood basis. More...
class	Dune::Functions::Experimental::TransformedIndexPreBasis< RPB, T >
	A pre-basis transforming multi-indices. More...

Typedefs
template<class GV, class R = double>
using	Dune::Functions::ArgyrisBasis = DefaultGlobalBasis<ArgyrisPreBasis<GV, R> >
	Nodal basis of a scalar cubic Argyris finite element space.
template<typename GV>
using	Dune::Functions::BSplineBasis = DefaultGlobalBasis<BSplinePreBasis<GV> >
	A global B-spline basis.
template<class GV, bool reduced = false, class R = double>
using	Dune::Functions::CubicHermiteBasis = DefaultGlobalBasis<CubicHermitePreBasis<GV, R, reduced> >
	Nodal basis of a scalar cubic Hermite finite element space.
template<typename GV, int k, typename R = double>
using	Dune::Functions::HierarchicalLagrangeBasis = DefaultGlobalBasis<HierarchicalLagrangePreBasis<GV, k, R> >
	Basis of a scalar Hierarchical Lagrange finite element space.
template<typename GV, int k, typename R = double>
using	Dune::Functions::HierarchicalLagrangeWithElementBubbleBasis = DefaultGlobalBasis<HierarchicalLagrangeWithElementBubblePreBasis<GV, k, R> >
	Basis of a Hierarchical Lagrange finite element space with element bubble functions.
template<typename GV, int k = -1, typename R = double>
using	Dune::Functions::LagrangeBasis = DefaultGlobalBasis<LagrangePreBasis<GV, k, R> >
	Nodal basis of a scalar k-th-order Lagrangean finite element space.
template<typename GV, int k = -1, typename R = double>
using	Dune::Functions::LagrangeDGBasis = DefaultGlobalBasis<LagrangeDGPreBasis<GV, k, R> >
	Basis of a scalar k-th-order Lagrangean-DG finite element space.
template<class GV, class R = double>
using	Dune::Functions::MorleyBasis = DefaultGlobalBasis<MorleyPreBasis<GV, R> >
	Nodal basis of a scalar quadratic Morley finite element space.
template<typename GV>
using	Dune::Functions::RannacherTurekBasis = DefaultGlobalBasis<RannacherTurekPreBasis<GV> >
	Rannacher-Turek basis.
template<typename GV, int k, typename R = double>
using	Dune::Functions::RefinedLagrangeBasis = DefaultGlobalBasis<RefinedLagrangePreBasis<GV,k,R> >
	Nodal basis of a continuous Lagrange finite-element space on a uniformly refined simplex element.
template<typename GV>
using	Dune::Functions::TaylorHoodBasis = DefaultGlobalBasis<TaylorHoodPreBasis<GV> >
	Nodal basis for a lowest order Taylor-Hood Lagrangean finite element space.

Functions
template<std::size_t k>
auto	Dune::Functions::BasisFactory::brezziDouglasMarini ()
	Create a pre-basis factory that can create a Brezzi-Douglas-Marini pre-basis.
auto	Dune::Functions::BasisFactory::bSpline (const std::vector< double > &knotVector, unsigned int order, bool makeOpen=true)
	Create a pre-basis factory that can create a B-spline pre-basis.
template<typename... Args, std::enable_if_t< Concept::isIndexMergingStrategy< typename LastType< Args... >::type >(), int > = 0>
auto	Dune::Functions::BasisFactory::composite (Args &&... args)
	Create a factory builder that can build a CompositePreBasis.
template<class ChildPreBasisFactory, class IndexMergingStrategy>
auto	Dune::Functions::BasisFactory::power (ChildPreBasisFactory &&childPreBasisFactory, std::size_t k, const IndexMergingStrategy &)
	Create a pre-basis factory that can build a PowerPreBasis.
template<class ChildPreBasisFactory>
auto	Dune::Functions::BasisFactory::power (ChildPreBasisFactory &&childPreBasisFactory, std::size_t k)
	Create a factory builder that can build a PowerPreBasis.
template<int k, typename R = double>
auto	Dune::Functions::BasisFactory::hierarchicalLagrange ()
	A factory that can create a HierarchicalLagrange pre-basis.
template<int k, typename R = double>
auto	Dune::Functions::BasisFactory::hierarchicalLagrangeWithElementBubble ()
	A factory that can create a HierarchicalLagrangeWithElementBubble pre-basis.
template<std::size_t k, typename R = double>
auto	Dune::Functions::BasisFactory::lagrange ()
	Create a pre-basis factory that can create a Lagrange pre-basis.
template<typename R = double>
auto	Dune::Functions::BasisFactory::lagrange (int order)
	Create a pre-basis factory that can create a Lagrange pre-basis with a run-time order.
template<std::size_t order, typename R = double>
auto	Dune::Functions::BasisFactory::lagrangeDG ()
	Create a pre-basis factory that can create a LagrangeDG pre-basis.
template<typename R = double>
auto	Dune::Functions::BasisFactory::lagrangeDG (unsigned int order)
	Create a pre-basis factory that can create a LagrangeDG pre-basis.
template<std::size_t kind, std::size_t order, typename Range = double>
auto	Dune::Functions::BasisFactory::nedelec ()
	Create a pre-basis factory that can create a Nédélec pre-basis.
template<class RawPreBasisIndicator, class PIS>
auto	Dune::Functions::BasisFactory::Experimental::periodic (RawPreBasisIndicator &&rawPreBasisIndicator, PIS &&periodicIndexSet)
	Create a pre-basis factory that can create a periodic pre-basis.
template<std::size_t k, class ChildPreBasisFactory, class IndexMergingStrategy>
auto	Dune::Functions::BasisFactory::power (ChildPreBasisFactory &&childPreBasisFactory, const IndexMergingStrategy &)
	Create a pre-basis factory that can build a PowerPreBasis.
template<std::size_t k, class ChildPreBasisFactory>
auto	Dune::Functions::BasisFactory::power (ChildPreBasisFactory &&childPreBasisFactory)
	Create a factory builder that can build a PowerPreBasis.
template<class Dummy = void>
auto	Dune::Functions::BasisFactory::rannacherTurek ()
	Create a pre-basis factory that can create a Rannacher-Turek pre-basis.
template<std::size_t k>
auto	Dune::Functions::BasisFactory::raviartThomas ()
	Create a pre-basis factory that can create a Raviart-Thomas pre-basis.
template<int k, typename R = double>
auto	Dune::Functions::BasisFactory::refinedLagrange ()
	Create a pre-basis factory that can create a RefinedLagrange pre-basis.
template<class SubDomainBasisFactory, class SubDomain>
auto	Dune::Functions::Experimental::BasisFactory::restrict (SubDomainBasisFactory &&subPreBasisFactory, const SubDomain &subDomain)
	Create a RestrictedPreBasisFactory.
auto	Dune::Functions::BasisFactory::taylorHood ()
	Create a pre-basis factory that can create a Taylor-Hood pre-basis.

Detailed Description

Implementations of the GlobalBasis concept.

Typedef Documentation

◆ ArgyrisBasis

template<class GV, class R = double>

using Dune::Functions::ArgyrisBasis = DefaultGlobalBasis<ArgyrisPreBasis<GV, R> >

Nodal basis of a scalar cubic Argyris finite element space.

Note

This only works for simplex grids. The Argyris basis is only implemented for degree 5.

The Argyris Finite element has the following properties:

Its global space is in .
Its interpolation evaluates derivatives up to order 2, i.e. you cannot interpolate into a lambda function.
Strongly enforcing boundary conditions is not as simple as with langrange bases
It global space is not nested, i.e. the space on a refined grid is not a subspace of the space on the coarser grid. All arguments passed to the constructor will be forwarded to the constructor of ArgyrisPreBasis.

Template Parameters

GV	The GridView that the space is defined on
R	The range type of the local basis

◆ BSplineBasis

template<typename GV>

using Dune::Functions::BSplineBasis = DefaultGlobalBasis<BSplinePreBasis<GV> >

A global B-spline basis.

Template Parameters

GV	The GridView that the space is defined on

◆ CubicHermiteBasis

template<class GV, bool reduced = false, class R = double>

using Dune::Functions::CubicHermiteBasis = DefaultGlobalBasis<CubicHermitePreBasis<GV, R, reduced> >

Nodal basis of a scalar cubic Hermite finite element space.

Note

This only works for simplex grids. The Hermite basis is only implemented for degree 3.

The Hermite Finite element has the following properties:

Its global space is in if 1d otherwise in .
The reduced version (only 2d) is part of the Discrete Kirchhoff Triangle.
Its interpolation evaluates derivatives, i.e. you cannot interpolate into a lambda function.
Strongly enforcing boundary conditions is not as simple as with langrange bases
It global space is not nested, i.e. the space on a refined grid is not a subspace of the space on the coarser grid. All arguments passed to the constructor will be forwarded to the constructor of CubicHermitePreBasis.

Template Parameters

GV	The GridView that the space is defined on
reduced	whether to use the reduced Hermite finite element (only in 2d).
R	The range type of the local basis

◆ HierarchicalLagrangeBasis

template<typename GV, int k, typename R = double>

using Dune::Functions::HierarchicalLagrangeBasis = DefaultGlobalBasis<HierarchicalLagrangePreBasis<GV, k, R> >

Basis of a scalar Hierarchical Lagrange finite element space.

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis (0 < k <= 2)
R	The range type of the local basis

Note: currently only supports simplex grids

◆ HierarchicalLagrangeWithElementBubbleBasis

template<typename GV, int k, typename R = double>

using Dune::Functions::HierarchicalLagrangeWithElementBubbleBasis = DefaultGlobalBasis<HierarchicalLagrangeWithElementBubblePreBasis<GV, k, R> >

Basis of a Hierarchical Lagrange finite element space with element bubble functions.

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis (0 < k <= 2)
R	The range field-type of the local basis

Note: currently only supports simplex grids

◆ LagrangeBasis

template<typename GV, int k = -1, typename R = double>

using Dune::Functions::LagrangeBasis = DefaultGlobalBasis<LagrangePreBasis<GV, k, R> >

Nodal basis of a scalar k-th-order Lagrangean finite element space.

Note

This only works for certain grids. The following restrictions hold

If k is no larger than 2, then the grids can have any dimension
If k is larger than 3 then the grid must be two-dimensional
If k is 3, then the grid can be 3d if it is a simplex grid

All arguments passed to the constructor will be forwarded to the constructor of LagrangePreBasis.

Warning: The implementation of the basis with run-time order order uses the LagrangeFiniteElement implementation of dune-localfunctions, which is known to violate strict-aliasing rules (see https://gitlab.dune-project.org/core/dune-localfunctions/issues/14) Keep this in mind if ever you experience difficult-to-explain crashes or wrong results.; For pyramid elements in 3d, the shape functions are different for run-time and compile-time order. While the former are defined using the Duffy-transformation the latter are continuous and piecewise polynomial with discontinuous gradients.

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis; -1 means 'order determined at run-time'
R	The range type of the local basis

◆ LagrangeDGBasis

template<typename GV, int k = -1, typename R = double>

using Dune::Functions::LagrangeDGBasis = DefaultGlobalBasis<LagrangeDGPreBasis<GV, k, R> >

Basis of a scalar k-th-order Lagrangean-DG finite element space.

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis
R	The range type of the local basis

◆ MorleyBasis

template<class GV, class R = double>

using Dune::Functions::MorleyBasis = DefaultGlobalBasis<MorleyPreBasis<GV, R> >

Nodal basis of a scalar quadratic Morley finite element space.

Note

This only works for simplex grids. The Morley basis is only implemented for degree 2.

The Morley Finite element has the following properties:

Its global space is not in but can be used for nonconforming method in .
Its interpolation evaluates derivatives, i.e. you cannot interpolate into a lambda function.
Strongly enforcing boundary conditions is not as simple as with langrange bases.
It global space is not nested, i.e. the space on a refined grid is not a subspace of the space on the coarser grid. All arguments passed to the constructor will be forwarded to the constructor of MorleyPreBasis.

Template Parameters

GV	The GridView that the space is defined on
R	The range type of the local basis

◆ RannacherTurekBasis

template<typename GV>

using Dune::Functions::RannacherTurekBasis = DefaultGlobalBasis<RannacherTurekPreBasis<GV> >

Rannacher-Turek basis.

These are Crouzeix-Raviart-elements for quadrilateral elements. See Rolf Rannacher and Stefan Turek. Simple nonconforming quadrilateral Stokes element. Numerical Methods for Partial Differential Equations, 8:97–111, 1992.

Template Parameters

GV	The GridView that the space is defined on

◆ RefinedLagrangeBasis

template<typename GV, int k, typename R = double>

using Dune::Functions::RefinedLagrangeBasis = DefaultGlobalBasis<RefinedLagrangePreBasis<GV,k,R> >

Nodal basis of a continuous Lagrange finite-element space on a uniformly refined simplex element.

Note: This only works for simplex grids.

All arguments passed to the constructor will be forwarded to the constructor of RefinedLagrangeBasis.

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis
R	The range type of the local basis

◆ TaylorHoodBasis

template<typename GV>

using Dune::Functions::TaylorHoodBasis = DefaultGlobalBasis<TaylorHoodPreBasis<GV> >

Nodal basis for a lowest order Taylor-Hood Lagrangean finite element space.

Template Parameters

GV	The GridView that the space is defined on.

Note: This mainly serves as an example, since you can construct a basis with the same functionality manually using
static const int k = 1;

auto taylorHoodBasis = makeBasis(

gridView,

composite(

power<dim>(

lagrange<k+1>(),

flatInterleaved()),

lagrange<k>()

));

Function Documentation

◆ brezziDouglasMarini()

template<std::size_t k>

auto Dune::Functions::BasisFactory::brezziDouglasMarini ( )

Create a pre-basis factory that can create a Brezzi-Douglas-Marini pre-basis.

Template Parameters

k	Order of the Brezzi-Douglas-Marini element

◆ bSpline()

auto Dune::Functions::BasisFactory::bSpline	(	const std::vector< double > &	knotVector,
		unsigned int	order,
		bool	makeOpen = true )

inline

Create a pre-basis factory that can create a B-spline pre-basis.

◆ composite()

template<typename... Args, std::enable_if_t< Concept::isIndexMergingStrategy< typename LastType< Args... >::type >(), int > = 0>

auto Dune::Functions::BasisFactory::composite ( Args &&... args )

Create a factory builder that can build a CompositePreBasis.

Template Parameters

Args	Types of child factory builders and IndexMergingStrategy type

Parameters

args	Child factory builder objects and an IndexMergingStrategy

This is the overload used if the last argument is an IndexMergingStrategy.

◆ hierarchicalLagrange()

template<int k, typename R = double>

auto Dune::Functions::BasisFactory::hierarchicalLagrange ( )

A factory that can create a HierarchicalLagrange pre-basis.

Template Parameters

k	The polynomial order of the ansatz functions (0 < k <= 2)
R	The range field-type of the local basis

◆ hierarchicalLagrangeWithElementBubble()

template<int k, typename R = double>

auto Dune::Functions::BasisFactory::hierarchicalLagrangeWithElementBubble ( )

A factory that can create a HierarchicalLagrangeWithElementBubble pre-basis.

Template Parameters

k	The polynomial order of the ansatz functions (0 < k <= 2)
R	The range field-type of the local basis

◆ lagrange() [1/2]

template<std::size_t k, typename R = double>

auto Dune::Functions::BasisFactory::lagrange ( )

Create a pre-basis factory that can create a Lagrange pre-basis.

Template Parameters

k	The polynomial order of the ansatz functions; -1 means 'order determined at run-time'
R	The range type of the local basis

◆ lagrange() [2/2]

template<typename R = double>

auto Dune::Functions::BasisFactory::lagrange ( int order )

Create a pre-basis factory that can create a Lagrange pre-basis with a run-time order.

Template Parameters

R	The range type of the local basis

◆ lagrangeDG() [1/2]

template<std::size_t order, typename R = double>

auto Dune::Functions::BasisFactory::lagrangeDG ( )

Create a pre-basis factory that can create a LagrangeDG pre-basis.

Template Parameters

order	The polynomial order of the ansatz functions
R	The range type of the local basis

◆ lagrangeDG() [2/2]

template<typename R = double>

auto Dune::Functions::BasisFactory::lagrangeDG ( unsigned int order )

Create a pre-basis factory that can create a LagrangeDG pre-basis.

Template Parameters

R	The range type of the local basis

Parameters

order The polynomial order of the ansatz functions

◆ nedelec()

template<std::size_t kind, std::size_t order, typename Range = double>

auto Dune::Functions::BasisFactory::nedelec ( )

Create a pre-basis factory that can create a Nédélec pre-basis.

Template Parameters

kind	Kind of the Nédélec element (1 or 2)
order	Order of the Nédélec element (lowest order is '1')
Range	Number type used for shape function values

◆ periodic()

template<class RawPreBasisIndicator, class PIS>

auto Dune::Functions::BasisFactory::Experimental::periodic	(	RawPreBasisIndicator &&	rawPreBasisIndicator,
		PIS &&	periodicIndexSet )

Create a pre-basis factory that can create a periodic pre-basis.

Parameters

rawPreBasisIndicator	Object encoding the raw non-periodic basis
periodicIndexSet	A PeriodicIndexSet containing the indices to be identified

The rawPreBasisIndicator can either be a PreBasisFactory, a PreBasis, or a GlobalBasis. In the latter two cases the multi index type of those bases and the periodic basis to be constructed, has to coincide. Both arguments will be copied. Currently only wrapped bases with flat indices are supported.

◆ power() [1/4]

template<std::size_t k, class ChildPreBasisFactory>

auto Dune::Functions::BasisFactory::power ( ChildPreBasisFactory && childPreBasisFactory )

Create a factory builder that can build a PowerPreBasis.

Template Parameters

ChildPreBasisFactory Types of child pre-basis factory

Parameters

childPreBasisFactory Child pre-basis factory

This overload will select the BasisFactory::BlockedInterleaved strategy.

◆ power() [2/4]

template<std::size_t k, class ChildPreBasisFactory, class IndexMergingStrategy>

auto Dune::Functions::BasisFactory::power	(	ChildPreBasisFactory &&	childPreBasisFactory,
		const IndexMergingStrategy &	)

Create a pre-basis factory that can build a PowerPreBasis.

Template Parameters

ChildPreBasisFactory	Types of child pre-basis factory
IndexMergingStrategy	An IndexMergingStrategy type

Parameters

childPreBasisFactory Child pre-basis factory

This overload can be used to explicitly supply an IndexMergingStrategy.

◆ power() [3/4]

template<class ChildPreBasisFactory>

auto Dune::Functions::BasisFactory::power	(	ChildPreBasisFactory &&	childPreBasisFactory,
		std::size_t	k )

Create a factory builder that can build a PowerPreBasis.

Template Parameters

ChildPreBasisFactory Types of child pre-basis factory

Parameters

childPreBasisFactory Child pre-basis factory

This overload will select the BasisFactory::BlockedInterleaved strategy.

◆ power() [4/4]

template<class ChildPreBasisFactory, class IndexMergingStrategy>

auto Dune::Functions::BasisFactory::power	(	ChildPreBasisFactory &&	childPreBasisFactory,
		std::size_t	k,
		const IndexMergingStrategy &	)

Create a pre-basis factory that can build a PowerPreBasis.

Template Parameters

ChildPreBasisFactory	Types of child pre-basis factory
IndexMergingStrategy	An IndexMergingStrategy type

Parameters

childPreBasisFactory Child pre-basis factory

This overload can be used to explicitly supply an IndexMergingStrategy.

◆ rannacherTurek()

template<class Dummy = void>

auto Dune::Functions::BasisFactory::rannacherTurek ( )

Create a pre-basis factory that can create a Rannacher-Turek pre-basis.

◆ raviartThomas()

template<std::size_t k>

auto Dune::Functions::BasisFactory::raviartThomas ( )

Create a pre-basis factory that can create a Raviart-Thomas pre-basis.

Template Parameters

k	Order of the Raviart-Thomas element

◆ refinedLagrange()

template<int k, typename R = double>

auto Dune::Functions::BasisFactory::refinedLagrange ( )

Create a pre-basis factory that can create a RefinedLagrange pre-basis.

Template Parameters

R	The range type of the local basis

◆ restrict()

template<class SubDomainBasisFactory, class SubDomain>

auto Dune::Functions::Experimental::BasisFactory::restrict	(	SubDomainBasisFactory &&	subPreBasisFactory,
		const SubDomain &	subDomain )

Create a RestrictedPreBasisFactory.

This creates a preBasisFactory that restricts a pre-basis to a sub-domain. The subDomain object must support subDomain.gridView(). The returned gridView must be defined on a subset of the host grid view, it must support gridView.contains(element) to check if an element is contained in the sub-domain and it must provide all the interface functions required by the to-be-constructed pre-basis type.

Parameters

subPreBasisFactory	A PreBasisFactory use to create a pre-basis on the sub-domain
subDomain	A sub-domain object

◆ taylorHood()

auto Dune::Functions::BasisFactory::taylorHood ( )

inline

Create a pre-basis factory that can create a Taylor-Hood pre-basis.

Classes

Typedefs

Functions

Detailed Description

Typedef Documentation

◆ ArgyrisBasis

◆ BSplineBasis

◆ CubicHermiteBasis

◆ HierarchicalLagrangeBasis

◆ HierarchicalLagrangeWithElementBubbleBasis

◆ LagrangeBasis

◆ LagrangeDGBasis

◆ MorleyBasis

◆ RannacherTurekBasis

◆ RefinedLagrangeBasis

◆ TaylorHoodBasis

Function Documentation

◆ brezziDouglasMarini()

◆ bSpline()

◆ composite()

◆ hierarchicalLagrange()

◆ hierarchicalLagrangeWithElementBubble()

◆ lagrange() [1/2]

◆ lagrange() [2/2]

◆ lagrangeDG() [1/2]

◆ lagrangeDG() [2/2]

◆ nedelec()

◆ periodic()

◆ power() [1/4]

◆ power() [2/4]

◆ power() [3/4]

◆ power() [4/4]

◆ rannacherTurek()

◆ raviartThomas()

◆ refinedLagrange()

◆ restrict()

◆ taylorHood()