1 #ifndef ALUGRID_ENTITY_INLINE_HH 2 #define ALUGRID_ENTITY_INLINE_HH 3 #include <dune/common/exceptions.hh> 4 5 #include "geometry.hh" 6 #include "grid.hh" 7 8 9 namespace Dune { 10 11 ///////////////////////////////////////////////////////////////// 12 // 13 // --Entity0 14 // --Codim0Entity 15 // 16 //////////////////////////////////////////////////////////////// 17 /* 18 template<int dim, class GridImp> 19 inline void ALU3dGridEntity<0,dim,GridImp> :: 20 removeElement () 21 { 22 item_ = 0; 23 ghost_ = 0; 24 geo_.invalidate(); 25 } 26 27 template<int dim, class GridImp> 28 inline void ALU3dGridEntity<0,dim,GridImp> :: 29 reset (int walkLevel ) 30 { 31 item_ = 0; 32 ghost_ = 0; 33 34 // reset geometry information 35 geo_.invalidate(); 36 } 37 38 // works like assignment 39 template<int dim, class GridImp> 40 inline void 41 ALU3dGridEntity<0,dim,GridImp> :: setEntity(const ALU3dGridEntity<0,dim,GridImp> & org) 42 { 43 item_ = org.item_; 44 ghost_ = org.ghost_; 45 46 // reset geometry information 47 geo_.invalidate(); 48 } 49 50 template<int dim, class GridImp> 51 inline void 52 ALU3dGridEntity<0,dim,GridImp>:: 53 setElement(const EntitySeed& key ) 54 { 55 if( ! key.isGhost() ) 56 setElement( *key.interior() ); 57 else 58 setGhost( *key.ghost() ); 59 } 60 61 template<int dim, class GridImp> 62 inline void 63 ALU3dGridEntity<0,dim,GridImp>:: 64 setElement(HElementType & element) 65 { 66 item_ = static_cast<IMPLElementType *> (&element); 67 alugrid_assert ( item_ ); 68 // make sure this method is not called for ghosts 69 alugrid_assert ( ! item_->isGhost() ); 70 ghost_ = 0; 71 72 // reset geometry information 73 geo_.invalidate(); 74 } 75 76 template<int dim, class GridImp> 77 inline void 78 ALU3dGridEntity<0,dim,GridImp> :: setGhost(HBndSegType & ghost) 79 { 80 // use element as ghost 81 item_ = static_cast<IMPLElementType *> ( ghost.getGhost().first ); 82 83 // method getGhost can return 0, but then is something wrong 84 alugrid_assert (item_); 85 alugrid_assert (item_->isGhost()); 86 87 // remember pointer to ghost face 88 ghost_ = static_cast<BNDFaceType *> (&ghost); 89 alugrid_assert ( ghost_ ); 90 91 // check wether ghost is leaf or not, ghost leaf means 92 // that this is the ghost that we want in the leaf iterator 93 // not necessarily is real leaf element 94 // see Intersection Iterator, same story 95 96 // reset geometry information 97 geo_.invalidate(); 98 } 99 100 template<int dim, class GridImp> 101 inline int 102 ALU3dGridEntity<0,dim,GridImp> :: level() const 103 { 104 alugrid_assert( item_ ); 105 return item_->level(); 106 } 107 108 template<int dim, class GridImp> 109 inline bool ALU3dGridEntity<0,dim,GridImp> :: 110 equals (const ALU3dGridEntity<0,dim,GridImp> &org ) const 111 { 112 return (item_ == org.item_); 113 } 114 115 template<int dim, class GridImp> 116 inline GeometryType 117 ALU3dGridEntity<0,dim,GridImp> :: type () const 118 { 119 return geo_.type(); 120 } 121 122 template<int dim, class GridImp> 123 inline int ALU3dGridEntity<0,dim,GridImp> :: getIndex() const 124 { 125 alugrid_assert ( item_ ); 126 return (*item_).getIndex(); 127 } 128 129 template<int dim, class GridImp> 130 template<int cc> 131 inline int ALU3dGridEntity<0,dim,GridImp> :: count () const 132 { 133 return subEntities( cc ); 134 } 135 136 template<int dim, class GridImp> 137 inline unsigned int ALU3dGridEntity<0,dim,GridImp> :: subEntities (unsigned int codim) const 138 { 139 return GridImp::referenceElement().size( codim ); 140 } 141 142 template<int dim, class GridImp> 143 inline PartitionType ALU3dGridEntity<0,dim,GridImp> :: 144 partitionType () const 145 { 146 alugrid_assert ( item_ ); 147 // make sure we really got a ghost 148 alugrid_assert ( (isGhost()) ? item_->isGhost() : true ); 149 return (isGhost() ? GhostEntity : InteriorEntity); 150 } 151 152 template<int dim, class GridImp> 153 inline bool ALU3dGridEntity<0,dim,GridImp> :: isLeaf() const 154 { 155 alugrid_assert( item_ ); 156 if( isGhost() ) 157 { 158 alugrid_assert( ghost_ ); 159 // for ghost elements the situation is more complicated 160 // we have to compare the ghost level with our current level 161 BNDFaceType * dwn = static_cast<BNDFaceType *> (ghost_->down()); 162 return ( dwn ) ? (dwn->ghostLevel() == level()) : true; 163 } 164 else 165 { 166 // no children means leaf entity 167 return ! item_->down(); 168 } 169 } 170 171 template<int dim, class GridImp> 172 inline ALU3dGridHierarchicIterator<GridImp> 173 ALU3dGridEntity<0,dim,GridImp> :: hbegin (int maxlevel) const 174 { 175 alugrid_assert (item_ != 0); 176 // if isGhost is true the end iterator will be returned 177 if( isGhost() ) 178 { 179 return ALU3dGridHierarchicIterator<GridImp>( *ghost_, maxlevel, isLeaf() ); 180 } 181 else 182 return ALU3dGridHierarchicIterator<GridImp>( *item_, maxlevel, isLeaf() ); 183 } 184 185 template<int dim, class GridImp> 186 inline ALU3dGridHierarchicIterator<GridImp> ALU3dGridEntity<0,dim,GridImp> :: hend (int maxlevel) const 187 { 188 alugrid_assert (item_ != 0); 189 return ALU3dGridHierarchicIterator<GridImp> ( *item_, maxlevel, true); 190 } 191 192 // Adaptation methods 193 template<int dim, class GridImp> 194 inline bool ALU3dGridEntity<0,dim,GridImp> :: isNew () const 195 { 196 alugrid_assert ( item_ ); 197 return item_->hasBeenRefined(); 198 } 199 200 template<int dim, class GridImp> 201 inline bool ALU3dGridEntity<0,dim,GridImp> :: mightVanish () const 202 { 203 alugrid_assert ( item_ ); 204 return ((*item_).requestrule() == coarse_element_t); 205 } 206 */ 207 208 //******************************************************************* 209 // 210 // --EntityPointer 211 // --EnPointer 212 // 213 //******************************************************************* 214 template<int codim, class GridImp > 215 inline ALU3dGridEntityPointerBase<codim,GridImp> :: ALU3dGridEntityPointerBase(const HElementType & item)216 ALU3dGridEntityPointerBase( const HElementType &item ) 217 : seed_( item ) 218 , entity_( EntityImp( item ) ) 219 { 220 } 221 222 template<int codim, class GridImp > 223 inline ALU3dGridEntityPointerBase<codim,GridImp> :: ALU3dGridEntityPointerBase(const HBndSegType & ghostFace)224 ALU3dGridEntityPointerBase( const HBndSegType & ghostFace ) 225 : seed_( ghostFace ) 226 , entity_ ( EntityImp( ghostFace ) ) 227 { 228 } 229 230 template<int codim, class GridImp > 231 inline ALU3dGridEntityPointerBase<codim,GridImp> :: ALU3dGridEntityPointerBase(const ALU3dGridEntitySeedType & key)232 ALU3dGridEntityPointerBase( const ALU3dGridEntitySeedType& key ) 233 : seed_( key ) 234 , entity_( EntityImp( seed_ ) ) 235 { 236 } 237 238 // constructor Level,Leaf and HierarchicIterator 239 template<int codim, class GridImp > 240 inline ALU3dGridEntityPointerBase<codim,GridImp> :: ALU3dGridEntityPointerBase()241 ALU3dGridEntityPointerBase() 242 : seed_() 243 , entity_ ( EntityImp() ) 244 { 245 } 246 247 template<int codim, class GridImp > 248 inline ALU3dGridEntityPointerBase<codim,GridImp> :: ALU3dGridEntityPointerBase(const ALU3dGridEntityPointerType & org)249 ALU3dGridEntityPointerBase(const ALU3dGridEntityPointerType & org) 250 : seed_( org.seed_ ) 251 , entity_( org.entity_.impl() ) 252 { 253 alugrid_assert( seed_ == org.seed_ ); 254 alugrid_assert( entity_ == org.entity_ ); 255 } 256 257 template<int codim, class GridImp > 258 inline ALU3dGridEntityPointerBase<codim,GridImp> & 259 ALU3dGridEntityPointerBase<codim,GridImp> :: operator =(const ALU3dGridEntityPointerType & org)260 operator = (const ALU3dGridEntityPointerType & org) 261 { 262 clone( org ); 263 return *this; 264 } 265 266 template<int codim, class GridImp > 267 inline void 268 ALU3dGridEntityPointerBase<codim,GridImp> :: clone(const ALU3dGridEntityPointerType & org)269 clone (const ALU3dGridEntityPointerType & org) 270 { 271 // copy seed 272 seed_ = org.seed_; 273 274 if( seed_.isValid() ) 275 { 276 // update entity if seed is valid 277 entityImp().setEntity( org.entityImp() ); 278 } 279 else // otherwise mark as finished (iterators) 280 { 281 this->done(); 282 } 283 } 284 285 template<int codim, class GridImp > done()286 inline void ALU3dGridEntityPointerBase<codim,GridImp>::done () 287 { 288 seed_.clear(); 289 } 290 291 template<int codim, class GridImp > 292 inline bool ALU3dGridEntityPointerBase<codim,GridImp>:: equals(const ALU3dGridEntityPointerBase<codim,GridImp> & i) const293 equals (const ALU3dGridEntityPointerBase<codim,GridImp>& i) const 294 { 295 // check equality of underlying items 296 return (seed_.equals( i.seed_ )); 297 } 298 299 template<int codim, class GridImp > 300 inline void ALU3dGridEntityPointerBase<codim,GridImp>:: updateGhostPointer(HBndSegType & ghostFace)301 updateGhostPointer( HBndSegType & ghostFace ) 302 { 303 seed_.set( ghostFace ); 304 if( seed_.isValid() ) 305 { 306 entityImp().setGhost( ghostFace ); 307 } 308 } 309 310 template<int codim, class GridImp > 311 inline void ALU3dGridEntityPointerBase<codim,GridImp>:: updateEntityPointer(HElementType * item,int)312 updateEntityPointer( HElementType * item , int ) 313 { 314 seed_.set( *item ); 315 if( seed_.isValid() ) 316 { 317 entityImp().setElement( *item ); 318 } 319 } 320 321 /////////////////////////////////////////////////////////////////// 322 // 323 // specialisation for higher codims 324 // 325 /////////////////////////////////////////////////////////////////// 326 327 template<int codim, class GridImp > 328 inline void ALU3dGridEntityPointer<codim,GridImp>:: updateEntityPointer(HElementType * item,int level)329 updateEntityPointer( HElementType * item, int level) 330 { 331 seed_.set( *item, level ); 332 if( seed_.isValid() ) 333 { 334 entityImp().setElement( seed_ ); 335 } 336 } 337 338 } // end namespace Dune 339 #endif 340