Dune Core Modules (2.4.2)

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_ALU3DGRIDENTITY_HH
4#define DUNE_ALU3DGRIDENTITY_HH
5
6// System includes
7
8// Dune includes
9#include <dune/grid/common/entity.hh>
11
12// Local includes
13#include "alu3dinclude.hh"
14#include "iterator.hh"
15#include "entityseed.hh"
16
17namespace Dune
18{
19
20 // Forward declarations
21 template<int cd, int dim, class GridImp>
22 class ALU3dGridEntity;
23 template<int cd, PartitionIteratorType pitype, class GridImp >
24 class ALU3dGridLevelIterator;
25 template<int cd, class GridImp >
26 class ALU3dGridEntityPointer;
27 template<int mydim, int coorddim, class GridImp>
28 class ALU3dGridGeometry;
29 template<class GridImp>
30 class ALU3dGridHierarchicIterator;
31 template<class GridImp>
32 class ALU3dGridIntersectionIterator;
33 template<int codim, PartitionIteratorType, class GridImp>
34 class ALU3dGridLeafIterator;
35 template< ALU3dGridElementType, class >
36 class ALU3dGrid;
37
44 template<int cd, int dim, class GridImp>
46 public EntityDefaultImplementation <cd,dim,GridImp,ALU3dGridEntity>
47 {
48 // default just returns level
49 template <class GridType, int cdim>
50 struct GetLevel
51 {
52 template <class ItemType>
53 static int getLevel(const GridType & grid, const ItemType & item )
54 {
55 return item.level();
56 }
57 };
58
59 // for leaf vertices the level is somewhat difficult to obtain, because
60 // this the maximum of levels of elements that have this vertex as sub
61 // entity
62 template <class GridType>
63 struct GetLevel<GridType,3>
64 {
65 template <class ItemType>
66 static int getLevel(const GridType & grid, const ItemType & item)
67 {
68 return (item.isLeafEntity()) ? grid.getLevelOfLeafVertex(item) : item.level();
69 }
70 };
71
72 enum { dimworld = GridImp::dimensionworld };
73
74 typedef typename GridImp::MPICommunicatorType Comm;
75
76 friend class ALU3dGrid< GridImp::elementType, Comm >;
77 friend class ALU3dGridEntity < 0, dim, GridImp >;
78 friend class ALU3dGridLevelIterator < cd, All_Partition, GridImp >;
79
80 friend class ALU3dGridHierarchicIndexSet< GridImp::elementType, Comm >;
81
82 template< class > friend class ALU3dGridFactory;
83
84 typedef typename GridImp::Traits::template Codim< cd >::GeometryImpl GeometryImpl;
85
86 public:
87 typedef typename GridImp::GridObjectFactoryType FactoryType;
88
89 typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
90 typedef typename ImplTraits::template Codim<cd>::InterfaceType HItemType;
91 typedef typename ImplTraits::template Codim<cd>::ImplementationType ItemType;
92 typedef typename ImplTraits::VertexType VertexType;
93 typedef typename ImplTraits::HBndSegType HBndSegType;
94
95 typedef typename GridImp::template Codim<cd>::Entity Entity;
96 typedef typename GridImp::template Codim<cd>::Geometry Geometry;
97
98 typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
99
101 typedef typename GridImp::template Codim<cd>::EntitySeed EntitySeed;
102
104 int level () const;
105
108
110 ALU3dGridEntity(const FactoryType &factory, int level);
111
113 ALU3dGridEntity(const ALU3dGridEntity & org);
114
116 Geometry geometry () const;
117
119 GeometryType type () const;
120
121 // set element as normal entity
122 void setElement(const HItemType & item);
123 void setElement(const HItemType & item, const int level, int twist=0, int face = -1);
124
125 /* set entity from seed */
126 void setElement(const EntitySeed& seed);
127
129 void setGhost(const HBndSegType &ghost);
130
132 void removeElement ();
133
135 void reset ( int l );
136
138 bool equals ( const ALU3dGridEntity<cd,dim,GridImp> & org ) const;
139
141 void setEntity ( const ALU3dGridEntity<cd,dim,GridImp> & org );
142
143 // return reference to internal item
144 const ItemType & getItem () const { return *item_; }
145
147 const GridImp& grid() const { return factory_.grid(); }
148
150 const FactoryType& factory() const { return factory_; }
151
154 {
155 return EntitySeed( getItem(), level(), twist_, face_ );
156 }
157
158 private:
160 int getIndex () const;
161
163 PartitionType convertBndId(const HItemType & item) const ;
164
166 mutable GeometryImpl geo_;
167
168 // the factory that created this entity
169 const FactoryType& factory_;
170
171 // corresponding ALU3dGrid item, here face, edge, or vertex
172 const ItemType * item_;
173
174 int level_;
175 int gIndex_;
176 int twist_;
177 int face_;
178
179 mutable PartitionType partitionType_;
180 };
181
195 //***********************
196 //
197 // --ALU3dGridEntity
198 // --0Entity
199 //
200 //***********************
201 template<int dim, class GridImp>
202 class ALU3dGridEntity<0,dim,GridImp>
203 : public EntityDefaultImplementation<0,dim,GridImp,ALU3dGridEntity>
204 {
205 static const int dimworld = remove_const< GridImp >::type::dimensionworld;
206 static const ALU3dGridElementType elementType = remove_const< GridImp >::type::elementType;
207
208 typedef typename GridImp::MPICommunicatorType Comm;
209
210 typedef ALU3dImplTraits< elementType, Comm > ImplTraits;
211 typedef typename ImplTraits::template Codim<0>::InterfaceType HElementType;
212
213 typedef typename ImplTraits::GEOElementType GEOElementType;
214 typedef typename ImplTraits::BNDFaceType BNDFaceType;
215 typedef typename ImplTraits::IMPLElementType IMPLElementType;
216 typedef typename ImplTraits::HBndSegType HBndSegType;
217
218 enum { refine_element_t = ImplTraits::refine_element_t };
219 enum { bisect_element_t = ImplTraits::bisect_element_t };
220 enum { coarse_element_t = ImplTraits::coarse_element_t };
221 enum { nosplit_element_t = ImplTraits::nosplit_element_t };
222
223 typedef typename ImplTraits::MarkRuleType MarkRuleType;
224
225 friend class ALU3dGrid< elementType, Comm >;
226 friend class ALU3dGridIntersectionIterator < GridImp >;
227 friend class ALU3dGridIntersectionIterator < const GridImp >;
228 friend class ALU3dGridHierarchicIterator < const GridImp >;
229 friend class ALU3dGridHierarchicIterator < GridImp >;
230 friend class ALU3dGridLevelIterator <0,All_Partition,GridImp>;
231 friend class ALU3dGridLevelIterator <1,All_Partition,GridImp>;
232 friend class ALU3dGridLevelIterator <2,All_Partition,GridImp>;
233 friend class ALU3dGridLevelIterator <3,All_Partition,GridImp>;
234 friend class ALU3dGridLeafIterator <0, All_Partition,GridImp>;
235 friend class ALU3dGridLeafIterator <1, All_Partition,GridImp>;
236 friend class ALU3dGridLeafIterator <2, All_Partition,GridImp>;
237 friend class ALU3dGridLeafIterator <3, All_Partition,GridImp>;
238
239 friend class ALU3dGridHierarchicIndexSet< elementType, Comm >;
240
241 template< class > friend class ALU3dGridFactory;
242
243 // type of reference element
244 typedef typename GridImp :: ReferenceElementType ReferenceElementType;
245
246 typedef typename GridImp::Traits::template Codim< 0 >::GeometryImpl GeometryImpl;
247 typedef typename GridImp::Traits::template Codim< 0 >::LocalGeometryImpl LocalGeometryImpl;
248
249 public:
250 typedef typename GridImp::GridObjectFactoryType FactoryType;
251
252 typedef typename GridImp::template Codim< 0 >::Geometry Geometry;
253 typedef typename GridImp::template Codim< 0 >::LocalGeometry LocalGeometry;
255
259
260 typedef typename GridImp::template Codim<0>::Entity Entity;
261 typedef typename GridImp::template Codim<0>::EntityPointer EntityPointer;
262
263 template <int cd>
264 struct Codim
265 {
266 typedef typename GridImp::template Codim<cd>::EntityPointer EntityPointer;
267 };
268
270 typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
271
273 ALU3dGridEntity(const FactoryType& factory, int level);
274
277
279 int level () const ;
280
282 Geometry geometry () const;
283
285 GeometryType type () const;
286
289
293 template<int cc> int count () const ;
294
298 unsigned int subEntities (unsigned int codim) const ;
299
302 template< int codim >
303 typename Codim< codim >::EntityPointer subEntity ( int i ) const;
304
310 ALU3dGridLeafIntersectionIteratorType ileafbegin () const;
311
314
320 ALU3dGridLevelIntersectionIteratorType ilevelbegin () const;
321
324
326 bool isLeaf () const;
327
330 EntityPointer father () const;
332 bool hasFather () const
333 {
334 return (this->level()>0);
335 }
336
346 LocalGeometry geometryInFather () const;
347
352 ALU3dGridHierarchicIterator<GridImp> hbegin (int maxlevel) const;
353
355 ALU3dGridHierarchicIterator<GridImp> hend (int maxlevel) const;
356
357 //***************************************************************
358 // Interface for Adaptation
359 //***************************************************************
360
362 bool isNew () const;
363
365 bool mightVanish () const;
366
369
370 // private method
374 bool mark( int refCount ) const;
375
377 int getMark() const;
378
382 void setElement(HElementType &element);
383
384 /* set entity from seed */
385 void setElement(const EntitySeed& seed);
386
388 void setGhost(HBndSegType & ghost);
389
391 void reset ( int l );
392
394 void removeElement();
395
397 bool equals ( const ALU3dGridEntity<0,dim,GridImp> & org ) const;
398
399 void setEntity ( const ALU3dGridEntity<0,dim,GridImp> & org );
400
404 template<int cc> int getSubIndex (int i) const;
405
409 int subIndex(int i, unsigned int codim) const;
410
411 // return reference to internal item
412 const IMPLElementType& getItem () const { return *item_; }
413
414 // return reference to internal item
415 const BNDFaceType& getGhost () const
416 {
417 assert( isGhost() );
418 return *ghost_;
419 }
420
422 const GridImp& grid() const { return factory_.grid(); }
423
425 const FactoryType& factory() const { return factory_; }
426
428 bool isGhost () const { return ImplTraits::isGhost( ghost_ ); }
429
432 {
433 if( isGhost() )
434 return EntitySeed( getGhost () );
435 else
436 return EntitySeed( getItem() );
437 }
438
439 private:
441 int getIndex () const;
442
444 mutable GeometryImpl geo_;
445
446 // corresponding factory
447 const FactoryType& factory_;
448
449 // the current element of grid
450 mutable IMPLElementType* item_;
451
453 mutable BNDFaceType* ghost_;
454
455 int level_;
456 bool isLeaf_;
457
458 }; // end of ALU3dGridEntity codim = 0
459 //**********************************************************************
460 //
461 // --ALU3dGridEntityPointer
462 // --EntityPointer
463 // --EnPointer
467 template< int codim, class GridImp >
469 {
471 enum { dim = GridImp::dimension };
472 enum { dimworld = GridImp::dimensionworld };
473
474 typedef typename GridImp::MPICommunicatorType Comm;
475
476 friend class ALU3dGridEntity<codim,dim,GridImp>;
477 friend class ALU3dGridEntity< 0,dim,GridImp>;
478 friend class ALU3dGrid < GridImp::elementType, Comm >;
479
480 typedef ALU3dImplTraits<GridImp::elementType, Comm > ImplTraits;
481 typedef typename ImplTraits::template Codim<codim>::InterfaceType HElementType;
482
483 typedef typename ImplTraits::HBndSegType HBndSegType;
484 typedef typename ImplTraits::BNDFaceType BNDFaceType;
485 public:
486 typedef typename GridImp::GridObjectFactoryType FactoryType;
487
488 enum { codimension = codim };
489
491 typedef typename GridImp::template Codim<codimension>::Entity Entity;
494 typedef typename EntityObject :: ImplementationType EntityImp;
495
498
500 typedef ALU3dGridEntityPointer<codimension,GridImp> EntityPointerImp;
501
503 typedef ALU3dGridEntitySeed<codimension, GridImp> ALU3dGridEntitySeedType;
504
506 ALU3dGridEntityPointerBase(const FactoryType& factory,
507 const HElementType & item);
508
510 ALU3dGridEntityPointerBase(const FactoryType& factory,
511 const HElementType & item,
512 const int level,
513 const int twist,
514 const int duneFace
515 );
516
518 ALU3dGridEntityPointerBase(const FactoryType& factory,
519 const HBndSegType & ghostFace );
520
522 ALU3dGridEntityPointerBase(const FactoryType& factory,
523 const ALU3dGridEntitySeedType& seed );
524
527
530
532 bool equals (const ALU3dGridEntityPointerType& i) const;
533
535 ThisType & operator = (const ThisType & org);
536
538 Entity & dereference () const ;
539
541 int level () const ;
542
543 protected:
544 // clones object
545 void clone (const ALU3dGridEntityPointerType & org);
546
547 // get entity and assign from org.entity
548 void getEntity (const ALU3dGridEntityPointerType & org);
549
551 void done ();
552
554 void freeEntity ();
555
557 const GridImp& grid () const { return factory_.grid(); }
558
561 ALU3dGridEntityPointerBase(const FactoryType& factory, int level );
562
563 // update underlying item pointer and set ghost entity
564 void updateGhostPointer( HBndSegType & ghostFace );
565 // update underlying item pointer and set entity
566 void updateEntityPointer( HElementType * item , int level = -1 );
567
568 // reference to factory
569 const FactoryType& factory_;
570
571 // key to gererate entity
573
574 // entity that this EntityPointer points to
575 mutable EntityObject * entity_;
576
577 // return reference to internal entity implementation
578 EntityImp & entityImp () const {
579 assert( entity_ );
580 return GridImp :: getRealImplementation(*entity_);
581 }
582 };
583
587 template<class GridImp>
588 class ALU3dGridEntityPointer<0,GridImp> :
589 public ALU3dGridEntityPointerBase<0,GridImp>
590 {
591 protected:
593
594 enum { cd = 0 };
595 typedef ALU3dGridEntityPointer <cd,GridImp> ThisType;
596 enum { dim = GridImp::dimension };
597 enum { dimworld = GridImp::dimensionworld };
598
599 typedef typename GridImp::MPICommunicatorType Comm;
600
601 friend class ALU3dGridEntity<cd,dim,GridImp>;
602 friend class ALU3dGridEntity< 0,dim,GridImp>;
603 friend class ALU3dGrid < GridImp::elementType, Comm >;
604
605 typedef ALU3dImplTraits<GridImp::elementType, Comm > ImplTraits;
606 typedef typename ImplTraits::template Codim<cd>::InterfaceType HElementType;
607
608 typedef typename ImplTraits::HBndSegType HBndSegType;
609 typedef typename ImplTraits::BNDFaceType BNDFaceType;
610
611 typedef ALU3dGridEntity< 0,dim,GridImp> ALU3dGridEntityType ;
612
613 using BaseType :: seed_;
614 using BaseType :: entity_;
615 using BaseType :: entityImp;
616 using BaseType :: factory_;
617 public:
618 typedef typename GridImp::GridObjectFactoryType FactoryType;
619
621 typedef ALU3dGridEntitySeed<cd, GridImp> ALU3dGridEntitySeedType;
622
624 typedef typename GridImp::template Codim<cd>::Entity Entity;
625
628
630 ALU3dGridEntityPointer(const FactoryType& factory,
631 const HElementType & item)
632 : ALU3dGridEntityPointerBase<cd,GridImp> (factory,item) {}
633
635 ALU3dGridEntityPointer(const FactoryType& factory,
636 const HBndSegType & ghostFace )
637 : ALU3dGridEntityPointerBase<cd,GridImp> (factory,ghostFace) {}
638
640 ALU3dGridEntityPointer(const FactoryType& factory, const ALU3dGridEntitySeedType& seed)
641 : ALU3dGridEntityPointerBase<cd,GridImp> (factory, seed)
642 {
643 // for ghost entities we have to copy right away
644 if( seed.isGhost() )
645 {
646 assert( entity_ == 0 );
647 entity_ = factory_.template getNewEntity<0> ();
648 assert( entity_ );
649 entityImp().setGhost( *seed.ghost() );
650 }
651 }
652
655 : ALU3dGridEntityPointerBase<cd,GridImp> (entity.factory(),
656 entity.seed() )
657 {
658 // for ghost entities we have to copy right away
659 if( entity.isGhost() )
660 {
661 assert( entity_ == 0 );
662 entity_ = factory_.template getNewEntity<0> ();
663 assert( entity_ );
664 entityImp().setEntity( entity );
665 }
666 }
667
670 : ALU3dGridEntityPointerBase<cd,GridImp> (org)
671 {}
672
673 protected:
676 ALU3dGridEntityPointer(const FactoryType& factory, int level )
677 : ALU3dGridEntityPointerBase<cd,GridImp> (factory,level) {}
678 };
679
680
681 template<int cd, class GridImp>
682 class ALU3dGridEntityPointer :
683 public ALU3dGridEntityPointerBase<cd,GridImp>
684 {
685 protected:
686 typedef ALU3dGridEntityPointerBase<cd,GridImp> BaseType ;
687 typedef ALU3dGridEntityPointer <cd,GridImp> ThisType;
688 enum { dim = GridImp::dimension };
689 enum { dimworld = GridImp::dimensionworld };
690
691 typedef typename GridImp::MPICommunicatorType Comm;
692
693 friend class ALU3dGridEntity<cd,dim,GridImp>;
694 friend class ALU3dGridEntity< 0,dim,GridImp>;
695 friend class ALU3dGrid < GridImp::elementType, Comm >;
696
697 typedef ALU3dImplTraits< GridImp::elementType, Comm > ImplTraits;
698 typedef typename ImplTraits::template Codim<cd>::InterfaceType HElementType;
699
700 typedef typename ImplTraits::HBndSegType HBndSegType;
701 typedef typename ImplTraits::BNDFaceType BNDFaceType;
702 typedef ALU3dGridEntity<cd,dim,GridImp> ALU3dGridEntityType;
703
704 using BaseType :: seed_;
705 using BaseType :: entity_;
706 using BaseType :: entityImp;
707 using BaseType :: factory_;
708 using BaseType :: getEntity;
709
710 public:
711 typedef typename GridImp::GridObjectFactoryType FactoryType;
712
714 typedef ALU3dGridEntitySeed<cd, GridImp> ALU3dGridEntitySeedType;
715
717 typedef typename GridImp::template Codim<cd>::Entity Entity;
718
720 typedef ALU3dGridEntityPointer<cd,GridImp> ALU3dGridEntityPointerType;
721
722 protected:
723 static const int defaultValue = -665; //ALU3dGridEntityPointerType :: defaultValue;
724
725 public:
727 ALU3dGridEntityPointer(const FactoryType& factory,
728 const int level,
729 const HElementType & item,
730 const int twist = defaultValue,
731 const int duneFace = defaultValue
732 );
733
735 ALU3dGridEntityPointer(const ALU3dGridEntityType& entity)
736 : ALU3dGridEntityPointerBase<cd,GridImp> (entity.factory(),
737 entity.seed())
738 {}
739
741 ALU3dGridEntityPointer(const FactoryType& factory, const ALU3dGridEntitySeedType& seed)
742 : ALU3dGridEntityPointerBase<cd,GridImp> ( factory, seed )
743 {}
744
746 ALU3dGridEntityPointer(const ALU3dGridEntityPointerType & org);
747
749 Entity & dereference () const ;
750
752 ThisType & operator = (const ThisType & org);
753
755 int level () const ;
756
757 protected:
758 // clones object
759 void clone (const ALU3dGridEntityPointerType & org);
760
761 void updateEntityPointer( HElementType * item , int level );
762
765 ALU3dGridEntityPointer(const FactoryType& factory, int level )
766 : ALU3dGridEntityPointerBase<cd,GridImp> (factory,level)
767 {}
768 };
769
770} // end namespace Dune
771
772#include "entity_inline.hh"
773
774#if COMPILE_ALUGRID_INLINE
775 #include "entity_imp.cc"
776#endif
777
778#endif
Definition: entity.hh:469
GridImp::template Codim< codimension >::Entity Entity
type of Entity
Definition: entity.hh:491
void freeEntity()
put entity to entity stack
Definition: entity_inline.hh:446
~ALU3dGridEntityPointerBase()
Destructor.
Definition: entity_inline.hh:432
ThisType ALU3dGridEntityPointerType
typedef of my type
Definition: entity.hh:497
int level() const
ask for level of entities
Definition: entity_inline.hh:481
ALU3dGridEntityPointerBase(const FactoryType &factory, const HElementType &item)
Constructor for EntityPointer that points to an element.
Definition: entity_inline.hh:299
bool equals(const ALU3dGridEntityPointerType &i) const
equality
Definition: entity_inline.hh:459
ALU3dGridEntitySeed< codimension, GridImp > ALU3dGridEntitySeedType
type of entity seed
Definition: entity.hh:503
const GridImp & grid() const
return reference to grid
Definition: entity.hh:557
ALU3dGridEntityPointer< codimension, GridImp > EntityPointerImp
make type of entity pointer implementation available in derived classes
Definition: entity.hh:500
Entity & dereference() const
dereferencing
Definition: entity_inline.hh:467
ThisType & operator=(const ThisType &org)
assignment operator
Definition: entity_inline.hh:381
void done()
has to be called when iterator is finished
Definition: entity_inline.hh:438
MakeableInterfaceObject< Entity > EntityObject
underlying EntityImplementation
Definition: entity.hh:493
ALU3dGridEntityPointer(const ALU3dGridEntityPointerType &org)
copy constructor
Definition: entity.hh:669
GridImp::template Codim< cd >::Entity Entity
type of Entity
Definition: entity.hh:624
ALU3dGridEntityPointer(const ALU3dGridEntityType &entity)
Constructor for EntityPointer that points to an entity (interior or ghost)
Definition: entity.hh:654
ALU3dGridEntitySeed< cd, GridImp > ALU3dGridEntitySeedType
type of entity seed
Definition: entity.hh:621
ALU3dGridEntityPointer(const FactoryType &factory, const HBndSegType &ghostFace)
Constructor for EntityPointer that points to an ghost.
Definition: entity.hh:635
ALU3dGridEntityPointer(const FactoryType &factory, int level)
Definition: entity.hh:676
ThisType ALU3dGridEntityPointerType
typedef of my type
Definition: entity.hh:627
ALU3dGridEntityPointer(const FactoryType &factory, const ALU3dGridEntitySeedType &seed)
Constructor for EntityPointer that points to given entity.
Definition: entity.hh:640
Codim< codim >::EntityPointer subEntity(int i) const
bool hasBoundaryIntersections() const
returns true, if entity has intersections with boundary
const FactoryType & factory() const
return reference to factory
Definition: entity.hh:425
bool hasFather() const
returns true if father entity exists
Definition: entity.hh:332
GridImp::template Codim< 0 >::EntitySeed EntitySeed
typedef of my type
Definition: entity.hh:270
Geometry geometry() const
geometry of this entity
ALU3dGridEntity(const FactoryType &factory, int level)
Constructor creating empty Entity.
int getMark() const
return current adaptation mark for this entity
ALU3dGridEntity(const ALU3dGridEntity &org)
copy Constructor
int subIndex(int i, unsigned int codim) const
EntitySeed seed() const
return key for this entity
Definition: entity.hh:431
bool isGhost() const
returns true if entity is ghost
Definition: entity.hh:428
const GridImp & grid() const
return reference to grid
Definition: entity.hh:422
Definition: entity.hh:47
GeometryType type() const
type of geometry of this entity
Definition: entity_inline.hh:56
void setEntity(const ALU3dGridEntity< cd, dim, GridImp > &org)
set item from other entity, mainly for copy constructor of entity pointer
void removeElement()
reset item pointer to NULL
Definition: entity_inline.hh:22
int level() const
level of this element
Definition: entity_inline.hh:42
PartitionType partitionType() const
return partition type of this entity ( see grid.hh )
Definition: entity_inline.hh:49
void setGhost(const HBndSegType &ghost)
setGhost is not valid for this codim
const GridImp & grid() const
return reference to grid
Definition: entity.hh:147
GridImp::template Codim< cd >::EntitySeed EntitySeed
typedef of my type
Definition: entity.hh:101
void reset(int l)
reset item pointer to NULL
Definition: entity_inline.hh:12
Geometry geometry() const
geometry of this entity
EntitySeed seed() const
return seed of entity
Definition: entity.hh:153
const FactoryType & factory() const
return reference to factory
Definition: entity.hh:150
bool equals(const ALU3dGridEntity< cd, dim, GridImp > &org) const
compare 2 elements by comparing the item pointers
Definition: entity_inline.hh:30
hierarchic index set of ALU3dGrid
Definition: indexsets.hh:44
Definition: iterator.hh:57
Leaf iterator.
Definition: iterator.hh:585
Definition: iterator.hh:504
[ provides Dune::Grid ]
Definition: grid.hh:406
Default Implementations for EntityImp.
Definition: entity.hh:740
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:25
Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack ...
Definition: intersectioniteratorwrapper.hh:233
Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack ...
Definition: intersectioniteratorwrapper.hh:328
PartitionType
Attributes used in the generic overlap model.
Definition: gridenums.hh:28
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:84
@ All_Partition
all entities
Definition: gridenums.hh:139
Provides proxy classes for IntersectionsIterators.
Dune namespace.
Definition: alignment.hh:10
Static tag representing a codimension.
Definition: dimension.hh:22
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Dec 11, 23:30, 2024)