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         IdentityGridLeafIntersectionIterator,  // leaf  intersection
00047         IdentityGridLevelIntersectionIterator, // level  intersection
00048         IdentityGridLeafIntersectionIterator,  // leaf  intersection iterator
00049         IdentityGridLevelIntersectionIterator, // level  intersection iterator
00050         IdentityGridHierarchicIterator,
00051         IdentityGridLeafIterator,
00052         IdentityGridLevelIndexSet< const IdentityGrid<HostGrid> >,
00053         IdentityGridLevelIndexSetTypes< const IdentityGrid<HostGrid> >,
00054         IdentityGridLeafIndexSet< const IdentityGrid<HostGrid> >,
00055         IdentityGridLeafIndexSetTypes< const IdentityGrid<HostGrid> >,
00056         IdentityGridGlobalIdSet< const IdentityGrid<HostGrid> >,
00057         typename HostGrid::Traits::GlobalIdSet::IdType,
00058         IdentityGridLocalIdSet< const IdentityGrid<HostGrid> >,
00059         typename HostGrid::Traits::LocalIdSet::IdType,
00060         CollectiveCommunication<IdentityGrid<HostGrid> >
00061             > Traits;
00062 };
00063 
00064 
00065 
00066 
00067 //**********************************************************************
00068 //
00069 // --IdentityGrid
00070 //
00071 //**********************************************************************
00072 
00076 template <class HostGrid>
00077 class IdentityGrid :
00078         public GridDefaultImplementation  <HostGrid::dimension, HostGrid::dimensionworld, double, IdentityGridFamily<HostGrid::dimension,HostGrid> >
00079 {
00080     
00081     friend class IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >;
00082     friend class IdentityGridLeafIndexSet<const IdentityGrid<HostGrid> >;
00083     friend class IdentityGridGlobalIdSet<const IdentityGrid<HostGrid> >;
00084     friend class IdentityGridLocalIdSet<const IdentityGrid<HostGrid> >;
00085     friend class IdentityGridHierarchicIterator<const IdentityGrid<HostGrid> >;
00086     friend class IdentityGridLevelIntersectionIterator<const IdentityGrid<HostGrid> >;
00087     friend class IdentityGridLeafIntersectionIterator<const IdentityGrid<HostGrid> >;
00088 
00089     template<int codim, PartitionIteratorType pitype, class GridImp_>
00090     friend class IdentityGridLevelIterator;
00091 
00092     template<int codim, PartitionIteratorType pitype, class GridImp_>
00093     friend class IdentityGridLeafIterator;
00094     
00095     
00096     template<int codim_, int dim_, class GridImp_>
00097     friend class IdentityGridEntity;
00098 
00099     public:
00100         
00102         typedef HostGrid HostGridType;
00103         
00104         //**********************************************************
00105         // The Interface Methods
00106         //**********************************************************
00107     
00109         typedef IdentityGridFamily<HostGrid::dimension,HostGrid>  GridFamily;
00110     
00112     typedef typename IdentityGridFamily<HostGrid::dimension,HostGrid>::Traits Traits;
00113     
00115         typedef typename HostGrid::ctype ctype;
00116     
00117         
00120         explicit IdentityGrid(HostGrid& hostgrid) :
00121             hostgrid_(&hostgrid),
00122             leafIndexSet_(*this),
00123             globalIdSet_(*this),
00124             localIdSet_(*this)
00125         {
00126             setIndices();
00127         }
00128     
00129         
00131         ~IdentityGrid()
00132         {
00133             // Delete level index sets
00134             for (size_t i=0; i<levelIndexSets_.size(); i++)
00135                 if (levelIndexSets_[i])
00136                     delete (levelIndexSets_[i]);
00137         }
00138         
00139         
00141         std::string name() const
00142         {
00143             return "IdentityGrid";
00144         }
00145     
00146         
00149         int maxLevel() const {
00150             return hostgrid_->maxLevel();
00151         }
00152         
00153         
00155         template<int codim>
00156         typename Traits::template Codim<codim>::LevelIterator lbegin (int level) const{
00157             return IdentityGridLevelIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, level);
00158         }
00159     
00160         
00162         template<int codim>
00163         typename Traits::template Codim<codim>::LevelIterator lend (int level) const{
00164             return IdentityGridLevelIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, level, true);
00165         }
00166         
00167         
00169         template<int codim, PartitionIteratorType PiType>
00170         typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lbegin (int level) const{
00171             return IdentityGridLevelIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, level);
00172         }
00173         
00174 
00176         template<int codim, PartitionIteratorType PiType>
00177         typename Traits::template Codim<codim>::template Partition<PiType>::LevelIterator lend (int level) const{
00178             return IdentityGridLevelIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, level, true);
00179         }
00180         
00181     
00183         template<int codim>
00184         typename Traits::template Codim<codim>::LeafIterator leafbegin() const {
00185             return IdentityGridLeafIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this);
00186         }
00187         
00188     
00190         template<int codim>
00191         typename Traits::template Codim<codim>::LeafIterator leafend() const {
00192             return IdentityGridLeafIterator<codim,All_Partition, const IdentityGrid<HostGrid> >(this, true);
00193         }
00194         
00195     
00197         template<int codim, PartitionIteratorType PiType>
00198         typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafbegin() const {
00199             return IdentityGridLeafIterator<codim,PiType, const IdentityGrid<HostGrid> >(this);
00200         }
00201         
00202         
00204         template<int codim, PartitionIteratorType PiType>
00205         typename Traits::template Codim<codim>::template Partition<PiType>::LeafIterator leafend() const {
00206             return IdentityGridLeafIterator<codim,PiType, const IdentityGrid<HostGrid> >(this, true);
00207         }
00208         
00209 
00212         int size (int level, int codim) const {
00213             return hostgrid_->size(level,codim);        
00214         }
00215         
00216         
00218         int size (int codim) const{
00219             return leafIndexSet().size(codim);
00220         }
00221         
00222         
00224         int size (int level, GeometryType type) const {
00225             return levelIndexSets_[level]->size(type);
00226         }
00227         
00228             
00230         int size (GeometryType type) const
00231         {
00232             return leafIndexSet().size(type);
00233         }
00234         
00235         
00237         const typename Traits::GlobalIdSet& globalIdSet() const{
00238             return globalIdSet_;
00239         }
00240         
00241         
00243         const typename Traits::LocalIdSet& localIdSet() const{
00244             return localIdSet_;
00245         }
00246         
00247         
00249         const typename Traits::LevelIndexSet& levelIndexSet(int level) const
00250         {
00251             if (level<0 || level>maxLevel())
00252                 DUNE_THROW(GridError, "levelIndexSet of nonexisting level " << level << " requested!");
00253             return *levelIndexSets_[level];
00254         }
00255         
00256         
00258         const typename Traits::LeafIndexSet& leafIndexSet() const
00259         {
00260             return leafIndexSet_;
00261         }
00262         
00263         
00266         
00267         
00271         void globalRefine (int refCount)
00272         {
00273             hostgrid_->globalRefine(refCount);
00274         }
00275         
00286         bool mark(int refCount, const typename Traits::template Codim<0>::EntityPointer & e)
00287         {
00288             return hostgrid_->mark(refCount, getHostEntity<0>(*e));
00289         }
00290         
00295         int getMark(const typename Traits::template Codim<0>::EntityPointer & e) const
00296         {
00297             return hostgrid_->getMark(getHostEntity<0>(*e));
00298         }
00299 
00301         bool preAdapt() {
00302             return hostgrid_->preAdapt();
00303         }
00304         
00305         
00307         bool adapt()
00308         {
00309             return hostgrid_->adapt();
00310         }
00311 
00313         void postAdapt() {
00314             return hostgrid_->postAdapt();
00315         }
00316         
00320         unsigned int overlapSize(int codim) const {
00321             return hostgrid_->overlapSize(codim);
00322         }
00323         
00324         
00326         unsigned int ghostSize(int codim) const {
00327             return hostgrid_->ghostSize(codim);
00328         }
00329         
00330         
00332         unsigned int overlapSize(int level, int codim) const {
00333             return hostgrid_->overlapSize(level,codim);
00334         }
00335         
00336         
00338         unsigned int ghostSize(int level, int codim) const {
00339             return hostgrid_->ghostSize(level,codim);
00340         }
00341         
00342             
00343 #if 0
00344 
00349         void loadBalance(int strategy, int minlevel, int depth, int maxlevel, int minelement){
00350             DUNE_THROW(NotImplemented, "IdentityGrid::loadBalance()");
00351         }
00352         
00364         template<class T, template<class> class P, int codim>
00365         void communicate (T& t, InterfaceType iftype, CommunicationDirection dir, int level);
00366         
00371         template<class DataHandle>
00372         void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir, int level) const
00373         {}
00374         
00375         template<class DataHandle>
00376         void communicate (DataHandle& data, InterfaceType iftype, CommunicationDirection dir) const
00377         {}
00378 #endif
00379         
00380         
00382         const CollectiveCommunication<IdentityGrid>& comm () const
00383         {
00384             return ccobj;
00385         }
00386         
00387         
00388         // **********************************************************
00389         // End of Interface Methods
00390         // **********************************************************
00391         
00393         HostGridType& getHostGrid() const
00394         {
00395             return *hostgrid_;
00396         }
00397         
00398         
00400         template <int codim>
00401         typename HostGrid::Traits::template Codim<codim>::EntityPointer getHostEntity(const typename Traits::template Codim<codim>::Entity& e) const
00402         {
00403             return getRealImplementation(e).hostEntity_;
00404         }
00405         
00406     protected:
00407         
00409         HostGrid* hostgrid_;
00410     
00411     private:
00412 
00414     void setIndices()
00415     {
00416             localIdSet_.update();
00417             
00418             globalIdSet_.update();
00419             
00420             // //////////////////////////////////////////
00421             //   Create the index sets
00422             // //////////////////////////////////////////
00423             for (int i=levelIndexSets_.size(); i<=maxLevel(); i++) {
00424                 IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >* p
00425                     = new IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >();
00426                 levelIndexSets_.push_back(p);
00427             }
00428             
00429             for (int i=0; i<=maxLevel(); i++)
00430                 if (levelIndexSets_[i])
00431                     levelIndexSets_[i]->update(*this, i);
00432             
00433             leafIndexSet_.update(*this);
00434             
00435         }
00436          
00438         CollectiveCommunication<IdentityGrid> ccobj;
00439         
00441         std::vector<IdentityGridLevelIndexSet<const IdentityGrid<HostGrid> >*> levelIndexSets_;
00442         
00444         IdentityGridLeafIndexSet<const IdentityGrid<HostGrid> > leafIndexSet_;
00445     
00447         IdentityGridGlobalIdSet<const IdentityGrid<HostGrid> > globalIdSet_;
00448     
00450         IdentityGridLocalIdSet<const IdentityGrid<HostGrid> > localIdSet_;
00451     
00452 }; // end Class IdentityGrid
00453 
00454 
00455 
00456 
00457 namespace Capabilities
00458 {
00460     template<class HostGrid, int codim>
00461     struct hasEntity< IdentityGrid<HostGrid>, codim>
00462     {
00463         static const bool v = hasEntity<HostGrid,codim>::v;
00464     };
00465     
00466     
00468     template<class HostGrid>
00469     struct isParallel< IdentityGrid<HostGrid> >
00470     {
00471         static const bool v = isParallel<HostGrid>::v;
00472     };
00473     
00474     
00476     template<class HostGrid>
00477     struct hasHangingNodes< IdentityGrid<HostGrid> >
00478     {
00479         static const bool v = hasHangingNodes<HostGrid>::v;
00480     };
00481 
00483     template<class HostGrid>
00484     struct isLevelwiseConforming< IdentityGrid<HostGrid> >
00485     {
00486         static const bool v = isLevelwiseConforming<HostGrid>::v;
00487     };
00488 
00490     template<class HostGrid>
00491     struct isLeafwiseConforming< IdentityGrid<HostGrid> >
00492     {
00493         static const bool v = isLeafwiseConforming<HostGrid>::v;
00494     };
00495 }
00496 
00497 } // namespace Dune
00498 
00499 #endif

Generated on 2 Apr 2009 with Doxygen (ver 1.5.6)