DUNE-FEM (unstable)

lagrangepoints.hh
1#ifndef DUNE_FEM_SPACE_LAGRANGE_LAGRANGEPOINTS_HH
2#define DUNE_FEM_SPACE_LAGRANGE_LAGRANGEPOINTS_HH
3
4#include <type_traits>
5
6// dune-common includes
7#include <dune/fem/common/forloop.hh>
8
9// dune-geometry includes
10#include <dune/geometry/referenceelements.hh>
11
12// dune-fem includes
13#include <dune/fem/quadrature/cachingquadrature.hh>
14#include <dune/fem/space/mapper/localkey.hh>
15
16// local includes
17#include "genericgeometry.hh"
18#include "genericlagrangepoints.hh"
19
20
21namespace Dune
22{
23
24 namespace Fem
25 {
26
35 template< unsigned int topologyId, unsigned int dim, unsigned int polOrder >
36 class LagrangePoint
37 : public GenericLagrangePoint< typename GeometryWrapper< topologyId, dim >::ImplType, polOrder >
38 {
39 typedef LagrangePoint< topologyId, dim, polOrder > ThisType;
40 typedef GenericLagrangePoint< typename GeometryWrapper< topologyId, dim >::ImplType, polOrder > BaseType;
41
42 public:
43 static const unsigned int dimension = BaseType::dimension;
44
45 typedef typename BaseType::DofCoordinateType DofCoordinateType;
46
47 static const unsigned int polynomialOrder = BaseType::polynomialOrder;
48 static const unsigned int numLagrangePoints = BaseType::numLagrangePoints;
49
50 template< unsigned int codim >
51 struct Codim
52 {
53 static unsigned int maxDofs ()
54 {
55 return BaseType::template Codim< codim >::maxDofs();
56 }
57 };
58
59 LagrangePoint ( unsigned int index )
60 : BaseType( index )
61 {}
62
63 LagrangePoint ( const BaseType &point )
64 : BaseType( point )
65 {}
66
67 void dofSubEntity ( unsigned int &codim, unsigned int &subEntity )
68 {
69 BaseType::dofSubEntity( codim, subEntity );
70 }
71
72 void dofSubEntity ( unsigned int &codim, unsigned int &subEntity, unsigned int &dofNumber )
73 {
74 BaseType::dofSubEntity( codim, subEntity, dofNumber );
75 }
76
77 static unsigned int
78 entityDofNumber ( unsigned int codim, unsigned int subEntity, unsigned int dof )
79 {
80 return BaseType::entityDofNumber( codim, subEntity, dof );
81 }
82 };
83
84 template< unsigned int dim, unsigned int maxPolOrder >
85 class LagrangePointInterface
86 {
87 typedef LagrangePointInterface< dim, maxPolOrder > ThisType;
88 protected:
89 LagrangePointInterface() = default;
90
91 public:
92 static const unsigned int dimension = dim;
93
94 static const unsigned int maxPolynomialOrder = maxPolOrder;
95
97 virtual ~LagrangePointInterface() = default;
98
99 virtual unsigned int entityDofNumber ( unsigned int codim,
100 unsigned int subEntity,
101 unsigned int dofNumber ) const = 0;
102
103 virtual GeometryType geometryType () const = 0;
104
111 virtual unsigned int maxDofs ( unsigned int codim ) const = 0;
112
113 static int maxOrder ()
114 {
115 return maxPolynomialOrder;
116 }
117
125 virtual unsigned int numDofs ( unsigned int codim, unsigned int subEntity ) const = 0;
126
133 virtual unsigned int numDofs ( unsigned int codim ) const = 0;
134
135 virtual int order () const
136 {
137 return maxPolynomialOrder;
138 }
139 };
140
141 template< unsigned int topologyId, unsigned int dim, unsigned int maxPolOrder, int polOrder >
142 class LagrangePointImplementation :
143 public LagrangePointInterface< dim, maxPolOrder >
144 {
145 typedef LagrangePoint< topologyId, dim, polOrder > LagrangePointType;
146 public:
147 LagrangePointImplementation() = default;
148
149 virtual ~LagrangePointImplementation() = default;
150
151 virtual unsigned int
152 entityDofNumber ( unsigned int codim, unsigned int subEntity, unsigned int dofNumber ) const
153 {
154 return LagrangePointType::entityDofNumber( codim, subEntity, dofNumber );
155 }
156
157 virtual GeometryType geometryType () const
158 {
159 return GeometryType( topologyId, dim );
160 }
161
164 virtual unsigned int maxDofs ( unsigned int codim ) const
165 {
166 return LagrangePointType::maxDofs( codim );
167 }
168
171 virtual unsigned int
172 numDofs ( unsigned int codim, unsigned int subEntity ) const
173 {
174 return LagrangePointType::numDofs( codim, subEntity );
175 }
176
179 virtual unsigned int numDofs ( unsigned int codim ) const
180 {
181 return LagrangePointType::numDofs( codim );
182 }
183
184 virtual int order () const { return polOrder; }
185 };
186
197 template< class FieldImp, int dim, unsigned int maxPolOrder >
198 class LagrangePointListInterface
199 : public IntegrationPointListImp< FieldImp, dim >
200 {
201 typedef LagrangePointListInterface< FieldImp, dim, maxPolOrder > ThisType;
202 typedef IntegrationPointListImp< FieldImp, dim > BaseType;
203
204 public:
206 typedef FieldImp FieldType;
207
209 static const int dimension = dim;
210
212 static const unsigned int maxPolynomialOrder = maxPolOrder;
213
215 typedef FieldVector< FieldType, dimension > CoordinateType;
216
217 private:
218 typedef LagrangePointInterface< dim, maxPolynomialOrder >
219 LagrangePointInterfaceType;
220
221 const LagrangePointInterfaceType &lagrangePointImpl () const
222 {
223 assert( lagrangePointImpl_ ) ;
224 return *lagrangePointImpl_;
225 }
226
227 public:
228 explicit LagrangePointListInterface ( const size_t id )
229 : BaseType( id ),
230 dofInfos_(),
231 lagrangePointImpl_( 0 )
232 {}
233
234 ~LagrangePointListInterface ()
235 {
236 delete lagrangePointImpl_;
237 }
238
239 LagrangePointListInterface ( const ThisType& ) = delete;
240
241 void setLagrangePointImpl ( const LagrangePointInterfaceType* lpImpl )
242 {
243 assert( lagrangePointImpl_ == 0 );
244 lagrangePointImpl_ = lpImpl ;
245 }
246
247 const LocalKey &dofInfo ( unsigned int index ) const
248 {
249 return dofInfos_[ index ];
250 }
251
252 void dofSubEntity ( unsigned int index,
253 unsigned int &codim,
254 unsigned int &subEntity,
255 unsigned int &dofNumber ) const
256 {
257 const LocalKey &dofInfo = this->dofInfo( index );
258 codim = dofInfo.codim();
259 subEntity = dofInfo.subEntity();
260 dofNumber = dofInfo.index();
261 }
262
263 unsigned int entityDofNumber ( unsigned int codim,
264 unsigned int subEntity,
265 unsigned int dofNumber ) const
266 {
267 return lagrangePointImpl().entityDofNumber( codim, subEntity, dofNumber );
268 }
269
270 GeometryType geometryType () const
271 {
272 return lagrangePointImpl().geometryType();
273 }
274
281 unsigned int maxDofs ( unsigned int codim ) const
282 {
283 return lagrangePointImpl().maxDofs( codim );
284 }
285
286 static int maxOrder ()
287 {
288 return LagrangePointInterfaceType::maxOrder();
289 }
290
298 unsigned int numDofs ( unsigned int codim, unsigned int subEntity ) const
299 {
300 return lagrangePointImpl().numDofs( codim, subEntity );
301 }
302
309 unsigned int numDofs ( unsigned int codim ) const
310 {
311 return lagrangePointImpl().numDofs( codim );
312 }
313
314 int order () const
315 {
316 return lagrangePointImpl().order();
317 }
318
319 protected:
320 void addDofInfo ( const LocalKey &dofInfo )
321 {
322 dofInfos_.push_back( dofInfo );
323 }
324
325 private:
326 std::vector< LocalKey > dofInfos_;
327 const LagrangePointInterfaceType* lagrangePointImpl_;
328 };
329
330
331 template< class FieldImp, unsigned int topologyId, unsigned int dim, unsigned int maxPolOrder >
332 class LagrangePointListImplementation
333 : public LagrangePointListInterface< FieldImp, dim, maxPolOrder >
334 {
335 typedef LagrangePointListImplementation< FieldImp, topologyId, dim, maxPolOrder > ThisType;
336 typedef LagrangePointListInterface< FieldImp, dim, maxPolOrder > BaseType;
337
338 public:
340 typedef FieldImp FieldType;
341
343 enum { dimension = dim };
344
346 static const int maxPolynomialOrder = maxPolOrder ;
347
349 typedef FieldVector< FieldType, dimension > CoordinateType;
350
351 private:
352 template <int pOrd>
353 struct CreateLagrangePoint
354 {
355 typedef LagrangePoint< topologyId, dimension, pOrd > LagrangePointType;
356 enum { numLagrangePoints = LagrangePointType::numLagrangePoints };
357
358 static void apply( ThisType& lp, const int order )
359 {
360 // if order is not equal to pOrd, do nothing
361 if( order != pOrd ) return ;
362
363 for( unsigned int i = 0; i < numLagrangePoints; ++i )
364 {
365 LagrangePointType pt( i );
366
367 CoordinateType local;
368 pt.local( local );
369 lp.addIntegrationPoint( local );
370
371 unsigned int codim, subEntity, dofNumber;
372 pt.dofSubEntity( codim, subEntity, dofNumber );
373 lp.addDofInfo( LocalKey( subEntity, codim, dofNumber ) );
374 }
375
376 typedef LagrangePointImplementation< topologyId, dim, maxPolynomialOrder, pOrd >
377 LagrangePointImplementationType;
378 lp.setLagrangePointImpl( new LagrangePointImplementationType() );
379 }
380 };
381 public:
382 LagrangePointListImplementation ( const size_t id )
383 : BaseType( id )
384 {
385 Fem::ForLoop< CreateLagrangePoint, 1, maxPolynomialOrder > :: apply( *this, maxPolynomialOrder );
386 }
387
388 LagrangePointListImplementation ( const GeometryType &geo, const int order, const size_t id )
389 : BaseType( id )
390 {
391 Fem::ForLoop< CreateLagrangePoint, 1, maxPolynomialOrder > :: apply( *this, order );
392
393 // assert this after lagrangePointImpl has been created since
394 // this->geometry() uses this class
395 assert( order <= maxPolynomialOrder );
396 assert( geo == this->geometryType() );
397 }
398
399 LagrangePointListImplementation ( const ThisType& ) = delete;
400 };
401
402
403 template< class FieldImp, unsigned int topologyId, unsigned int dim, unsigned int maxPolOrder >
404 const int LagrangePointListImplementation< FieldImp, topologyId, dim, maxPolOrder >::maxPolynomialOrder;
405
406
407
408
409 template< class Field, int dim, unsigned int maxPolOrder >
410 struct LagrangePointSetTraits
411 {
413 typedef Field FieldType;
414
416 static const unsigned int maxPolynomialOrder = maxPolOrder;
417
419 static const int dimension = dim;
420
422 static const int codimension = 0;
423
425 template< typename ct, int quaddim >
426 struct PointListTraits
427 {
428 typedef LagrangePointListImplementation< ct, 0, 0, maxPolynomialOrder >
429 PointQuadratureType;
430
431 typedef LagrangePointListImplementation< ct, 0, 1, maxPolynomialOrder >
432 LineQuadratureType;
433
434 typedef LagrangePointListImplementation< ct, 0, dimension, maxPolynomialOrder >
435 SimplexQuadratureType;
436
437 typedef LagrangePointListImplementation< ct, (1 << dimension)-1, dimension, maxPolynomialOrder >
438 CubeQuadratureType;
439
440 typedef LagrangePointListImplementation< ct, (1 << (dimension-1)), dimension, maxPolynomialOrder >
441 PrismQuadratureType;
442
443 typedef LagrangePointListImplementation< ct, (1 << (dimension-1))-1, dimension, maxPolynomialOrder >
444 PyramidQuadratureType;
445
447 typedef LagrangePointListInterface< ct, quaddim, maxPolynomialOrder > IntegrationPointListType;
448
449 typedef int QuadratureKeyType ;
450 };
451
453 typedef Fem::IntegrationPointList< FieldType, dimension, PointListTraits > IntegrationPointListType;
454
456 typedef typename IntegrationPointListType::CoordinateType CoordinateType;
457 };
458
459
460
461 template< class GridPart, unsigned int maxPolOrder >
462 class LagrangePointSet;
463
464
465
466 // SubEntityLagrangePointIterator
467 // ------------------------------
468
469 template< class GridPart, int codim, unsigned int polOrder >
470 class SubEntityLagrangePointIterator
471 {
472 typedef SubEntityLagrangePointIterator< GridPart, codim, polOrder > ThisType;
473
474 public:
475 typedef GridPart GridPartType;
476
477 typedef typename GridPartType::ctype FieldType;
478
479 static const int dimension = GridPartType::dimension;
480 static const int codimension = codim;
481
482 static const unsigned int polynomialOrder = polOrder;
483
484 typedef FieldVector< FieldType, dimension > pointType;
485
486 typedef LagrangePointSet< GridPartType, polynomialOrder > LagrangePointSetType;
487
488 private:
490 typedef Dune::ReferenceElements< FieldType, dimension > ReferenceElementsType;
491 typedef std::decay_t< decltype( ReferenceElementsType::general( std::declval< const Dune::GeometryType & >() ) ) > ReferenceElementType;
492
493 SubEntityLagrangePointIterator ( const LagrangePointSetType &lagrangePointSet,
494 const unsigned int subEntity,
495 const bool beginIterator )
496 : lagrangePointSet_( &lagrangePointSet ),
497 refElement_( &ReferenceElementsType::general( lagrangePointSet_->geometryType() ) ),
498 subEntity_( subEntity ),
499 codim_( beginIterator ? codimension : dimension+1 ),
500 subIndex_( 0 ),
501 numSubIndices_( 1 ),
502 subSubEntity_( subEntity_ ),
503 dofNumber_( 0 ),
504 numDofs_( lagrangePointSet_->numDofs( codimension, subSubEntity_ ) )
505 {
506 if( beginIterator )
507 assertDof();
508 }
509
510 public:
511 SubEntityLagrangePointIterator ()
512 : lagrangePointSet_( 0 ),
513 refElement_( 0 ),
514 codim_( dimension+1 ),
515 subEntity_( 0 ),
516 subIndex_( 0 ),
517 dofNumber_( 0 )
518 {}
519
520 unsigned int operator* () const
521 {
522 assert( lagrangePointSet_ );
523 assert( codim_ <= dimension );
524
525 return lagrangePointSet_->entityDofNumber( codim_, subSubEntity_, dofNumber_ );
526 }
527
528 ThisType &operator++ ()
529 {
530 assert( codim_ <= dimension );
531 ++dofNumber_;
532 assertDof();
533 return *this;
534 }
535
536 bool operator== ( const ThisType& other ) const
537 {
538 if( (other.codim_ != codim_)
539 || (other.subIndex_ != subIndex_)
540 || (other.dofNumber_ != dofNumber_) )
541 return false;
542
543 return (other.lagrangePointSet_ == lagrangePointSet_)
544 && (other.subEntity_ == subEntity_);
545 }
546
547 bool operator!= ( const ThisType& other ) const
548 {
549 return !(*this == other);
550 }
551
552 static ThisType begin ( const LagrangePointSetType &lagrangePointSet,
553 unsigned int subEntity )
554 {
555 return ThisType( lagrangePointSet, subEntity, true );
556 }
557
558 static ThisType end ( const LagrangePointSetType &lagrangePointSet,
559 unsigned int subEntity )
560 {
561 return ThisType( lagrangePointSet, subEntity, false );
562 }
563
564 private:
565 void assertDof ()
566 {
567 assert( lagrangePointSet_ );
568 assert( refElement_ );
569
570 while( dofNumber_ >= numDofs_ )
571 {
572 const ReferenceElementType &refElement = *refElement_;
573
574 dofNumber_ = 0;
575 ++subIndex_;
576 while( subIndex_ >= numSubIndices_ )
577 {
578 subIndex_ = 0;
579 if( ++codim_ > dimension )
580 return;
581 numSubIndices_ = refElement.size( subEntity_, codimension, codim_ );
582 }
583 subSubEntity_ = refElement.subEntity( subEntity_, codimension, subIndex_, codim_ );
584 numDofs_ = lagrangePointSet_->numDofs( codim_, subSubEntity_ );
585 }
586 }
587
588 const LagrangePointSetType *lagrangePointSet_;
589 const ReferenceElementType *refElement_;
590 unsigned int subEntity_;
591
592 int codim_;
593 unsigned int subIndex_, numSubIndices_;
594 unsigned int subSubEntity_;
595 unsigned int dofNumber_, numDofs_;
596 };
597
598
599
600 // SubEntityLagrangePointIterator for codimension 0
601 // ------------------------------------------------
602
603 template< class GridPart, unsigned int polOrder >
604 class SubEntityLagrangePointIterator< GridPart, 0, polOrder >
605 {
606 typedef SubEntityLagrangePointIterator< GridPart, 0, polOrder > ThisType;
607
608 public:
609 typedef GridPart GridPartType;
610
611 typedef typename GridPartType::ctype FieldType;
612
613 static const int dimension = GridPartType::dimension;
614 static const int codimension = 0;
615
616 static const unsigned int polynomialOrder = polOrder;
617
618 typedef FieldVector< FieldType, dimension > pointType;
619
620 typedef LagrangePointSet< GridPartType, polynomialOrder > LagrangePointSetType;
621
622 private:
623 SubEntityLagrangePointIterator ( const LagrangePointSetType &lagrangePointSet,
624 const unsigned int subEntity,
625 const bool beginIterator )
626 : lagrangePointSet_( &lagrangePointSet ),
627 numDofs_( lagrangePointSet_->size() ),
628 index_( beginIterator ? 0 : numDofs_ )
629 {
630 assert( subEntity == 0 );
631 }
632
633 public:
634 SubEntityLagrangePointIterator ()
635 : lagrangePointSet_( 0 ),
636 numDofs_( 0 ),
637 index_( 0 )
638 {}
639
640 unsigned int operator* () const
641 {
642 assert( lagrangePointSet_ );
643 assert( index_ < numDofs_ );
644 return index_;
645 }
646
647 ThisType& operator++ ()
648 {
649 assert( index_ < numDofs_ );
650 ++index_;
651 return *this;
652 }
653
654 bool operator== ( const ThisType& other ) const
655 {
656 return (other.index_ == index_)
657 && (other.lagrangePointSet_ == lagrangePointSet_);
658 }
659
660 bool operator!= ( const ThisType& other ) const
661 {
662 return !(*this == other);
663 }
664
665
666 static ThisType begin ( const LagrangePointSetType &lagrangePointSet,
667 unsigned int subEntity )
668 {
669 return ThisType( lagrangePointSet, subEntity, true );
670 }
671
672 static ThisType end ( const LagrangePointSetType &lagrangePointSet,
673 unsigned int subEntity )
674 {
675 return ThisType( lagrangePointSet, subEntity, false );
676 }
677
678 private:
679 const LagrangePointSetType *lagrangePointSet_;
680 unsigned int numDofs_, index_;
681 };
682
683
684
685 template< class GridPart, unsigned int maxPolOrder >
686 class LagrangePointSet
687 : public CachingPointList< GridPart, 0, LagrangePointSetTraits< typename GridPart::ctype, GridPart::dimension, maxPolOrder > >
688 {
689 typedef LagrangePointSet< GridPart, maxPolOrder > ThisType;
690 typedef CachingPointList< GridPart, 0, LagrangePointSetTraits< typename GridPart::ctype, GridPart::dimension, maxPolOrder > > BaseType;
691
692 public:
693 typedef LagrangePointSetTraits< typename GridPart::ctype, GridPart::dimension, maxPolOrder > Traits;
694
695 typedef GridPart GridPartType;
696
697 typedef typename GridPartType::ctype FieldType;
698
699 static const int dimension = BaseType::dimension;
700
701 enum { maxPolynomialOrder = Traits::maxPolynomialOrder };
702
703 typedef typename BaseType::CoordinateType CoordinateType;
704 typedef typename Traits::CoordinateType PointType;
705
706 template< unsigned int codim >
707 struct Codim
708 {
710 typedef SubEntityLagrangePointIterator< GridPartType, codim, maxPolynomialOrder >
711 SubEntityIteratorType;
712 };
713
714 private:
715 typedef typename BaseType::IntegrationPointListType::IntegrationPointListType
716 LagrangePointListType;
717
718 public:
720 LagrangePointSet ( const GeometryType &geometry, const int polynomialOrder )
721 : BaseType( geometry, polynomialOrder ), lagrangePointList_( this->quadImp().ipList() )
722 {}
723
725 LagrangePointSet ( const ThisType &other )
726 : BaseType( other ), lagrangePointList_( this->quadImp().ipList() )
727 {}
728
729 ThisType& operator=( const ThisType& ) = delete;
730
731 const LocalKey &localKey ( unsigned int index ) const
732 {
733 return lagrangePointList_.dofInfo( index );
734 }
735
736 void dofSubEntity ( unsigned int index, unsigned int &codim,
737 unsigned int &subEntity ) const
738 {
739 unsigned int dofNumber;
740 lagrangePointList_.dofSubEntity( index, codim, subEntity, dofNumber );
741 }
742
743 void dofSubEntity ( unsigned int index, unsigned int &codim,
744 unsigned int &subEntity, unsigned int &dofNumber ) const
745 {
746 lagrangePointList_.dofSubEntity( index, codim, subEntity, dofNumber );
747 }
748
749 unsigned int entityDofNumber ( unsigned int codim, unsigned int subEntity,
750 unsigned int dofNumber ) const
751 {
752 return lagrangePointList_.entityDofNumber( codim, subEntity, dofNumber );
753 }
754
755 unsigned int maxDofs ( unsigned int codim ) const
756 {
757 return lagrangePointList_.maxDofs( codim );
758 }
759
760 unsigned int numDofs ( unsigned int codim, unsigned int subEntity ) const
761 {
762 return lagrangePointList_.numDofs( codim, subEntity );
763 }
764
765 unsigned int numDofs ( unsigned int codim ) const
766 {
767 return lagrangePointList_.numDofs( codim );
768 }
769
771 std::size_t size () const
772 {
773 return this->nop();
774 }
775
776 template< unsigned int codim >
777 typename Codim< codim >::SubEntityIteratorType
778 beginSubEntity ( unsigned int subEntity ) const
779 {
780 return Codim< codim >::SubEntityIteratorType::begin( *this, subEntity );
781 }
782
783 template< unsigned int codim >
784 typename Codim< codim >::SubEntityIteratorType
785 endSubEntity ( unsigned int subEntity ) const
786 {
787 return Codim< codim >::SubEntityIteratorType::end( *this, subEntity );
788 }
789
790 private:
791 const LagrangePointListType &lagrangePointList_;
792 };
793
794 } // namespace Fem
795
796} // namespace Dune
797
798#endif // #ifndef DUNE_FEM_SPACE_LAGRANGE_LAGRANGEPOINTS_HH
Dune::Fem::IntegrationPointListImp
Generic implementation of an IntegrationPointList.
Definition: quadratureimp.hh:33
Dune::Fem::IntegrationPointListImp::id
size_t id() const
obtain the identifier of the integration point list
Definition: quadratureimp.hh:122
Dune::Fem::IntegrationPointList
actual interface class for integration point lists
Definition: quadrature.hh:158
Dune::Fem::IntegrationPointList::CoordinateType
IntegrationPointListType::CoordinateType CoordinateType
type of coordinate
Definition: quadrature.hh:180
Dune::Fem::LagrangePointListInterface
Set of lagrange points.
Definition: lagrangepoints.hh:200
Dune::Fem::LagrangePointListInterface::maxDofs
unsigned int maxDofs(unsigned int codim) const
obtain the maximal number of DoFs in one entity of a codimension
Definition: lagrangepoints.hh:281
Dune::Fem::LagrangePointListInterface::CoordinateType
FieldVector< FieldType, dimension > CoordinateType
type of points
Definition: lagrangepoints.hh:215
Dune::Fem::LagrangePointListInterface::numDofs
unsigned int numDofs(unsigned int codim, unsigned int subEntity) const
obtain the number of DoFs on one entity
Definition: lagrangepoints.hh:298
Dune::Fem::LagrangePointListInterface::dimension
static const int dimension
dimension of points
Definition: lagrangepoints.hh:209
Dune::Fem::LagrangePointListInterface::geometryType
GeometryType geometryType() const
obtain GeometryType for this integration point list
Definition: lagrangepoints.hh:270
Dune::Fem::LagrangePointListInterface::FieldType
FieldImp FieldType
field type of points
Definition: lagrangepoints.hh:206
Dune::Fem::LagrangePointListInterface::maxPolynomialOrder
static const unsigned int maxPolynomialOrder
polynomial order of corresponding base functions
Definition: lagrangepoints.hh:212
Dune::Fem::LagrangePointListInterface::order
int order() const
obtain order of the integration point list
Definition: lagrangepoints.hh:314
Dune::Fem::LagrangePointListInterface::numDofs
unsigned int numDofs(unsigned int codim) const
obtain the total number of DoFs in a codimension
Definition: lagrangepoints.hh:309
Dune::Fem::LagrangePoint
A single lagrange point.
Definition: lagrangepoints.hh:38
Dune::FieldVector
vector space out of a tensor product of fields.
Definition: fvector.hh:91
Dune::GeometryType
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:114
Dune::VTK::geometryType
GeometryType geometryType(const Dune::GeometryType &t)
mapping from GeometryType to VTKGeometryType
Definition: common.hh:151
Dune::VTK::GeometryType
GeometryType
Type representing VTK's entity geometry types.
Definition: common.hh:132
Dune::operator==
EnableIfInterOperable< T1, T2, bool >::type operator==(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for equality.
Definition: iteratorfacades.hh:238
Dune::operator!=
EnableIfInterOperable< T1, T2, bool >::type operator!=(const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
Checks for inequality.
Definition: iteratorfacades.hh:260
Dune
Dune namespace.
Definition: alignedallocator.hh:13
Dune::size
constexpr std::integral_constant< std::size_t, sizeof...(II)> size(std::integer_sequence< T, II... >)
Return the size of the sequence.
Definition: integersequence.hh:75
Dune::Fem::LagrangePointSetTraits::PointListTraits
default defines for used point lists
Definition: lagrangepoints.hh:427
Dune::Fem::LagrangePointSetTraits::PointListTraits::IntegrationPointListType
LagrangePointListInterface< ct, quaddim, maxPolynomialOrder > IntegrationPointListType
type of integration point list implemementation
Definition: lagrangepoints.hh:447
Dune::Geo::ReferenceElements
Class providing access to the singletons of the reference elements.
Definition: referenceelements.hh:128
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 24, 23:30, 2024)