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

Namespaces

 BasisBuilder
 
 Concept
 
 Imp
 

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  BSplineNodeFactory
 Node factory for B-spline basis. More...
 
class  BSplineNodeIndexSet
 
class  CallableFunctionWrapper
 Wrap a Dune::VirtualFunction into a callable object. More...
 
class  CompositeBasisNode
 
class  CompositeNodeFactory
 A factory for composite bases. More...
 
class  CompositeNodeIndexSet
 
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 node factory. 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  DiscreteScalarGlobalBasisFunction
 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  LagrangeDGNodeFactory
 
class  LagrangeDGNodeIndexSet
 
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  Optional
 A wrapper that can either contain an object of T or be empty. 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  PowerNodeFactory
 A factory for power bases. More...
 
class  PowerNodeIndexSet
 
class  PQ1Node
 
class  PQ1NodeFactory
 Factory for a first order PQ-lagrange basis. More...
 
class  PQ1NodeIndexSet
 
class  PQkNode
 
class  PQkNodeFactory
 A factory for PQ-lagrange bases with given order. More...
 
class  PQkNodeIndexSet
 
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  TaylorHoodNodeFactory
 Factory for lowest order Taylor-Hood basis. More...
 
class  TaylorHoodNodeIndexSet
 
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 , 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< BSplineNodeFactory< GV, FlatMultiIndex< std::size_t >> >
 A global B-spline basis. More...
 
template<typename GV , int k>
using LagrangeBasis = DefaultGlobalBasis< PQkNodeFactory< 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< LagrangeDGNodeFactory< 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< PQ1NodeFactory< 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< PQkNodeFactory< GV, k, FlatMultiIndex< std::size_t >> >
 Nodal basis of a scalar k-th-order Lagrangean finite element space. More...
 
template<typename GV >
using TaylorHoodBasis = DefaultGlobalBasis< TaylorHoodNodeFactory< GV, std::array< 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 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 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>

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

§ 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 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() [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
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

§ 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
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

§ 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
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 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
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 TypeTree::HybridTreePath< PrefixTreeIndices... > &  prefixPath 
)

§ subspaceBasis() [2/2]

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