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

Generated on 12 Dec 2007 with Doxygen (ver 1.5.1)