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
4#include <dune/common/stdstreams.hh>
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 >
20 inline ALU3dGrid< elType, 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;
74 checkMacroGrid ();
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 >
100 inline int ALU3dGrid< elType, Comm >::maxLevel () const
101 {
102 return maxlevel_;
103 }
104
105
106 template< ALU3dGridElementType elType, class Comm >
107 inline typename ALU3dGrid< elType, Comm >::GitterImplType &
108 ALU3dGrid< elType, Comm >::myGrid () const
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
119 ALU3dGrid< elType, Comm >::lbegin ( int level ) const
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
133 ALU3dGrid< elType, Comm >::lend ( int level ) const
134 {
135 assert( level >= 0 );
136 return ALU3dGridLevelIterator< cd, pitype, const ThisType >( factory(), level );
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
144 ALU3dGrid< elType, Comm >::lbegin ( int level ) const
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
153 ALU3dGrid< elType, Comm >::lend ( int level ) const
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
168 ALU3dGrid< elType, Comm >::createLeafIteratorBegin ( int level ) const
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 >
313 inline int ALU3dGrid< elType, 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
324 void ALU3dGrid< elType, Comm >
325 ::globalRefine ( int refCount, AdaptDataHandleInterface< GridImp, DataHandle > &handle )
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
344 bool ALU3dGrid< elType, Comm >
345 ::adapt ( AdaptDataHandleInterface< GridImp, DataHandle > &handle )
346 {
347 typedef AdaptDataHandleInterface< GridImp, DataHandle > AdaptDataHandle;
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 {
404 typedef ALU3dGrid< elType, No_Comm > Grid;
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,
607 InterfaceType iftype, CommunicationDirection dir )
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 >
639 inline bool ALU3dGrid< elType, Comm >::loadBalance ()
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>
657 inline void ALU3dGrid< elType, Comm >::
658 communicate (CommDataHandleIF<DataHandleImp,DataType> &data,
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>
668 inline void ALU3dGrid< elType, Comm >::
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 >
678 inline std::string ALU3dGrid< elType, Comm >::name ()
679 {
680 if( elType == hexa )
681 return "ALUCubeGrid";
682 else
683 return "ALUSimplexGrid";
684 }
685
686} // end namespace Dune
Dune::ALU3dGridLeafIterator
Leaf iterator.
Definition: iterator.hh:585
Dune::ALU3dGridLevelIterator
Definition: iterator.hh:504
Dune::ALU3dGrid
[ provides Dune::Grid ]
Definition: grid.hh:406
Dune::ALU3dGrid::mark
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
Dune::ALU3dGrid::adapt
bool adapt()
Refine all positive marked leaf entities, coarsen all negative marked entities if possible.
Dune::ALU3dGrid::communicate
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...
Dune::ALU3dGrid::DuneBoundaryProjectionVector
Traits::DuneBoundaryProjectionVector DuneBoundaryProjectionVector
boundary projection type
Definition: grid.hh:496
Dune::ALU3dGrid::checkMacroGridFile
void checkMacroGridFile(const std::string filename)
check whether macro grid format is of our type
Dune::ALU3dGrid::globalRefine
void globalRefine(int refCount)
uses the interface, mark on entity and refineLocal
Dune::ALU3dGrid::loadBalance
bool loadBalance()
Calculates load of each process and repartition the grid if neccessary. For parameters of the load ba...
Definition: grid_inline.hh:639
Dune::ALU3dGrid::global_size
int global_size(int cd) const
number of grid entities on all levels for given codim
Definition: grid_inline.hh:82
Dune::ALU3dGrid::getMark
int getMark(const typename Traits::template Codim< 0 >::Entity &e) const
returns adaptation mark for given entity
Definition: grid_inline.hh:314
Dune::ALU3dGrid::calcExtras
void calcExtras()
reset size and global size, update Level- and LeafIndexSet, if they exist
Dune::ALU3dGrid::name
static std::string name()
for grid identification
Definition: grid_inline.hh:678
Dune::ALU3dGrid::ALU3dGrid
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
Dune::ALU3dGrid::comm
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
Dune::ALU3dGrid::postAdapt
void postAdapt()
clear all entity new markers
Dune::ALU3dGrid::lend
Traits::template Codim< cd >::template Partition< pitype >::LevelIterator lend(int level) const
one past the end on this level
Definition: grid_inline.hh:133
Dune::ALU3dGrid::lbegin
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
Dune::ALU3dGrid::checkMacroGrid
void checkMacroGrid()
check whether macro grid has the right element type
Dune::ALU3dGrid::maxLevel
int maxLevel() const
Return maximum level defined in this grid. Levels are numbered maxLevel with 0 the coarsest level.
Definition: grid_inline.hh:100
Dune::ALUGridBoundaryProjection
ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection...
Definition: bndprojection.hh:15
Dune::AdaptDataHandleInterface
Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface.
Definition: adaptcallback.hh:31
Dune::CollectiveCommunication::rank
int rank() const
Return rank, is between 0 and size()-1.
Definition: collectivecommunication.hh:82
Dune::CommDataHandleIF
CommDataHandleIF describes the features of a data handle for communication in parallel runs using the...
Definition: datahandleif.hh:73
Dune::GeometryType
Unique label for each type of entities that can occur in DUNE grids.
Definition: type.hh:25
Dune::GeometryType::makeSimplex
void makeSimplex(unsigned int dim)
Make a simplex of given dimension.
Definition: type.hh:193
Dune::GeometryType::makeCube
void makeCube(unsigned int dim)
Make a hypercube of given dimension.
Definition: type.hh:200
Dune::Grid
Grid abstract base class.
Definition: grid.hh:388
DUNE_THROW
#define DUNE_THROW(E, m)
Definition: exceptions.hh:243
Dune::CommunicationDirection
CommunicationDirection
Define a type for communication direction parameter.
Definition: gridenums.hh:168
Dune::InterfaceType
InterfaceType
Parameter to be used for the communication functions.
Definition: gridenums.hh:84
Dune::BackwardCommunication
@ BackwardCommunication
reverse communication direction
Definition: gridenums.hh:170
Dune::ForwardCommunication
@ ForwardCommunication
communicate as given in InterfaceType
Definition: gridenums.hh:169
Dune::InteriorBorder_All_Interface
@ InteriorBorder_All_Interface
send interior and border, receive all entities
Definition: gridenums.hh:86
Dune::All_All_Interface
@ All_All_Interface
send all and receive all entities
Definition: gridenums.hh:89
Dune::Overlap_All_Interface
@ Overlap_All_Interface
send overlap, receive all entities
Definition: gridenums.hh:88
Dune::Overlap_OverlapFront_Interface
@ Overlap_OverlapFront_Interface
send overlap, receive overlap and front entities
Definition: gridenums.hh:87
Dune::InteriorBorder_InteriorBorder_Interface
@ InteriorBorder_InteriorBorder_Interface
send/receive interior and border entities
Definition: gridenums.hh:85
Dune::dverb
DVerbType dverb(std::cout)
Singleton of verbose debug stream.
Definition: stdstreams.hh:114
Dune
Dune namespace.
Definition: alignment.hh:10
Dune::ALUGridRefinementType
ALUGridRefinementType
available refinement types for ALUGrid
Definition: declaration.hh:20
stdstreams.hh
Standard Dune debug streams.
Dune::Codim
Static tag representing a codimension.
Definition: dimension.hh:22
Dune::DuneBoundaryProjection
Interface class for vertex projection at the boundary.
Definition: boundaryprojection.hh:24
Dune::MakeableInterfaceObject
Definition: grid.hh:1467
Dune::ReferenceElements
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 (Dec 22, 23:30, 2024)