dune-fem  2.8-git
const.hh
Go to the documentation of this file.
1 #ifndef DUNE_FEM_FUNCTION_LOCALFUNCTION_CONST_HH
2 #define DUNE_FEM_FUNCTION_LOCALFUNCTION_CONST_HH
3 
4 #include <algorithm>
5 #include <type_traits>
6 #include <utility>
7 
8 #include <dune/common/dynvector.hh>
9 
13 
14 namespace Dune
15 {
16 
17  namespace Fem
18  {
19 
20  // External Forward Declerations
21  // -----------------------------
22 
23  template< class >
24  struct DiscreteFunctionTraits;
25 
26  class HasLocalFunction;
27  class IsDiscreteFunction;
28  struct BindableFunction;
29 
30  // BasicConstLocalFunction
31  // -----------------------
32 
33  template < class BasisFunctionSet, class LocalDofVector >
35  : public LocalFunction< BasisFunctionSet, LocalDofVector >
36  {
39 
40  public:
42  typedef typename BaseType::DofType DofType;
43 
46 
49 
52 
54  typedef typename BaseType::SizeType SizeType;
55 
58 
60 
62 
65  {}
66 
68 
71  {}
72 
73  BasicConstLocalFunction ( const BaseType &other ) : BaseType( other ) {}
74 
75  BasicConstLocalFunction ( const ThisType &other ) : BaseType( static_cast<const BaseType &>( other ) ) {}
76  BasicConstLocalFunction ( ThisType && other ) : BaseType( static_cast<BaseType&&>(other) ) {}
77 
78  const DofType &operator[] ( SizeType i ) const { return static_cast< const BaseType & >( *this )[ i ]; }
79  const DofType &operator[] ( SizeType i ) { return static_cast< const BaseType & >( *this )[ i ]; }
80 
82 
83  protected:
84  using BaseType::clear;
85  using BaseType::assign;
86  using BaseType::operator +=;
87  using BaseType::operator -=;
88  using BaseType::axpy;
89  };
90 
108  template< class DiscreteFunction >
110  : public BasicConstLocalFunction<
111  typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DiscreteFunctionSpaceType::BasisFunctionSetType,
112  Dune::DynamicVector< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType,
113  typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::LocalDofVectorAllocatorType
114  :: template rebind< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > > ::DofType > ::other > >
115  {
117  typedef BasicConstLocalFunction< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DiscreteFunctionSpaceType::BasisFunctionSetType,
118  Dune::DynamicVector< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType,
119  typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > > :: LocalDofVectorAllocatorType
120  :: template rebind< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType >::other > >
121  BaseType;
122 
123  public:
124  typedef std::remove_const_t< DiscreteFunction > DiscreteFunctionType;
125  typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
126  typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
127  typedef typename DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
128 
130 
131  typedef typename BaseType::DofType DofType;
133  typedef typename GridPartType::IntersectionType IntersectionType;
137  typedef typename BaseType::RangeType RangeType;
140 
155  : BaseType( LocalDofVectorType( df.localDofVectorAllocator() ) ),
156  discreteFunction_( &df )
157  {
158  }
159 
161  ConstLocalDiscreteFunction ( const typename DiscreteFunctionType::LocalFunctionType &localFunction )
164  {
165  std::copy( localFunction.localDofVector().begin(), localFunction.localDofVector().end(), localDofVector().begin() );
166  }
167 
182  : BaseType( df.space().basisFunctionSet( entity ), LocalDofVectorType( df.localDofVectorAllocator() ) ),
183  discreteFunction_( &df )
184  {
185  discreteFunction().getLocalDofs( entity, localDofVector() );
186  }
188  : BaseType( df.space().basisFunctionSet( entity ), LocalDofVectorType( df.localDofVectorAllocator() ) ),
189  discreteFunction_( &df )
190  {
191  discreteFunction().getLocalDofs( entity, localDofVector() );
192  }
193 
196  : BaseType( static_cast<const BaseType &>( other ) ),
198  {}
199 
202  : BaseType( static_cast< BaseType &&>( other ) ),
204  {}
205 
207 
208  using BaseType::evaluate;
209  using BaseType::jacobian;
210  using BaseType::hessian;
211 
217  template< class Point >
218  RangeType evaluate ( const Point &p ) const
219  {
220  RangeType val;
221  evaluate( p, val );
222  return val;
223  }
224 
233  template< class Point >
234  JacobianRangeType jacobian ( const Point &p ) const
235  {
236  JacobianRangeType jac;
237  jacobian( p, jac );
238  return jac;
239  }
240 
249  template< class Point >
250  HessianRangeType hessian ( const Point &p ) const
251  {
253  hessian( p, h );
254  return h;
255  }
256 
258  void init ( const EntityType &entity )
259  {
261  discreteFunction().getLocalDofs( entity, localDofVector() );
262  }
263 
264  void bind ( const EntityType &entity ) { init( entity ); }
265  void unbind () {}
266  void bind(const IntersectionType &intersection, IntersectionSide side)
267  {
268  bind( side==IntersectionSide::in?
269  intersection.inside(): intersection.outside() );
270  }
271 
273  const GridFunctionType &gridFunction() const { return discreteFunction(); }
274 
275  protected:
277  };
278 
279 
280 
281  // ConstLocalFunction
282  // ------------------
283 
284  namespace Impl
285  {
286 
287  template< class GF, class = void >
288  struct ConstLocalFunction;
289 
290  template< class GF >
291  struct ConstLocalFunction< GF, std::enable_if_t< std::is_base_of< Fem::HasLocalFunction, GF >::value && std::is_base_of< Fem::IsDiscreteFunction, GF >::value > >
292  {
294  };
295 
296  template< class GF >
297  struct ConstLocalFunction< GF, std::enable_if_t< std::is_base_of< Fem::HasLocalFunction, GF >::value && !std::is_base_of< Fem::IsDiscreteFunction, GF >::value && std::is_class< typename GF::LocalFunctionType >::value > >
298  {
299  struct Type
300  : public GF::LocalFunctionType
301  {
302  typedef GF GridFunctionType;
303  typedef typename GridFunctionType::LocalFunctionType::EntityType EntityType;
304 
305  typedef typename GF::LocalFunctionType::DomainType DomainType;
306  typedef typename GF::LocalFunctionType::RangeType RangeType;
307  typedef typename GF::LocalFunctionType::JacobianRangeType JacobianRangeType;
308  typedef typename GF::LocalFunctionType::HessianRangeType HessianRangeType;
309 
310  explicit Type ( const GridFunctionType &gridFunction )
311  : GridFunctionType::LocalFunctionType( gridFunction ),
312  gridFunction_( gridFunction )
313  {}
314  explicit Type ( const EntityType &entity, const GridFunctionType &gridFunction )
315  : GridFunctionType::LocalFunctionType( gridFunction ),
316  gridFunction_( gridFunction )
317  { bind(entity); }
318 
319  using GF::LocalFunctionType::evaluate;
320  using GF::LocalFunctionType::jacobian;
321  using GF::LocalFunctionType::hessian;
322  using GF::LocalFunctionType::init;
323  using GF::LocalFunctionType::entity;
324 
326  template< class Point >
327  RangeType evaluate ( const Point &p ) const
328  {
329  RangeType val;
330  evaluate( p, val );
331  return val;
332  }
333 
335  template< class Point >
336  JacobianRangeType jacobian ( const Point &p ) const
337  {
338  JacobianRangeType jac;
339  jacobian( p, jac );
340  return jac;
341  }
342 
344  template< class Point >
345  HessianRangeType hessian ( const Point &p ) const
346  {
347  HessianRangeType h;
348  hessian( p, h );
349  return h;
350  }
351 
352  void bind ( const EntityType &entity ) { init( entity ); }
353  void unbind () {}
354  template <class IntersectionType>
355  void bind(const IntersectionType &intersection, IntersectionSide side)
356  {
357  bind( side==IntersectionSide::in?
358  intersection.inside(): intersection.outside() );
359  }
360 
361  const GridFunctionType &gridFunction () const { return gridFunction_; }
362 
363  private:
364  const GridFunctionType &gridFunction_;
365  };
366  };
367 
368  template< class GF >
369  struct ConstLocalFunction< GF, std::enable_if_t< std::is_base_of< Fem::BindableFunction, std::decay_t<GF> >::value && !std::is_base_of< Fem::IsDiscreteFunction, std::decay_t<GF> >::value > >
370  {
371  struct Type
372  {
373  typedef GF GridFunctionType;
374  typedef std::decay_t<GF> GridFunctionDecayType;
375  typedef typename GridFunctionDecayType::GridPartType GridPartType;
376  typedef typename GridFunctionDecayType::EntityType EntityType;
377  typedef typename GridFunctionDecayType::RangeFieldType RangeFieldType;
378  typedef typename GridFunctionDecayType::DomainType DomainType;
379  typedef typename GridFunctionDecayType::RangeType RangeType;
380  typedef typename GridFunctionDecayType::JacobianRangeType JacobianRangeType;
381  typedef typename GridFunctionDecayType::HessianRangeType HessianRangeType;
382  typedef typename GridFunctionDecayType::FunctionSpaceType FunctionSpaceType;
383 
384  template<class Arg, std::enable_if_t<std::is_constructible<GF, Arg>::value, int> = 0>
385  explicit Type ( Arg&& gridFunction )
386  : gridFunction_( std::forward<Arg>(gridFunction) )
387  {}
388  template<class Arg, std::enable_if_t<std::is_constructible<GF, Arg>::value, int> = 0>
389  explicit Type ( const EntityType &entity, Arg&& gridFunction )
390  : gridFunction_( std::forward<Arg>(gridFunction) )
391  { bind(entity); }
392 
393  template <class Point>
394  void evaluate(const Point &x, RangeType &ret) const
395  {
396  gridFunction().evaluate(x,ret);
397  }
398  template <class Point>
399  void jacobian(const Point &x, JacobianRangeType &ret) const
400  {
401  gridFunction().jacobian(x,ret);
402  }
403  template <class Point>
404  void hessian(const Point &x, HessianRangeType &ret) const
405  {
406  gridFunction().hessian(x,ret);
407  }
408  unsigned int order() const { return gridFunction().order(); }
409 
411  template< class Point >
412  RangeType evaluate ( const Point &p ) const
413  {
414  RangeType val;
415  evaluate( p, val );
416  return val;
417  }
418 
420  template< class Point >
421  JacobianRangeType jacobian ( const Point &p ) const
422  {
423  JacobianRangeType jac;
424  jacobian( p, jac );
425  return jac;
426  }
427 
429  template< class Point >
430  HessianRangeType hessian ( const Point &p ) const
431  {
432  HessianRangeType h;
433  hessian( p, h );
434  return h;
435  }
436 
437  template< class Quadrature, class ... Vectors >
438  void evaluateQuadrature ( const Quadrature &quad, Vectors & ... values ) const
439  {
440  static_assert( sizeof...( Vectors ) > 0, "evaluateQuadrature needs to be called with at least one vector." );
441  evaluateFullQuadrature( PriorityTag<42>(), quad, values... );
442  }
443  template< class Quadrature, class Jacobians >
444  void jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians ) const
445  { jacobianQuadrature(quadrature,jacobians, PriorityTag<42>() ); }
446  template< class Quadrature, class Hessians >
447  void hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians ) const
448  { hessianQuadrature(quadrature,hessians, PriorityTag<42>() ); }
449 
450  void bind ( const EntityType &entity ) { gridFunction_.bind( entity ); }
451  void unbind () { gridFunction_.unbind(); }
452  template <class IntersectionType>
453  void bind(const IntersectionType &intersection, IntersectionSide side)
454  { defaultIntersectionBind(gridFunction_,intersection, side); }
455 
456  const EntityType& entity() const
457  {
458  return gridFunction_.entity();
459  }
460 
461  const GridFunctionDecayType &gridFunction () const { return gridFunction_; }
462 
463  private:
464  template< class Quadrature, class ... Vectors, class GF_=GridFunctionDecayType >
465  auto evaluateFullQuadrature ( PriorityTag<1>, const Quadrature &quad, Vectors & ... values ) const
466  -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().evaluateQuadrature(quad,values...))>::value >
467  { gridFunction().evaluateQuadrature(quad,values...); }
468  template< class Quadrature, class ... Vectors >
469  void evaluateFullQuadrature ( PriorityTag<0>, const Quadrature &quad, Vectors & ... values ) const
470  { std::ignore = std::make_tuple( ( evaluateSingleQuadrature( quad, values ), 1 ) ... ); }
471 
472  template< class Quadrature, class Jacobians, class GF_=GridFunctionDecayType>
473  auto jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians, PriorityTag<1> ) const
474  -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().jacobianQuadrature(quadrature,jacobians))>::value >
475  { gridFunction().jacobianQuadrature(quadrature,jacobians); }
476  template< class Quadrature, class Jacobians >
477  void jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians, PriorityTag<0> ) const
478  {
479  for( const auto qp : quadrature )
480  jacobians[ qp.index() ] = jacobian( qp );
481  }
482 
483  template< class Quadrature, class Hessians, class GF_=GridFunctionDecayType >
484  auto hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians, PriorityTag<1> ) const
485  -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().hessianQuadrature(quadrature,hessians))>::value >
486  { gridFunction().hessianQuadrature(quadrature,hessians); }
487  template< class Quadrature, class Hessians >
488  void hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians, PriorityTag<0> ) const
489  {
490  for( const auto qp : quadrature )
491  hessians[ qp.index() ] = hessian( qp );
492  }
493 
494  template< class Quadrature, class Vector >
495  auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
496  -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, RangeType >::value >
497  {
498  for( const auto qp : quad )
499  v[ qp.index() ] = evaluate( qp );
500  }
501  template< class Quadrature, class Vector >
502  auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
503  -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, JacobianRangeType >::value >
504  { jacobianQuadrature(quad,v); }
505  template< class Quadrature, class Vector >
506  auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
507  -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, HessianRangeType >::value >
508  { hessianQuadrature(quad,v); }
509 
510  GridFunctionType gridFunction_;
511  };
512  };
513  } // namespace Impl
514 
515 
516  template< class GridFunction >
517  using ConstLocalFunction = typename Impl::ConstLocalFunction< GridFunction >::Type;
519  template<class T, class SFINAE = void>
521  : std::false_type
522  {};
523 
525  template<class T>
526  struct IsConstLocalFunction<T, std::enable_if_t<!std::is_same<T, std::decay_t<T> >{}> >
527  : IsConstLocalFunction<std::decay_t<T> >
528  {};
529 
531  template<class T>
533  T,
534  std::enable_if_t<(std::is_same<T, std::decay_t<T> >{}
535  && std::is_same<T, Fem::ConstLocalFunction<typename T::GridFunctionType> >{}
536  )> >
537  : std::true_type
538  {};
539 
540 
544  template<class F, std::enable_if_t<!IsConstLocalFunction<F>::value, int> = 0>
545  constexpr auto constLocalFunction(F&& f)
546  {
547  return Fem::ConstLocalFunction<std::decay_t<F> >(std::forward<F>(f));
548  }
549 
551  template<class F, std::enable_if_t<IsConstLocalFunction<F>::value, int> = 0>
552  constexpr decltype(auto) constLocalFunction(F&& f)
553  {
554  return std::forward<F>(f);
555  }
556 
557  template<class F, class Entity>
558  constexpr auto constLocalFunction(F&& f, const Entity &entity)
559  {
560  return Dune::Fem::ConstLocalFunction<std::decay_t<F> >(entity,std::forward<F>(f));
561  }
562 
563  } // namespace Fem
564 
565 } // namespace Dune
566 
567 #endif // #ifndef DUNE_FEM_FUNCTION_LOCALFUNCTION_CONST_HH
Definition: bindguard.hh:11
static GridFunctionView< GF > localFunction(const GF &gf)
Definition: gridfunctionview.hh:118
constexpr auto constLocalFunction(F &&f)
Definition: const.hh:545
void defaultIntersectionBind(GF &gf, const Intersection &intersection, IntersectionSide side)
Definition: intersectionside.hh:25
typename Impl::ConstLocalFunction< GridFunction >::Type ConstLocalFunction
Definition: const.hh:517
IntersectionSide
Definition: intersectionside.hh:10
Definition: explicitfieldvector.hh:75
Traits class for a DiscreteFunction.
Definition: common/discretefunction.hh:61
Definition: const.hh:36
BasicConstLocalFunction(const BasisFunctionSetType &basisFunctionSet, LocalDofVectorType &&localDofVector)
Definition: const.hh:69
BasicConstLocalFunction(const BasisFunctionSetType &basisFunctionSet, const LocalDofVectorType &localDofVector)
Definition: const.hh:63
BasicConstLocalFunction(const BaseType &other)
Definition: const.hh:73
BasicConstLocalFunction(ThisType &&other)
Definition: const.hh:76
BaseType::SizeType SizeType
type of SizeType
Definition: const.hh:54
const DofType & operator[](SizeType i) const
Definition: const.hh:78
BaseType ::LocalDofVectorType LocalDofVectorType
type of LocalDofVector
Definition: const.hh:51
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
BasicConstLocalFunction(const BasisFunctionSetType &basisFunctionSet)
Definition: const.hh:59
BaseType ::BasisFunctionSetType BasisFunctionSetType
type of BasisFunctionSet
Definition: const.hh:48
BasicConstLocalFunction(LocalDofVectorType &&localDofVector)
Definition: const.hh:67
BasicConstLocalFunction(const ThisType &other)
Definition: const.hh:75
BasicConstLocalFunction(const LocalDofVectorType &localDofVector)
Definition: const.hh:61
BaseType::DofType DofType
type of Dof
Definition: const.hh:42
BasicConstLocalFunction()
default ctor
Definition: const.hh:57
BaseType ::EntityType EntityType
type of Entity
Definition: const.hh:45
A constant local function carrying values for one entity.
Definition: const.hh:115
const GridFunctionType & gridFunction() const
Definition: const.hh:273
BaseType::HessianRangeType HessianRangeType
Definition: const.hh:139
BaseType::RangeType RangeType
Definition: const.hh:137
ConstLocalDiscreteFunction(ThisType &&other)
move constructor
Definition: const.hh:201
const DiscreteFunctionType & discreteFunction() const
Definition: const.hh:272
ConstLocalDiscreteFunction(const DiscreteFunctionType &df)
constructor creating a local function without binding it to an entity
Definition: const.hh:154
RangeType evaluate(const Point &p) const
evaluate the local function
Definition: const.hh:218
DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType
Definition: const.hh:127
const DiscreteFunctionType * discreteFunction_
Definition: const.hh:276
std::remove_const_t< DiscreteFunction > DiscreteFunctionType
Definition: const.hh:124
void init(const EntityType &entity)
interface for local functions :: init
Definition: const.hh:258
ConstLocalDiscreteFunction(const ThisType &other)
copy constructor
Definition: const.hh:195
BaseType::LocalDofVectorType LocalDofVectorType
Definition: const.hh:135
ConstLocalDiscreteFunction(const DiscreteFunctionType &df, const EntityType &entity)
constructor creating a local function and binding it to an entity
Definition: const.hh:181
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
DiscreteFunctionType GridFunctionType
Definition: const.hh:129
BaseType::DofType DofType
Definition: const.hh:131
DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType
Definition: const.hh:125
ConstLocalDiscreteFunction(const typename DiscreteFunctionType::LocalFunctionType &localFunction)
cast a MutableLocalFunction into this one !!! expensive !!!
Definition: const.hh:161
BaseType::BasisFunctionSetType BasisFunctionSetType
Definition: const.hh:134
DiscreteFunctionSpaceType::GridPartType GridPartType
Definition: const.hh:126
BaseType::JacobianRangeType JacobianRangeType
Definition: const.hh:138
void bind(const EntityType &entity)
Definition: const.hh:264
HessianRangeType hessian(const Point &p) const
evaluate Hessian of the local function
Definition: const.hh:250
ConstLocalDiscreteFunction(const EntityType &entity, const DiscreteFunctionType &df)
Definition: const.hh:187
void bind(const IntersectionType &intersection, IntersectionSide side)
Definition: const.hh:266
BaseType::DomainType DomainType
Definition: const.hh:136
BaseType::EntityType EntityType
Definition: const.hh:132
JacobianRangeType jacobian(const Point &p) const
evaluate Jacobian of the local function
Definition: const.hh:234
GridPartType::IntersectionType IntersectionType
Definition: const.hh:133
void unbind()
Definition: const.hh:265
Definition: const.hh:522
interface for local functions
Definition: localfunction.hh:77
void evaluate(const PointType &x, RangeType &ret) const
evaluate the local function
Definition: localfunction.hh:311
void init(const EntityType &entity)
initialize the local function for an entity
Definition: localfunction.hh:437
FunctionSpaceType::DomainType DomainType
type of domain vectors, i.e., type of coordinates
Definition: localfunction.hh:105
const EntityType & entity() const
obtain the entity, this local function lives on
Definition: localfunction.hh:302
BasisFunctionSet BasisFunctionSetType
type of basis function set
Definition: localfunction.hh:83
void hessian(const PointType &x, HessianRangeType &ret) const
evaluate Hessian of the local function
Definition: localfunction.hh:339
LocalDofVectorType::value_type DofType
type of DoF use with the discrete function
Definition: localfunction.hh:89
FunctionSpaceType::RangeType RangeType
type of range vectors, i.e., type of function values
Definition: localfunction.hh:107
void axpy(const PointType &x, const RangeType &factor)
axpy operation for local function
Definition: localfunction.hh:233
const BasisFunctionSetType & basisFunctionSet() const
obtain the basis function set for this local function
Definition: localfunction.hh:296
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
void jacobian(const PointType &x, JacobianRangeType &ret) const
evaluate Jacobian of the local function
Definition: localfunction.hh:325
FunctionSpaceType::JacobianRangeType JacobianRangeType
type of the Jacobian, i.e., type of evaluated Jacobian matrix
Definition: localfunction.hh:109
LocalDofVectorType::size_type SizeType
type of index
Definition: localfunction.hh:92
void clear()
set all DoFs to zero
Definition: localfunction.hh:195
BasisFunctionSetType::EntityType EntityType
type of the entity, the local function lives on is given by the space
Definition: localfunction.hh:95
void assign(const LocalFunction< BasisFunctionSet, T > &other)
assign all DoFs of this local function
Definition: localfunction.hh:189
LocalDofVector LocalDofVectorType
type of local Dof Vector
Definition: localfunction.hh:86
SizeType size() const
obtain the number of local DoFs
Definition: localfunction.hh:360