identitygridentity.hh

Go to the documentation of this file.
00001 #ifndef DUNE_IDENTITYGRIDENTITY_HH
00002 #define DUNE_IDENTITYGRIDENTITY_HH
00003 
00008 #include <dune/grid/common/referenceelements.hh>
00009 
00010 
00011 namespace Dune {
00012 
00013 
00014 // Forward declarations
00015 
00016 template<int codim, int dim, class GridImp>
00017 class IdentityGridEntity;
00018 
00019 template<int codim, class GridImp>
00020 class IdentityGridEntityPointer;
00021 
00022 template<int codim, PartitionIteratorType pitype, class GridImp>
00023 class IdentityGridLevelIterator;
00024 
00025 template<class GridImp>
00026 class IdentityGridLevelIntersectionIterator;
00027 
00028 template<class GridImp>
00029 class IdentityGridLeafIntersectionIterator;
00030 
00031 template<class GridImp>
00032 class IdentityGridHierarchicIterator;
00033 
00034 
00035 
00036 
00037 template<int codim, int dim, class GridImp>
00038 class IdentityGridMakeableEntity :
00039     public GridImp::template Codim<codim>::Entity
00040 {
00041     public:
00042     
00043         // The codimension of this entitypointer wrt the host grid
00044         enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};
00045     
00046         // EntityPointer to the equivalent entity in the host grid
00047         typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;
00048         
00049         
00051         IdentityGridMakeableEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :
00052             GridImp::template Codim<codim>::Entity (IdentityGridEntity<codim, dim, const GridImp>(identityGrid,hostEntity)),
00053             identityGrid_(identityGrid)
00054         {}
00055         
00056         
00058         void setToTarget(const HostGridEntityPointer& hostEntity) {
00059             this->realEntity.setToTarget(hostEntity);
00060         }
00061         
00062         
00064         const HostGridEntityPointer& getTarget() {
00065             return this->realEntity.hostEntity_;
00066         }
00067     
00068         
00069     private:
00070         
00071         const GridImp* identityGrid_;
00072 };
00073 
00074 
00075 //**********************************************************************
00076 //
00077 // --IdentityGridEntity
00078 // --Entity
00079 //
00087 template<int codim, int dim, class GridImp>
00088 class IdentityGridEntity :
00089     public EntityDefaultImplementation <codim,dim,GridImp,IdentityGridEntity>
00090 {
00091     friend class IdentityGridMakeableEntity<codim,dim,GridImp>;
00092 
00093     template <class GridImp_>
00094     friend class IdentityGridLevelIndexSet;
00095 
00096     template <class GridImp_>
00097     friend class IdentityGridLeafIndexSet;
00098 
00099     template <class GridImp_>
00100     friend class IdentityGridLocalIdSet;
00101 
00102     template <class GridImp_>
00103     friend class IdentityGridGlobalIdSet;
00104 
00105     template <class GridImp_, int EntityDim>
00106     friend class IndexSetter;
00107 
00108     friend class IdentityGridEntityPointer<codim,GridImp>;
00109 
00110     
00111     private:
00112         
00113         typedef typename GridImp::ctype ctype;
00114         
00115         // The codimension of this entitypointer wrt the host grid
00116         enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension + codim};
00117 
00118         // EntityPointer to the equivalent entity in the host grid
00119         typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;
00120         
00121 
00122     public:
00123     
00124         typedef typename GridImp::template Codim<codim>::Geometry Geometry;
00125     
00126         
00128         IdentityGridEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :
00129             hostEntity_(hostEntity),
00130             identityGrid_(identityGrid),
00131             geo_(0),
00132             geoInFather_(0)
00133         {}
00134         
00135     
00137         IdentityGridEntity(const IdentityGridEntity& original) :
00138             hostEntity_(original.hostEntity_),
00139             identityGrid_(original.identityGrid_),
00140             geo_(0),
00141             geoInFather_(0)
00142         {}
00143     
00144         
00146         ~IdentityGridEntity()
00147         {
00148             if (geo_!=0)
00149             {
00150                 delete geo_;
00151                 geo_ = 0;
00152             }
00153             if (geoInFather_!=0)
00154             {
00155                 delete geoInFather_;
00156                 geoInFather_ = 0;
00157             }
00158         }
00159         
00160         
00162         IdentityGridEntity& operator=(const IdentityGridEntity& original)
00163         {
00164             if (this != &original)
00165             {
00166                 if (geo_!=0)
00167                 {
00168                     delete geo_;
00169                     geo_ = 0;
00170                 }
00171                 if (geoInFather_!=0)
00172                 {
00173                     delete geoInFather_;
00174                     geoInFather_ = 0;
00175                 }
00176                 identityGrid_ = original.identityGrid_;
00177                 hostEntity_ = original.hostEntity_;
00178             }
00179             return *this;
00180         }
00181     
00182     
00184         int level () const {
00185             return hostEntity_->level();
00186         }
00187     
00188         
00191         PartitionType partitionType () const {
00192             return hostEntity_->partitionType();
00193         }
00194     
00195         
00199         template<int cc> int count () const{
00200             return hostEntity_->template count<cc>();
00201         }
00202         
00203         
00205         const Geometry& geometry () const
00206         {
00207             if (geo_==0)
00208                 geo_ = new MakeableInterfaceObject<Geometry>(hostEntity_->geometry());
00209             return *geo_;
00210         }
00211     
00212         
00213         HostGridEntityPointer hostEntity_;
00214     
00215         
00216     private:
00217     
00219         void setToTarget(const HostGridEntityPointer& target)
00220         {
00221             if(geo_!=0)
00222             {
00223                 delete geo_;
00224                 geo_ = 0;
00225             }
00226             if (geoInFather_!=0)
00227             {
00228                 delete geoInFather_;
00229                 geoInFather_ = 0;
00230             }
00231             hostEntity_ = target;
00232         }
00233     
00234         
00235         const GridImp* identityGrid_;
00236         
00238     mutable MakeableInterfaceObject<Geometry> *geo_;
00239     mutable MakeableInterfaceObject<Geometry> *geoInFather_;
00240 };
00241 
00242 
00243 
00244 
00245 //***********************
00246 //
00247 //  --IdentityGridEntity
00248 //
00249 //***********************
00257 template<int dim, class GridImp>
00258 class IdentityGridEntity<0,dim,GridImp> :
00259     public EntityDefaultImplementation<0,dim,GridImp, IdentityGridEntity>
00260 {
00261     public:
00262     
00263         // The codimension of this entitypointer wrt the host grid
00264         enum {CodimInHostGrid = GridImp::HostGridType::dimension - GridImp::dimension};
00265     
00266         // EntityPointer to the equivalent entity in the host grid
00267         typedef typename GridImp::HostGridType::Traits::template Codim<CodimInHostGrid>::EntityPointer HostGridEntityPointer;
00268         
00269         typedef typename GridImp::template Codim<0>::Geometry Geometry;
00270     
00271         typedef typename GridImp::template Codim<0>::LocalGeometry LocalGeometry;
00272     
00274         typedef IdentityGridLevelIntersectionIterator<GridImp> LevelIntersectionIterator;
00275     
00277         typedef IdentityGridLeafIntersectionIterator<GridImp> LeafIntersectionIterator;
00278     
00280         typedef IdentityGridHierarchicIterator<GridImp> HierarchicIterator;
00281         
00282         
00284         IdentityGridEntity(const GridImp* identityGrid, const HostGridEntityPointer& hostEntity) :
00285             identityGrid_(identityGrid),
00286             geo_(0),
00287             geoInFather_(0),
00288             hostEntity_(hostEntity)
00289         {}
00290         
00291         
00293         IdentityGridEntity(const IdentityGridEntity& original) :
00294             identityGrid_(original.identityGrid_),
00295             geo_(0),
00296             geoInFather_(0),
00297             hostEntity_(original.hostEntity_)
00298         {}
00299     
00300         
00302         ~IdentityGridEntity()
00303         {
00304             if (geo_!=0)
00305             {
00306                 delete geo_;
00307                 geo_ = 0;
00308             }
00309             if (geoInFather_!=0)
00310             {
00311                 delete geoInFather_;
00312                 geoInFather_ = 0;
00313             }
00314         }
00315         
00316         
00318         IdentityGridEntity& operator=(const IdentityGridEntity& original)
00319         {
00320             if (this != &original)
00321             {
00322                 if (geo_!=0)
00323                 {
00324                     delete geo_;
00325                     geo_ = 0;
00326                 }
00327                 if (geoInFather_!=0)
00328                 {
00329                     delete geoInFather_;
00330                     geoInFather_ = 0;
00331                 }
00332                 identityGrid_ = original.identityGrid_;
00333                 hostEntity_ = original.hostEntity_;
00334             }
00335             return *this;
00336         }
00337     
00338         
00340         int level () const
00341         {
00342             return hostEntity_->level();
00343         }
00344     
00345         
00347         PartitionType partitionType () const {
00348             return hostEntity_->partitionType();
00349         }
00350     
00351         
00353         const Geometry& geometry () const
00354         {
00355             if (geo_==0)
00356             {
00357                 geo_ = new MakeableInterfaceObject<Geometry>(hostEntity_->geometry());
00358             }
00359             return *geo_;
00360         }
00361     
00362         
00365         template<int cc>
00366         int count () const
00367         {
00368             return hostEntity_->template count<cc>();
00369         }
00370         
00371         
00375         template<int cc>
00376         typename GridImp::template Codim<cc>::EntityPointer entity (int i) const{
00377             return IdentityGridEntityPointer<cc,GridImp>(identityGrid_, hostEntity_->template entity<cc>(i));
00378         }
00379     
00380         
00382         IdentityGridLevelIntersectionIterator<GridImp> ilevelbegin () const{
00383             return IdentityGridLevelIntersectionIterator<GridImp>(identityGrid_,
00384                                                              hostEntity_->ilevelbegin());
00385         }
00386     
00387         
00389         IdentityGridLevelIntersectionIterator<GridImp> ilevelend () const{
00390             return IdentityGridLevelIntersectionIterator<GridImp>(identityGrid_,
00391                                                              hostEntity_->ilevelend());
00392         }
00393     
00394         
00396         IdentityGridLeafIntersectionIterator<GridImp> ileafbegin () const{
00397             return IdentityGridLeafIntersectionIterator<GridImp>(identityGrid_,
00398                                                                  hostEntity_->ileafbegin());
00399         }
00400     
00401         
00403         IdentityGridLeafIntersectionIterator<GridImp> ileafend () const{
00404             return IdentityGridLeafIntersectionIterator<GridImp>(identityGrid_,
00405                                                                  hostEntity_->ileafend());
00406         }
00407     
00408         
00410         bool isLeaf() const {
00411             return hostEntity_->isLeaf();
00412         }
00413     
00414         
00417         IdentityGridEntityPointer<0,GridImp> father () const {
00418             return IdentityGridEntityPointer<0,GridImp>(identityGrid_, hostEntity_->father());
00419         }
00420     
00421     
00431         const LocalGeometry& geometryInFather () const {
00432             if (geoInFather_==0)
00433                 geoInFather_ = new MakeableInterfaceObject<LocalGeometry>(hostEntity_->geometryInFather());
00434             return *geoInFather_;
00435         }
00436     
00437         
00442         IdentityGridHierarchicIterator<GridImp> hbegin (int maxLevel) const
00443         {
00444             return IdentityGridHierarchicIterator<const GridImp>(identityGrid_, *this, maxLevel);
00445         }
00446     
00447         
00449         IdentityGridHierarchicIterator<GridImp> hend (int maxLevel) const
00450         {
00451             return IdentityGridHierarchicIterator<const GridImp>(identityGrid_, *this, maxLevel, true);
00452         }
00453         
00454         
00456         bool wasRefined () const
00457         {
00458             if (identityGrid_->adaptationStep!=GridImp::adaptDone)
00459                 return false;
00460             
00461             int level = this->level();
00462             int index = identityGrid_->levelIndexSet(level).index(*this);
00463             return identityGrid_->refinementMark_[level][index];
00464         }
00465         
00466         
00468         bool mightBeCoarsened () const
00469         {
00470             return true;
00471         }
00472     
00473         
00474         // /////////////////////////////////////////
00475         //   Internal stuff
00476         // /////////////////////////////////////////
00477     
00478         
00480         void setToTarget(const HostGridEntityPointer& target)
00481         {
00482             if(geo_!=0)
00483             {
00484                 delete geo_;
00485                 geo_ = 0;
00486             }
00487             if (geoInFather_!=0)
00488             {
00489                 delete geoInFather_;
00490                 geoInFather_ = 0;
00491             }
00492             hostEntity_ = target;
00493         }
00494         
00495         
00496         const GridImp* identityGrid_;
00497         
00499         mutable MakeableInterfaceObject<Geometry> *geo_;
00500         
00502         mutable MakeableInterfaceObject<LocalGeometry> *geoInFather_;
00503 
00505         HostGridEntityPointer hostEntity_;
00506     
00507         
00508     private:
00509     
00510         typedef typename GridImp::ctype ctype;
00511 
00512 }; // end of IdentityGridEntity codim = 0
00513 
00514 
00515 } // namespace Dune
00516 
00517 
00518 #endif

Generated on 29 Jul 2009 with Doxygen (ver 1.5.6)