Dune Core Modules (2.4.2)

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 
13 namespace 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::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::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::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::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::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.80.0 (May 16, 22:29, 2024)