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
14namespace 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 >
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;
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 {
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 {
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
STL namespace.
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
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
BasicConstLocalFunction(const BasisFunctionSetType &basisFunctionSet, LocalDofVectorType &&localDofVector)
Definition: const.hh:69
BaseType::BasisFunctionSetType BasisFunctionSetType
type of BasisFunctionSet
Definition: const.hh:48
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::EntityType EntityType
type of Entity
Definition: const.hh:45
BasicConstLocalFunction(const BasisFunctionSetType &basisFunctionSet)
Definition: const.hh:59
BaseType::LocalDofVectorType LocalDofVectorType
type of LocalDofVector
Definition: const.hh:51
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
A constant local function carrying values for one entity.
Definition: const.hh:115
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
BaseType::HessianRangeType HessianRangeType
Definition: const.hh:139
BaseType::RangeType RangeType
Definition: const.hh:137
const DiscreteFunctionType & discreteFunction() const
Definition: const.hh:272
ConstLocalDiscreteFunction(ThisType &&other)
move constructor
Definition: const.hh:201
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
DiscreteFunctionType GridFunctionType
Definition: const.hh:129
const GridFunctionType & gridFunction() const
Definition: const.hh:273
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
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:415
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
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
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
const BasisFunctionSetType & basisFunctionSet() const
obtain the basis function set for this local function
Definition: localfunction.hh:296
LocalDofVector LocalDofVectorType
type of local Dof Vector
Definition: localfunction.hh:86
Interface class for basis function sets.
Definition: basisfunctionset/basisfunctionset.hh:31