DUNE-FEM (unstable)

const.hh
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
10#include <dune/fem/misc/mpimanager.hh>
11#include <dune/fem/function/localfunction/mutable.hh>
12#include <dune/fem/function/localfunction/localfunction.hh>
13#include <dune/fem/common/intersectionside.hh>
14
15namespace Dune
16{
17
18 namespace Fem
19 {
20
21 // External Forward Declerations
22 // -----------------------------
23
24 template< class >
25 struct DiscreteFunctionTraits;
26
27 class HasLocalFunction;
28 class IsDiscreteFunction;
29 struct BindableFunction;
30
31 // BasicConstLocalFunction
32 // -----------------------
33
34 template < class BasisFunctionSet, class LocalDofVector >
35 class BasicConstLocalFunction
36 : public LocalFunction< BasisFunctionSet, LocalDofVector >
37 {
38 typedef BasicConstLocalFunction< BasisFunctionSet, LocalDofVector > ThisType;
39 typedef LocalFunction< BasisFunctionSet, LocalDofVector > BaseType;
40
41 public:
43 typedef typename BaseType::DofType DofType;
44
46 typedef typename BaseType :: EntityType EntityType;
47
49 typedef typename BaseType :: BasisFunctionSetType BasisFunctionSetType;
50
52 typedef typename BaseType :: LocalDofVectorType LocalDofVectorType;
53
55 typedef typename BaseType::SizeType SizeType;
56
58 BasicConstLocalFunction () {}
59
60 explicit BasicConstLocalFunction ( const BasisFunctionSetType & basisFunctionSet ) : BaseType( basisFunctionSet ) {}
61
62 explicit BasicConstLocalFunction ( const LocalDofVectorType &localDofVector ) : BaseType( localDofVector ) {}
63
64 BasicConstLocalFunction ( const BasisFunctionSetType &basisFunctionSet, const LocalDofVectorType &localDofVector )
65 : BaseType( basisFunctionSet, localDofVector )
66 {}
67
68 explicit BasicConstLocalFunction ( LocalDofVectorType &&localDofVector ) : BaseType( localDofVector ) {}
69
70 BasicConstLocalFunction ( const BasisFunctionSetType &basisFunctionSet, LocalDofVectorType &&localDofVector )
71 : BaseType( basisFunctionSet, localDofVector )
72 {}
73
74 BasicConstLocalFunction ( const BaseType &other ) : BaseType( other ) {}
75
76 BasicConstLocalFunction ( const ThisType &other ) : BaseType( static_cast<const BaseType &>( other ) ) {}
77 BasicConstLocalFunction ( ThisType && other ) : BaseType( static_cast<BaseType&&>(other) ) {}
78
79 const DofType &operator[] ( SizeType i ) const { return static_cast< const BaseType & >( *this )[ i ]; }
80 const DofType &operator[] ( SizeType i ) { return static_cast< const BaseType & >( *this )[ i ]; }
81
82 using BaseType::localDofVector;
83
84 protected:
85 using BaseType::clear;
86 using BaseType::assign;
87 using BaseType::operator +=;
88 using BaseType::operator -=;
89 using BaseType::axpy;
90 };
91
109 template< class DiscreteFunction >
110 class ConstLocalDiscreteFunction
111 : public BasicConstLocalFunction<
112 typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DiscreteFunctionSpaceType::BasisFunctionSetType,
113 Dune::DynamicVector< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType,
114 typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::LocalDofVectorAllocatorType
115 :: template rebind< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > > ::DofType > ::other > >
116 {
117 typedef ConstLocalDiscreteFunction< DiscreteFunction > ThisType;
118 typedef BasicConstLocalFunction< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DiscreteFunctionSpaceType::BasisFunctionSetType,
119 Dune::DynamicVector< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType,
120 typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > > :: LocalDofVectorAllocatorType
121 :: template rebind< typename DiscreteFunctionTraits< std::remove_const_t< DiscreteFunction > >::DofType >::other > >
122 BaseType;
123
124 public:
125 typedef std::remove_const_t< DiscreteFunction > DiscreteFunctionType;
126 typedef typename DiscreteFunctionType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
127 typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
128 typedef typename DiscreteFunctionSpaceType::FunctionSpaceType FunctionSpaceType;
129
130 typedef DiscreteFunctionType GridFunctionType;
131
132 typedef typename BaseType::DofType DofType;
133 typedef typename BaseType::EntityType EntityType;
134 typedef typename GridPartType::IntersectionType IntersectionType;
135 typedef typename BaseType::BasisFunctionSetType BasisFunctionSetType;
136 typedef typename BaseType::LocalDofVectorType LocalDofVectorType;
137 typedef typename BaseType::DomainType DomainType;
138 typedef typename BaseType::RangeType RangeType;
139 typedef typename BaseType::JacobianRangeType JacobianRangeType;
140 typedef typename BaseType::HessianRangeType HessianRangeType;
141
155 explicit ConstLocalDiscreteFunction ( const DiscreteFunctionType &df )
156 : BaseType( LocalDofVectorType( df.localDofVectorAllocator() ) )
157 , discreteFunction_( &df )
158#ifdef TESTTHREADING
159 , thread_(-1)
160#endif
161 {}
162
164 ConstLocalDiscreteFunction ( const typename DiscreteFunctionType::LocalFunctionType &localFunction )
165 : BaseType( localFunction.basisFunctionSet(), LocalDofVectorType( localFunction.size(), localFunction.discreteFunction().localDofVectorAllocator() ) )
166 , discreteFunction_( &localFunction.discreteFunction() )
167#ifdef TESTTHREADING
168 , thread_(-1)
169#endif
170 {
171 std::copy( localFunction.localDofVector().begin(), localFunction.localDofVector().end(), localDofVector().begin() );
172 }
173
187 ConstLocalDiscreteFunction ( const DiscreteFunctionType &df, const EntityType &entity )
188 : BaseType( df.space().basisFunctionSet( entity ), LocalDofVectorType( df.localDofVectorAllocator() ) )
189 , discreteFunction_( &df )
190#ifdef TESTTHREADING
191 , thread_(-1)
192#endif
193 {
194 discreteFunction().getLocalDofs( entity, localDofVector() );
195 }
196 ConstLocalDiscreteFunction ( const EntityType &entity, const DiscreteFunctionType &df )
197 : BaseType( df.space().basisFunctionSet( entity ), LocalDofVectorType( df.localDofVectorAllocator() ) )
198 , discreteFunction_( &df )
199#ifdef TESTTHREADING
200 , thread_(-1)
201#endif
202 {
203 discreteFunction().getLocalDofs( entity, localDofVector() );
204 }
205
207 ConstLocalDiscreteFunction ( const ThisType &other )
208 : BaseType( static_cast<const BaseType &>( other ) )
209 , discreteFunction_( other.discreteFunction_ )
210#ifdef TESTTHREADING
211 , thread_(-1)
212#endif
213 {}
214
216 ConstLocalDiscreteFunction ( ThisType &&other )
217 : BaseType( static_cast< BaseType &&>( other ) )
218 , discreteFunction_( other.discreteFunction_ )
219#ifdef TESTTHREADING
220 , thread_(-1)
221#endif
222 {}
223
224 using BaseType::localDofVector;
225
226 using BaseType::evaluate;
227 using BaseType::jacobian;
228 using BaseType::hessian;
229
235 template< class Point >
236 RangeType evaluate ( const Point &p ) const
237 {
238 RangeType val;
239 evaluate( p, val );
240 return val;
241 }
242
251 template< class Point >
252 JacobianRangeType jacobian ( const Point &p ) const
253 {
254 JacobianRangeType jac;
255 jacobian( p, jac );
256 return jac;
257 }
258
267 template< class Point >
268 HessianRangeType hessian ( const Point &p ) const
269 {
270 HessianRangeType h;
271 hessian( p, h );
272 return h;
273 }
274
276 void init ( const EntityType &entity )
277 {
278#ifdef TESTTHREADING
279 if (thread_ == -1) thread_ = MPIManager::thread();
280 if (thread_ != MPIManager::thread())
281 {
282 std::cout << "wrong thread number\n";
283 assert(0);
284 std::abort();
285 }
286#endif
287 BaseType::init( discreteFunction().space().basisFunctionSet( entity ) );
288 discreteFunction().getLocalDofs( entity, localDofVector() );
289 }
290
291 void bind ( const EntityType &entity ) { init( entity ); }
292 void unbind ()
293 {
294#ifdef TESTTHREADING
295 if (thread_ != MPIManager::thread())
296 {
297 std::cout << "wrong thread number\n";
298 assert(0);
299 std::abort();
300 }
301#endif
302 }
303 void bind(const IntersectionType &intersection, IntersectionSide side)
304 {
305 // store local copy to avoid problems with casting to temporary types
306 const EntityType entity = side==IntersectionSide::in? intersection.inside(): intersection.outside();
307 bind( entity );
308 }
309
310 const DiscreteFunctionType &discreteFunction() const { return *discreteFunction_; }
311 const GridFunctionType &gridFunction() const { return discreteFunction(); }
312
313 protected:
314 const DiscreteFunctionType* discreteFunction_;
315#ifdef TESTTHREADING
316 int thread_;
317#endif
318 };
319
320
321
322 // ConstLocalFunction
323 // ------------------
324
325 namespace Impl
326 {
327
328 template< class GF, class = void >
329 struct ConstLocalFunction;
330
331 template< class GF >
332 struct ConstLocalFunction< GF, std::enable_if_t< std::is_base_of< Fem::HasLocalFunction, GF >::value && std::is_base_of< Fem::IsDiscreteFunction, GF >::value > >
333 {
334 typedef ConstLocalDiscreteFunction< GF > Type;
335 };
336
337 template< class GF >
338 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 > >
339 {
340 struct Type
341 : public GF::LocalFunctionType
342 {
343 typedef GF GridFunctionType;
344 typedef typename GridFunctionType::LocalFunctionType::EntityType EntityType;
345
346 typedef typename GF::LocalFunctionType::DomainType DomainType;
347 typedef typename GF::LocalFunctionType::RangeType RangeType;
348 typedef typename GF::LocalFunctionType::JacobianRangeType JacobianRangeType;
349 typedef typename GF::LocalFunctionType::HessianRangeType HessianRangeType;
350
351 explicit Type ( const GridFunctionType &gridFunction )
352 : GridFunctionType::LocalFunctionType( gridFunction ),
353 gridFunction_( gridFunction ) {}
354 explicit Type ( const EntityType &entity, const GridFunctionType &gridFunction )
355 : GridFunctionType::LocalFunctionType( gridFunction ),
356 gridFunction_( gridFunction )
357 { bind(entity); }
358
359 using GF::LocalFunctionType::evaluate;
360 using GF::LocalFunctionType::jacobian;
361 using GF::LocalFunctionType::hessian;
362 using GF::LocalFunctionType::init;
363 using GF::LocalFunctionType::entity;
364 using GF::LocalFunctionType::geometry;
365
367 template< class Point >
368 RangeType evaluate ( const Point &p ) const
369 {
370 RangeType val;
371 evaluate( p, val );
372 return val;
373 }
374
376 template< class Point >
377 JacobianRangeType jacobian ( const Point &p ) const
378 {
379 JacobianRangeType jac;
380 jacobian( p, jac );
381 return jac;
382 }
383
385 template< class Point >
386 HessianRangeType hessian ( const Point &p ) const
387 {
388 HessianRangeType h;
389 hessian( p, h );
390 return h;
391 }
392
393 void bind ( const EntityType &entity ) { init( entity ); }
394 void unbind () {}
395 template <class IntersectionType>
396 void bind(const IntersectionType &intersection, IntersectionSide side)
397 {
398 // store local copy to avoid problems with casting to temporary types
399 const EntityType entity = side==IntersectionSide::in? intersection.inside(): intersection.outside();
400 bind( entity );
401 }
402
403 const GridFunctionType &gridFunction () const { return gridFunction_; }
404
405 private:
406 const GridFunctionType &gridFunction_;
407 };
408 };
409
410 template< class GF >
411 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 > >
412 {
413 static_assert( !std::is_reference<GF>::value );
414 struct Type
415 {
416 typedef GF GridFunctionType;
417 typedef std::decay_t<GF> GridFunctionDecayType;
418 typedef typename GridFunctionDecayType::GridPartType GridPartType;
419 typedef typename GridFunctionDecayType::EntityType EntityType;
420 typedef typename EntityType::Geometry Geometry;
421 typedef typename GridFunctionDecayType::RangeFieldType RangeFieldType;
422 typedef typename GridFunctionDecayType::DomainType DomainType;
423 typedef typename GridFunctionDecayType::RangeType RangeType;
424 typedef typename GridFunctionDecayType::JacobianRangeType JacobianRangeType;
425 typedef typename GridFunctionDecayType::HessianRangeType HessianRangeType;
426 typedef typename GridFunctionDecayType::FunctionSpaceType FunctionSpaceType;
427
428 template<class Arg, std::enable_if_t<std::is_constructible<GF, Arg>::value, int> = 0>
429 explicit Type ( Arg&& gridFunction )
430 : gridFunction_( std::forward<Arg>(gridFunction) )
431#ifdef TESTTHREADING
432 , thread_(-1)
433#endif
434 {
435 // if (MPIManager::thread()==0 || MPIManager::thread()==1) std::cout << "[" << MPIManager::thread() << "]: CLF " << &gridFunction_ << std::endl;
436 }
437 template<class Arg, std::enable_if_t<std::is_constructible<GF, Arg>::value, int> = 0>
438 explicit Type ( const EntityType &entity, Arg&& gridFunction )
439 : gridFunction_( std::forward<Arg>(gridFunction) )
440#ifdef TESTTHREADING
441 , thread_(-1)
442#endif
443 {
444 bind(entity);
445 }
446
447 Type ( const Type& other )
448 : gridFunction_( other.gridFunction_ )
449 {
450 if (other.gridFunction_.valid())
451 bind(other.gridFunction_.entity());
452 }
453 Type ( Type&& other ) = default;
454
455 template <class Point>
456 void evaluate(const Point &x, RangeType &ret) const
457 {
458 gridFunction().evaluate(x,ret);
459 }
460 template <class Point>
461 void jacobian(const Point &x, JacobianRangeType &ret) const
462 {
463 gridFunction().jacobian(x,ret);
464 }
465 template <class Point>
466 void hessian(const Point &x, HessianRangeType &ret) const
467 {
468 gridFunction().hessian(x,ret);
469 }
470 unsigned int order() const { return gridFunction().order(); }
471
473 template< class Point >
474 RangeType evaluate ( const Point &p ) const
475 {
476 RangeType val;
477 evaluate( p, val );
478 return val;
479 }
480
482 template< class Point >
483 JacobianRangeType jacobian ( const Point &p ) const
484 {
485 JacobianRangeType jac;
486 jacobian( p, jac );
487 return jac;
488 }
489
491 template< class Point >
492 HessianRangeType hessian ( const Point &p ) const
493 {
494 HessianRangeType h;
495 hessian( p, h );
496 return h;
497 }
498
499 template< class Quadrature, class ... Vectors >
500 void evaluateQuadrature ( const Quadrature &quad, Vectors & ... values ) const
501 {
502 static_assert( sizeof...( Vectors ) > 0, "evaluateQuadrature needs to be called with at least one vector." );
503 evaluateFullQuadrature( PriorityTag<42>(), quad, values... );
504 }
505 template< class Quadrature, class Jacobians >
506 void jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians ) const
507 { jacobianQuadrature(quadrature,jacobians, PriorityTag<42>() ); }
508 template< class Quadrature, class Hessians >
509 void hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians ) const
510 { hessianQuadrature(quadrature,hessians, PriorityTag<42>() ); }
511
512 void bind ( const EntityType &entity )
513 {
514#ifdef TESTTHREADING
515 if (thread_ == -1) thread_ = MPIManager::thread();
516 if (thread_ != MPIManager::thread())
517 {
518 std::cout << "wrong thread number\n";
519 assert(0);
520 std::abort();
521 }
522#endif
523 gridFunction_.bind( entity );
524 }
525 void unbind ()
526 {
527#ifdef TESTTHREADING
528 if (thread_ != MPIManager::thread())
529 {
530 std::cout << "wrong thread number\n";
531 assert(0);
532 std::abort();
533 }
534#endif
535 gridFunction_.unbind();
536 }
537 template <class IntersectionType>
538 void bind(const IntersectionType &intersection, IntersectionSide side)
539 {
540#ifdef TESTTHREADING
541 if (thread_ == -1) thread_ = MPIManager::thread();
542 if (thread_ != MPIManager::thread())
543 {
544 std::cout << "wrong thread number\n";
545 assert(0);
546 std::abort();
547 }
548#endif
549 defaultIntersectionBind(gridFunction_,intersection, side);
550 }
551
552 const EntityType& entity() const
553 {
554 return gridFunction_.entity();
555 }
556
557 const Geometry& geometry () const
558 {
559 return gridFunction_.geometry();
560 }
561
562 const GridPartType& gridPart() const { return gridFunction_.gridPart(); }
563 const std::string& name() const { return gridFunction_.name(); }
564
565 bool valid () const { return gridFunction_.valid(); }
566
567 const GridFunctionDecayType &gridFunction () const { return gridFunction_; }
568
569 private:
570 template< class Quadrature, class ... Vectors, class GF_=GridFunctionDecayType >
571 auto evaluateFullQuadrature ( PriorityTag<1>, const Quadrature &quad, Vectors & ... values ) const
572 -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().evaluateQuadrature(quad,values...))>::value >
573 { gridFunction().evaluateQuadrature(quad,values...); }
574 template< class Quadrature, class ... Vectors >
575 void evaluateFullQuadrature ( PriorityTag<0>, const Quadrature &quad, Vectors & ... values ) const
576 { std::ignore = std::make_tuple( ( evaluateSingleQuadrature( quad, values ), 1 ) ... ); }
577
578 template< class Quadrature, class Jacobians, class GF_=GridFunctionDecayType>
579 auto jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians, PriorityTag<1> ) const
580 -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().jacobianQuadrature(quadrature,jacobians))>::value >
581 { gridFunction().jacobianQuadrature(quadrature,jacobians); }
582 template< class Quadrature, class Jacobians >
583 void jacobianQuadrature ( const Quadrature &quadrature, Jacobians &jacobians, PriorityTag<0> ) const
584 {
585 for( const auto qp : quadrature )
586 jacobians[ qp.index() ] = jacobian( qp );
587 }
588
589 template< class Quadrature, class Hessians, class GF_=GridFunctionDecayType >
590 auto hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians, PriorityTag<1> ) const
591 -> std::enable_if_t< std::is_void< decltype( std::declval< const GF_& >().hessianQuadrature(quadrature,hessians))>::value >
592 { gridFunction().hessianQuadrature(quadrature,hessians); }
593 template< class Quadrature, class Hessians >
594 void hessianQuadrature ( const Quadrature &quadrature, Hessians &hessians, PriorityTag<0> ) const
595 {
596 for( const auto qp : quadrature )
597 hessians[ qp.index() ] = hessian( qp );
598 }
599
600 template< class Quadrature, class Vector >
601 auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
602 -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, RangeType >::value >
603 {
604 for( const auto qp : quad )
605 v[ qp.index() ] = evaluate( qp );
606 }
607 template< class Quadrature, class Vector >
608 auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
609 -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, JacobianRangeType >::value >
610 { jacobianQuadrature(quad,v); }
611 template< class Quadrature, class Vector >
612 auto evaluateSingleQuadrature ( const Quadrature &quad, Vector &v ) const
613 -> std::enable_if_t< std::is_same< std::decay_t< decltype(v[ 0 ]) >, HessianRangeType >::value >
614 { hessianQuadrature(quad,v); }
615
616 GridFunctionType gridFunction_;
617#ifdef TESTTHREADING
618 int thread_;
619#endif
620 };
621 };
622 } // namespace Impl
623
624
625 template< class GridFunction >
626 using ConstLocalFunction = typename Impl::ConstLocalFunction< GridFunction >::Type;
628 template<class T, class SFINAE = void>
629 struct IsConstLocalFunction
630 : std::false_type
631 {};
632
634 template<class T>
635 struct IsConstLocalFunction<T, std::enable_if_t<!std::is_same<T, std::decay_t<T> >{}> >
636 : IsConstLocalFunction<std::decay_t<T> >
637 {};
638
640 template<class T>
641 struct IsConstLocalFunction<
642 T,
643 std::enable_if_t<(std::is_same<T, std::decay_t<T> >{}
644 && std::is_same<T, Fem::ConstLocalFunction<typename T::GridFunctionType> >{}
645 )> >
646 : std::true_type
647 {};
648
649
653 template<class F, std::enable_if_t<!IsConstLocalFunction<F>::value, int> = 0>
654 constexpr auto constLocalFunction(F&& f)
655 {
656 return Fem::ConstLocalFunction<std::decay_t<F> >(std::forward<F>(f));
657 }
658
660 template<class F, std::enable_if_t<IsConstLocalFunction<F>::value, int> = 0>
661 constexpr decltype(auto) constLocalFunction(F&& f)
662 {
663 return std::forward<F>(f);
664 }
665
666 template<class F, class Entity>
667 constexpr auto constLocalFunction(F&& f, const Entity &entity)
668 {
669 return Dune::Fem::ConstLocalFunction<std::decay_t<F> >(entity,std::forward<F>(f));
670 }
671
672 } // namespace Fem
673
674} // namespace Dune
675
676#endif // #ifndef DUNE_FEM_FUNCTION_LOCALFUNCTION_CONST_HH
Dune::DenseVector< LocalFunction< BasisFunctionSet, LocalDofVector > >::begin
constexpr Iterator begin()
begin iterator
Definition: densevector.hh:348
Dune::DynamicVector
Construct a vector with a dynamic size.
Definition: dynvector.hh:59
Dune::Entity
Wrapper class for entities.
Definition: entity.hh:66
Dune::Fem::AdaptiveGridPartBase< AdaptiveLeafGridPartTraits< Grid, idxpitype, onlyCodimensionZero > >::IntersectionType
IntersectionIteratorType::Intersection IntersectionType
type of intersection
Definition: adaptiveleafgridpart.hh:95
Dune::Fem::BasisFunctionSet
Interface class for basis function sets.
Definition: basisfunctionset.hh:32
Dune::Fem::ConstLocalDiscreteFunction
A constant local function carrying values for one entity.
Definition: const.hh:116
Dune::Fem::ConstLocalDiscreteFunction::localDofVector
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:424
Dune::Fem::ConstLocalDiscreteFunction::ConstLocalDiscreteFunction
ConstLocalDiscreteFunction(ThisType &&other)
move constructor
Definition: const.hh:216
Dune::Fem::ConstLocalDiscreteFunction::ConstLocalDiscreteFunction
ConstLocalDiscreteFunction(const DiscreteFunctionType &df)
constructor creating a local function without binding it to an entity
Definition: const.hh:155
Dune::Fem::ConstLocalDiscreteFunction::evaluate
RangeType evaluate(const Point &p) const
evaluate the local function
Definition: const.hh:236
Dune::Fem::ConstLocalDiscreteFunction::init
void init(const EntityType &entity)
interface for local functions :: init
Definition: const.hh:276
Dune::Fem::ConstLocalDiscreteFunction::ConstLocalDiscreteFunction
ConstLocalDiscreteFunction(const ThisType &other)
copy constructor
Definition: const.hh:207
Dune::Fem::ConstLocalDiscreteFunction::ConstLocalDiscreteFunction
ConstLocalDiscreteFunction(const DiscreteFunctionType &df, const EntityType &entity)
constructor creating a local function and binding it to an entity
Definition: const.hh:187
Dune::Fem::ConstLocalDiscreteFunction::ConstLocalDiscreteFunction
ConstLocalDiscreteFunction(const typename DiscreteFunctionType::LocalFunctionType &localFunction)
cast a MutableLocalFunction into this one !!! expensive !!!
Definition: const.hh:164
Dune::Fem::ConstLocalDiscreteFunction::hessian
HessianRangeType hessian(const Point &p) const
evaluate Hessian of the local function
Definition: const.hh:268
Dune::Fem::ConstLocalDiscreteFunction::jacobian
JacobianRangeType jacobian(const Point &p) const
evaluate Jacobian of the local function
Definition: const.hh:252
Dune::Fem::ExplicitFieldVector
Definition: explicitfieldvector.hh:75
Dune::Fem::FunctionSpace
A vector valued function space.
Definition: functionspace.hh:60
Dune::Fem::LocalFunction
interface for local functions
Definition: localfunction.hh:77
Dune::Fem::LocalFunction::localDofVector
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:424
Dune::Fem::LocalFunction::DomainType
FunctionSpaceType::DomainType DomainType
type of domain vectors, i.e., type of coordinates
Definition: localfunction.hh:108
Dune::Fem::LocalFunction::BasisFunctionSetType
BasisFunctionSet BasisFunctionSetType
type of basis function set
Definition: localfunction.hh:83
Dune::Fem::LocalFunction::entity
const EntityType & entity() const
obtain the entity, this local function lives on
Definition: localfunction.hh:305
Dune::Fem::LocalFunction::DofType
LocalDofVectorType::value_type DofType
type of DoF use with the discrete function
Definition: localfunction.hh:89
Dune::Fem::LocalFunction::RangeType
FunctionSpaceType::RangeType RangeType
type of range vectors, i.e., type of function values
Definition: localfunction.hh:110
Dune::Fem::LocalFunction::axpy
void axpy(const PointType &x, const RangeType &factor)
axpy operation for local function
Definition: localfunction.hh:236
Dune::Fem::LocalFunction::JacobianRangeType
FunctionSpaceType::JacobianRangeType JacobianRangeType
type of the Jacobian, i.e., type of evaluated Jacobian matrix
Definition: localfunction.hh:112
Dune::Fem::LocalFunction::SizeType
LocalDofVectorType::size_type SizeType
type of index
Definition: localfunction.hh:92
Dune::Fem::LocalFunction::clear
void clear()
set all DoFs to zero
Definition: localfunction.hh:198
Dune::Fem::LocalFunction::EntityType
BasisFunctionSetType::EntityType EntityType
type of the entity, the local function lives on is given by the space
Definition: localfunction.hh:95
Dune::Fem::LocalFunction::assign
void assign(const LocalFunction< BasisFunctionSet, T > &other)
assign all DoFs of this local function
Definition: localfunction.hh:192
Dune::Fem::LocalFunction::basisFunctionSet
const BasisFunctionSetType & basisFunctionSet() const
obtain the basis function set for this local function
Definition: localfunction.hh:299
Dune::Fem::LocalFunction::LocalDofVectorType
LocalDofVector LocalDofVectorType
type of local Dof Vector
Definition: localfunction.hh:86
Dune::Fem::LocalFunction::size
SizeType size() const
obtain the number of local DoFs
Definition: localfunction.hh:369
Dune::Fem::MutableLocalFunction::localDofVector
const LocalDofVectorType & localDofVector() const
return const reference to local Dof Vector
Definition: localfunction.hh:424
Dune::Fem::TupleDiscreteFunction
forward declaration
Definition: discretefunction.hh:51
Dune::Fem::TupleDiscreteFunction::DiscreteFunctionSpaceType
TupleDiscreteFunctionSpace< typename DiscreteFunctions::DiscreteFunctionSpaceType ... > DiscreteFunctionSpaceType
type for the discrete function space this function lives in
Definition: discretefunction.hh:69
Quadrature
actual interface class for quadratures
dynvector.hh
This file implements a dense vector with a dynamic size.
Dune
Dune namespace.
Definition: alignedallocator.hh:13
std
STL namespace.
Dune::Fem::DiscreteFunctionTraits
Traits class for a DiscreteFunction.
Definition: discretefunction.hh:61
Dune::Fem::IsConstLocalFunction
Definition: const.hh:631
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden & Uni Heidelberg  |  generated with Hugo v0.111.3 (Nov 3, 23:36, 2025)