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
00009
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
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
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
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
00114 bool isOnElement(int elementIndex, int idx, int codim) const
00115 {
00116 assert( up2Date_ );
00117
00118 assert( codim == 1 );
00119 return marker_[idx] == elementIndex;
00120 }
00121
00122
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
00131 {
00132 int s = grid.hierSetSize(1);
00133 if((int) marker_.size() < s ) marker_.resize(s);
00134
00135 size_t markerSize = marker_.size();
00136
00137 for(size_t k=0; k<markerSize; ++k) marker_[k] = -1;
00138 }
00139
00140
00141 {
00142 int s = grid.hierSetSize(2);
00143 if((int) vertexLevels_.size() < s ) vertexLevels_.resize(s);
00144
00145
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
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
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
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
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 }
00224 #endif