Namespaces
	BasisBuilder

	Concept

Classes
class	AnalyticGridViewFunction

class	AnalyticGridViewFunction< Range(Domain), GV, F, DerivativeTraits >
	Class wrapping any differentiable function as grid function. More...

class	BasisNodeMixin

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	BSplineNodeIndexSet

class	BSplinePreBasis
	Pre-basis for B-spline basis. More...

class	CallableFunctionWrapper
	Wrap a Dune::VirtualFunction into a callable object. More...

class	CompositeBasisNode

class	CompositeNodeIndexSet

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	DefaultLocalIndexSet

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	FlatMultiIndex
	A multi-index class with only one level. More...

struct	FlatVectorBackend

struct	FlatVectorBackend< typename Dune::FieldMatrix< K, n, m > >

class	FunctionFromCallable

class	FunctionFromCallable< Range(Domain), F, FunctionInterface >
	Wrap a callable object as Dune::Function or Dune::VirtualFunction. 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	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	LagrangeDGNodeIndexSet

class	LagrangeDGPreBasis

struct	LastType
	Get last entry of type list. More...

class	LeafBasisNode

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	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 scalar polynomial implementation. More...

class	PowerBasisNode

class	PowerNodeIndexSet

class	PowerPreBasis
	A pre-basis for power bases. More...

class	PQ1Node

class	PQ1NodeIndexSet

class	PQ1PreBasis
	Pre-basis for a first order PQ-lagrange basis. More...

class	PQkNode

class	PQkNodeIndexSet

class	PQkPreBasis
	A pre-basis for PQ-lagrange bases with given order. More...

class	RannacherTurekNode

class	RannacherTurekNodeIndexSet

class	RannacherTurekPreBasis
	Pre-basis for a Rannacher-Turek basis. More...

class	RaviartThomasNode

class	RaviartThomasNodeIndexSet

class	RaviartThomasPreBasis

class	ReservedDeque
	A Vector class with statically reserved memory. More...

struct	RotateTuple
	Rotate type list by one, such that last entry is moved to first position. More...

class	ShiftedMultiIndex
	Class representing a shifted multi index. 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...

struct	StaticSize
	Obtain size of statically sized container. More...

class	SubspaceBasis

class	SubspaceLocalView
	The restriction of a finite element basis to a single element. More...

class	TaylorHoodBasisTree

class	TaylorHoodNodeIndexSet

class	TaylorHoodPreBasis
	Pre-basis for lowest order Taylor-Hood basis. More...

class	TaylorHoodVelocityTree

class	TreeData
	Container allowing to attach data to each node of a tree. More...

class	TrigonometricFunction
	A linear combination of trigonomic functions. More...

class	TupleVector
	A class augmenting std::tuple by element access via operator[]. More...

class	TypeErasureBase
	Base class for type-erased interface wrapper. More...

struct	UniformNodeVisitor
	Mixin for visitors that should apply the same action on all nodes. More...

Typedefs
template<class T >
using	Optional = Std::optional< T >

template<class T , class... Args>
using	enableIfConstructible = typename std::enable_if< std::is_constructible< T, Args... >::value, int >::type
	Helper to constrain forwarding constructors. More...

template<template< class... > class T, class ArgTuple >
using	ExpandTuple = typename Imp::ExpandTupleHelper< T, ArgTuple >::Type
	Expand tuple arguments as template arguments. More...

template<template< class... > class F, class... Tuples>
using	TransformTuple = typename Imp::TransformTupleHelper< F, Tuples... >::Type
	Transform tuple types argument using type-functor. More...

template<class IntegerSequence >
using	IntegerSequenceTuple = typename Imp::IntegerSequenceTupleHelper< IntegerSequence >::Type
	Transform integer_sequence<I,k...> to tuple<integral_constant<I,k>...> More...

template<typename GV >
using	BSplineBasis = DefaultGlobalBasis< BSplinePreBasis< GV, FlatMultiIndex< std::size_t > > >
	A global B-spline basis. More...

template<typename GV , int k>
using	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, typename TP >
using	LagrangeDGNode = PQkNode< GV, k, TP >

template<typename GV , int k>
using	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	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	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	RannacherTurekBasis = DefaultGlobalBasis< RannacherTurekPreBasis< GV, FlatMultiIndex< std::size_t > > >
	Rannacher-Turek basis. More...

template<typename GV , int k, GeometryType::BasicType basic_type, class ST = std::size_t>
using	RaviartThomasNodalBasis = DefaultGlobalBasis< RaviartThomasPreBasis< GV, k, FlatMultiIndex< ST >, ST, basic_type > >
	Nodal basis of a scalar k-th-order Raviart Thomas finite element space. More...

template<typename GV >
using	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<class K , int sinFactor, int cosFactor>
TrigonometricFunction< K, -cosFactor, sinFactor >	derivative (const TrigonometricFunction< K, sinFactor, cosFactor > &f)
	Obtain derivative of TrigonometricFunction function. More...

template<class F >
CallableFunctionWrapper< F >	callable (const F &f)
	Create a callable object from some Dune::VirtualFunction. More...

template<class F >
CallableFunctionWrapper< F >	callable (const std::shared_ptr< F > &fp)
	Create a callable object from shared_ptr<F> More...

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

template<class C , class I , class F , typename std::enable_if< Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int >::type = 0>
auto	hybridIndexAccess (C &&c, const I &i, F &&f) -> decltype(f(c[i]))
	Provide operator[] index-access for containers. More...

template<class C , class I , class F , typename std::enable_if< not Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int >::type = 0>
decltype(auto)	hybridIndexAccess (C &&c, const I &i, F &&f)
	Provide operator[] index-access for containers. More...

template<std::size_t offset, class Index >
ShiftedMultiIndex< Index, offset >	shiftedMultiIndex (const Index &index)
	Create a ShiftedMultiIndex. More...

template<class Index >
ShiftedMultiIndex< Index, 1 >	shiftedMultiIndex (const Index &index)
	Create a ShiftedMultiIndex with one position truncated. More...

template<class Result , class C , class MultiIndex >
Result	hybridMultiIndexAccess (C &&c, const MultiIndex &index)
	Provide multi-index access by chaining operator[]. More...

template<class Range , class Domain , template< class > class DerivativeTraits>
auto	derivativeSignatureTag (SignatureTag< Range(Domain), DerivativeTraits > tag)
	Construct SignatureTag for derivative. More...

template<std::size_t maxOrder, class Signature , template< class > class DerivativeTraits>
auto	derivativeSignatureTags (Dune::Functions::SignatureTag< Signature, DerivativeTraits > tag)
	Construct SignatureTags for derivatives. More...

template<std::size_t begin_t, std::size_t end_t, class F , class... Args>
void	staticFindInRange (F &&f, Args &&... args)
	Static find loop. More...

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::TypeTree::Indices::_0, std::forward< Args >(args)...))
	Transform dynamic index to static index_constant. More...

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

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

template<class F , class ArgTuple , class I , I... i>
decltype(auto)	applyPartial (F &&f, ArgTuple &&args, std::integer_sequence< I, i... > indices)
	Apply function with arguments from a given tuple. More...

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 V >
HierarchicVectorWrapper< V >	hierarchicVector (V &v)

template<class MultiIndex , class V , typename std::enable_if< models< Concept::HasIndexAccess, V, MultiIndex >(), int >::type = 0>
V &	makeHierarchicVectorForMultiIndex (V &v)

template<class MultiIndex , class V , typename std::enable_if< not models< Concept::HasIndexAccess, V, MultiIndex >(), int >::type = 0>
HierarchicVectorWrapper< V >	makeHierarchicVectorForMultiIndex (V &v)

template<class B , class... TreeIndices, class NTRE , class C , class F , class BV >
void	interpolateTreeSubset (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f, const NTRE &nodeToRangeEntry, const BV &bv)
	Interpolate given function in discrete function space. More...

template<class B , class... TreeIndices, class C , class F , class BV >
void	interpolateTreeSubset (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f, const BV &bitVector)

template<class B , class... TreeIndices, class NTRE , class C , class F >
void	interpolateTree (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f, const NTRE &nodeToRangeEntry)

template<class B , class... TreeIndices, class C , class F >
void	interpolateTree (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f)

template<class B , class... TreeIndices, class C , class F , class BV >
void	interpolate (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f, const BV &bitVector)
	Interpolate given function in discrete function space. More...

template<class B , class C , class F , class BV , std::enable_if_t< not Imp::isHybridTreePath< C >(), int > = 0>
void	interpolate (const B &basis, C &&coeff, const F &f, const BV &bitVector)
	Interpolate given function in discrete function space. More...

template<class B , class C , class F >
void	interpolate (const B &basis, C &&coeff, const F &f)
	Interpolate given function in discrete function space. More...

template<class B , class... TreeIndices, class C , class F >
void	interpolate (const B &basis, const TypeTree::HybridTreePath< TreeIndices... > &treePath, C &&coeff, const F &f)
	Interpolate given function in discrete function space. More...

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 RootBasis , class... PrefixTreeIndices>
auto	subspaceBasis (const RootBasis &rootBasis, const TypeTree::HybridTreePath< PrefixTreeIndices... > &prefixPath)

template<class RootBasis , class... PrefixTreeIndices>
auto	subspaceBasis (const RootBasis &rootBasis, const PrefixTreeIndices &... prefixTreeIndices)

template<class F , class GridView >
AnalyticGridViewFunction< typename std::result_of< F(typename GridView::template Codim< 0 >::Geometry::GlobalCoordinate)>::type(typename GridView::template Codim< 0 >::Geometry::GlobalCoordinate), GridView, typename std::decay< F >::type >	makeAnalyticGridViewFunction (F &&f, const GridView &gridView)
	Construct AnalyticGridViewFunction from function and grid view. More...

template<typename... TT>
void	localFunction (DiscreteGlobalBasisFunction< TT... > &&t)=delete
	Construction of local functions from a temporary DiscreteGlobalBasisFunction (forbidden) More...

template<typename R , typename B , typename TP , typename V >
auto	makeDiscreteGlobalBasisFunction (B &&basis, const TP &treePath, V &&vector)

template<typename R , typename B , typename V >
auto	makeDiscreteGlobalBasisFunction (B &&basis, V &&vector)

template<class F , class GridView , typename std::enable_if< models< Imp::HasFreeLocalFunction, F >(), int >::type = 0>
std::decay< F >::type	makeGridViewFunction (F &&f, const GridView &gridView)
	Construct a function modeling GridViewFunction from function and grid view. More...

template<class F , class GridView , typename std::enable_if< not(models< Imp::HasFreeLocalFunction, F >()), int >::type = 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. More...

Typedef Documentation

◆ 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, typename TP >

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

◆ Optional

template<class T >

using Dune::Functions::Optional = typedef Std::optional< T >

◆ RaviartThomasNodalBasis

template<typename GV , int k, GeometryType::BasicType basic_type, class ST = std::size_t>

using Dune::Functions::RaviartThomasNodalBasis = typedef DefaultGlobalBasis<RaviartThomasPreBasis<GV, k, FlatMultiIndex<ST>, ST, basic_type> >

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

TODO

Template Parameters

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

Function Documentation

◆ 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
	)

◆ 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)...))

◆ hierarchicVector()

template<class V >

HierarchicVectorWrapper< V > Dune::Functions::hierarchicVector ( V & v )

◆ hybridIndexAccess()

template<class C , class I , class F , typename std::enable_if< not Dune::models< Imp::Concept::HasDynamicIndexAccess< I >, C >(), int >::type = 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/4]

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

void Dune::Functions::interpolate	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f,
		const BV &	bitVector
	)

Interpolate given function in discrete function space.

Interpolation is done wrt the leaf node of the ansatz tree corresponding to the given tree path.

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

Parameters

basis	Global function space basis of discrete function space
treePath	Tree path specifying the part of the ansatz tree to use
coeff	Coefficient vector to represent the interpolation
f	Function to interpolate
bitVector	A vector with flags marking all DOFs that should be interpolated

◆ interpolate() [2/4]

template<class B , class C , class F , class BV , std::enable_if_t< not Imp::isHybridTreePath< C >(), int > = 0>

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

Interpolate given function in discrete function space.

Interpolation is done wrt the leaf node of the ansatz tree corresponding to the given tree path. 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 FlatVectorBackend.

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/4]

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

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() [4/4]

template<class B , class... TreeIndices, class C , class F >

void Dune::Functions::interpolate	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f
	)

Interpolate given function in discrete function space.

Interpolation is done wrt the leaf node of the ansatz tree corresponding to the given tree path.

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

Parameters

basis	Global function space basis of discrete function space
treePath	Tree path specifying the part of the ansatz tree to use
coeff	Coefficient vector to represent the interpolation
f	Function to interpolate

◆ interpolateTree() [1/2]

template<class B , class... TreeIndices, class NTRE , class C , class F >

void Dune::Functions::interpolateTree	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f,
		const NTRE &	nodeToRangeEntry
	)

◆ interpolateTree() [2/2]

template<class B , class... TreeIndices, class C , class F >

void Dune::Functions::interpolateTree	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f
	)

◆ interpolateTreeSubset() [1/2]

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

void Dune::Functions::interpolateTreeSubset	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f,
		const NTRE &	nodeToRangeEntry,
		const BV &	bv
	)

Interpolate given function in discrete function space.

Interpolation is done wrt the leaf node of the ansatz tree corresponding to the given tree path.

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

Parameters

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

◆ interpolateTreeSubset() [2/2]

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

void Dune::Functions::interpolateTreeSubset	(	const B &	basis,
		const TypeTree::HybridTreePath< TreeIndices... > &	treePath,
		C &&	coeff,
		const F &	f,
		const BV &	bitVector
	)

◆ makeAnalyticGridViewFunction()

template<class F , class GridView >

AnalyticGridViewFunction< typename std::result_of<F(typename GridView::template Codim<0>::Geometry::GlobalCoordinate)>::type (typename GridView::template Codim<0>::Geometry::GlobalCoordinate), GridView, typename std::decay<F>::type > Dune::Functions::makeAnalyticGridViewFunction	(	F &&	f,
		const GridView &	gridView
	)

Construct AnalyticGridViewFunction from function and grid view.

The returned function supports localFunction() and stores a copy of the original function.

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.

◆ makeDefaultNodeToRangeMap() [1/2]

template<class Tree >

DefaultNodeToRangeMap<Tree> Dune::Functions::makeDefaultNodeToRangeMap ( const Tree & tree )

◆ makeDefaultNodeToRangeMap() [2/2]

template<class Basis , class TreePath >

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

◆ makeDiscreteGlobalBasisFunction() [1/2]

template<typename R , typename B , typename TP , typename V >

auto Dune::Functions::makeDiscreteGlobalBasisFunction	(	B &&	basis,
		const TP &	treePath,
		V &&	vector
	)

◆ makeDiscreteGlobalBasisFunction() [2/2]

template<typename R , typename B , typename V >

auto Dune::Functions::makeDiscreteGlobalBasisFunction	(	B &&	basis,
		V &&	vector
	)

◆ makeGridViewFunction() [1/2]

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

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

Construct a function modeling GridViewFunction from function and grid view.

This spezialization 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 , typename std::enable_if< not(models< Imp::HasFreeLocalFunction, F >()), int >::type = 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 spezialization 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 a pointer to the GridView. It can only be used as long as the latter exists. Hence you must take care to store the GridView yourself.

Todo:: Should we store a copy of 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 , typename std::enable_if< models< Concept::HasIndexAccess, V, MultiIndex >(), int >::type = 0>

V& Dune::Functions::makeHierarchicVectorForMultiIndex ( V & v )

◆ makeHierarchicVectorForMultiIndex() [2/2]

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

HierarchicVectorWrapper< V > Dune::Functions::makeHierarchicVectorForMultiIndex ( V & v )

◆ shiftedMultiIndex() [1/2]

template<std::size_t offset, class Index >

ShiftedMultiIndex<Index, offset> Dune::Functions::shiftedMultiIndex ( const Index & index )

Create a ShiftedMultiIndex.

Template Parameters

offset Number of positions to shift left

◆ shiftedMultiIndex() [2/2]

template<class Index >

ShiftedMultiIndex<Index, 1> Dune::Functions::shiftedMultiIndex ( const Index & index )

Create a ShiftedMultiIndex with one position truncated.

Template Parameters

offset Number of positions to shift left

◆ sizeInfo()

template<class Basis >

SizeInfo<Basis> Dune::Functions::sizeInfo ( const Basis & basis )

◆ subspaceBasis() [1/2]

template<class RootBasis , class... PrefixTreeIndices>

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

◆ subspaceBasis() [2/2]

template<class RootBasis , class... PrefixTreeIndices>

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

Namespaces

Classes

Typedefs

Functions

Typedef Documentation

◆ IntegerSequenceTuple

◆ LagrangeDGNode

◆ Optional

◆ RaviartThomasNodalBasis

Function Documentation

◆ bindTree()

◆ clearSize()

◆ forwardAsStaticInteger() [1/2]

◆ forwardAsStaticInteger() [2/2]

◆ hierarchicVector()

◆ hybridIndexAccess()

◆ initializeTree()

◆ interpolate() [1/4]

◆ interpolate() [2/4]

◆ interpolate() [3/4]

◆ interpolate() [4/4]

◆ interpolateTree() [1/2]

◆ interpolateTree() [2/2]

◆ interpolateTreeSubset() [1/2]

◆ interpolateTreeSubset() [2/2]

◆ makeAnalyticGridViewFunction()

◆ makeDefaultNodeToRangeMap() [1/2]

◆ makeDefaultNodeToRangeMap() [2/2]

◆ makeDiscreteGlobalBasisFunction() [1/2]

◆ makeDiscreteGlobalBasisFunction() [2/2]

◆ makeGridViewFunction() [1/2]

◆ makeGridViewFunction() [2/2]

◆ makeHierarchicVectorForMultiIndex() [1/2]

◆ makeHierarchicVectorForMultiIndex() [2/2]

◆ shiftedMultiIndex() [1/2]

◆ shiftedMultiIndex() [2/2]

◆ sizeInfo()

◆ subspaceBasis() [1/2]

◆ subspaceBasis() [2/2]