Dune::Functions Namespace Reference

Namespaces
namespace	BasisBuilder
namespace	BasisFactory
namespace	Concept
namespace	ContainerDescriptors
namespace	Experimental
namespace	ImplDoc

Classes
class	AnalyticGridViewFunction
class	AnalyticGridViewFunction< Range(Domain), GV, F, DerivativeTraits >
	Class wrapping any differentiable function as grid function. More...
class	BasisNodeMixin
class	BrezziDouglasMariniNode
class	BrezziDouglasMariniPreBasis
class	BSplineLocalBasis
	LocalBasis class in the sense of dune-localfunctions, presenting the restriction of a B-spline patch to a knot span. More...
class	BSplineLocalCoefficients
	Attaches a shape function to an entity. More...
class	BSplineLocalFiniteElement
	LocalFiniteElement in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids. More...
class	BSplineLocalInterpolation
	Local interpolation in the sense of dune-localfunctions, for the B-spline basis on tensor-product grids. More...
class	BSplineNode
class	BSplinePreBasis
	Pre-basis for B-spline basis. More...
class	ComposedGridFunction
	Composition of grid functions with another function. More...
class	CompositeBasisNode
class	CompositePreBasis
	A pre-basis for composite bases. More...
struct	DefaultDerivativeTraits
	Default implementation for derivative traits. More...
struct	DefaultDerivativeTraits< double(double) >
	Default implementation for derivative traits. More...
struct	DefaultDerivativeTraits< FieldMatrix< K, 1, m >(FieldVector< K, n >)>
	Default implementation for derivative traits. More...
struct	DefaultDerivativeTraits< FieldVector< K, m >(FieldVector< K, n >)>
	Default implementation for derivative traits. More...
struct	DefaultDerivativeTraits< K(FieldVector< K, n >)>
	Default implementation for derivative traits. More...
class	DefaultGlobalBasis
	Global basis for given pre-basis. More...
class	DefaultLocalView
	The restriction of a finite element basis to a single element. More...
struct	DefaultNodeToRangeMap
	A simple node to range map using lexicographic ordering. More...
class	DifferentiableFunction
class	DifferentiableFunction< Range(Domain), DerivativeTraits, bufferSize >
	Class storing differentiable functions using type erasure. More...
class	DifferentiableFunctionFromCallables
class	DifferentiableFunctionFromCallables< Range(Domain), DerivativeTraits, F >
	Wrap a list of callable objects as derivative sequence modelling Concept::DifferentiableFunction<Range(Domain), DerivativeTraits> More...
class	DifferentiableFunctionFromCallables< Range(Domain), DerivativeTraits, F, DF, Derivatives... >
	Wrap a list of callable objects as derivative sequence modelling Concept::DifferentiableFunction<Range(Domain), DerivativeTraits> More...
class	DiscreteGlobalBasisFunction
	A grid function induced by a global basis and a coefficient vector. More...
class	DiscreteGlobalBasisFunctionDerivative
	Derivative of a DiscreteGlobalBasisFunction More...
class	DynamicPowerBasisNode
class	DynamicPowerPreBasis
	A pre-basis for dynamic power bases. More...
class	FaceNormalGridFunction
	Grid function implementing the piecewise element face normal. More...
class	GridFunction
class	GridFunction< Range(Domain), ES, DerivativeTraits, bufferSize >
	Wrapper class for functions defined on a Grid. More...
class	GridViewEntitySet
	An entity set for all entities of given codim in a grid view. More...
class	GridViewFunction
class	GridViewFunction< Range(Domain), GV, DerivativeTraits, bufferSize >
	Wrapper class for functions defined on a GridView. More...
struct	HasStaticSize
	Check if type is a statically sized container. More...
class	HierarchicalLagrangePreBasis
	A pre-basis for a hierarchical Lagrange basis. More...
class	HierarchicalLagrangePreBasis< GV, 1, R >
class	HierarchicalLagrangePreBasis< GV, 2, R >
struct	HierarchicNodeToRangeMap
	A simple node to range map using the nested tree indices. More...
class	HierarchicVectorWrapper
	A wrapper providing multiindex access to vector entries. More...
class	InvalidRange
	Dummy range class to be used if no proper type is available. More...
struct	IsCallable
	Helper class to check that F is callable. More...
class	LagrangeDGPreBasis
class	LagrangeNode
class	LagrangePreBasis
	A pre-basis for a PQ-lagrange bases with given order. More...
struct	LastType
	Get last entry of type list. More...
class	LeafBasisNode
class	LeafPreBasisMapperMixin
	A generic MixIn class for PreBasis with flat indices computed from a mapper. More...
class	LeafPreBasisMixin
	A generic MixIn class for PreBasis. More...
class	LFEPreBasisMixin
	A pre-basis mixin class parametrized with a local finite-element and a DOF layout. More...
struct	LocalDerivativeTraits
	Derivative traits for local functions. More...
class	LocalFunction
class	LocalFunction< Range(Domain), LocalContext, DerivativeTraits, bufferSize >
	Class storing local functions using type erasure. More...
class	NedelecNode
class	NedelecPreBasis
class	OverflowArray
	A dynamically sized array-like class with overflow. More...
class	PolymorphicSmallObject
	A wrapper providing small object optimization with polymorphic types. More...
class	PolymorphicType
	Base class with polymorphic type boiler plate code. More...
class	Polynomial
	A univariate polynomial implementation. More...
class	PowerBasisNode
class	PowerPreBasis
	A pre-basis for power bases. More...
class	RannacherTurekNode
class	RannacherTurekPreBasis
	Pre-basis for a Rannacher-Turek basis. More...
class	RaviartThomasNode
class	RaviartThomasPreBasis
class	RefinedLagrangeNode
class	RefinedLagrangePreBasis
	A pre-basis for a refined Lagrange bases. More...
class	ReservedDeque
	A double-ended queue (deque) class with statically reserved memory. More...
struct	RotateTuple
	Rotate type list by one, such that last entry is moved to first position. More...
struct	SignatureTag
struct	SignatureTag< Range(Domain), DerivativeTraitsT >
	Tag-class to encapsulate signature information. More...
struct	SignatureTraits
	Helper class to deduce the signature of a callable. More...
class	SizeInfo
	A class encapsulating size information. More...
class	StaticMultiIndex
	A statically sized MultiIndex type. More...
class	StaticMultiIndex< size_type, 1 >
	A statically sized MultiIndex type. More...
struct	StaticSizeOrZero
	Obtain size of statically sized container, or 0 if dynamic size. More...
class	SubEntityDOFs
	Range of DOFs associated to sub-entity. More...
class	SubspaceBasis
class	SubspaceLocalView
	The restriction of a finite element basis to a single element. More...
class	TaylorHoodBasisTree
class	TaylorHoodPreBasis
	Pre-basis for lowest order Taylor-Hood basis. More...
class	TaylorHoodVelocityTree
class	TrigonometricFunction
	A linear combination of trigonomic functions. More...
class	TypeErasureBase
	Base class for type-erased interface wrapper. More...

Typedefs
template<class T , class... Args>
using	enableIfConstructible = std::enable_if_t< std::is_constructible_v< T, Args... >, int >
	Helper to constrain forwarding constructors.
template<class T >
using	StaticSize = std::enable_if_t< HasStaticSize_v< T >, decltype(Dune::Hybrid::size(std::declval< T >()))>
	Obtain size of statically sized container as integral_constant, or fail.
template<template< class... > class T, class ArgTuple >
using	ExpandTuple = typename Imp::ExpandTupleHelper< T, ArgTuple >::Type
	Expand tuple arguments as template arguments.
template<template< class... > class F, class... Tuples>
using	TransformTuple = typename Imp::TransformTupleHelper< F, Tuples... >::Type
	Transform tuple types argument using type-functor.
template<class IntegerSequence >
using	IntegerSequenceTuple = typename Imp::IntegerSequenceTupleHelper< IntegerSequence >::Type
	Transform integer_sequence<I,k...> to tuple<integral_constant<I,k>...>
template<typename GV , int k>
using	BrezziDouglasMariniBasis = DefaultGlobalBasis< BrezziDouglasMariniPreBasis< GV, k > >
	Basis of a scalar k-th-order BDM finite element space on simplex and cube grids.
template<typename GV >
using	BSplineBasis = DefaultGlobalBasis< BSplinePreBasis< GV > >
	A global B-spline basis.
template<class size_type >
using	FlatMultiIndex = StaticMultiIndex< size_type, 1 >
	A multi-index class with only one level.
template<typename GV , int k, typename R = double>
using	HierarchicalLagrangeBasis = DefaultGlobalBasis< HierarchicalLagrangePreBasis< GV, k, R > >
	Basis of a scalar Hierarchical Lagrange finite element space.
template<typename GV , int k = -1, typename R = double>
using	LagrangeBasis = DefaultGlobalBasis< LagrangePreBasis< GV, k, R > >
	Nodal basis of a scalar k-th-order Lagrangean finite element space.
template<typename GV , int k>
using	LagrangeDGNode = LagrangeNode< GV, k >
template<typename GV , int k>
using	LagrangeDGBasis = DefaultGlobalBasis< LagrangeDGPreBasis< GV, k > >
	Basis of a scalar k-th-order Lagrangean-DG finite element space.
template<typename GV , std::size_t kind, std::size_t order, typename Range = double>
using	NedelecBasis = DefaultGlobalBasis< NedelecPreBasis< GV, Range, kind, order > >
	Basis of a k-th-order Nédélec finite element space.
template<typename GV >
using	RannacherTurekBasis = DefaultGlobalBasis< RannacherTurekPreBasis< GV > >
	Rannacher-Turek basis.
template<typename GV , int k>
using	RaviartThomasBasis = DefaultGlobalBasis< RaviartThomasPreBasis< GV, k > >
	Basis of a k-th-order Raviart Thomas finite element space.
template<typename GV , int k, typename R = double>
using	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	TaylorHoodBasis = DefaultGlobalBasis< TaylorHoodPreBasis< GV > >
	Nodal basis for a lowest order Taylor-Hood Lagrangean finite element space.

Functions
template<class K >
	Polynomial (std::vector< K >) -> Polynomial< K, std::vector< K > >
template<class K , std::size_t n>
	Polynomial (std::array< K, n >) -> Polynomial< K, std::array< K, n > >
template<class K , K... ci>
	Polynomial (std::integer_sequence< K, ci... >) -> Polynomial< K, std::integer_sequence< K, ci... > >
template<class K >
	Polynomial (std::initializer_list< K >) -> Polynomial< K, std::vector< K > >
template<class K , class Coefficients >
auto	makePolynomial (Coefficients coefficients)
	Create Polynomial.
template<class K , class C >
auto	makePolynomial (std::initializer_list< C > coefficients)
	Create Polynomial.
template<class K , int sinFactor, int cosFactor>
TrigonometricFunction< K, -cosFactor, sinFactor >	derivative (const TrigonometricFunction< K, sinFactor, cosFactor > &f)
	Obtain derivative of TrigonometricFunction function.
template<class V >
constexpr auto	fieldTypes ()
	Generate list of field types in container.
template<class V >
constexpr bool	hasUniqueFieldType ()
	Check if container has a unique field type.
template<class Vector >
auto	istlVectorBackend (Vector &v)
	Return a vector backend wrapping non-const ISTL like containers.
template<class Vector >
auto	istlVectorBackend (const Vector &v)
	Return a vector backend wrapping const ISTL like containers.
template<class Signature , template< class > class DerivativeTraits, class... F>
DifferentiableFunctionFromCallables< Signature, DerivativeTraits, F... >	makeDifferentiableFunctionFromCallables (const SignatureTag< Signature, DerivativeTraits > &signatureTag, F &&... f)
	Create a DifferentiableFunction from callables.
template<class C , class I , class F , std::enable_if_t< Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int > = 0>
auto	hybridIndexAccess (C &&c, const I &i, F &&f) -> decltype(f(c[i]))
	Provide operator[] index-access for containers.
template<class C , class I , class F , std::enable_if_t< not Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int > = 0>
decltype(auto)	hybridIndexAccess (C &&c, const I &i, F &&f)
	Provide operator[] index-access for containers.
template<class Result , class C , class MultiIndex >
Result	hybridMultiIndexAccess (C &&c, const MultiIndex &index)
	Provide multi-index access by chaining operator[].
template<class C , class MultiIndex , class IsFinal >
constexpr decltype(auto)	resolveDynamicMultiIndex (C &&c, const MultiIndex &multiIndex, const IsFinal &isFinal)
	Provide multi-index access by chaining operator[].
template<class C , class MultiIndex >
constexpr decltype(auto)	resolveDynamicMultiIndex (C &&c, const MultiIndex &multiIndex)
	Provide multi-index access by chaining operator[].
template<class C , class MultiIndex >
constexpr decltype(auto)	resolveStaticMultiIndex (C &&c, const MultiIndex &multiIndex)
	Provide multi-index access by chaining operator[].
template<typename Stream , class size_type , std::size_t n>
Stream &	operator<< (Stream &stream, const StaticMultiIndex< size_type, n > &c)
template<class Range , class Domain , template< class > class DerivativeTraits>
auto	derivativeSignatureTag (SignatureTag< Range(Domain), DerivativeTraits > tag)
	Construct SignatureTag for derivative.
template<std::size_t maxOrder, class Signature , template< class > class DerivativeTraits>
auto	derivativeSignatureTags (Dune::Functions::SignatureTag< Signature, DerivativeTraits > tag)
	Construct SignatureTags for derivatives.
template<std::size_t begin_t, std::size_t end_t, class F , class... Args>
void	staticFindInRange (F &&f, Args &&... args)
	Static find loop.
template<class F , class size_type , size_type firstValue, class... Args>
auto	forwardAsStaticInteger (std::integer_sequence< size_type, firstValue > values, const size_type &i, F &&f, Args &&... args) -> decltype(f(std::integral_constant< size_type, firstValue >(), std::forward< Args >(args)...))
template<class F , class size_type , size_type firstValue, size_type secondValue, size_type... otherValues, class... Args>
auto	forwardAsStaticInteger (std::integer_sequence< size_type, firstValue, secondValue, otherValues... > values, const size_type i, F &&f, Args &&... args) -> decltype(f(std::integral_constant< size_type, firstValue >(), std::forward< Args >(args)...))
template<std::size_t end, class F , class size_type , class... Args>
auto	forwardAsStaticIndex (const size_type &i, F &&f, Args &&... args) -> decltype(f(Dune::Indices::_0, std::forward< Args >(args)...))
	Transform dynamic index to static index_constant.
template<class F , class... T>
auto	transformTuple (F &&f, const std::tuple< T... > &tuple) -> decltype(Imp::transformTupleHelper(std::forward< F >(f), tuple, std::index_sequence_for< T... >{}))
	Transform tuple value using a functor.
template<class F , class... T1, class... T2>
auto	transformTuple (F &&f, const std::tuple< T1... > &tuple1, const std::tuple< T2... > &tuple2) -> decltype(Imp::transformTupleHelper(std::forward< F >(f), tuple1, tuple2, std::index_sequence_for< T1... >{}))
	Transform tuple value using a binary functor.
template<class Expression >
auto	callableCheck (Expression f)
	Create a predicate for checking validity of expressions.
template<class Check >
auto	negatePredicate (Check check)
	Negate given predicate.
template<class T >
auto	forwardCapture (T &&t)
	Create a capture object for perfect forwarding.
template<class Basis , class F , decltype(std::declval< std::decay_t< F > >()(0, std::declval< typename Basis::LocalView >(), std::declval< typename Basis::GridView::Intersection >()), 0) = 0>
void	forEachBoundaryDOF (const Basis &basis, F &&f)
	Loop over all DOFs on the boundary.
template<class PreBasis >
auto	containerDescriptor (const PreBasis &preBasis)
	Return the container descriptor of the pre-basis, if defined, otherwise ContainerDescriptor::Unknown.
template<class PreBasis >
	DefaultGlobalBasis (PreBasis &&) -> DefaultGlobalBasis< std::decay_t< PreBasis > >
template<class GridView , class PreBasisFactory >
	DefaultGlobalBasis (const GridView &gv, PreBasisFactory &&f) -> DefaultGlobalBasis< std::decay_t< decltype(f(gv))> >
template<class Tree >
DefaultNodeToRangeMap< Tree >	makeDefaultNodeToRangeMap (const Tree &tree)
template<class Basis , class TreePath >
auto	makeDefaultNodeToRangeMap (const Basis &basis, TreePath &&treePath) -> decltype(makeDefaultNodeToRangeMap(TypeTree::child(basis.localView().tree(), treePath)))
template<class T >
auto	flatVectorView (T &t)
	Create flat vector view of passed mutable container.
template<class T >
auto	flatVectorView (const T &t)
	Create flat vector view of passed const container.
template<class T >
auto	flatVectorView (T &&t)
	Create flat vector view of passed container temporary.
template<class V >
HierarchicVectorWrapper< V >	hierarchicVector (V &v)
template<class MultiIndex , class V , std::enable_if_t< models< Concept::HasIndexAccess, V, MultiIndex >(), int > = 0>
V &	makeHierarchicVectorForMultiIndex (V &v)
template<class MultiIndex , class V , std::enable_if_t< not models< Concept::HasIndexAccess, V, MultiIndex >(), int > = 0>
HierarchicVectorWrapper< V >	makeHierarchicVectorForMultiIndex (V &v)
template<class B , class C , class F , class BV , class NTRE >
void	interpolate (const B &basis, C &&coeff, const F &f, const BV &bv, const NTRE &nodeToRangeEntry)
	Interpolate given function in discrete function space.
template<class B , class C , class F , class BV >
void	interpolate (const B &basis, C &&coeff, const F &f, const BV &bitVector)
	Interpolate given function in discrete function space.
template<class B , class C , class F >
void	interpolate (const B &basis, C &&coeff, const F &f)
	Interpolate given function in discrete function space.
template<class GridView , class LocalCoefficients >
auto	subIndexRange (const Dune::MultipleCodimMultipleGeomTypeMapper< GridView > &mapper, const typename GridView::template Codim< 0 >::Entity &element, const LocalCoefficients &localCoefficients)
template<class GV , class LFE >
	LFEPreBasisMixin (const GV &, const LFE &, MCMGLayout) -> LFEPreBasisMixin< GV, LFE >
template<typename Tree >
void	clearSize (Tree &tree, std::size_t offset)
template<typename Tree , typename Entity >
void	bindTree (Tree &tree, const Entity &entity, std::size_t offset=0)
template<typename Tree >
void	initializeTree (Tree &tree, std::size_t treeIndexOffset=0)
template<class Basis >
SizeInfo< Basis >	sizeInfo (const Basis &basis)
template<class T >
auto	subEntityDOFs (const T &)
	Create SubEntityDOFs object.
template<class LocalView >
auto	subEntityDOFs (const LocalView &localView, std::size_t subEntityIndex, std::size_t subEntityCodim)
	Create bound SubEntityDOFs object.
template<class LocalView , class Intersection >
auto	subEntityDOFs (const LocalView &localView, const Intersection &intersection)
	Create bound SubEntityDOFs object.
template<class RB , class TP >
	SubspaceBasis (const RB &, const TP) -> SubspaceBasis< RB, TP >
template<class RootRootBasis , class InnerTP , class OuterTP >
	SubspaceBasis (const SubspaceBasis< RootRootBasis, InnerTP > &rootBasis, const OuterTP &prefixPath) -> SubspaceBasis< std::decay_t< decltype(rootBasis.rootBasis())>, Impl::JoinTreePath_t< InnerTP, OuterTP > >
template<class RootBasis , class... PrefixTreeIndices>
auto	subspaceBasis (const RootBasis &rootBasis, const TypeTree::HybridTreePath< PrefixTreeIndices... > &prefixPath)
	Create SubspaceBasis from a root basis and a prefixPath.
template<class RootBasis , class... PrefixTreeIndices>
auto	subspaceBasis (const RootBasis &rootBasis, const PrefixTreeIndices &... prefixTreeIndices)
template<class F , class GridView , class Domain = typename GridView::template Codim<0>::Geometry::GlobalCoordinate, class Range = std::invoke_result_t<F,Domain>>
	AnalyticGridViewFunction (const F &, const GridView &) -> AnalyticGridViewFunction< Range(Domain), GridView, F >
template<class F , class GridView >
auto	makeAnalyticGridViewFunction (F &&f, const GridView &gridView)
	Create an AnalyticGridViewFunction from a function and a grid view.
template<class OF , class... IF>
	ComposedGridFunction (const OF &, const IF &...) -> ComposedGridFunction< OF, IF... >
template<class OF , class... IF>
auto	makeComposedGridFunction (OF &&outerFunction, IF &&... innerFunction)
	Create a ComposedGridFunction that composes grid-functions with another function.
template<typename R , typename B , typename V >
auto	makeDiscreteGlobalBasisFunction (B &&basis, V &&vector)
	Generate a DiscreteGlobalBasisFunction.
template<class F , class GridView , std::enable_if_t< models< Imp::HasFreeLocalFunction, F >(), int > = 0>
std::decay_t< F >	makeGridViewFunction (F &&f, const GridView &gridView)
	Construct a function modeling GridViewFunction from function and grid view.
template<class F , class GridView , std::enable_if_t< not(models< Imp::HasFreeLocalFunction, F >()), int > = 0>
auto	makeGridViewFunction (F &&f, const GridView &gridView) -> decltype(makeAnalyticGridViewFunction(std::forward< F >(f), gridView))
	Construct a function modeling GridViewFunction from function and grid view.

Variables
template<class T >
constexpr bool	HasStaticSize_v = HasStaticSize<T>::value
	A variable template representing the value of HasStaticSize.

Typedef Documentation

BrezziDouglasMariniBasis

template<typename GV , int k>

using Dune::Functions::BrezziDouglasMariniBasis = typedef DefaultGlobalBasis<BrezziDouglasMariniPreBasis<GV, k> >

Basis of a scalar k-th-order BDM finite element space on simplex and cube grids.

TODO: Fix this for grids with more than one element type

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis

IntegerSequenceTuple

template<class IntegerSequence >

using Dune::Functions::IntegerSequenceTuple = typedef typename Imp::IntegerSequenceTupleHelper<IntegerSequence>::Type

Transform integer_sequence<I,k...> to tuple<integral_constant<I,k>...>

LagrangeDGNode

template<typename GV , int k>

using Dune::Functions::LagrangeDGNode = typedef LagrangeNode<GV, k>

NedelecBasis

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

using Dune::Functions::NedelecBasis = typedef DefaultGlobalBasis<NedelecPreBasis<GV, Range, kind, order > >

Basis of a k-th-order Nédélec finite element space.

Template Parameters

GV	The GridView that the space is defined on
Range	Number type used for shape function values
kind	Kind of the basis: 1 (for Nédélec element of the first kind) or 2
order	The order of the basis (lowest order is '1')

RaviartThomasBasis

template<typename GV , int k>

using Dune::Functions::RaviartThomasBasis = typedef DefaultGlobalBasis<RaviartThomasPreBasis<GV, k> >

Basis of a k-th-order Raviart Thomas finite element space.

TODO: Fix this for grids with more than one element type

Template Parameters

GV	The GridView that the space is defined on
k	The order of the basis

Function Documentation

AnalyticGridViewFunction()

template<class F , class GridView , class Domain = typename GridView::template Codim<0>::Geometry::GlobalCoordinate, class Range = std::invoke_result_t<F,Domain>>

Dune::Functions::AnalyticGridViewFunction	(	const F &	,
		const GridView &
	)		-> AnalyticGridViewFunction< Range(Domain), GridView, F >

bindTree()

template<typename Tree , typename Entity >

void Dune::Functions::bindTree	(	Tree &	tree,
		const Entity &	entity,
		std::size_t	offset = 0
	)

clearSize()

template<typename Tree >

void Dune::Functions::clearSize	(	Tree &	tree,
		std::size_t	offset
	)

ComposedGridFunction()

template<class OF , class... IF>

Dune::Functions::ComposedGridFunction	(	const OF &	,
		const IF &	...
	)		-> ComposedGridFunction< OF, IF... >

containerDescriptor()

template<class PreBasis >

auto Dune::Functions::containerDescriptor

(

const PreBasis &

preBasis

)

Return the container descriptor of the pre-basis, if defined, otherwise ContainerDescriptor::Unknown.

DefaultGlobalBasis() [1/2]

template<class GridView , class PreBasisFactory >

Dune::Functions::DefaultGlobalBasis	(	const GridView &	gv,
		PreBasisFactory &&	f
	)		-> DefaultGlobalBasis< std::decay_t< decltype(f(gv))> >

DefaultGlobalBasis() [2/2]

template<class PreBasis >

Dune::Functions::DefaultGlobalBasis

(

PreBasis &&

)

-> DefaultGlobalBasis< std::decay_t< PreBasis > >

fieldTypes()

template<class V >

constexpr auto Dune::Functions::fieldTypes ( )

constexpr

Generate list of field types in container.

This generates a Dune::TypeList of the field types in the given container type. To determine the field types, operator[] is called as often as passible with std::size_t or Dune::index_constant arguments. The return types obtained if no more operator[] call is available are returned as Dune::TypeList. Notice that possible duplicate entries are removed. However, const and reference qualifiers are deliberately preserved.

flatVectorView() [1/3]

template<class T >

auto Dune::Functions::flatVectorView

(

const T &

t

)

Create flat vector view of passed const container.

When passed a nested container, the resulting value is a flat-vector-like view object. It provides an operator[] method to access all entries of the underlying nested container using flat consecutive indices and a size() method to compute the corresponding total size.

This method will create a view object storing a pointer to the passed const container.

flatVectorView() [2/3]

template<class T >

auto Dune::Functions::flatVectorView

(

T &&

t

)

Create flat vector view of passed container temporary.

When passed a nested container, the resulting value is a flat-vector-like view object. It provides an operator[] method to access all entries of the underlying nested container using flat consecutive indices and a size() method to compute the corresponding total size.

This method will create a 'view' object storing the provided temporary container by value.

flatVectorView() [3/3]

template<class T >

auto Dune::Functions::flatVectorView

(

T &

t

)

Create flat vector view of passed mutable container.

When passed a nested container, the resulting value is a flat-vector-like view object. It provides an operator[] method to access all entries of the underlying nested container using flat consecutive indices and a size() method to compute the corresponding total size.

This method will create a view object storing a pointer to the passed mutable container.

forwardAsStaticInteger() [1/2]

template<class F , class size_type , size_type firstValue, class... Args>

auto Dune::Functions::forwardAsStaticInteger	(	std::integer_sequence< size_type, firstValue >	values,
		const size_type &	i,
		F &&	f,
		Args &&...	args
	)		-> decltype(f(std::integral_constant<size_type, firstValue>(), std::forward<Args>(args)...))

forwardAsStaticInteger() [2/2]

template<class F , class size_type , size_type firstValue, size_type secondValue, size_type... otherValues, class... Args>

auto Dune::Functions::forwardAsStaticInteger	(	std::integer_sequence< size_type, firstValue, secondValue, otherValues... >	values,
		const size_type	i,
		F &&	f,
		Args &&...	args
	)		-> decltype(f(std::integral_constant<size_type, firstValue>(), std::forward<Args>(args)...))

forwardCapture()

template<class T >

auto Dune::Functions::forwardCapture

(

T &&

t

)

Create a capture object for perfect forwarding.

The returned object will capture the passed argument t. If t is passed as r-value, then it is captured by value, otherwise by reference. The captured value is accessible once using the forward() method which either returns the catured reference or moves the captured value.

This allows to capture values for perfect forwarding in lambda functions using [t=forwardCapture(std::forward<T>(t))]() -> decltype(auto) { return t.forward(); }

hasUniqueFieldType()

template<class V >

constexpr bool Dune::Functions::hasUniqueFieldType ( )

constexpr

Check if container has a unique field type.

This returns if fieldTypes<V>() has exactly one entry.

hierarchicVector()

template<class V >

HierarchicVectorWrapper< V > Dune::Functions::hierarchicVector

(

V &

v

)

Deprecated:

This function is deprecated. Use istlVectorBackend() instead.

hybridIndexAccess()

template<class C , class I , class F , std::enable_if_t< not Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int > = 0>

decltype(auto) Dune::Functions::hybridIndexAccess	(	C &&	c,
		const I &	i,
		F &&	f
	)

Provide operator[] index-access for containers.

This is the overload for types providing a operator[] only for static arguments of type std::integral_constant<std::size_t,k>. This does a static linear search until a static index matching the given dynamic index is found. Since the result type will in general be different for different indices the method does not return the result directly but passes it to a given functor.

Parameters

c	Container to access
i	The index to use for accessing the container
f	A functor to call with the result of operator[]

initializeTree()

template<typename Tree >

void Dune::Functions::initializeTree	(	Tree &	tree,
		std::size_t	treeIndexOffset = 0
	)

interpolate() [1/3]

template<class B , class C , class F >

void Dune::Functions::interpolate	(	const B &	basis,
		C &&	coeff,
		const F &	f
	)

Interpolate given function in discrete function space.

Notice that this will only work if the range type of f and the block type of coeff are compatible and supported by flatVectorView.

This function will only work, if the local ansatz tree of the basis is trivial, i.e., a single leaf node.

Parameters

basis	Global function space basis of discrete function space
coeff	Coefficient vector to represent the interpolation
f	Function to interpolate

interpolate() [2/3]

template<class B , class C , class F , class BV >

void Dune::Functions::interpolate	(	const B &	basis,
		C &&	coeff,
		const F &	f,
		const BV &	bitVector
	)

Interpolate given function in discrete function space.

Only vector coefficients marked as 'true' in the bitVector argument are interpolated. Use this, e.g., to interpolate Dirichlet boundary values.

Notice that this will only work if the range type of f and the block type of coeff are compatible and supported by flatVectorView.

Parameters

basis	Global function space basis of discrete function space
coeff	Coefficient vector to represent the interpolation
f	Function to interpolate
bitVector	A vector with flags marking all DOFs that should be interpolated

interpolate() [3/3]

template<class B , class C , class F , class BV , class NTRE >

void Dune::Functions::interpolate	(	const B &	basis,
		C &&	coeff,
		const F &	f,
		const BV &	bv,
		const NTRE &	nodeToRangeEntry
	)

Interpolate given function in discrete function space.

Only vector coefficients marked as 'true' in the bitVector argument are interpolated. Use this, e.g., to interpolate Dirichlet boundary values.

Notice that this will only work if the range type of f and the block type of coeff are compatible and supported by flatVectorView.

Parameters

basis	Global function space basis of discrete function space
coeff	Coefficient vector to represent the interpolation
f	Function to interpolate
bitVector	A vector with flags marking all DOFs that should be interpolated
nodeToRangeEntry	Polymorphic functor mapping local ansatz nodes to range-indices of given function

LFEPreBasisMixin()

template<class GV , class LFE >

Dune::Functions::LFEPreBasisMixin	(	const GV &	,
		const LFE &	,
		MCMGLayout
	)		-> LFEPreBasisMixin< GV, LFE >

makeDefaultNodeToRangeMap() [1/2]

template<class Basis , class TreePath >

auto Dune::Functions::makeDefaultNodeToRangeMap	(	const Basis &	basis,
		TreePath &&	treePath
	)		-> decltype(makeDefaultNodeToRangeMap(TypeTree::child(basis.localView().tree(),treePath)))

makeDefaultNodeToRangeMap() [2/2]

template<class Tree >

DefaultNodeToRangeMap< Tree > Dune::Functions::makeDefaultNodeToRangeMap

(

const Tree &

tree

)

makeGridViewFunction() [1/2]

template<class F , class GridView , std::enable_if_t< models< Imp::HasFreeLocalFunction, F >(), int > = 0>

std::decay_t< F > Dune::Functions::makeGridViewFunction	(	F &&	f,
		const GridView &	gridView
	)

Construct a function modeling GridViewFunction from function and grid view.

This specialization is used for functions that already support localFunction(). It will simply return a copy of f.

Parameters

f	A function object supporting argument compatible with global coordinates
gridView	The GridView the function should act on.

Returns

A function that models the GridViewFunction interface.

makeGridViewFunction() [2/2]

template<class F , class GridView , std::enable_if_t< not(models< Imp::HasFreeLocalFunction, F >()), int > = 0>

auto Dune::Functions::makeGridViewFunction	(	F &&	f,
		const GridView &	gridView
	)		-> decltype(makeAnalyticGridViewFunction(std::forward<F>(f), gridView))

Construct a function modeling GridViewFunction from function and grid view.

This specialization is used for functions that do not support localFunction() themselves. It will forward to makeAnalyticGridViewFunction().

Notice that the returned function will store a copy of the original function and the GridView.

Parameters

f	A function object supporting argument compatible with global coordinates
gridView	The GridView the function should act on.

Returns

A function that models the GridFunction interface.

makeHierarchicVectorForMultiIndex() [1/2]

template<class MultiIndex , class V , std::enable_if_t< models< Concept::HasIndexAccess, V, MultiIndex >(), int > = 0>

V & Dune::Functions::makeHierarchicVectorForMultiIndex

(

V &

v

)

Deprecated:

This function is deprecated. Use istlVectorBackend() instead.

makeHierarchicVectorForMultiIndex() [2/2]

template<class MultiIndex , class V , std::enable_if_t< not models< Concept::HasIndexAccess, V, MultiIndex >(), int > = 0>

HierarchicVectorWrapper< V > Dune::Functions::makeHierarchicVectorForMultiIndex

(

V &

v

)

Deprecated:

This function is deprecated. Use istlVectorBackend() instead.

makePolynomial() [1/2]

template<class K , class Coefficients >

auto Dune::Functions::makePolynomial

(

Coefficients

coefficients

)

Create Polynomial.

Template Parameters

K	Scalar type. The polynomial will map K to K
C	Coefficient container type

This helper function allows to specify K, but lets C be deduced from the argument. If the scalar type K is the same as the coefficient type (i.e. the entry type of the coefficient container C), then you can also rely on class template argument deduction and call Polynomial(coefficients) directly.

makePolynomial() [2/2]

template<class K , class C >

auto Dune::Functions::makePolynomial

(

std::initializer_list< C >

coefficients

)

Create Polynomial.

Template Parameters

K	Scalar type. The polynomial will map K to K
C	Coefficient type

The initilizer list will be stored as std::vector in the created object of type Polynomial<K,std::vector<C>>.

operator<<()

template<typename Stream , class size_type , std::size_t n>

Stream & Dune::Functions::operator<< ( Stream &  stream, const StaticMultiIndex< size_type, n > &  c  )

inline

Polynomial() [1/4]

template<class K , std::size_t n>

Dune::Functions::Polynomial

(

std::array< K, n >

)

-> Polynomial< K, std::array< K, n > >

Polynomial() [2/4]

template<class K >

Dune::Functions::Polynomial

(

std::initializer_list< K >

)

-> Polynomial< K, std::vector< K > >

Polynomial() [3/4]

template<class K , K... ci>

Dune::Functions::Polynomial

(

std::integer_sequence< K, ci... >

)

-> Polynomial< K, std::integer_sequence< K, ci... > >

Polynomial() [4/4]

template<class K >

Dune::Functions::Polynomial

(

std::vector< K >

)

-> Polynomial< K, std::vector< K > >

sizeInfo()

template<class Basis >

SizeInfo< Basis > Dune::Functions::sizeInfo

(

const Basis &

basis

)

Deprecated:

This function is deprecated.

subIndexRange()

template<class GridView , class LocalCoefficients >

auto Dune::Functions::subIndexRange	(	const Dune::MultipleCodimMultipleGeomTypeMapper< GridView > &	mapper,
		const typename GridView::template Codim< 0 >::Entity &	element,
		const LocalCoefficients &	localCoefficients
	)

SubspaceBasis() [1/2]

template<class RB , class TP >

Dune::Functions::SubspaceBasis	(	const RB &	,
		const TP
	)		-> SubspaceBasis< RB, TP >

subspaceBasis() [1/2]

template<class RootBasis , class... PrefixTreeIndices>

auto Dune::Functions::subspaceBasis	(	const RootBasis &	rootBasis,
		const PrefixTreeIndices &...	prefixTreeIndices
	)

subspaceBasis() [2/2]

template<class RootBasis , class... PrefixTreeIndices>

auto Dune::Functions::subspaceBasis	(	const RootBasis &	rootBasis,
		const TypeTree::HybridTreePath< PrefixTreeIndices... > &	prefixPath
	)

Create SubspaceBasis from a root basis and a prefixPath.

This will not return a nested SubspaceBasis if rootBasis is already a SubspaceBasis. Instead it will join the tree paths and use them to construct a non-nested SubspaceBasis relative to rootBasis.rootBasis().

Parameters

rootBasis	Create a subspace basis relative to this basis
prefixPath	A prefix path of the subspace within the root basis

SubspaceBasis() [2/2]

template<class RootRootBasis , class InnerTP , class OuterTP >

Dune::Functions::SubspaceBasis	(	const SubspaceBasis< RootRootBasis, InnerTP > &	rootBasis,
		const OuterTP &	prefixPath
	)		-> SubspaceBasis< std::decay_t< decltype(rootBasis.rootBasis())>, Impl::JoinTreePath_t< InnerTP, OuterTP > >

Variable Documentation

HasStaticSize_v

template<class T >

constexpr bool Dune::Functions::HasStaticSize_v = HasStaticSize<T>::value

inlineconstexpr

A variable template representing the value of HasStaticSize.