alu2dinclude.hh

00001 #ifndef DUNE_ALU2DGRID_INCLUDE_HH
00002 #define DUNE_ALU2DGRID_INCLUDE_HH
00003 
00004 #include <alugrid_2d.h>
00005 #define ALU2DSPACE ALUGridSpace ::
00006 #define ALU2DSPACENAME ALUGridSpace
00007 
00008 // use the ALU3dGrid Parallel detection 
00009 //#define ALU2DGRID_PARALLEL ALU3DGRID_PARALLEL
00010 #define ALU2DGRID_PARALLEL 0
00011 
00012 #if ALU2DGRID_PARALLEL
00013 #warning "Using ALU2dGrid in parallel"
00014 #endif
00015 
00016 namespace Dune {
00017   
00018   struct ALU2dImplTraits {
00019     template <int cdim>
00020     struct Codim;
00021   };
00022 
00023   template<>
00024   struct ALU2dImplTraits::Codim<0> {
00025     typedef ALU2DSPACE Hmesh_basic::helement_t InterfaceType;    
00026   };
00027  
00028   template<>
00029   struct ALU2dImplTraits::Codim<1> {
00030     typedef ALU2DSPACE Hmesh_basic::helement_t InterfaceType;    
00031   }; 
00032   
00033   template <>
00034   struct ALU2dImplTraits::Codim<2> {
00035     typedef ALU2DSPACE Vertex InterfaceType;    
00036   };  
00037 
00038   class ALU2dGridMarkerVector 
00039   {
00040     typedef std::vector< int > VectorType;
00041   public:
00042     ALU2dGridMarkerVector() : up2Date_(false) {}
00043    
00044     bool up2Date() const { return up2Date_; }
00045 
00046     void unsetUp2Date() { up2Date_ = false; }
00047     
00048     bool isOnElement(int elementIndex, int idx, int codim) const 
00049     {
00050       return marker_[codim-1][idx] == elementIndex; 
00051     }
00052     
00053     template <class GridType> 
00054     void update (const GridType & grid, int level ) 
00055     {
00056       typedef typename Dune::ALU2dImplTraits::template Codim<0>::InterfaceType ElementType;
00057       typedef typename Dune::ALU2dImplTraits::template Codim<2>::InterfaceType VertexType;
00058       typedef ALU2DSPACE Listwalkptr< ElementType > IteratorType;
00059 
00060       // resize 
00061       for(int i=0; i<2; ++i) 
00062       {
00063         int s = grid.hierSetSize(i+1);
00064         if((int) marker_[i].size() < s ) marker_[i].resize(s);
00065 
00066         size_t markerSize = marker_[i].size();
00067         // reset marker vector to default value 
00068         for(size_t k=0; k<markerSize; ++k) marker_[i][k] = -1;
00069       }
00070      
00071       enum { dim = GridType::dimension };
00072       IteratorType iter(grid.myGrid(), level);
00073 
00074       for(iter->first(); !iter->done(); iter->next())
00075       {
00076         ElementType & elem = iter->getitem();
00077         int elIdx = elem.getIndex();
00078 
00079         // if element is not valid, go to next 
00080 #if ALU2DGRID_PARALLEL 
00081         if( ! grid.rankManager().isValid( elIdx , All_Partition ) ) continue;
00082 #endif
00083         for(int i=0; i<dim+1; ++i) 
00084         {
00085           enum { vxCodim = 1 };
00086           int vxIdx = elem.getVertex(i)->getIndex();
00087           if( marker_[vxCodim][vxIdx] < 0) marker_[vxCodim][vxIdx] = elIdx;
00088           
00089           enum { edgeCodim = 0 };
00090           int edgeIdx = elem.edge_idx(i);
00091           if( marker_[edgeCodim][edgeIdx] < 0) marker_[edgeCodim][edgeIdx] = elIdx;
00092         }
00093       }
00094       up2Date_ = true;
00095     }
00096 
00097   private:
00098     VectorType marker_[2];
00099 
00100     bool up2Date_;
00101   };
00102 
00103   class ALU2dGridLeafMarkerVector 
00104   {
00105     typedef std::vector< int > VectorType;
00106   public:
00107     ALU2dGridLeafMarkerVector() : up2Date_(false) {}
00108    
00109     bool up2Date() const { return up2Date_; }
00110 
00111     void unsetUp2Date() { up2Date_ = false; }
00112     
00113     // return true, if edge is visited on given element 
00114     bool isOnElement(int elementIndex, int idx, int codim) const 
00115     {
00116       assert( up2Date_ );
00117       // this marker only works for codim 1, i.e. edges  
00118       assert( codim == 1 );
00119       return marker_[idx] == elementIndex; 
00120     }
00121     
00122     // this is for the LeafIterator
00123     template <class GridType> 
00124     void update (const GridType & grid) 
00125     {
00126       typedef typename Dune::ALU2dImplTraits::template Codim<0>::InterfaceType ElementType;
00127       typedef typename Dune::ALU2dImplTraits::template Codim<2>::InterfaceType VertexType;
00128       typedef ALU2DSPACE Listwalkptr< ElementType > IteratorType;
00129 
00130       // resize edge marker 
00131       {
00132         int s = grid.hierSetSize(1);
00133         if((int) marker_.size() < s ) marker_.resize(s);
00134 
00135         size_t markerSize = marker_.size();
00136         // reset marker vector to default value 
00137         for(size_t k=0; k<markerSize; ++k) marker_[k] = -1;
00138       }
00139 
00140       // resize vertex levels 
00141       {
00142         int s = grid.hierSetSize(2);
00143         if((int) vertexLevels_.size() < s ) vertexLevels_.resize(s);
00144 
00145         // initialize with -1 
00146         size_t vxSize = vertexLevels_.size();
00147         for(size_t k=0; k<vxSize; ++k) vertexLevels_[k] = -1;
00148       }
00149 
00150       enum { dim = GridType::dimension };
00151       IteratorType iter(grid.myGrid());
00152 
00153       for(iter->first(); !iter->done(); iter->next())
00154       {
00155         ElementType & elem = iter->getitem();
00156         int elIdx = elem.getIndex();
00157 
00158 #if ALU2DGRID_PARALLEL 
00159         // is element is not valid, go to next 
00160         if( ! grid.rankManager().isValid( elIdx , All_Partition ) ) continue;
00161 #endif
00162         int level = elem.level();
00163 
00164         for(int i=0; i<dim+1; ++i) 
00165         {
00166           int vxIdx = elem.getVertex(i)->getIndex();
00167 
00168           // set max level to vertices, see Grid docu paper
00169           if(level > vertexLevels_[vxIdx]) vertexLevels_[vxIdx] = level;    
00170           
00171           int edgeIdx = elem.edge_idx(i);
00172           if( marker_[edgeIdx] < 0) marker_[edgeIdx] = elIdx;
00173         }
00174       }     
00175       up2Date_ = true;
00176     }
00177 
00179     int levelOfVertex(const int vxIdx) const 
00180     {
00181       assert( up2Date_ );
00182       assert( vxIdx >= 0 && vxIdx < (int) vertexLevels_.size());
00183       // if this assertion is thrown, the level has not been initialized 
00184       assert( vertexLevels_[vxIdx] >= 0 );
00185       return vertexLevels_[vxIdx];
00186     }
00187 
00189     bool isValidVertex(const int vxIdx) const 
00190     {
00191       assert( up2Date_ );
00192       assert( vxIdx >= 0 && vxIdx < (int) vertexLevels_.size());
00193       return (vertexLevels_[vxIdx] >= 0);
00194     }
00195 
00196   private:
00197     VectorType marker_;
00198     VectorType vertexLevels_;
00199 
00200     bool up2Date_;
00201   };
00202 
00203   // dummy object stream class 
00204   class ALU2dGridObjectStream
00205   {
00206     public:
00207       class EOFException {} ;
00208       template <class T>
00209       void readObject (T &) {}
00210       void readObject (int) {}
00211       void readObject (double) {}
00212       template <class T>
00213       void writeObject (T &) {}
00214       void writeObject (int) {}
00215       void writeObject (double) {}
00216      
00217       template <class T>
00218       void read (T &) const {}
00219       template <class T> 
00220       void write (const T &) {}
00221   };  
00222       
00223 } //end namespace Dune
00224 #endif

Generated on 6 Nov 2008 with Doxygen (ver 1.5.6) [logfile].