Dune Core Modules (2.5.0)

entity.hh
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3#ifndef DUNE_GEOGRID_ENTITY_HH
4#define DUNE_GEOGRID_ENTITY_HH
5
6#include <dune/geometry/referenceelements.hh>
7
9#include <dune/grid/geometrygrid/capabilities.hh>
10#include <dune/grid/geometrygrid/cornerstorage.hh>
11
12namespace Dune
13{
14
15 namespace GeoGrid
16 {
17
18 // Internal Forward Declarations
19 // -----------------------------
20
31 template< int codim, class Grid, bool fake = !(Capabilities::hasHostEntity< Grid, codim >::v) >
33
46 template< int codim, int dim, class Grid >
47 class Entity;
48
49
50
51 // External Forward Declarations
52 // -----------------------------
53
54 template< class Grid >
55 class HierarchicIterator;
56
57 template< class Grid, class HostIntersectionIterator >
58 class IntersectionIterator;
59
60
61
62 // EntityBase (real)
63 // -----------------
64
72 template< int codim, class Grid >
73 class EntityBase< codim, Grid, false >
74 {
75 typedef typename std::remove_const< Grid >::type::Traits Traits;
76
77 public:
82 static const int codimension = codim;
84 static const int dimension = Traits::dimension;
86 static const int mydimension = dimension - codimension;
88 static const int dimensionworld = Traits::dimensionworld;
89
91 static const bool fake = false;
92
99 typedef typename Traits::ctype ctype;
100
102 typedef typename Traits::template Codim< codimension >::Geometry Geometry;
105 private:
106 typedef typename Traits::HostGrid HostGrid;
107 typedef typename Traits::CoordFunction CoordFunction;
108
109 public:
114 typedef typename HostGrid::template Codim< codimension >::Entity HostEntity;
115
117 typedef typename Traits::template Codim< codimension >::EntitySeed EntitySeed;
118
120 typedef typename HostGrid::template Codim< 0 >::Entity HostElement;
123 typedef typename Traits::template Codim< codim >::GeometryImpl GeometryImpl;
124
125 private:
126 typedef typename HostGrid::template Codim< codimension >::Geometry HostGeometry;
127
128 typedef GeoGrid::CoordVector< mydimension, Grid, fake > CoordVector;
129
130 public:
134 EntityBase ()
135 : hostEntity_()
136 , grid_( nullptr )
137 , geo_()
138 {}
139
140 EntityBase ( const Grid &grid, const EntitySeed &seed )
141 : hostEntity_( grid.hostGrid().entity( grid.getRealImplementation(seed).hostEntitySeed() ) )
142 , grid_( &grid )
143 {}
144
145 EntityBase ( const Grid &grid, const HostElement &hostElement, int i )
146 : hostEntity_( hostElement.template subEntity<codim>(i) )
147 , grid_( &grid )
148 {}
149
150
151 EntityBase ( const GeometryImpl &geo, const HostEntity &hostEntity )
152 : hostEntity_( hostEntity )
153 , grid_( &geo.grid() )
154 , geo_( geo )
155 {}
156
157 EntityBase ( const GeometryImpl &geo, HostEntity&& hostEntity )
158 : hostEntity_( std::move( hostEntity ) )
159 , grid_( &geo.grid() )
160 , geo_( geo )
161 {}
162
163 EntityBase ( const Grid &grid, const HostEntity& hostEntity )
164 : hostEntity_( hostEntity )
165 , grid_( &grid )
166 {}
167
168 EntityBase ( const Grid &grid, HostEntity&& hostEntity )
169 : hostEntity_( std::move( hostEntity ) )
170 , grid_( &grid )
171 {}
172
173
174 EntityBase ( const EntityBase &other )
175 : hostEntity_( other.hostEntity_ )
176 , grid_( other.grid_ )
177 , geo_( other.geo_ )
178 {}
179
180 EntityBase ( EntityBase&& other )
181 : hostEntity_( std::move( other.hostEntity_ ) )
182 , grid_( other.grid_ )
183 , geo_( std::move( other.geo_ ) )
184 {}
185
188 const EntityBase &operator= ( const EntityBase &other )
189 {
190 hostEntity_ = other.hostEntity_;
191 grid_ = other.grid_;
192 geo_ = other.geo_;
193 return *this;
194 }
195
196 const EntityBase &operator= ( EntityBase&& other )
197 {
198 hostEntity_ = std::move( other.hostEntity_ );
199 grid_ = std::move( other.grid_ );
200 geo_ = std::move( other.geo_ );
201 return *this;
202 }
203
205 bool equals ( const EntityBase &other) const
206 {
207 return hostEntity_ == other.hostEntity_;
208 }
209
210 public:
219 {
220 return hostEntity().type();
221 }
222
224 int level () const
225 {
226 return hostEntity().level();
227 }
228
231 {
232 return hostEntity().partitionType();
233 }
234
250 {
251 if( !geo_ )
252 {
253 CoordVector coords( hostEntity(), grid().coordFunction() );
254 geo_ = GeometryImpl( grid(), type(), coords );
255 }
256 return Geometry( geo_ );
257 }
258
259 unsigned int subEntities ( unsigned int cc ) const
260 {
261 return hostEntity().subEntities( cc );
262 }
263
265 EntitySeed seed () const { return typename EntitySeed::Implementation( hostEntity().seed() ); }
272 const Grid &grid () const { assert( grid_ ); return *grid_; }
273
274 const HostEntity &hostEntity () const
275 {
276 return hostEntity_;
277 }
278
284 void initialize ( const HostEntity &hostEntity ) { hostEntity_ = hostEntity; }
285
293 template< class HostIndexSet >
294 typename HostIndexSet::IndexType
295 index ( const HostIndexSet &indexSet ) const
296 {
297 return indexSet.template index< codimension >( hostEntity() );
298 }
299
309 template< class HostIndexSet >
310 typename HostIndexSet::IndexType
311 subIndex ( const HostIndexSet &indexSet, int i, unsigned int cd ) const
312 {
313 return indexSet.subIndex( hostEntity(), i, cd );
314 }
315
323 template< class HostIndexSet >
324 bool isContained ( const HostIndexSet &indexSet ) const
325 {
326 return indexSet.contains( hostEntity() );
327 }
328
336 template< class HostIdSet >
337 typename HostIdSet::IdType id ( const HostIdSet &idSet ) const
338 {
339 return idSet.template id< codimension >( hostEntity() );
340 }
343 private:
344 HostEntity hostEntity_;
345 const Grid *grid_;
346 mutable GeometryImpl geo_;
347 };
348
349
350
351 // EntityBase (fake)
352 // -----------------
353
361 template< int codim, class Grid >
362 class EntityBase< codim, Grid, true >
363 {
364 typedef typename std::remove_const< Grid >::type::Traits Traits;
365
366 public:
371 static const int codimension = codim;
373 static const int dimension = Traits::dimension;
375 static const int mydimension = dimension - codimension;
377 static const int dimensionworld = Traits::dimensionworld;
378
380 static const bool fake = true;
387 typedef typename Traits::ctype ctype;
388
390 typedef typename Traits::template Codim< codimension >::Geometry Geometry;
393 private:
394 typedef typename Traits::HostGrid HostGrid;
395 typedef typename Traits::CoordFunction CoordFunction;
396
397 public:
402 typedef typename HostGrid::template Codim< codimension >::Entity HostEntity;
403
405 typedef typename Traits::template Codim< codimension >::EntitySeed EntitySeed;
406
408 typedef typename HostGrid::template Codim< 0 >::Entity HostElement;
411 typedef typename Traits::template Codim< codimension >::GeometryImpl GeometryImpl;
412
413 private:
414 typedef typename HostGrid::template Codim< 0 >::Geometry HostGeometry;
415
416 typedef GeoGrid::CoordVector< mydimension, Grid, fake > CoordVector;
417
418 public:
422 EntityBase ()
423 : hostElement_()
424 , subEntity_(-1)
425 , grid_(nullptr)
426 , geo_()
427 {}
428
429 EntityBase(const Grid& grid, const HostElement& hostElement, unsigned int subEntity)
430 : hostElement_(hostElement)
431 , subEntity_(subEntity)
432 , grid_(&grid)
433 {}
434
435 EntityBase ( const Grid &grid, const EntitySeed &seed )
436 : hostElement_( grid.hostGrid().entity( grid.getRealImplementation(seed).hostElementSeed() ) )
437 , subEntity_( grid.getRealImplementation(seed).subEntity() )
438 , grid_( &grid )
439 {}
440
441 EntityBase ( const EntityBase &other )
442 : hostElement_( other.hostElement_ )
443 , subEntity_( other.subEntity_ )
444 , grid_(other.grid_)
445 , geo_( other.geo_ )
446 {}
447
448 EntityBase ( EntityBase &&other )
449 : hostElement_( std::move( other.hostElement_ ) )
450 , subEntity_( std::move( other.subEntity_ ) )
451 , grid_( std::move( other.grid_ ) )
452 , geo_( std::move( other.geo_ ) )
453 {}
454
455 /*
456 * This method is required by constructors in the `Entity` class
457 * below, however it cannot do anything useful for fake
458 * entities.
459 */
460 EntityBase(const Grid& grid, const HostEntity& hostEntity)
461 {
462 DUNE_THROW(Dune::Exception, "GeometryGrid: Cannot create fake entity of codim " << codimension << " from real host entity.");
463 }
464
467 const EntityBase &operator= ( const EntityBase &other )
468 {
469 hostElement_ = other.hostElement_;
470 subEntity_ = other.subEntity_;
471 grid_ = other.grid_;
472 geo_ = other.geo_;
473 return *this;
474 }
475
476 const EntityBase &operator= ( EntityBase&& other )
477 {
478 hostElement_ = std::move( other.hostElement_ );
479 subEntity_ = std::move( other.subEntity_ );
480 grid_ = std::move( other.grid_ );
481 geo_ = std::move( other.geo_ );
482 return *this;
483 }
484
486 bool equals ( const EntityBase &other) const
487 {
488 const bool thisEnd = (subEntity() < 0);
489 const bool otherEnd = (other.subEntity() < 0);
490 if( thisEnd || otherEnd )
491 return thisEnd && otherEnd;
492
493 const int lvl = level();
494 if( lvl != other.level() )
495 return false;
496
497 const typename Traits::HostGrid::Traits::LevelIndexSet &indexSet
498 = grid().hostGrid().levelIndexSet( lvl );
499
500 const HostElement &thisElement = hostElement();
501 assert( indexSet.contains( thisElement ) );
502 const HostElement &otherElement = other.hostElement();
503 assert( indexSet.contains( otherElement ) );
504
505 const int thisIndex = indexSet.subIndex( thisElement, subEntity(), codimension );
506 const int otherIndex = indexSet.subIndex( otherElement, other.subEntity(), codimension );
507 return (thisIndex == otherIndex);
508 }
509
518 {
520 = ReferenceElements< ctype, dimension >::general( hostElement().type() );
521 return refElement.type( subEntity_, codimension );
522 }
523
525 int level () const
526 {
527 return hostElement().level();
528 }
529
532 {
534 = ReferenceElements< ctype, dimension >::general( hostElement().type() );
535
536 PartitionType type = vertexPartitionType( refElement, 0 );
537 if( (type != BorderEntity) && (type != FrontEntity) )
538 return type;
539
540 const int numVertices = refElement.size( subEntity_, codimension, dimension );
541 for( int i = 1; i < numVertices; ++i )
542 {
543 PartitionType vtxType = vertexPartitionType( refElement, i );
544 if( (vtxType != BorderEntity) && (vtxType != FrontEntity) )
545 return vtxType;
546 if( type != vtxType )
547 return OverlapEntity;
548 }
549 assert( (type == BorderEntity) || (type == FrontEntity) );
550 return type;
551 }
552
568 {
569 if( !geo_ )
570 {
571 CoordVector coords( hostElement(), subEntity_, grid().coordFunction() );
572 geo_ = GeometryImpl( grid(), type(), coords );
573 }
574 return Geometry( geo_ );
575 }
576
577 unsigned int subEntities ( unsigned int cc ) const
578 {
580 = ReferenceElements< ctype, dimension >::general( hostElement().type() );
581 return refElement.size( subEntity_, codimension, cc );
582 }
583
585 EntitySeed seed () const { return typename EntitySeed::Implementation( hostElement().seed(), subEntity_ ); }
591 const Grid &grid () const { assert( grid_ ); return *grid_; }
592
593 const HostEntity &hostEntity () const
594 {
595 DUNE_THROW( NotImplemented, "HostGrid has no entities of codimension " << codimension << "." );
596 }
597
598 const HostElement &hostElement () const
599 {
600 return hostElement_;
601 }
602
603 int subEntity () const { return subEntity_; }
604
612 void initialize ( const HostElement &hostElement ) { hostElement_ = hostElement; }
613
621 template< class HostIndexSet >
622 typename HostIndexSet::IndexType index ( const HostIndexSet &indexSet ) const
623 {
624 return indexSet.subIndex( hostElement(), subEntity_, codimension );
625 }
626
636 template< class HostIndexSet >
637 typename HostIndexSet::IndexType
638 subIndex ( const HostIndexSet &indexSet, int i, unsigned int cd ) const
639 {
641 = ReferenceElements< ctype, dimension >::general( hostElement().type() );
642 const int j = refElement.subEntity( subEntity_, codimension, i, codimension+cd );
643 return indexSet.subIndex( hostElement(), j, codimension+cd );
644 }
645
653 template< class HostIndexSet >
654 bool isContained ( const HostIndexSet &indexSet ) const
655 {
656 return indexSet.contains( hostElement() );
657 }
658
666 template< class HostIdSet >
667 typename HostIdSet::IdType id ( const HostIdSet &idSet ) const
668 {
669 return idSet.subId( hostElement(), subEntity_, codimension );
670 }
673 private:
675 vertexPartitionType ( const ReferenceElement< ctype, dimension > &refElement, int i ) const
676 {
677 const int j = refElement.subEntity( subEntity_, codimension, i, dimension );
678 return hostElement().template subEntity< dimension >( j ).partitionType();
679 }
680
681 private:
682 HostElement hostElement_;
683 unsigned int subEntity_;
684 const Grid *grid_;
685 mutable GeometryImpl geo_;
686 };
687
688
689
690 // Entity
691 // ------
692
693 template< int codim, int dim, class Grid >
694 class Entity
695 : public EntityBase< codim, Grid >
696 {
698
699 public:
700 typedef typename Base::HostEntity HostEntity;
701 typedef typename Base::HostElement HostElement;
702 typedef typename Base::GeometryImpl GeometryImpl;
703 typedef typename Base::EntitySeed EntitySeed;
704
705 Entity () : Base() {}
706
707 Entity ( const Grid &grid, const EntitySeed &seed ) : Base( grid, seed ) {}
708
709 Entity ( const Grid &grid, const HostEntity &hostEntity ) : Base( grid, hostEntity ) {}
710 Entity ( const Grid &grid, HostEntity&& hostEntity ) : Base( grid, std::move( hostEntity ) ) {}
711
712 Entity ( const Grid &grid, const HostElement &hostEntity, int i ) : Base( grid, hostEntity, i ) {}
713
714 };
715
716
717
718 // Entity for codimension 0
719 // ------------------------
720
721 template< int dim, class Grid >
722 class Entity< 0, dim, Grid >
723 : public EntityBase< 0, Grid >
724 {
725 typedef EntityBase< 0, Grid > Base;
726
727 typedef typename std::remove_const< Grid >::type::Traits Traits;
728
729 typedef typename Traits::HostGrid HostGrid;
730
731 public:
736 static const int codimension = Base::codimension;
738 static const int dimension = Base::dimension;
740 static const int mydimension = Base::mydimension;
742 static const int dimensionworld = Base::dimensionworld;
743
745 static const bool fake = Base::fake;
752 typedef typename Traits::template Codim< codimension >::LocalGeometry LocalGeometry;
753
755
757 typedef typename Traits::HierarchicIterator HierarchicIterator;
759 typedef typename Traits::LeafIntersectionIterator LeafIntersectionIterator;
761 typedef typename Traits::LevelIntersectionIterator LevelIntersectionIterator;
762
765 typedef typename Base::HostEntity HostEntity;
766 typedef typename Base::HostElement HostElement;
767 typedef typename Base::GeometryImpl GeometryImpl;
768 typedef typename Base::EntitySeed EntitySeed;
769
770 using Base::grid;
771 using Base::hostEntity;
772
773 Entity () : Base() {}
774
775 Entity ( const Grid &grid, const HostEntity &hostEntity ) : Base( grid, hostEntity ) {}
776 Entity ( const Grid &grid, HostEntity&& hostEntity ) : Base( grid, std::move( hostEntity ) ) {}
777 Entity ( const GeometryImpl &geo, const HostEntity& hostEntity ) : Base( geo, hostEntity ) {}
778 Entity ( const GeometryImpl &geo, HostEntity &&hostEntity ) : Base( geo, std::move( hostEntity ) ) {}
779
780 Entity ( const Grid &grid, const EntitySeed &seed ) : Base( grid, seed ) {}
781
782 Entity ( const Grid &grid, const HostEntity &hostEntity, int i ) : Base( grid, hostEntity )
783 {
784 assert( i == 0 );
785 }
786
787 template< int codim >
788 typename Grid::template Codim< codim >::Entity
789 subEntity ( int i ) const
790 {
791 typedef typename Traits::template Codim< codim >::EntityImpl EntityImpl;
792 return EntityImpl( grid(), hostEntity(), i );
793 }
794
795 LevelIntersectionIterator ilevelbegin () const
796 {
797 typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LevelIntersectionIterator > LevelIntersectionIteratorImpl;
798 return LevelIntersectionIteratorImpl( *this, hostEntity().ilevelbegin() );
799 }
800
801 LevelIntersectionIterator ilevelend () const
802 {
803 typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LevelIntersectionIterator > LevelIntersectionIteratorImpl;
804 return LevelIntersectionIteratorImpl( *this, hostEntity().ilevelend() );
805 }
806
807 LeafIntersectionIterator ileafbegin () const
808 {
809 typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LeafIntersectionIterator > LeafIntersectionIteratorImpl;
810 return LeafIntersectionIteratorImpl( *this, hostEntity().ileafbegin() );
811 }
812
813 LeafIntersectionIterator ileafend () const
814 {
815 typedef GeoGrid::IntersectionIterator< Grid, typename HostGrid::LeafIntersectionIterator > LeafIntersectionIteratorImpl;
816 return LeafIntersectionIteratorImpl( *this, hostEntity().ileafend() );
817 }
818
819 bool hasBoundaryIntersections () const
820 {
821 return hostEntity().hasBoundaryIntersections();
822 }
823
824 bool isLeaf () const
825 {
826 return hostEntity().isLeaf();
827 }
828
829 EntityFacade father () const
830 {
831 return Entity( grid(), hostEntity().father() );
832 }
833
834 bool hasFather () const
835 {
836 return hostEntity().hasFather();
837 }
838
839 LocalGeometry geometryInFather () const
840 {
841 return hostEntity().geometryInFather();
842 }
843
844 HierarchicIterator hbegin ( int maxLevel ) const
845 {
846 typedef GeoGrid::HierarchicIterator< Grid > HierarchicIteratorImpl;
847 return HierarchicIteratorImpl( grid(), hostEntity().hbegin( maxLevel ) );
848 }
849
850 HierarchicIterator hend ( int maxLevel ) const
851 {
852 typedef GeoGrid::HierarchicIterator< Grid > HierarchicIteratorImpl;
853 return HierarchicIteratorImpl( grid(), hostEntity().hend( maxLevel ) );
854 }
855
856 bool isRegular () const
857 {
858 return hostEntity().isRegular();
859 }
860
861 bool isNew () const
862 {
863 return hostEntity().isNew();
864 }
865
866 bool mightVanish () const
867 {
868 return hostEntity().mightVanish();
869 }
870 };
871
872 } // namespace GeoGrid
873
874} // namespace Dune
875
876#endif // #ifndef DUNE_GEOGRID_ENTITY_HH
Store a reference to an entity with a minimal memory footprint.
Definition: entityseed.hh:24
EntitySeedImp Implementation
Export the implementation type.
Definition: entityseed.hh:31
Wrapper class for entities.
Definition: entity.hh:65
Base class for Dune-Exceptions.
Definition: exceptions.hh:94
GeometryType type() const
obtain the name of the corresponding reference element
Definition: entity.hh:218
bool equals(const EntityBase &other) const
compare two entities
Definition: entity.hh:205
Traits::ctype ctype
coordinate type of the grid
Definition: entity.hh:99
Geometry geometry() const
Definition: entity.hh:249
void initialize(const HostEntity &hostEntity)
initiliaze an entity
Definition: entity.hh:284
EntitySeed seed() const
return EntitySeed of host grid entity
Definition: entity.hh:265
HostIdSet::IdType id(const HostIdSet &idSet) const
obtain the entity's id from a host IdSet
Definition: entity.hh:337
Traits::template Codim< codimension >::Geometry Geometry
type of corresponding geometry
Definition: entity.hh:102
HostGrid::template Codim< codimension >::Entity HostEntity
type of corresponding host entity
Definition: entity.hh:114
Traits::template Codim< codimension >::EntitySeed EntitySeed
type of corresponding entity seed
Definition: entity.hh:117
HostIndexSet::IndexType index(const HostIndexSet &indexSet) const
obtain the entity's index from a host IndexSet
Definition: entity.hh:295
HostGrid::template Codim< 0 >::Entity HostElement
type of host elements, i.e., of host entities of codimension 0
Definition: entity.hh:120
PartitionType partitionType() const
obtain the partition type of this entity
Definition: entity.hh:230
int level() const
obtain the level of this entity
Definition: entity.hh:224
HostIndexSet::IndexType subIndex(const HostIndexSet &indexSet, int i, unsigned int cd) const
obtain the index of a subentity from a host IndexSet
Definition: entity.hh:311
bool isContained(const HostIndexSet &indexSet) const
check whether the entity is contained in a host index set
Definition: entity.hh:324
int level() const
obtain the level of this entity
Definition: entity.hh:525
HostGrid::template Codim< 0 >::Entity HostElement
type of host elements, i.e., of host entities of codimension 0
Definition: entity.hh:408
PartitionType partitionType() const
obtain the partition type of this entity
Definition: entity.hh:531
bool equals(const EntityBase &other) const
compare two entities
Definition: entity.hh:486
HostIndexSet::IndexType index(const HostIndexSet &indexSet) const
obtain the entity's index from a host IndexSet
Definition: entity.hh:622
Traits::template Codim< codimension >::EntitySeed EntitySeed
type of corresponding entity seed
Definition: entity.hh:405
Traits::template Codim< codimension >::Geometry Geometry
type of corresponding geometry
Definition: entity.hh:390
HostIdSet::IdType id(const HostIdSet &idSet) const
obtain the entity's id from a host IdSet
Definition: entity.hh:667
EntitySeed seed() const
return EntitySeed of host grid entity
Definition: entity.hh:585
HostIndexSet::IndexType subIndex(const HostIndexSet &indexSet, int i, unsigned int cd) const
obtain the index of a subentity from a host IndexSet
Definition: entity.hh:638
void initialize(const HostElement &hostElement)
initiliaze an entity
Definition: entity.hh:612
Geometry geometry() const
Definition: entity.hh:567
Traits::ctype ctype
coordinate type of the grid
Definition: entity.hh:387
bool isContained(const HostIndexSet &indexSet) const
check whether the entity is contained in a host index set
Definition: entity.hh:654
GeometryType type() const
obtain the name of the corresponding reference element
Definition: entity.hh:517
HostGrid::template Codim< codimension >::Entity HostEntity
type of corresponding host entity
Definition: entity.hh:402
actual implementation of the entity
Definition: entity.hh:32
DUNE-conform implementation of the entity.
Definition: entity.hh:696
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:268
Grid abstract base class.
Definition: grid.hh:373
Default exception for dummy implementations.
Definition: exceptions.hh:261
This class provides access to geometric and topological properties of a reference element.
Definition: referenceelements.hh:354
int size(int c) const
number of subentities of codimension c
Definition: referenceelements.hh:381
int subEntity(int i, int c, int ii, int cc) const
obtain number of ii-th subentity with codim cc of (i,c)
Definition: referenceelements.hh:417
const GeometryType & type(int i, int c) const
obtain the type of subentity (i,c)
Definition: referenceelements.hh:431
Different resources needed by all grid implementations.
#define DUNE_THROW(E, m)
Definition: exceptions.hh:216
PartitionType
Attributes used in the generic overlap model.
Definition: gridenums.hh:28
@ FrontEntity
on boundary between overlap and ghost
Definition: gridenums.hh:32
@ BorderEntity
on boundary between interior and overlap
Definition: gridenums.hh:30
@ OverlapEntity
all entities lying in the overlap zone
Definition: gridenums.hh:31
Dune namespace.
Definition: alignment.hh:11
STL namespace.
Static tag representing a codimension.
Definition: dimension.hh:22
static const ReferenceElement< ctype, dim > & general(const GeometryType &type)
get general reference elements
Definition: referenceelements.hh:757
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 23, 23:29, 2024)