dune-functions  2.6-dev
Classes | Typedefs | Functions
Function space basis implementations

Implementations of the GlobalBasis concept. More...

Collaboration diagram for Function space basis implementations:

Classes

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, MI >
 Pre-basis for B-spline basis. More...
 
class  Dune::Functions::CompositePreBasis< MI, IMS, SPB >
 A pre-basis for composite bases. More...
 
class  Dune::Functions::PQ1PreBasis< GV, MI >
 Pre-basis for a first order PQ-lagrange basis. More...
 
class  Dune::Functions::PQkPreBasis< GV, k, MI >
 A pre-basis for PQ-lagrange bases with given order. More...
 
class  Dune::Functions::RannacherTurekPreBasis< GV, MI >
 Pre-basis for a Rannacher-Turek basis. More...
 
class  Dune::Functions::TaylorHoodPreBasis< GV, MI, HI >
 Pre-basis for lowest order Taylor-Hood basis. More...
 

Typedefs

template<typename GV >
using Dune::Functions::BSplineBasis = DefaultGlobalBasis< BSplinePreBasis< GV, FlatMultiIndex< std::size_t > > >
 A global B-spline basis. More...
 
template<typename GV , int k>
using Dune::Functions::LagrangeBasis = DefaultGlobalBasis< PQkPreBasis< GV, k, FlatMultiIndex< std::size_t > > >
 Nodal basis of a scalar k-th-order Lagrangean finite element space. More...
 
template<typename GV , int k>
using Dune::Functions::LagrangeDGBasis = DefaultGlobalBasis< LagrangeDGPreBasis< GV, k, FlatMultiIndex< std::size_t > > >
 Basis of a scalar k-th-order Lagrangean-DG finite element space. More...
 
template<typename GV >
using Dune::Functions::PQ1NodalBasis = DefaultGlobalBasis< PQ1PreBasis< GV, FlatMultiIndex< std::size_t > > >
 Nodal basis of a scalar first-order Lagrangian finite element space. More...
 
template<typename GV , int k>
using Dune::Functions::PQkNodalBasis = DefaultGlobalBasis< PQkPreBasis< GV, k, FlatMultiIndex< std::size_t > > >
 Nodal basis of a scalar k-th-order Lagrangean finite element space. More...
 
template<typename GV >
using Dune::Functions::RannacherTurekBasis = DefaultGlobalBasis< RannacherTurekPreBasis< GV, FlatMultiIndex< std::size_t > > >
 Rannacher-Turek basis. More...
 
template<typename GV >
using Dune::Functions::TaylorHoodBasis = DefaultGlobalBasis< TaylorHoodPreBasis< GV, Dune::ReservedVector< std::size_t, 2 > > >
 Nodal basis for a lowest order Taylor-Hood Lagrangean finite element space. More...
 

Functions

template<typename... Args, std::enable_if_t< Concept::isIndexMergingStrategy< typename LastType< Args... >::type >(), int > = 0>
auto Dune::Functions::BasisBuilder::composite (Args &&... args)
 Create a factory builder that can build a CompositePreBasis. More...
 
template<std::size_t k>
auto Dune::Functions::BasisBuilder::lagrange ()
 Create a pre-basis factory that can create a PQ_k pre-basis. More...
 
template<std::size_t k, class ChildPreBasisFactory , class IndexMergingStrategy >
auto Dune::Functions::BasisBuilder::power (ChildPreBasisFactory &&childPreBasisFactory, const IndexMergingStrategy &ims)
 Create a pre-basis factory that can build a PowerPreBasis. More...
 
template<std::size_t k, class ChildPreBasisFactory >
auto Dune::Functions::BasisBuilder::power (ChildPreBasisFactory &&childPreBasisFactory)
 Create a factory builder that can build a PowerPreBasis. More...
 
template<std::size_t k>
auto Dune::Functions::BasisBuilder::pq ()
 Create a pre-basis factory that can create a PQ_k pre-basis. More...
 
template<class Dummy = void>
auto Dune::Functions::BasisBuilder::rannacherTurek ()
 Create a pre-basis factory that can create a Rannacher-Turek pre-basis. More...
 
template<std::size_t k, GeometryType::BasicType basic_type, class size_type = std::size_t>
auto Dune::Functions::BasisBuilder::rt ()
 Create a pre-basis factory that can create a Raviart-Thomas pre-basis. More...
 

Detailed Description

Implementations of the GlobalBasis concept.

Typedef Documentation

◆ BSplineBasis

template<typename GV >
using Dune::Functions::BSplineBasis = typedef DefaultGlobalBasis<BSplinePreBasis<GV, FlatMultiIndex<std::size_t> > >

A global B-spline basis.

Template Parameters
GVThe GridView that the space is defined on

◆ LagrangeBasis

template<typename GV , int k>
using Dune::Functions::LagrangeBasis = typedef DefaultGlobalBasis<PQkPreBasis<GV, k, FlatMultiIndex<std::size_t> > >

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 PQkPreBasis.

Template Parameters
GVThe GridView that the space is defined on
kThe order of the basis

◆ LagrangeDGBasis

template<typename GV , int k>
using Dune::Functions::LagrangeDGBasis = typedef DefaultGlobalBasis<LagrangeDGPreBasis<GV, k, FlatMultiIndex<std::size_t> > >

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

Template Parameters
GVThe GridView that the space is defined on
kThe order of the basis

◆ PQ1NodalBasis

template<typename GV >
using Dune::Functions::PQ1NodalBasis = typedef DefaultGlobalBasis<PQ1PreBasis<GV, FlatMultiIndex<std::size_t> > >

Nodal basis of a scalar first-order Lagrangian finite element space.

Template Parameters
GVThe GridView that the space is defined on
Note
This mainly serves as an example, since PQkNodalBasis<GV,1> provides the same functionality.

◆ PQkNodalBasis

template<typename GV , int k>
using Dune::Functions::PQkNodalBasis = typedef DefaultGlobalBasis<PQkPreBasis<GV, k, FlatMultiIndex<std::size_t> > >

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 PQkPreBasis.

Template Parameters
GVThe GridView that the space is defined on
kThe order of the basis

◆ RannacherTurekBasis

template<typename GV >
using Dune::Functions::RannacherTurekBasis = typedef DefaultGlobalBasis<RannacherTurekPreBasis<GV, FlatMultiIndex<std::size_t> > >

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
GVThe GridView that the space is defined on

◆ TaylorHoodBasis

template<typename GV >
using Dune::Functions::TaylorHoodBasis = typedef DefaultGlobalBasis<TaylorHoodPreBasis<GV, Dune::ReservedVector<std::size_t, 2> > >

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

Template Parameters
GVThe 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,
power<dim>(
lagrange<k+1>(),
lagrange<k>()
));

Function Documentation

◆ composite()

template<typename... Args, std::enable_if_t< Concept::isIndexMergingStrategy< typename LastType< Args... >::type >(), int > = 0>
auto Dune::Functions::BasisBuilder::composite ( Args &&...  args)

Create a factory builder that can build a CompositePreBasis.

Template Parameters
ArgsTypes of child factory builders and IndexMergingStrategy type
Parameters
argsChild factory builder objects and an IndexMergingStrategy

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

Template Parameters
ArgsTypes of child factory builders
Parameters
argsChild factory builder objects

This is the overload used if no IndexMergingStrategy is supplied. In this case the BasisBuilder::BlockedLexicographic strategy is used.

◆ lagrange()

template<std::size_t k>
auto Dune::Functions::BasisBuilder::lagrange ( )

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

Template Parameters
kThe polynomial order of ansatz functions

◆ power() [1/2]

template<std::size_t k, class ChildPreBasisFactory , class IndexMergingStrategy >
auto Dune::Functions::BasisBuilder::power ( ChildPreBasisFactory &&  childPreBasisFactory,
const IndexMergingStrategy ims 
)

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

Template Parameters
ChildPreBasisFactoryTypes of child pre-basis factory
IndexMergingStrategyAn IndexMergingStrategy type
Parameters
childPreBasisFactoryChild pre-basis factory
imsIndexMergingStrategy to be used

This overload can be used to explicitly supply an IndexMergingStrategy.

◆ power() [2/2]

template<std::size_t k, class ChildPreBasisFactory >
auto Dune::Functions::BasisBuilder::power ( ChildPreBasisFactory &&  childPreBasisFactory)

Create a factory builder that can build a PowerPreBasis.

Template Parameters
ChildPreBasisFactoryTypes of child pre-basis factory
Parameters
childPreBasisFactoryChild pre-basis factory

This overload will select the BasisBuilder::LeafBlockedInterleaved strategy.

◆ pq()

template<std::size_t k>
auto Dune::Functions::BasisBuilder::pq ( )

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

Template Parameters
kThe polynomial order of ansatz functions

◆ rannacherTurek()

template<class Dummy = void>
auto Dune::Functions::BasisBuilder::rannacherTurek ( )

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

◆ rt()

template<std::size_t k, GeometryType::BasicType basic_type, class size_type = std::size_t>
auto Dune::Functions::BasisBuilder::rt ( )

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

Template Parameters
kOrder of the Raviart-Thomas element
basic_typeBasic geometry type