Dune Core Modules (2.4.1)

grid_inline.hh
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3// Dune includes
5
6// Local includes
7#include "alu3dinclude.hh"
8#include "entity.hh"
9#include "iterator.hh"
10#include "datahandle.hh"
11#include "grid.hh"
12
13namespace Dune
14{
15
16 // Implementation of ALU3dGrid
17 // ---------------------------
18
19 template< ALU3dGridElementType elType, class Comm >
21 ::ALU3dGrid ( const std::string &macroTriangFilename,
22 const MPICommunicatorType mpiComm,
23 const DuneBoundaryProjectionType *bndPrj,
24 const DuneBoundaryProjectionVector *bndVec,
25 const ALUGridRefinementType refinementType )
26 : mygrid_( 0 )
27 , maxlevel_( 0 )
28 , coarsenMarked_( 0 )
29 , refineMarked_( 0 )
30 , geomTypes_() //dim+1, std::vector<GeometryType>(1) )
31 , hIndexSet_ (*this)
32 , globalIdSet_( 0 )
33 , localIdSet_( *this )
34 , levelIndexVec_(MAXL,0) , leafIndexSet_(0)
35 , referenceElement_( elType == tetra
36 ? ReferenceElements< alu3d_ctype, dimension > :: simplex()
37 : ReferenceElements< alu3d_ctype, dimension > :: cube() )
38 , sizeCache_ ( 0 )
39#ifdef USE_SMP_PARALLEL
40 , factoryVec_( GridObjectFactoryType :: maxThreads(), GridObjectFactoryType( *this ) )
41#else
42 , factory_( *this )
43#endif
44 , lockPostAdapt_( false )
45 , bndPrj_ ( bndPrj )
46 , bndVec_ ( (bndVec) ? (new DuneBoundaryProjectionVector( *bndVec )) : 0 )
47 , vertexProjection_( (bndPrj || bndVec) ? new ALUGridBoundaryProjectionType( *this ) : 0 )
48 , communications_( new Communications( mpiComm ) )
49 , refinementType_( refinementType )
50 {
51 assert( elType == tetra || elType == hexa );
52
53 geomTypes_.resize( dimension+1 );
54 GeometryType tmpType;
55 for( int codim = 0; codim <= dimension; ++codim )
56 {
57 if (elType == tetra)
58 tmpType.makeSimplex( dimension - codim );
59 else
60 tmpType.makeCube( dimension - codim );
61
62 geomTypes_[ codim ].push_back( tmpType );
63 }
64
65 // check macro grid file for keyword
66 checkMacroGridFile( macroTriangFilename );
67
68 mygrid_ = createALUGrid( macroTriangFilename );
69 assert( mygrid_ );
70
71 dverb << "************************************************" << std::endl;
72 dverb << "Created grid on p=" << comm().rank() << std::endl;
73 dverb << "************************************************" << std::endl;
75
76 postAdapt();
77 calcExtras();
78 } // end constructor
79
80
81 template< ALU3dGridElementType elType, class Comm >
82 inline int ALU3dGrid< elType, Comm >::global_size ( int codim ) const
83 {
84 // return actual size of hierarchical index set
85 // this is always up to date
86 // maxIndex is the largest index used + 1
87 return myGrid().indexManager(codim).getMaxIndex();
88 }
89
90
91 template< ALU3dGridElementType elType, class Comm >
92 inline int ALU3dGrid< elType, Comm >::hierSetSize ( int codim ) const
93 {
94 // return actual size of hierarchical index set
95 return myGrid().indexManager(codim).getMaxIndex();
96 }
97
98
99 template< ALU3dGridElementType elType, class Comm >
101 {
102 return maxlevel_;
103 }
104
105
106 template< ALU3dGridElementType elType, class Comm >
107 inline typename ALU3dGrid< elType, Comm >::GitterImplType &
109 {
110 assert( mygrid_ );
111 return *mygrid_;
112 }
113
114
115 // lbegin methods
116 template< ALU3dGridElementType elType, class Comm >
117 template< int cd, PartitionIteratorType pitype >
118 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LevelIterator
120 {
121 assert( level >= 0 );
122 // if we dont have this level return empty iterator
123 if( level > maxlevel_ )
124 return this->template lend<cd,pitype> (level);
125
126 return ALU3dGridLevelIterator< cd, pitype, const ThisType >( factory(), level, true );
127 }
128
129
130 template< ALU3dGridElementType elType, class Comm >
131 template< int cd, PartitionIteratorType pitype >
132 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LevelIterator
134 {
135 assert( level >= 0 );
137 }
138
139
140 // lbegin methods
141 template< ALU3dGridElementType elType, class Comm >
142 template< int cd >
143 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator
145 {
146 return this->template lbegin<cd,All_Partition>( level );
147 }
148
149
150 template< ALU3dGridElementType elType, class Comm >
151 template< int cd >
152 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< All_Partition >::LevelIterator
154 {
155 assert( level >= 0 );
156 return this->template lend<cd,All_Partition>( level );
157 }
158
159
160 //***********************************************************
161 //
162 // leaf methods , first all begin methods
163 //
164 //***********************************************************
165 template< ALU3dGridElementType elType, class Comm >
166 template< int cd, PartitionIteratorType pitype >
167 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
169 {
170 assert( level >= 0 );
171 return ALU3dGridLeafIterator< cd, pitype, const ThisType >( factory(), level, true );
172 }
173
174
175 template< ALU3dGridElementType elType, class Comm >
176 template< int cd, PartitionIteratorType pitype >
177 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
178 ALU3dGrid< elType, Comm >::leafbegin ( int level ) const
179 {
180 return createLeafIteratorBegin<cd, pitype> (level) ;
181 }
182
183
184 template< ALU3dGridElementType elType, class Comm >
185 template< int cd >
186 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::LeafIterator
187 ALU3dGrid< elType, Comm >::leafbegin ( int level ) const
188 {
189 return createLeafIteratorBegin<cd, All_Partition> (level) ;
190 }
191
192
193 template< ALU3dGridElementType elType, class Comm >
194 template< int cd, PartitionIteratorType pitype >
195 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
196 ALU3dGrid< elType, Comm >::leafbegin () const
197 {
198 return createLeafIteratorBegin< cd, pitype > (maxlevel_) ;
199 }
200
201
202 template< ALU3dGridElementType elType, class Comm >
203 template< int cd >
204 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::LeafIterator
205 ALU3dGrid< elType, Comm >::leafbegin () const
206 {
207 return createLeafIteratorBegin< cd, All_Partition> (maxlevel_) ;
208 }
209
210
211 template< ALU3dGridElementType elType, class Comm >
212 inline typename ALU3dGrid< elType, Comm >::LeafIteratorType
213 ALU3dGrid< elType, Comm >::leafbegin ( int level ) const
214 {
215 return createLeafIteratorBegin<0, All_Partition> (level) ;
216 }
217
218
219 template< ALU3dGridElementType elType, class Comm >
220 inline typename ALU3dGrid< elType, Comm >::LeafIteratorType
221 ALU3dGrid< elType, Comm >::leafbegin () const
222 {
223 return createLeafIteratorBegin<0, All_Partition> (maxlevel_) ;
224 }
225
226
227 //****************************************************************
228 //
229 // all leaf end methods
230 //
231 //****************************************************************
232 template< ALU3dGridElementType elType, class Comm >
233 template< int cd, PartitionIteratorType pitype >
234 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
235 ALU3dGrid< elType, Comm >::createLeafIteratorEnd ( int level ) const
236 {
237 assert( level >= 0 );
238 return ALU3dGridLeafIterator<cd, pitype, const MyType> ( factory() , level);
239 }
240
241
242 template< ALU3dGridElementType elType, class Comm >
243 template< int cd, PartitionIteratorType pitype >
244 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
245 ALU3dGrid< elType, Comm >::leafend ( int level ) const
246 {
247 return createLeafIteratorEnd < cd, pitype> (level);
248 }
249
250
251 template< ALU3dGridElementType elType, class Comm >
252 template< int cd >
253 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::LeafIterator
254 ALU3dGrid< elType, Comm >::leafend ( int level ) const
255 {
256 return createLeafIteratorEnd < cd, All_Partition> (level);
257 }
258
259
260 template< ALU3dGridElementType elType, class Comm >
261 template< int cd, PartitionIteratorType pitype >
262 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::template Partition< pitype >::LeafIterator
263 ALU3dGrid< elType, Comm >::leafend () const
264 {
265 return createLeafIteratorEnd < cd, pitype> (maxlevel_);
266 }
267
268
269 template< ALU3dGridElementType elType, class Comm >
270 template< int cd >
271 inline typename ALU3dGrid< elType, Comm >::Traits::template Codim< cd >::LeafIterator
272 ALU3dGrid< elType, Comm >::leafend () const
273 {
274 return createLeafIteratorEnd < cd, All_Partition> (maxlevel_);
275 }
276
277
278 template< ALU3dGridElementType elType, class Comm >
279 inline typename ALU3dGrid< elType, Comm >::LeafIteratorType
280 ALU3dGrid< elType, Comm >::leafend ( int level ) const
281 {
282 return createLeafIteratorEnd <0, All_Partition> (level);
283 }
284
285
286 template< ALU3dGridElementType elType, class Comm >
287 inline typename ALU3dGrid< elType, Comm >::LeafIteratorType
288 ALU3dGrid< elType, Comm >::leafend () const
289 {
290 return createLeafIteratorEnd <0,All_Partition> (maxlevel_);
291 }
292
293
294 //*****************************************************************
295
296 // mark given entity
297 template< ALU3dGridElementType elType, class Comm >
298 inline bool ALU3dGrid< elType, Comm >
299 ::mark ( int ref, const typename Traits::template Codim< 0 >::Entity &entity )
300 {
301 bool marked = (this->getRealImplementation( entity )).mark(ref);
302 if(marked)
303 {
304 if(ref > 0) ++refineMarked_;
305 if(ref < 0) ++coarsenMarked_;
306 }
307 return marked;
308 }
309
310
311 // get Mark of given entity
312 template< ALU3dGridElementType elType, class Comm >
314 ::getMark ( const typename Traits::template Codim< 0 >::Entity &entity ) const
315 {
316 return this->getRealImplementation( entity ).getMark();
317 }
318
319
320 // global refine
321 template< ALU3dGridElementType elType, class Comm >
322 template< class GridImp, class DataHandle >
323 inline
326 {
327 assert( (refCount + maxLevel()) < MAXL );
328
329 for( int count = refCount; count > 0; --count )
330 {
331 const LeafIteratorType end = leafend();
332 for( LeafIteratorType it = leafbegin(); it != end; ++it )
333 mark( 1 , *it );
334 adapt( handle );
335 }
336 }
337
338
339 // adapt grid
340 // --adapt
341 template< ALU3dGridElementType elType, class Comm >
342 template< class GridImp, class DataHandle >
343 inline
346 {
348
349 typedef typename EntityObject::ImplementationType EntityImp;
350 EntityObject father( EntityImp( factory(), this->maxLevel() ) );
351 EntityObject son ( EntityImp( factory(), this->maxLevel() ) );
352
353 // true if at least one element was marked for coarsening
354 bool mightCoarse = preAdapt();
355
356 bool refined = false ;
357 if(globalIdSet_)
358 {
359 // if global id set exists then include into
360 // prolongation process
361 ALU3DSPACE AdaptRestrictProlongGlSet< MyType, AdaptDataHandle, GlobalIdSetImp >
362 rp(*this,
363 father,this->getRealImplementation(father),
364 son, this->getRealImplementation(son),
365 handle,
366 *globalIdSet_);
367
368 refined = myGrid().duneAdapt(rp); // adapt grid
369 }
370 else
371 {
372 ALU3DSPACE AdaptRestrictProlongImpl< MyType, AdaptDataHandle >
373 rp(*this,
374 father,this->getRealImplementation(father),
375 son, this->getRealImplementation(son),
376 handle);
377
378 refined = myGrid().duneAdapt(rp); // adapt grid
379 }
380
381 if(refined || mightCoarse)
382 {
383 // only calc extras and skip maxLevel calculation, because of
384 // refinement maxLevel was calculated already
385 updateStatus();
386
387 // no need to call postAdapt here, because markers
388 // are cleand during refinement callback
389 }
390
391 return refined;
392 }
393
394
395
396 //*****************************************************************
397
398 template< ALU3dGridElementType elType, class Comm >
399 struct ALU3dGridCommHelper;
400
401 template< ALU3dGridElementType elType >
402 struct ALU3dGridCommHelper< elType, No_Comm >
403 {
405
406 static bool loadBalance ( Grid &grid ) { return false; }
407
408 template< class DataHandle >
409 static bool loadBalance ( Grid &grid, DataHandle &data ) { return false; }
410
411 template< class DataHandle, class DataType >
412 static void communicate ( const Grid &grid,
413 const CommDataHandleIF< DataHandle, DataType > &data,
414 const InterfaceType iftype,
415 const CommunicationDirection dir,
416 const int level )
417 {}
418
419 template< class DataHandle, class DataType >
420 static void communicate ( const Grid &grid,
421 const CommDataHandleIF< DataHandle, DataType > &data,
422 const InterfaceType iftype,
423 const CommunicationDirection dir )
424 {}
425 }; // ALU3dGridCommHelper
426
427#if ALU3DGRID_PARALLEL
428 template< ALU3dGridElementType elType >
429 struct ALU3dGridCommHelper< elType, MPI_Comm >
430 {
431 typedef ALU3dGrid< elType, MPI_Comm > Grid;
432 typedef ALU3DSPACE GatherScatter GatherScatterType;
433
434 static bool loadBalance ( Grid &grid )
435 {
436 if( grid.comm().size() <= 1 )
437 return false;
438
439 const bool changed = grid.myGrid().duneLoadBalance();
440 if( changed )
441 {
442 // some exchanges on ALUGrid side
443 grid.myGrid().duneExchangeDynamicState();
444
445 // calculate new maxlevel
446 // reset size and things
447 grid.updateStatus();
448
449 // build new Id Set. Only do that after updateStatus, because here
450 // the item lists are needed
451 if( grid.globalIdSet_ )
452 grid.globalIdSet_->updateIdSet();
453
454 // unset all leaf markers
455 grid.postAdapt();
456 }
457
458 return changed;
459 }
460
461
462 template< class DataHandle >
463 static bool loadBalance ( Grid &grid, DataHandle &data )
464 {
465 if( grid.comm().size() <= 1 )
466 return false;
467
468 typedef typename Grid :: EntityObject EntityObject;
469 typedef typename EntityObject::ImplementationType EntityImp;
470 EntityObject en ( EntityImp( grid.factory(), grid.maxLevel()) );
471 EntityObject father ( EntityImp( grid.factory(), grid.maxLevel()) );
472 EntityObject son ( EntityImp( grid.factory(), grid.maxLevel()) );
473
474 typedef ALU3DSPACE LoadBalanceElementCount< Grid, DataHandle > LDBElCountType;
475
476 // elCount is the adaption restPro operator used during the refinement
477 // cause be creating new elements on processors
478 LDBElCountType elCount( grid,
479 father, Grid::getRealImplementation( father ),
480 son, Grid::getRealImplementation( son ),
481 data );
482
483 ALU3DSPACE GatherScatterLoadBalance< Grid, DataHandle, LDBElCountType >
484 gs( grid, en, Grid::getRealImplementation( en ), data, elCount );
485
486 // call load Balance
487 const bool changed = grid.myGrid().duneLoadBalance( gs, elCount );
488
489 if( changed )
490 {
491 // exchange some data for internal useage
492 grid.myGrid().duneExchangeDynamicState();
493
494 // calculate new maxlevel
495 // reset size and things
496 grid.updateStatus();
497
498 // build new Id Set. Only do that after updateStatus, because here
499 // the item lists are needed
500 if( grid.globalIdSet_ )
501 grid.globalIdSet_->updateIdSet();
502
503 // compress data, wrapper for dof manager
504 gs.compress();
505
506 grid.postAdapt();
507 }
508 return changed;
509 }
510
511
512 template< class DataHandle, class DataType >
513 static void communicate ( const Grid &grid,
514 CommDataHandleIF< DataHandle, DataType > &data,
515 const InterfaceType iftype,
516 const CommunicationDirection dir,
517 const int level )
518 {
519 typedef CommDataHandleIF< DataHandle, DataType > DataHandleType;
520 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 3 >::Entity > VertexObject;
521 typedef typename VertexObject::ImplementationType VertexImp;
522 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 2 >::Entity > EdgeObject;
523 typedef typename EdgeObject::ImplementationType EdgeImp;
524 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 1 >::Entity > FaceObject;
525 typedef typename FaceObject::ImplementationType FaceImp;
526 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 0 >::Entity> ElementObject;
527 typedef typename ElementObject::ImplementationType ElementImp;
528
529 if( grid.comm().size() > 1 )
530 {
531 // for level communication the level index set is needed.
532 // if non-existent, then create for communicaton
533 const typename Grid::LevelIndexSetImp *levelISet;
534 if( !grid.levelIndexVec_[ level ] )
535 levelISet = new typename Grid::LevelIndexSetImp(
536 grid,
537 grid.template lbegin<0>( level ),
538 grid.template lend<0>( level ), level );
539 else
540 levelISet = grid.levelIndexVec_[ level ];
541
542 VertexObject vx( VertexImp( grid.factory(), level ) );
543 ALU3DSPACE GatherScatterLevelData< Grid, DataHandleType, 3 >
544 vertexData( grid, vx, Grid::getRealImplementation( vx ), data, *levelISet, level );
545
546 EdgeObject edge( EdgeImp( grid.factory(), level ) );
547 ALU3DSPACE GatherScatterLevelData< Grid, DataHandleType, 2 >
548 edgeData( grid, edge, Grid::getRealImplementation( edge ), data, *levelISet, level );
549
550 FaceObject face( FaceImp( grid.factory(), level ) );
551 ALU3DSPACE GatherScatterLevelData< Grid, DataHandleType, 1 >
552 faceData( grid, face, Grid::getRealImplementation( face ), data, *levelISet, level );
553
554 ElementObject element( ElementImp( grid.factory(), level ) );
555 ALU3DSPACE GatherScatterLevelData< Grid, DataHandleType, 0 >
556 elementData( grid, element, Grid::getRealImplementation( element ), data, *levelISet, level );
557
558 doCommunication( grid, vertexData, edgeData, faceData, elementData, iftype, dir );
559
560 if( !grid.levelIndexVec_[ level ] )
561 delete levelISet;
562 }
563 }
564
565 template< class DataHandle, class DataType >
566 static void communicate ( const Grid &grid,
567 CommDataHandleIF< DataHandle, DataType > &data,
568 const InterfaceType iftype,
569 const CommunicationDirection dir )
570 {
571 typedef CommDataHandleIF< DataHandle, DataType > DataHandleType;
572 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 3 >::Entity > VertexObject;
573 typedef typename VertexObject::ImplementationType VertexImp;
574 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 2 >::Entity > EdgeObject;
575 typedef typename EdgeObject::ImplementationType EdgeImp;
576 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 1 >::Entity > FaceObject;
577 typedef typename FaceObject::ImplementationType FaceImp;
578 typedef MakeableInterfaceObject< typename Grid::Traits::template Codim< 0 >::Entity> ElementObject;
579 typedef typename ElementObject::ImplementationType ElementImp;
580
581 if( grid.comm().size() > 1 )
582 {
583 VertexObject vx( VertexImp( grid.factory(), grid.maxLevel() ) );
584 ALU3DSPACE GatherScatterLeafData< Grid, DataHandleType, 3 >
585 vertexData( grid, vx, Grid::getRealImplementation( vx ), data );
586
587 EdgeObject edge( EdgeImp( grid.factory(), grid.maxLevel() ) );
588 ALU3DSPACE GatherScatterLeafData< Grid, DataHandleType, 2 >
589 edgeData( grid, edge, Grid::getRealImplementation( edge ), data );
590
591 FaceObject face( FaceImp( grid.factory(), grid.maxLevel()) );
592 ALU3DSPACE GatherScatterLeafData< Grid, DataHandleType, 1 >
593 faceData( grid, face, Grid::getRealImplementation( face ), data );
594
595 ElementObject element( ElementImp( grid.factory(), grid.maxLevel() ) );
596 ALU3DSPACE GatherScatterLeafData< Grid, DataHandleType, 0 >
597 elementData( grid, element, Grid::getRealImplementation( element ), data );
598
599 doCommunication( grid, vertexData, edgeData, faceData, elementData, iftype, dir );
600 }
601 }
602
603 static void
604 doCommunication ( const Grid &grid,
605 GatherScatterType &vertexData, GatherScatterType &edgeData,
606 GatherScatterType &faceData, GatherScatterType &elementData,
608 {
609 // check interface types
610 if( (iftype == Overlap_OverlapFront_Interface) || (iftype == Overlap_All_Interface) )
611 {
612 dverb << "ALUGrid contains no overlap, therefore no communication for" << std::endl;
613 dverb << "Overlap_OverlapFront_Interface or Overlap_All_Interface interfaces!" << std::endl;
614 }
615 // communication from border to border
616 else if( iftype == InteriorBorder_InteriorBorder_Interface )
617 grid.myGrid().borderBorderCommunication(vertexData,edgeData,faceData,elementData);
618 // communication from interior to ghost including border
619 else if( iftype == InteriorBorder_All_Interface )
620 {
621 if( dir == ForwardCommunication )
622 grid.myGrid().interiorGhostCommunication(vertexData,edgeData,faceData,elementData);
623 // reverse communiction interface (here All_InteriorBorder)
624 else if( dir == BackwardCommunication )
625 grid.myGrid().ghostInteriorCommunication(vertexData,edgeData,faceData,elementData);
626 }
627 // communication from interior to ghost including border
628 else if( iftype == All_All_Interface )
629 grid.myGrid().allAllCommunication(vertexData,edgeData,faceData,elementData);
630 else
631 DUNE_THROW( GridError, "Wrong set of parameters in ALUGridCommHelper::doCommunication" );
632 }
633 }; // ALU3dGridCommHelper
634#endif // #if ALU3DGRID_PARALLEL
635
636
637
638 template< ALU3dGridElementType elType, class Comm >
640 {
641 return ALU3dGridCommHelper< elType, Comm >::loadBalance( *this );
642 }
643
644
645 // load balance grid
646 template< ALU3dGridElementType elType, class Comm >
647 template< class DataHandle >
648 inline bool ALU3dGrid< elType, Comm >::loadBalance ( DataHandle &data )
649 {
650 return ALU3dGridCommHelper< elType, Comm >::loadBalance( *this, data );
651 }
652
653
654 // communicate level data
655 template< ALU3dGridElementType elType, class Comm >
656 template <class DataHandleImp,class DataType>
659 InterfaceType iftype, CommunicationDirection dir, int level ) const
660 {
661 ALU3dGridCommHelper< elType, Comm >::communicate( *this, data, iftype, dir, level );
662 }
663
664
665 // communicate data
666 template< ALU3dGridElementType elType, class Comm >
667 template <class DataHandleImp, class DataType>
669 communicate (CommDataHandleIF<DataHandleImp,DataType> & data,
670 InterfaceType iftype, CommunicationDirection dir) const
671 {
672 ALU3dGridCommHelper< elType, Comm >::communicate( *this, data, iftype, dir );
673 }
674
675
676 // return Grid name
677 template< ALU3dGridElementType elType, class Comm >
679 {
680 if( elType == hexa )
681 return "ALUCubeGrid";
682 else
683 return "ALUSimplexGrid";
684 }
685
686} // end namespace Dune
Leaf iterator.
Definition: iterator.hh:585
Definition: iterator.hh:504
[ provides Dune::Grid ]
Definition: grid.hh:406
bool mark(int refCount, const typename Traits::template Codim< 0 >::Entity &e)
Marks an entity to be refined/coarsened in a subsequent adapt.
Definition: grid_inline.hh:299
bool adapt()
Refine all positive marked leaf entities, coarsen all negative marked entities if possible.
void communicate(CommDataHandleIF< DataHandleImp, DataTypeImp > &data, InterfaceType iftype, CommunicationDirection dir, int level) const
Communicate information on distributed entities on a given level Template parameter is a model of Dun...
Traits::DuneBoundaryProjectionVector DuneBoundaryProjectionVector
boundary projection type
Definition: grid.hh:496
void checkMacroGridFile(const std::string filename)
check whether macro grid format is of our type
void globalRefine(int refCount)
uses the interface, mark on entity and refineLocal
bool loadBalance()
Calculates load of each process and repartition the grid if neccessary. For parameters of the load ba...
Definition: grid_inline.hh:639
int global_size(int cd) const
number of grid entities on all levels for given codim
Definition: grid_inline.hh:82
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition: grid_inline.hh:314
void calcExtras()
reset size and global size, update Level- and LeafIndexSet, if they exist
static std::string name()
for grid identification
Definition: grid_inline.hh:678
ALU3dGrid(const std::string &macroTriangFilename, const MPICommunicatorType mpiComm, const DuneBoundaryProjectionType *bndPrj, const DuneBoundaryProjectionVector *bndVec, const ALUGridRefinementType refinementType) DUNE_DEPRECATED_MSG("ALUGrid is deprecated
Definition: grid_inline.hh:21
const CollectiveCommunication & comm() const
return const reference to a collective communication object. The return type is a model of Dune::Coll...
Definition: grid.hh:785
void postAdapt()
clear all entity new markers
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lend(int level) const
one past the end on this level
Definition: grid_inline.hh:133
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lbegin(int level) const
Iterator to first entity of given codim on level.
Definition: grid_inline.hh:119
void checkMacroGrid()
check whether macro grid has the right element type
int maxLevel() const
Return maximum level defined in this grid. Levels are numbered maxLevel with 0 the coarsest level.
Definition: grid_inline.hh:100
ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection...
Definition: bndprojection.hh:15
Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface.
Definition: adaptcallback.hh:31
int rank() const
Return rank, is between 0 and size()-1.
Definition: collectivecommunication.hh:82
CommDataHandleIF describes the features of a data handle for communication in parallel runs using the...
Definition: datahandleif.hh:73
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:25
void makeSimplex(unsigned int dim)
Make a simplex of given dimension.
Definition: type.hh:193
void makeCube(unsigned int dim)
Make a hypercube of given dimension.
Definition: type.hh:200
Grid abstract base class.
Definition: grid.hh:388
#define DUNE_THROW(E, m)
Definition: exceptions.hh:243
CommunicationDirection
Define a type for communication direction parameter.
Definition: gridenums.hh:168
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:84
@ BackwardCommunication
reverse communication direction
Definition: gridenums.hh:170
@ ForwardCommunication
communicate as given in InterfaceType
Definition: gridenums.hh:169
@ InteriorBorder_All_Interface
send interior and border, receive all entities
Definition: gridenums.hh:86
@ All_All_Interface
send all and receive all entities
Definition: gridenums.hh:89
@ Overlap_All_Interface
send overlap, receive all entities
Definition: gridenums.hh:88
@ Overlap_OverlapFront_Interface
send overlap, receive overlap and front entities
Definition: gridenums.hh:87
@ InteriorBorder_InteriorBorder_Interface
send/receive interior and border entities
Definition: gridenums.hh:85
DVerbType dverb(std::cout)
Singleton of verbose debug stream.
Definition: stdstreams.hh:114
Dune namespace.
Definition: alignment.hh:10
ALUGridRefinementType
available refinement types for ALUGrid
Definition: declaration.hh:20
Standard Dune debug streams.
Static tag representing a codimension.
Definition: dimension.hh:22
Interface class for vertex projection at the boundary.
Definition: boundaryprojection.hh:24
Definition: grid.hh:1467
Class providing access to the singletons of the reference elements.
Definition: referenceelements.hh:479
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Nov 12, 23:30, 2024)