dune-functions  2.6-dev
Namespaces | Classes | Typedefs | Functions
Dune::Functions Namespace Reference

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  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
GVThe GridView that the space is defined on
kThe 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
cContainer to access
iThe index to use for accessing the container
fA 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 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
basisGlobal function space basis of discrete function space
coeffCoefficient vector to represent the interpolation
fFunction to interpolate

◆ 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
basisGlobal function space basis of discrete function space
coeffCoefficient vector to represent the interpolation
fFunction to interpolate
bitVectorA vector with flags marking all DOFs that should be interpolated

◆ interpolate() [3/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
basisGlobal function space basis of discrete function space
treePathTree path specifying the part of the ansatz tree to use
coeffCoefficient vector to represent the interpolation
fFunction to interpolate

◆ interpolate() [4/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
basisGlobal function space basis of discrete function space
treePathTree path specifying the part of the ansatz tree to use
coeffCoefficient vector to represent the interpolation
fFunction to interpolate
bitVectorA vector with flags marking all DOFs that should be interpolated

◆ interpolateTree() [1/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 
)

◆ interpolateTree() [2/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 
)

◆ interpolateTreeSubset() [1/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 
)

◆ interpolateTreeSubset() [2/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
basisGlobal function space basis of discrete function space
treePathTree path specifying the part of the ansatz tree to use
coeffCoefficient vector to represent the interpolation
fFunction to interpolate
nodeToRangeEntryPolymorphic functor mapping local ansatz nodes to range-indices of given function
bitVectorA vector with flags marking all DOFs that should be interpolated

◆ 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
fA function object supporting argument compatible with global coordinates
gridViewThe GridView the function should act on.
Returns
A function that models the GridFunction interface.

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

◆ 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
fA function object supporting argument compatible with global coordinates
gridViewThe 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
fA function object supporting argument compatible with global coordinates
gridViewThe 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
offsetNumber 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
offsetNumber 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 PrefixTreeIndices &...  prefixTreeIndices 
)

◆ subspaceBasis() [2/2]

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