dune-foamgrid 2.8.0
Loading...
Searching...
No Matches
foamgridentity.hh
Go to the documentation of this file.
1// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2// vi: set ts=8 sw=4 et sts=4:
3#ifndef DUNE_FOAMGRID_ENTITY_HH
4#define DUNE_FOAMGRID_ENTITY_HH
5
10#include <memory>
11#include <array>
12
13#include <dune/common/version.hh>
14
15#include <dune/geometry/type.hh>
16#include <dune/grid/common/gridenums.hh>
17#include <dune/grid/common/grid.hh>
18
21
22namespace Dune {
23
24
25// Forward declarations
26
27template<int codim, int dimentity, class GridImp>
28class FoamGridEntity;
29
30template<int codim, class GridImp>
31class FoamGridEntityPointer;
32
33template<int codim, PartitionIteratorType pitype, class GridImp>
34class FoamGridLevelIterator;
35
36template<class GridImp>
37class FoamGridLevelIntersectionIterator;
38
39template<class GridImp>
40class FoamGridLeafIntersectionIterator;
41
42template<class GridImp>
43class FoamGridHierarchicIterator;
44
45
51template<int codim, int dimgrid, class GridImp>
53 public EntityDefaultImplementation <codim, dimgrid, GridImp, FoamGridEntity>
54{
55 template <class GridImp_>
57
58 template <class GridImp_>
60
61 template <class GridImp_>
62 friend class FoamGridLocalIdSet;
63
64 template <class GridImp_>
65 friend class FoamGridGlobalIdSet;
66
67 friend class FoamGridEntityPointer<codim,GridImp>;
68
69
70 private:
71
72 typedef typename GridImp::ctype ctype;
73
74 enum{dimworld = GridImp::dimensionworld};
75
76 public:
77
78 typedef typename GridImp::template Codim<codim>::Geometry Geometry;
79
81 typedef typename GridImp::template Codim<codim>::EntitySeed EntitySeed;
82
83
84
87 target_(target)
88 {}
89
91 FoamGridEntity(const FoamGridEntity& original) :
92 target_(original.target_)
93 {}
94
97 target_(nullptr)
98 {}
99
100
103 {
104 if (this != &original)
105 {
106 target_ = original.target_;
107 }
108 return *this;
109 }
110
111
113 int level () const {
114 return target_->level();
115 }
116
117
120 PartitionType partitionType () const {
121 return target_->partitionType();
122 }
123
124
128 template<int cc> int count () const{
129 return target_->template count<cc>();
130 }
131
132
135 {
136 // we currently only support simplices
137 std::array<FieldVector<ctype, dimworld>, dimgrid-codim+1> coordinates;
138 assert(dimgrid-codim+1 == target_->corners() && "Target entity is not a simplex!");
139 for (int i=0; i<target_->corners(); i++)
140 coordinates[i] = target_->corner(i);
141
143 }
144
147 {
148 return EntitySeed(*this);
149 }
150
151 const FoamGridEntityImp<dimgrid-codim, dimgrid, dimworld, ctype>* target_;
152
153
156 {
157 target_ = target;
158 }
159
162 {
163 return target_ == other.target_;
164 }
165
167 GeometryType type () const { return target_->type(); }
168};
169
170
171
172
180template<class GridImp>
181class FoamGridEntity<0, 2, GridImp> :
182 public EntityDefaultImplementation<0, 2, GridImp, FoamGridEntity>
183{
184
185 enum {dimworld = GridImp::dimensionworld};
186 enum {dimgrid = GridImp::dimension};
187
188 private:
189
190 typedef typename GridImp::ctype ctype;
191
192 public:
193
194 typedef typename GridImp::template Codim<0>::Geometry Geometry;
195
196 typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
197
200
203
206
208 typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
209
210 template<int codim>
211 struct Codim
212 {
213 typedef typename GridImp::Traits::template Codim<codim>::Entity Entity;
214 };
215
216 typedef typename GridImp::Traits::template Codim<0>::Entity Entity;
217
218
221 target_(hostEntity)
222 {}
223
224
227 target_(original.target_)
228 {}
229
232 target_(nullptr)
233 {}
234
237 {
238 if (this != &original)
239 {
240 target_ = original.target_;
241 }
242 return *this;
243 }
244
245
247 int level () const
248 {
249 return target_->level_;
250 }
251
252
254 PartitionType partitionType () const {
255 return InteriorEntity;
256 }
257
258
261 {
262 // we currently only support simplices
263 std::array<FieldVector<ctype, dimworld>, dimgrid+1> coordinates;
264 assert(dimgrid+1 == target_->corners() && "Target entity is not a simplex!");
265 for (int i=0; i<target_->corners(); i++)
266 coordinates[i] = target_->vertex_[i]->pos_;
267
269 }
270
273 {
274 return EntitySeed(*this);
275 }
276
277
280 template<int cc>
281 int count () const
282 {
283 static_assert(0<=cc && cc<=2, "Only codimensions with 0 <= cc <= 2 are valid!");
284 return (cc==0) ? 1 : 3;
285 }
286
289 unsigned int count (unsigned int codim) const
290 {
291 assert(0<=codim && codim<=2);
292 return (codim==0) ? 1 : 3;
293 }
294
299 unsigned int subEntities (unsigned int codim) const
300 {
301 assert(0<=codim && codim<=2);
302 return (codim==0) ? 1 : 3;
303 }
304
307 int subId (int i, unsigned int codim) const {
308 assert(0<=codim && codim<=dimgrid);
309 switch (codim) {
310 case 0:
311 return target_->id_;
312 case 1:
313 return target_->facet_[i]->id_;
314 case 2:
315 return target_->vertex_[i]->id_;
316 }
317 DUNE_THROW(GridError, "Non-existing codimension requested!");
318 }
319
321 template<int codim>
322 typename std::enable_if<codim==0, typename Codim<0>::Entity>::type
323 subEntity (int i) const
324 {
325 assert(i==0);
327 }
328
330 template<int codim>
331 typename std::enable_if<codim==1, typename Codim<1>::Entity>::type
332 subEntity (int i) const
333 {
334 assert(i==0 || i==1 || i==2);
335 return typename Codim<1>::Entity(FoamGridEntity<1, dimgrid, GridImp>(this->target_->facet_[i]));
336 }
337
339 template<int codim>
340 typename std::enable_if<codim==2, typename Codim<2>::Entity>::type
341 subEntity (int i) const
342 {
343 assert(i==0 || i==1 || i==2);
344 return typename Codim<2>::Entity(FoamGridEntity<2, dimgrid, GridImp>(this->target_->vertex_[i]));
345 }
346
350 }
351
352
356 }
357
358
361 if(isLeaf())
363 else
365 }
366
367
371 }
372
373
375 bool isLeaf() const {
376 return target_->isLeaf();
377 }
378
380 bool hasFather() const {
381 return level()>0;
382 }
383
384 bool isNew() const
385 {
386 return target_->isNew();
387 }
388
389 bool mightVanish() const
390 {
391 return target_->mightVanish();
392 }
393
396 Entity father () const {
398 }
399
411 // Check whether there really is a father
412 if(father==nullptr)
413 DUNE_THROW(GridError, "There is no father Element.");
414
415 // Sanity check
416 if(target_->type().isTriangle()){
417 // Lookup the coordinates within the father
418 // As in the refinement routine the children
419 // are number as follows:
420 // First come the ones located in the corner
421 // ascending with the corner index.
422 // Their first corner (origin in the reference simplex)
423 // is always the corner that is also a corner of the father.
424 // For the element with all corners on the edge midpoints of
425 // the father, the corner are numbered according to the edge indices
426 // of the father.
427 ctype mapping[4][3][2] ={
428 { {0.0,0.0}, {0.5,0.0}, {0.0,0.5} },
429 { {1.0,0.0}, {0.5,0.5}, {0.5,0.0} },
430 { {0.0,1.0}, {0.0,0.5}, {0.5,0.5} },
431 { {0.5,0.0}, {0.5,0.5}, {0.0,0.5} }
432 };
433
434 std::array<FieldVector<ctype, dimgrid>, 3> coordinates;
435
436 for(int corner=0; corner <3; ++corner)
437 for(int entry=0; entry <2; ++entry)
438 coordinates[corner][entry]=
439 mapping[target_->refinementIndex_][corner][entry];
440
441 // return LocalGeomety by value
443 coordinates));
444 }else{
445 DUNE_THROW(NotImplemented, "geometryInFather only supported for triangles!");
446 }
447
448 }
449
450
456 { return { target_, maxLevel }; }
457
458
461 { return { maxLevel }; }
462
463
464 // /////////////////////////////////////////
465 // Internal stuff
466 // /////////////////////////////////////////
467
468
471 {
472 target_ = target;
473 }
474
477 {
478 return target_ == other.target_;
479 }
480
482 GeometryType type () const { return target_->type(); }
483
486
487}; // end of FoamGridEntity codim = 0, dimgrid = 2
488
489
490template<class GridImp>
491class FoamGridEntity<0, 1, GridImp> :
492 public EntityDefaultImplementation<0, 1, GridImp, FoamGridEntity>
493{
494
495 enum {dimworld = GridImp::dimensionworld};
496 enum {dimgrid = GridImp::dimension};
497
498 private:
499
500 typedef typename GridImp::ctype ctype;
501
502 public:
503
504 typedef typename GridImp::template Codim<0>::Geometry Geometry;
505
506 typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
507
510
513
516
518 typedef typename GridImp::template Codim<0>::EntitySeed EntitySeed;
519
520 template<int codim>
521 struct Codim
522 {
523 typedef typename GridImp::Traits::template Codim<codim>::Entity Entity;
524 };
525
526 typedef typename GridImp::Traits::template Codim<0>::Entity Entity;
527
530 target_(hostEntity)
531 {}
532
533
536 target_(original.target_)
537 {}
538
541 target_(nullptr)
542 {}
543
546 {
547 if (this != &original)
548 {
549 target_ = original.target_;
550 }
551 return *this;
552 }
553
554
556 int level () const
557 {
558 return target_->level_;
559 }
560
561
563 PartitionType partitionType () const {
564 return InteriorEntity;
565 }
566
567
570 {
571 // we currently only support simplices
572 std::array<FieldVector<ctype, dimworld>, dimgrid+1> coordinates;
573 assert(dimgrid+1 == target_->corners() && "Target entity is not a simplex!");
574 for (int i=0; i<target_->corners(); i++)
575 coordinates[i] = target_->corner(i);
576
578 }
579
582 {
583 return EntitySeed(*this);
584 }
585
586
589 template<int cc>
590 int count () const
591 {
592 static_assert(0<=cc && cc<=1, "Only codimensions with 0 <= cc <= 1 are valid!");
593 return (cc==0) ? 1 : 2;
594 }
595
598 unsigned int count (unsigned int codim) const
599 {
600 assert(0<=codim && codim<=1);
601 return (codim==0) ? 1 : 2;
602 }
603
608 unsigned int subEntities (unsigned int codim) const
609 {
610 assert(0<=codim && codim<=1);
611 return (codim==0) ? 1 : 2;
612 }
613
616 int subId (int i,unsigned int codim) const {
617 assert(0<=codim && codim<=1);
618 switch (codim) {
619 case 0:
620 return target_->id_;
621 case 1:
622 return target_->vertex_[i]->id_;
623 }
624 DUNE_THROW(GridError, "Non-existing codimension requested!");
625 }
626
628 template<int codim>
629 typename std::enable_if<codim==0, typename Codim<0>::Entity>::type
630 subEntity (int i) const
631 {
632 assert(i==0);
634 }
635
637 template<int codim>
638 typename std::enable_if<codim==1, typename Codim<1>::Entity>::type
639 subEntity (int i) const
640 {
641 assert(i==0 || i==1);
642 return typename Codim<1>::Entity(FoamGridEntity<1, dimgrid, GridImp>(this->target_->vertex_[i]));
643 }
644
648 }
649
650
654 }
655
656
659 if(isLeaf())
661 else
663 }
664
665
669 }
670
671
673 bool isLeaf() const {
674 return target_->isLeaf();
675 }
676
678 bool hasFather() const {
679 return level()>0;
680 }
681
682 bool isNew() const
683 {
684 return target_->isNew();
685 }
686
687 bool mightVanish() const
688 {
689 return target_->mightVanish();
690 }
691
694 Entity father () const {
696 }
697
709 // Check whether there really is a father
710 if(father==nullptr)
711 DUNE_THROW(GridError, "There is no father Element.");
712
713 // Sanity check
714 if(target_->type().isLine()){
715 // Lookup the coordinates within the father
716 // As in the refinement routine the children
717 // are number as follows:
718 // First come the ones located in the corner
719 // ascending with the corner index.
720 // Their first corner (origin in the reference simplex)
721 // is always the corner that is also a corner of the father.
722 // For the element with all corners on the edge midpoints of
723 // the father, the corner are numbered according to the edge indices
724 // of the father.
725 ctype mapping[2][2] = {{0.0, 0.5}, {0.5, 1.0}};
726
727 std::array<FieldVector<ctype, dimgrid>, 2> coordinates;
728
729 for(int corner=0; corner <2; ++corner)
730 coordinates[corner][0] = mapping[target_->refinementIndex_][corner];
731
732 // return LocalGeomety by value
734 }
735 else
736 {
737 DUNE_THROW(NotImplemented, "geometryInFather only supported for lines!");
738 }
739 }
740
741
747 { return { target_, maxLevel }; }
748
749
752 { return { maxLevel }; }
753
754
755 // /////////////////////////////////////////
756 // Internal stuff
757 // /////////////////////////////////////////
758
759
762 {
763 target_ = target;
764 }
765
768 {
769 return target_ == other.target_;
770 }
771
773 GeometryType type () const { return target_->type(); }
774
777
778}; // end of FoamGridEntity codim = 0, dimgrid = 1
779
780} // namespace Dune
781
782
783#endif
The FoamGridGeometry class.
Definition: dgffoam.cc:6
The implementation of entities in a FoamGrid.
Definition: foamgridentity.hh:54
friend class FoamGridGlobalIdSet
Definition: foamgridentity.hh:65
Geometry geometry() const
geometry of this entity
Definition: foamgridentity.hh:134
FoamGridEntity & operator=(const FoamGridEntity &original)
Definition: foamgridentity.hh:102
GridImp::template Codim< codim >::Geometry Geometry
Definition: foamgridentity.hh:78
void setToTarget(const FoamGridEntityImp< dimgrid-codim, dimgrid, dimworld, ctype > *target)
Definition: foamgridentity.hh:155
int level() const
level of this element
Definition: foamgridentity.hh:113
bool equals(const Dune::FoamGridEntity< codim, dimgrid, GridImp > &other) const
equality
Definition: foamgridentity.hh:161
int count() const
Definition: foamgridentity.hh:128
FoamGridEntity(const FoamGridEntity &original)
Copy constructor.
Definition: foamgridentity.hh:91
PartitionType partitionType() const
The partition type for parallel computing.
Definition: foamgridentity.hh:120
EntitySeed seed() const
Create EntitySeed.
Definition: foamgridentity.hh:146
FoamGridEntity()
Default constructor.
Definition: foamgridentity.hh:96
friend class FoamGridLocalIdSet
Definition: foamgridentity.hh:62
const FoamGridEntityImp< dimgrid-codim, dimgrid, dimworld, ctype > * target_
Definition: foamgridentity.hh:151
GeometryType type() const
return the entity's type
Definition: foamgridentity.hh:167
GridImp::template Codim< codim >::EntitySeed EntitySeed
The type of the EntitySeed interface class.
Definition: foamgridentity.hh:81
FoamGridEntity(const FoamGridEntityImp< dimgrid-codim, dimgrid, dimworld, ctype > *target)
Constructor for an entity in a given grid level.
Definition: foamgridentity.hh:86
Definition: foamgridentitypointer.hh:20
Definition: foamgridintersectioniterators.hh:239
Iterator over all element neighborsMesh entities of codimension 0 ("elements") allow to visit all nei...
Definition: foamgridintersectioniterators.hh:28
Iterator over the descendants of an entity.Mesh entities of codimension 0 ("elements") allow to visit...
Definition: foamgridhierarchiciterator.hh:24
unsigned int subEntities(unsigned int codim) const
Definition: foamgridentity.hh:299
PartitionType partitionType() const
The partition type for parallel computing.
Definition: foamgridentity.hh:254
FoamGridEntity(const FoamGridEntityImp< dimgrid, dimgrid, dimworld, ctype > *hostEntity)
Constructor for an entity in a given grid level.
Definition: foamgridentity.hh:220
FoamGridLevelIntersectionIterator< GridImp > ilevelbegin() const
First level intersection.
Definition: foamgridentity.hh:348
FoamGridHierarchicIterator< GridImp > HierarchicIterator
Iterator over descendants of the entity.
Definition: foamgridentity.hh:205
FoamGridHierarchicIterator< GridImp > hbegin(int maxLevel) const
Inter-level access to son elements on higher levels<=maxlevel. This is provided for sparsely stored n...
Definition: foamgridentity.hh:455
bool equals(const Dune::FoamGridEntity< 0, dimgrid, GridImp > &other) const
equality
Definition: foamgridentity.hh:476
GridImp::template Codim< 0 >::Geometry Geometry
Definition: foamgridentity.hh:194
int subId(int i, unsigned int codim) const
Return index of sub entity with codim = cc and local number i.
Definition: foamgridentity.hh:307
std::enable_if< codim==1, typenameCodim< 1 >::Entity >::type subEntity(int i) const
Access to codim 1 subentities.
Definition: foamgridentity.hh:332
Geometry geometry() const
Geometry of this entity.
Definition: foamgridentity.hh:260
const FoamGridEntityImp< dimgrid, dimgrid,dimworld, ctype > * target_
pointer to the implementation
Definition: foamgridentity.hh:485
FoamGridLeafIntersectionIterator< GridImp > LeafIntersectionIterator
The Iterator over intersections on the leaf level.
Definition: foamgridentity.hh:202
GridImp::Traits::template Codim< 0 >::Entity Entity
Definition: foamgridentity.hh:216
bool hasFather() const
Return true if this element has a father element.
Definition: foamgridentity.hh:380
void setToTarget(const FoamGridEntityImp< dimgrid, dimgrid, dimworld, ctype > *target)
Make this class point to a new FoamGridEntityImp object.
Definition: foamgridentity.hh:470
FoamGridLeafIntersectionIterator< GridImp > ileafend() const
Reference to one past the last leaf intersection.
Definition: foamgridentity.hh:369
FoamGridEntity & operator=(const FoamGridEntity &original)
Definition: foamgridentity.hh:236
FoamGridEntity()
Default constructor.
Definition: foamgridentity.hh:231
FoamGridLevelIntersectionIterator< GridImp > ilevelend() const
Reference to one past the last neighbor.
Definition: foamgridentity.hh:354
unsigned int count(unsigned int codim) const
Return the number of subEntities of codimension cc.
Definition: foamgridentity.hh:289
FoamGridEntity(const FoamGridEntity &original)
Copy constructor.
Definition: foamgridentity.hh:226
GridImp::template Codim< 0 >::LocalGeometry LocalGeometry
Definition: foamgridentity.hh:196
std::enable_if< codim==0, typenameCodim< 0 >::Entity >::type subEntity(int i) const
Access to codim 0 subentities.
Definition: foamgridentity.hh:323
bool mightVanish() const
Definition: foamgridentity.hh:389
Entity father() const
Definition: foamgridentity.hh:396
FoamGridLeafIntersectionIterator< GridImp > ileafbegin() const
First leaf intersection.
Definition: foamgridentity.hh:360
LocalGeometry geometryInFather() const
Location of this element relative to the reference element element of the father. This is sufficient ...
Definition: foamgridentity.hh:409
bool isNew() const
Definition: foamgridentity.hh:384
EntitySeed seed() const
Create EntitySeed.
Definition: foamgridentity.hh:272
std::enable_if< codim==2, typenameCodim< 2 >::Entity >::type subEntity(int i) const
Access to codim 2 subentities.
Definition: foamgridentity.hh:341
int count() const
Return the number of subEntities of codimension cc.
Definition: foamgridentity.hh:281
int level() const
Level of this element.
Definition: foamgridentity.hh:247
bool isLeaf() const
returns true if Entity has NO children
Definition: foamgridentity.hh:375
GeometryType type() const
return the entity's type
Definition: foamgridentity.hh:482
FoamGridHierarchicIterator< GridImp > hend(int maxLevel) const
Returns iterator to one past the last son.
Definition: foamgridentity.hh:460
GridImp::template Codim< 0 >::EntitySeed EntitySeed
The type of the EntitySeed interface class.
Definition: foamgridentity.hh:208
FoamGridLevelIntersectionIterator< GridImp > LevelIntersectionIterator
The Iterator over intersections on this level.
Definition: foamgridentity.hh:199
GridImp::Traits::template Codim< codim >::Entity Entity
Definition: foamgridentity.hh:213
const FoamGridEntityImp< dimgrid, dimgrid,dimworld, ctype > * target_
pointer to the implementation
Definition: foamgridentity.hh:776
std::enable_if< codim==1, typenameCodim< 1 >::Entity >::type subEntity(int i) const
Access to codim 1 subentities.
Definition: foamgridentity.hh:639
void setToTarget(const FoamGridEntityImp< dimgrid, dimgrid, dimworld, ctype > *target)
Make this class point to a new FoamGridEntityImp object.
Definition: foamgridentity.hh:761
FoamGridHierarchicIterator< GridImp > HierarchicIterator
Iterator over descendants of the entity.
Definition: foamgridentity.hh:515
bool isNew() const
Definition: foamgridentity.hh:682
FoamGridLevelIntersectionIterator< GridImp > ilevelend() const
Reference to one past the last neighbor.
Definition: foamgridentity.hh:652
FoamGridHierarchicIterator< GridImp > hbegin(int maxLevel) const
Inter-level access to son elements on higher levels<=maxlevel. This is provided for sparsely stored n...
Definition: foamgridentity.hh:746
GridImp::Traits::template Codim< 0 >::Entity Entity
Definition: foamgridentity.hh:526
int count() const
Return the number of subEntities of codimension cc.
Definition: foamgridentity.hh:590
FoamGridLeafIntersectionIterator< GridImp > ileafend() const
Reference to one past the last leaf intersection.
Definition: foamgridentity.hh:667
FoamGridLeafIntersectionIterator< GridImp > LeafIntersectionIterator
The Iterator over intersections on the leaf level.
Definition: foamgridentity.hh:512
GridImp::template Codim< 0 >::Geometry Geometry
Definition: foamgridentity.hh:504
bool hasFather() const
Return true if this element has a father element.
Definition: foamgridentity.hh:678
Entity father() const
Definition: foamgridentity.hh:694
GridImp::template Codim< 0 >::EntitySeed EntitySeed
The type of the EntitySeed interface class.
Definition: foamgridentity.hh:518
bool mightVanish() const
Definition: foamgridentity.hh:687
Geometry geometry() const
Geometry of this entity.
Definition: foamgridentity.hh:569
int subId(int i, unsigned int codim) const
Return index of sub entity with codim = cc and local number i.
Definition: foamgridentity.hh:616
std::enable_if< codim==0, typenameCodim< 0 >::Entity >::type subEntity(int i) const
Access to codim 0 subentities.
Definition: foamgridentity.hh:630
FoamGridLeafIntersectionIterator< GridImp > ileafbegin() const
First leaf intersection.
Definition: foamgridentity.hh:658
FoamGridEntity(const FoamGridEntity &original)
Copy constructor.
Definition: foamgridentity.hh:535
FoamGridEntity(const FoamGridEntityImp< dimgrid, dimgrid, dimworld, ctype > *hostEntity)
Constructor for an entity in a given grid level.
Definition: foamgridentity.hh:529
bool isLeaf() const
returns true if Entity has NO children
Definition: foamgridentity.hh:673
LocalGeometry geometryInFather() const
Location of this element relative to the reference element element of the father. This is sufficient ...
Definition: foamgridentity.hh:707
int level() const
Level of this element.
Definition: foamgridentity.hh:556
bool equals(const Dune::FoamGridEntity< 0, dimgrid, GridImp > &other) const
equality
Definition: foamgridentity.hh:767
EntitySeed seed() const
Create EntitySeed.
Definition: foamgridentity.hh:581
GeometryType type() const
return the entity's type
Definition: foamgridentity.hh:773
unsigned int count(unsigned int codim) const
Return the number of subEntities of codimension cc.
Definition: foamgridentity.hh:598
FoamGridHierarchicIterator< GridImp > hend(int maxLevel) const
Returns iterator to one past the last son.
Definition: foamgridentity.hh:751
GridImp::template Codim< 0 >::LocalGeometry LocalGeometry
Definition: foamgridentity.hh:506
unsigned int subEntities(unsigned int codim) const
Definition: foamgridentity.hh:608
PartitionType partitionType() const
The partition type for parallel computing.
Definition: foamgridentity.hh:563
FoamGridLevelIntersectionIterator< GridImp > LevelIntersectionIterator
The Iterator over intersections on this level.
Definition: foamgridentity.hh:509
FoamGridLevelIntersectionIterator< GridImp > ilevelbegin() const
First level intersection.
Definition: foamgridentity.hh:646
FoamGridEntity & operator=(const FoamGridEntity &original)
Definition: foamgridentity.hh:545
FoamGridEntity()
Default constructor.
Definition: foamgridentity.hh:540
GridImp::Traits::template Codim< codim >::Entity Entity
Definition: foamgridentity.hh:523
Definition: foamgridgeometry.hh:21
Definition: foamgridindexsets.hh:26
Definition: foamgridindexsets.hh:200
The actual entity implementation.
Definition: foamgridvertex.hh:47