identitygrid.hh

Go to the documentation of this file.
00001 #ifndef DUNE_IDENTITYGRID_HH
00002 #define DUNE_IDENTITYGRID_HH
00003 
00008 #include <string>
00009 #include <map>
00010 
00011 #include <dune/common/collectivecommunication.hh>
00012 #include <dune/grid/common/capabilities.hh>
00013 #include <dune/grid/common/grid.hh>
00014 #include <dune/common/timer.hh>
00015 
00016 // The components of the Identitygrid interface
00017 #include "identitygrid/identitygridgeometry.hh"
00018 #include "identitygrid/identitygridentity.hh"
00019 #include "identitygrid/identitygridentitypointer.hh"
00020 #include "identitygrid/identitygridintersectioniterator.hh"
00021 #include "identitygrid/identitygridleveliterator.hh"
00022 #include "identitygrid/identitygridleafiterator.hh"
00023 #include "identitygrid/identitygridhierarchiciterator.hh"
00024 #include "identitygrid/identitygridindexsets.hh"
00025 
00026 namespace Dune {
00027 
00028 // Forward declaration
00029 template <class HostGrid>
00030 class IdentityGrid;
00031 
00032 
00033 
00034 
00035 template<int dim, class HostGrid>
00036 struct IdentityGridFamily
00037 {
00038     typedef GridTraits<
00039         dim,
00040         HostGrid::dimensionworld,
00041         Dune::IdentityGrid<HostGrid>,
00042         IdentityGridGeometry,
00043         IdentityGridEntity,
00044         IdentityGridEntityPointer,
00045         IdentityGridLevelIterator,
00046         IdentityGridLeafIntersection,
00047         IdentityGridLevelIntersection,
00048         IdentityGridLeafIntersectionIterator,
00049         IdentityGridLevelIntersectionIterator,
00050         IdentityGridHierarchicIterator,
00051         IdentityGridLeafIterator,
00052         IdentityGridLevelIndexSet< const IdentityGrid<HostGrid> >,
00053         IdentityGridLeafIndexSet< const IdentityGrid<HostGrid> >,
00054         IdentityGridGlobalIdSet< const IdentityGrid<HostGrid> >,
00055         typename HostGrid::Traits::GlobalIdSet::IdType,
00056         IdentityGridLocalIdSet< const IdentityGrid<HostGrid> >,
00057         typename HostGrid::Traits::LocalIdSet::IdType,
00058         CollectiveCommunication<IdentityGrid<HostGrid> >
00059             > Traits;
00060 };
00061 
00062 
00063 
00064 
00065 //**********************************************************************
00066 //
00067 // --IdentityGrid
00068 //
00069 //**********************************************************************
00070 
00074 template <class HostGrid>
00075 class IdentityGrid :
00076         public GridDefaultImplementation  <HostGrid::dimension, HostGrid::dimensionworld, double, IdentityGridFamily<HostGrid::dimension,HostGrid> >
00077 {
00078     
00079     friend class IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >;
00080     friend class IdentityGridLeafIndexSet<const IdentityGrid<HostGrid> >;
00081     friend class IdentityGridGlobalIdSet<const IdentityGrid<HostGrid> >;
00082     friend class IdentityGridLocalIdSet<const IdentityGrid<HostGrid> >;
00083     friend class IdentityGridHierarchicIterator<const IdentityGrid<HostGrid> >;
00084     friend class IdentityGridLevelIntersectionIterator<const IdentityGrid<HostGrid> >;
00085     friend class IdentityGridLeafIntersectionIterator<const IdentityGrid<HostGrid> >;
00086 
00087     template<int codim, PartitionIteratorType pitype, class GridImp_>
00088     friend class IdentityGridLevelIterator;
00089 
00090     template<int codim, PartitionIteratorType pitype, class GridImp_>
00091     friend class IdentityGridLeafIterator;
00092     
00093     
00094     template<int codim_, int dim_, class GridImp_>
00095     friend class IdentityGridEntity;
00096 
00097     public:
00098         
00100         typedef HostGrid HostGridType;
00101         
00102         //**********************************************************
00103         // The Interface Methods
00104         //**********************************************************
00105     
00107         typedef IdentityGridFamily<HostGrid::dimension,HostGrid>  GridFamily;
00108     
00110     typedef typename IdentityGridFamily<HostGrid::dimension,HostGrid>::Traits Traits;
00111     
00113         typedef typename HostGrid::ctype ctype;
00114     
00115         
00118         explicit IdentityGrid(HostGrid& hostgrid) :
00119             hostgrid_(&hostgrid),
00120             leafIndexSet_(*this),
00121             globalIdSet_(*this),
00122             localIdSet_(*this)
00123         {
00124             setIndices();
00125         }
00126     
00127         
00129         ~IdentityGrid()
00130         {
00131             // Delete level index sets
00132             for (size_t i=0; i<levelIndexSets_.size(); i++)
00133                 if (levelIndexSets_[i])
00134                     delete (levelIndexSets_[i]);
00135         }
00136         
00137         
00139         std::string name() const
00140         {
00141             return "IdentityGrid";
00142         }
00143     
00144         
00147         int maxLevel() const {
00148             return hostgrid_->maxLevel();
00149         }
00150         
00151         
00153         template<int codim>
00154         typename Traits::template Codim<codim>::LevelIterator lbegin (int level) const{
00155             return IdentityGridLevelIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, level);
00156         }
00157     
00158         
00160         template<int codim>
00161         typename Traits::template Codim<codim>::LevelIterator lend (int level) const{
00162             return IdentityGridLevelIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, level, true);
00163         }
00164         
00165         
00167         template<int codim, PartitionIteratorType PiType>
00168         typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lbegin (int level) const{
00169             return IdentityGridLevelIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, level);
00170         }
00171         
00172 
00174         template<int codim, PartitionIteratorType PiType>
00175         typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lend (int level) const{
00176             return IdentityGridLevelIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, level, true);
00177         }
00178         
00179     
00181         template<int codim>
00182         typename Traits::template Codim<codim>::LeafIterator leafbegin() const {
00183             return IdentityGridLeafIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this);
00184         }
00185         
00186     
00188         template<int codim>
00189         typename Traits::template Codim<codim>::LeafIterator leafend() const {
00190             return IdentityGridLeafIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, true);
00191         }
00192         
00193     
00195         template<int codim, PartitionIteratorType PiType>
00196         typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafbegin() const {
00197             return IdentityGridLeafIterator<codim,PiType, const IdentityGrid<HostGrid> >(this);
00198         }
00199         
00200         
00202         template<int codim, PartitionIteratorType PiType>
00203         typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafend() const {
00204             return IdentityGridLeafIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, true);
00205         }
00206         
00207 
00210         int size (int level, int codim) const {
00211             return hostgrid_->size(level,codim);        
00212         }
00213 
00216         size_t numBoundarySegments () const {
00217             return hostgrid_->numBoundarySegments();
00218         }
00219         
00221         int size (int codim) const{
00222             return leafIndexSet().size(codim);
00223         }
00224         
00225         
00227         int size (int level, GeometryType type) const {
00228             return levelIndexSets_[level]->size(type);
00229         }
00230         
00231             
00233         int size (GeometryType type) const
00234         {
00235             return leafIndexSet().size(type);
00236         }
00237         
00238         
00240         const typename Traits::GlobalIdSet& globalIdSet() const{
00241             return globalIdSet_;
00242         }
00243         
00244         
00246         const typename Traits::LocalIdSet& localIdSet() const{
00247             return localIdSet_;
00248         }
00249         
00250         
00252         const typename Traits::LevelIndexSet& levelIndexSet(int level) const
00253         {
00254             if (level<0 || level>maxLevel())
00255                 DUNE_THROW(GridError, "levelIndexSet of nonexisting level " << level << " requested!");
00256             return *levelIndexSets_[level];
00257         }
00258         
00259         
00261         const typename Traits::LeafIndexSet& leafIndexSet() const
00262         {
00263             return leafIndexSet_;
00264         }
00265         
00266         
00269         
00270         
00274         void globalRefine (int refCount)
00275         {
00276             hostgrid_->globalRefine(refCount);
00277         }
00278         
00289         bool mark(int refCount, const typename Traits::template Codim<0>::EntityPointer & e)
00290         {
00291             return hostgrid_->mark(refCount, *getHostEntityPointer<0>(*e));
00292         }
00293         
00298         int getMark(const typename Traits::template Codim<0>::EntityPointer & e) const
00299         {
00300             return hostgrid_->getMark(*getHostEntityPointer<0>(*e));
00301         }
00302 
00304         bool preAdapt() {
00305             return hostgrid_->preAdapt();
00306         }
00307         
00308         
00310         bool adapt()
00311         {
00312             return hostgrid_->adapt();
00313         }
00314 
00316         void postAdapt() {
00317             return hostgrid_->postAdapt();
00318         }
00319         
00323         unsigned int overlapSize(int codim) const {
00324             return hostgrid_->overlapSize(codim);
00325         }
00326         
00327         
00329         unsigned int ghostSize(int codim) const {
00330             return hostgrid_->ghostSize(codim);
00331         }
00332         
00333         
00335         unsigned int overlapSize(int level, int codim) const {
00336             return hostgrid_->overlapSize(level,codim);
00337         }
00338         
00339         
00341         unsigned int ghostSize(int level, int codim) const {
00342             return hostgrid_->ghostSize(level,codim);
00343         }
00344         
00345             
00346 #if 0
00347 
00352         void loadBalance(int strategy, int minlevel, int depth, int maxlevel, int minelement){
00353             DUNE_THROW(NotImplemented, "IdentityGrid::loadBalance()");
00354         }
00355         
00367         template<class T, template<class> class P, int codim>
00368         void communicate (T& t, InterfaceType iftype, CommunicationDirection dir, int level);
00369         
00374         template<class DataHandle>
00375         void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir, int level) const
00376         {}
00377         
00378         template<class DataHandle>
00379         void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir) const
00380         {}
00381 #endif
00382         
00383         
00385         const CollectiveCommunication<IdentityGrid>& comm () const
00386         {
00387             return ccobj;
00388         }
00389         
00390         
00391         // **********************************************************
00392         // End of Interface Methods
00393         // **********************************************************
00394         
00396         HostGridType& getHostGrid() const
00397         {
00398             return *hostgrid_;
00399         }
00400         
00401         
00403         template <int codim>
00404         typename HostGrid::Traits::template Codim<codim>::EntityPointer getHostEntityPointer(const typename Traits::template Codim<codim>::Entity& e) const
00405         {
00406             return getRealImplementation(e).hostEntity_;
00407         }
00408         
00409     protected:
00410         
00412         HostGrid* hostgrid_;
00413     
00414     private:
00415 
00417     void setIndices()
00418     {
00419             localIdSet_.update();
00420             
00421             globalIdSet_.update();
00422             
00423             // //////////////////////////////////////////
00424             //   Create the index sets
00425             // //////////////////////////////////////////
00426             for (int i=levelIndexSets_.size(); i<=maxLevel(); i++) {
00427                 IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >* p
00428                     = new IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >();
00429                 levelIndexSets_.push_back(p);
00430             }
00431             
00432             for (int i=0; i<=maxLevel(); i++)
00433                 if (levelIndexSets_[i])
00434                     levelIndexSets_[i]->update(*this, i);
00435             
00436             leafIndexSet_.update(*this);
00437             
00438         }
00439          
00441         CollectiveCommunication<IdentityGrid> ccobj;
00442         
00444         std::vector<IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >*> levelIndexSets_;
00445         
00447         IdentityGridLeafIndexSet<const IdentityGrid<HostGrid> > leafIndexSet_;
00448     
00450         IdentityGridGlobalIdSet<const IdentityGrid<HostGrid> > globalIdSet_;
00451     
00453         IdentityGridLocalIdSet<const IdentityGrid<HostGrid> > localIdSet_;
00454     
00455 }; // end Class IdentityGrid
00456 
00457 
00458 
00459 
00460 namespace Capabilities
00461 {
00463     template<class HostGrid, int codim>
00464     struct hasEntity< IdentityGrid<HostGrid>, codim>
00465     {
00466         static const bool v = hasEntity<HostGrid,codim>::v;
00467     };
00468     
00469     
00471     template<class HostGrid>
00472     struct isParallel< IdentityGrid<HostGrid> >
00473     {
00474         static const bool v = isParallel<HostGrid>::v;
00475     };
00476     
00477     
00479     template<class HostGrid>
00480     struct hasHangingNodes< IdentityGrid<HostGrid> >
00481     {
00482         static const bool v = hasHangingNodes<HostGrid>::v;
00483     };
00484 
00486     template<class HostGrid>
00487     struct isLevelwiseConforming< IdentityGrid<HostGrid> >
00488     {
00489         static const bool v = isLevelwiseConforming<HostGrid>::v;
00490     };
00491 
00493     template<class HostGrid>
00494     struct isLeafwiseConforming< IdentityGrid<HostGrid> >
00495     {
00496         static const bool v = isLeafwiseConforming<HostGrid>::v;
00497     };
00498 }
00499 
00500 } // namespace Dune
00501 
00502 #endif
Generated on Sat Apr 24 11:13:38 2010 for dune-grid-dev-howto by  doxygen 1.6.3