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
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
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
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
00103 bool isOnElement(int elementIndex, int idx, int codim) const
00104 {
00105 assert( up2Date_ );
00106
00107 assert( codim == 1 );
00108 return marker_[idx] == elementIndex;
00109 }
00110
00111
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
00120 {
00121 int s = grid.hierSetSize(1);
00122 if((int) marker_.size() < s ) marker_.resize(s);
00123
00124 size_t markerSize = marker_.size();
00125
00126 for(size_t k=0; k<markerSize; ++k) marker_[k] = -1;
00127 }
00128
00129
00130 {
00131 int s = grid.hierSetSize(2);
00132 if((int) vertexLevels_.size() < s ) vertexLevels_.resize(s);
00133
00134
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
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
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
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 }
00201 #endif