dune-alugrid  3.0.0
gridfactory.hh
Go to the documentation of this file.
1 #ifndef DUNE_ALU3DGRID_FACTORY_HH
2 #define DUNE_ALU3DGRID_FACTORY_HH
3 
4 #include <array>
5 #include <map>
6 #include <vector>
7 
8 #include <dune/common/shared_ptr.hh>
9 #include <dune/common/parallel/mpihelper.hh>
10 #include <dune/common/version.hh>
11 
12 #include <dune/geometry/referenceelements.hh>
13 
14 #include <dune/grid/common/gridfactory.hh>
15 #include <dune/grid/common/boundaryprojection.hh>
16 
19 
21 
22 namespace Dune
23 {
25  template< class ALUGrid >
26  class ALU3dGridFactory
27  : public GridFactoryInterface< ALUGrid >
28  {
29  typedef ALU3dGridFactory< ALUGrid > ThisType;
30  typedef GridFactoryInterface< ALUGrid > BaseType;
31 
32  public:
33  typedef ALUGrid Grid;
34 
35  typedef typename Grid::ctype ctype;
36 
37  static const ALU3dGridElementType elementType = Grid::elementType;
38 
39  static const unsigned int dimension = Grid::dimension;
40  static const unsigned int dimensionworld = Grid::dimensionworld;
41 
42  typedef typename Grid::MPICommunicatorType MPICommunicatorType;
43 
45  typedef DuneBoundaryProjection< dimensionworld > DuneBoundaryProjectionType;
46 
47  template< int codim >
48  struct Codim
49  {
50  typedef typename Grid::template Codim< codim >::Entity Entity;
51 #if !DUNE_VERSION_NEWER(DUNE_GRID,3,0)
52  typedef typename Grid::template Codim< codim >::EntityPointer EntityPointer;
53 #endif // #if !DUNE_VERSION_NEWER(DUNE_GRID,3,0)
54  };
55 
56  typedef unsigned int VertexId;
57  typedef unsigned int GlobalIdType;
58 
60 
65 
66  private:
67  static_assert ( (elementType == tetra || elementType == hexa),
68  "ALU3dGridFactory supports only grids containing "
69  "tetrahedrons or hexahedrons exclusively." );
70 
71  typedef Dune::BoundarySegmentWrapper< dimension, dimensionworld > BoundarySegmentWrapperType;
72 
73  static const unsigned int numCorners = EntityCount< elementType >::numVertices;
74  static const unsigned int numFaces = EntityCount< elementType >::numFaces;
75  static const unsigned int numFaceCorners = EntityCount< elementType >::numVerticesPerFace;
76 
77  static const unsigned int boundaryId2d = 87;
78 
81 
82  // type of vertex coordinates put into the factory
83  typedef FieldVector< ctype, dimensionworld > VertexInputType;
85 
86  // type of vertex coordinates stored inside the factory
87  typedef FieldVector< ctype, 3 > VertexType;
88 
89  typedef std::vector< unsigned int > ElementType;
90  typedef std::array< unsigned int, numFaceCorners > FaceType;
91 
92  struct FaceLess;
93 
94  typedef std::vector< std::pair< VertexType, GlobalIdType > > VertexVector;
95  typedef std::vector< ElementType > ElementVector;
96  typedef std::pair< FaceType, int > BndPair ;
97  typedef std::map< FaceType, int > BoundaryIdMap;
98  typedef std::vector< std::pair< BndPair, BndPair > > PeriodicBoundaryVector;
99  typedef std::pair< unsigned int, int > SubEntity;
100  typedef std::map< FaceType, SubEntity, FaceLess > FaceMap;
101 
102  typedef std::map< FaceType, const DuneBoundaryProjectionType* > BoundaryProjectionMap;
103  typedef std::vector< const DuneBoundaryProjectionType* > BoundaryProjectionVector;
104 
105  typedef std::vector< Transformation > FaceTransformationVector;
106 
107  static void copy ( const std::initializer_list< unsigned int > &vertices, FaceType &faceId )
108  {
109  std::copy_n( vertices.begin(), faceId.size(), faceId.begin() );
110  }
111 
112  static FaceType makeFace ( const std::vector< unsigned int > &vertices )
113  {
114  if( vertices.size() != (dimension == 2 ? 2 : numFaceCorners) )
115  DUNE_THROW( GridError, "Wrong number of face vertices passed: " << vertices.size() << "." );
116 
117  FaceType faceId;
118  if( dimension == 2 )
119  {
120  if( elementType == tetra )
121  copy( { 0, vertices[ 1 ]+1, vertices[ 0 ]+1 }, faceId );
122  else if( elementType == hexa )
123  copy( { 2*vertices[ 0 ], 2*vertices[ 1 ], 2*vertices[ 0 ]+1, 2*vertices[ 1 ]+1 }, faceId );
124  }
125  else if( dimension == 3 )
126  std::copy_n( vertices.begin(), numFaceCorners, faceId.begin() );
127  return faceId;
128  }
129 
130  static BndPair makeBndPair ( const FaceType &face, int id )
131  {
132  BndPair bndPair;
133  for( unsigned int i = 0; i < numFaceCorners; ++i )
134  {
135  const unsigned int j = FaceTopologyMappingType::dune2aluVertex( i );
136  bndPair.first[ j ] = face[ i ];
137  }
138  bndPair.second = 1;
139  return bndPair;
140  }
141 
142  private:
143  // return grid object
144  virtual Grid* createGridObj( BoundaryProjectionVector* bndProjections, const std::string& name ) const
145  {
146  return new Grid( communicator_, globalProjection_, bndProjections , name, realGrid_ );
147  }
148 
149  protected:
151  explicit ALU3dGridFactory ( const bool verbose, const MPICommunicatorType &communicator );
152 
153  public:
155  explicit ALU3dGridFactory ( const MPICommunicatorType &communicator = Grid::defaultCommunicator(),
156  bool removeGeneratedFile = true );
157 
159  explicit ALU3dGridFactory ( const std::string &filename,
160  const MPICommunicatorType &communicator = Grid::defaultCommunicator() );
161 
163  virtual ~ALU3dGridFactory ();
164 
169  virtual void insertVertex ( const VertexInputType &pos );
170 
176  void insertVertex ( const VertexInputType &pos, const VertexId globalId );
177 
186  virtual void
187  insertElement ( const GeometryType &geometry,
188  const std::vector< VertexId > &vertices );
189 
201  virtual void
202  insertBoundary ( const GeometryType &geometry, const std::vector< VertexId > &faceVertices, int boundaryId = 1 );
203 
204 
212  virtual void insertBoundary ( int element, int face, int boundaryId = 1 );
213 
214  // for testing parallel GridFactory
215  void insertProcessBorder ( int element, int face )
216  {
218  }
219 
228  virtual void
229  insertBoundaryProjection ( const GeometryType &type,
230  const std::vector< VertexId > &vertices,
231  const DuneBoundaryProjectionType *projection );
232 
237  virtual void
238  insertBoundarySegment ( const std::vector< VertexId >& vertices ) ;
239 
240  virtual void
241  insertProcessBorder ( const std::vector< VertexId >& vertices );
242 
248  virtual void
249  insertBoundarySegment ( const std::vector< VertexId >& vertices,
250  const shared_ptr<BoundarySegment<dimension,dimensionworld> >& boundarySegment ) ;
251 
256  virtual void insertBoundaryProjection ( const DuneBoundaryProjectionType& bndProjection );
257 
267  void insertFaceTransformation ( const WorldMatrix &matrix, const WorldVector &shift );
268 
273  Grid *createGrid ();
274 
275  Grid *createGrid ( const bool addMissingBoundaries, const std::string dgfName = "" );
276 
277  Grid *createGrid ( const bool addMissingBoundaries, bool temporary, const std::string dgfName = "" );
278 
279  virtual unsigned int
280  insertionIndex ( const typename Codim< 0 >::Entity &entity ) const
281  {
282  alugrid_assert( Grid::getRealImplementation( entity ).getIndex() < int(ordering_.size()) );
283  return ordering_[ Grid::getRealImplementation( entity ).getIndex() ];
284  }
285 
286  virtual unsigned int
287  insertionIndex ( const typename Codim< dimension >::Entity &entity ) const
288  {
289  if(dimension == 2 && elementType == hexa )
290  // for quadrilaterals we simply half the number, see gridfactory.cc doInsertVertex
291  return Grid::getRealImplementation( entity ).getIndex()/2;
292  else if ( dimension == 2 && elementType == tetra )
293  // for triangles we have to substract 1, see gridfactory.cc doInsertVertex
294  return Grid::getRealImplementation( entity ).getIndex() - 1;
295  else // dimension 3
296  return Grid::getRealImplementation( entity ).getIndex();
297  }
298 
299  virtual unsigned int
300  insertionIndex ( const typename Grid::LeafIntersection &intersection ) const
301  {
302  std::vector< unsigned int > vertices;
303 #if DUNE_VERSION_NEWER(DUNE_GRID,2,4)
304  const typename Codim< 0 >::Entity& in = intersection.inside();
305 #else
306  const typename Codim< 0 >::EntityPointer inPtr = intersection.inside();
307  const typename Codim< 0 >::Entity &in = *inPtr;
308 #endif
309 
310  const Dune::ReferenceElement< double, dimension > &refElem =
311  Dune::ReferenceElements< double, dimension >::general( in.type() );
312  int faceNr = intersection.indexInInside();
313  const int vxSize = refElem.size( faceNr, 1, dimension );
314  for (int i=0;i<vxSize;++i)
315  {
316  int vxIdx = refElem.subEntity( faceNr, 1 , i , dimension);
317 #if DUNE_VERSION_NEWER(DUNE_GRID,2,4)
318  vertices.push_back( insertionIndex( in.template subEntity<dimension>(vxIdx) ) );
319 #else
320  vertices.push_back( insertionIndex( *(in.template subEntity<dimension>(vxIdx) ) ) );
321 #endif
322  }
323 
324  FaceType faceId = makeFace( vertices );
325  std::sort( faceId.begin(), faceId.end() );
326 
327  typename BoundaryIdMap::const_iterator pos = insertionOrder_.find( faceId );
328  if( pos != insertionOrder_.end() )
329  return pos->second;
330  else
331  return std::numeric_limits<unsigned int>::max();
332  }
333 
334  virtual bool
335  wasInserted ( const typename Grid::LeafIntersection &intersection ) const
336  {
337  return intersection.boundary() &&
338  (insertionIndex(intersection) < std::numeric_limits<unsigned int>::max());
339  }
340 
341  const std::vector<unsigned int>& ordering () const { return ordering_; }
342 
343  private:
344  void doInsertVertex ( const VertexInputType &pos, const GlobalIdType globalId );
345  void doInsertBoundary ( int element, int face, int boundaryId );
346 
347  GlobalIdType globalId ( const VertexId &id ) const
348  {
349  alugrid_assert ( id < vertices_.size() );
350  return vertices_[ id ].second;
351  }
352 
353  const VertexType &position ( const VertexId &id ) const
354  {
355  alugrid_assert ( id < vertices_.size() );
356  return vertices_[ id ].first;
357  }
358 
359  const VertexInputType inputPosition ( const VertexId &id ) const
360  {
361  alugrid_assert ( id < vertices_.size() );
362  VertexType vertex = vertices_[ id ].first;
363  VertexInputType iVtx(0.);
364  for(unsigned i = 0 ; i < dimensionworld ; ++i)
365  iVtx[i] = vertex[i];
366  return iVtx;
367  }
368 
369  void assertGeometryType( const GeometryType &geometry );
370  static void generateFace ( const ElementType &element, const int f, FaceType &face );
371  void generateFace ( const SubEntity &subEntity, FaceType &face ) const;
372  void correctElementOrientation ();
373  bool identifyFaces ( const Transformation &transformation, const FaceType &key1, const FaceType &key2, const int defaultId );
374  void searchPeriodicNeighbor ( FaceMap &faceMap, const typename FaceMap::iterator &pos, const int defaultId );
375  void reinsertBoundary ( const FaceMap &faceMap, const typename FaceMap::const_iterator &pos, const int id );
376  void recreateBoundaryIds ( const int defaultId = 1 );
377 
378  // sort elements according to hilbert space filling curve (if Zoltan is available)
379  void sortElements( const VertexVector& vertices, const ElementVector& elements, std::vector< unsigned int >& ordering );
380 
381  int rank_;
382 
383  VertexVector vertices_;
384  ElementVector elements_;
385  BoundaryIdMap boundaryIds_,insertionOrder_;
386  PeriodicBoundaryVector periodicBoundaries_;
387  const DuneBoundaryProjectionType* globalProjection_ ;
388  BoundaryProjectionMap boundaryProjections_;
389  FaceTransformationVector faceTransformations_;
390  unsigned int numFacesInserted_;
391  bool realGrid_;
392  const bool allowGridGeneration_;
393  bool foundGlobalIndex_ ;
394 
395  MPICommunicatorType communicator_;
396 
397  typename SpaceFillingCurveOrderingType :: CurveType curveType_;
398  std::vector< unsigned int > ordering_;
399  };
400 
401 
402 
403  template< class ALUGrid >
405  : public std::binary_function< FaceType, FaceType, bool >
406  {
407  bool operator() ( const FaceType &a, const FaceType &b ) const
408  {
409  for( unsigned int i = 0; i < numFaceCorners; ++i )
410  {
411  if( a[ i ] != b[ i ] )
412  return (a[ i ] < b[ i ]);
413  }
414  return false;
415  }
416  };
417 
418 
419  template< class ALUGrid >
420  inline void ALU3dGridFactory< ALUGrid >
421  ::assertGeometryType( const GeometryType &geometry )
422  {
423  if( elementType == tetra )
424  {
425  if( !geometry.isSimplex() )
426  DUNE_THROW( GridError, "Only simplex geometries can be inserted into "
427  "ALUGrid< 3, 3, simplex, refrule >." );
428  }
429  else
430  {
431  if( !geometry.isCube() )
432  DUNE_THROW( GridError, "Only cube geometries can be inserted into "
433  "ALUGrid< 3, 3, cube, refrule >." );
434  }
435  }
436 
440  template<int dim, int dimw, ALUGridElementType eltype, ALUGridRefinementType refinementtype , class Comm >
441  class GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
442  : public ALU3dGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
443  {
444  typedef GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > > ThisType;
446 
447  public:
448  typedef typename BaseType::Grid Grid;
449 
451 
453  explicit GridFactory ( const MPICommunicatorType &communicator = Grid::defaultCommunicator() )
454  : BaseType( communicator )
455  {}
456 
458  explicit GridFactory ( const std::string &filename,
459  const MPICommunicatorType &communicator = Grid::defaultCommunicator() )
460  : BaseType( filename, communicator )
461  {}
462  };
463 
464  template< class Grid >
466 
467  // Specialization of the ReferenceGridFactory for ALUGrid
468  template<int dim, int dimw, ALUGridElementType eltype, ALUGridRefinementType refinementtype , class Comm >
469  class ReferenceGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
470  : public ALU3dGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
471  {
474 
475  public:
476  typedef typename BaseType::Grid Grid;
477 
479 
482  : BaseType(false, Grid::defaultCommunicator() )
483  {}
484  };
485 
486 
487 
488  // Implementation of ALU3dGridFactory
489  // ----------------------------------
490 
491  template< class ALUGrid >
492  inline
495  bool removeGeneratedFile )
496  : rank_( ALU3dGridCommunications< ALUGrid::dimension, ALUGrid::dimensionworld, elementType, MPICommunicatorType >::getRank( communicator ) ),
497  globalProjection_ ( 0 ),
498  numFacesInserted_ ( 0 ),
499  realGrid_( true ),
500  allowGridGeneration_( rank_ == 0 ),
501  foundGlobalIndex_( false ),
502  communicator_( communicator ),
503  curveType_( SpaceFillingCurveOrderingType :: DefaultCurve )
504  {}
505 
506  template< class ALUGrid >
507  inline
509  :: ALU3dGridFactory ( const std::string &filename,
510  const MPICommunicatorType &communicator )
511  : rank_( ALU3dGridCommunications< ALUGrid::dimension, ALUGrid::dimensionworld, elementType, MPICommunicatorType >::getRank( communicator ) ),
512  globalProjection_ ( 0 ),
513  numFacesInserted_ ( 0 ),
514  realGrid_( true ),
515  allowGridGeneration_( rank_ == 0 ),
516  foundGlobalIndex_( false ),
517  communicator_( communicator ),
518  curveType_( SpaceFillingCurveOrderingType :: DefaultCurve )
519  {}
520 
521  template< class ALUGrid >
522  inline
524  :: ALU3dGridFactory ( const bool realGrid,
525  const MPICommunicatorType &communicator )
526  : rank_( ALU3dGridCommunications< ALUGrid::dimension, ALUGrid::dimensionworld, elementType, MPICommunicatorType >::getRank( communicator ) ),
527  globalProjection_ ( 0 ),
528  numFacesInserted_ ( 0 ),
529  realGrid_( realGrid ),
530  allowGridGeneration_( true ),
531  foundGlobalIndex_( false ),
532  communicator_( communicator ),
533  curveType_( SpaceFillingCurveOrderingType :: DefaultCurve )
534  {}
535 
536  template< class ALUGrid >
538  insertBoundarySegment ( const std::vector< unsigned int >& vertices )
539  {
540  FaceType faceId = makeFace( vertices );
541 
542  boundaryIds_.insert( makeBndPair( faceId, 1 ) );
543 
544  std::sort( faceId.begin(), faceId.end() );
545  if( boundaryProjections_.find( faceId ) != boundaryProjections_.end() )
546  DUNE_THROW( GridError, "Only one boundary projection can be attached to a face." );
547 
548  boundaryProjections_[ faceId ] = nullptr;
549 
550  insertionOrder_.insert( std::make_pair( faceId, insertionOrder_.size() ) );
551  }
552 
553  template< class ALUGrid >
555  insertProcessBorder ( const std::vector< unsigned int >& vertices )
556  {
557  FaceType faceId = makeFace( vertices );
558 
559  boundaryIds_.insert( makeBndPair( faceId, ALU3DSPACE ProcessorBoundary_t ) );
560 
561  std::sort( faceId.begin(), faceId.end() );
562  boundaryProjections_[ faceId ] = nullptr;
563  }
564 
565  template< class ALUGrid >
567  insertBoundarySegment ( const std::vector< unsigned int >& vertices,
568  const shared_ptr<BoundarySegment<dimension,dimensionworld> >& boundarySegment )
569  {
570  FaceType faceId = makeFace( vertices );
571 
572  const size_t numVx = vertices.size();
573  GeometryType type;
574  if( elementType == tetra )
575  type.makeSimplex( dimension-1 );
576  else
577  type.makeCube( dimension-1 );
578 
579  // we need double here because of the structure of BoundarySegment
580  // and BoundarySegmentWrapper which have double as coordinate type
581  typedef FieldVector< double, dimensionworld > CoordType;
582  std::vector< CoordType > coords( numVx );
583  for( size_t i = 0; i < numVx; ++i )
584  {
585  // if this assertions is thrown vertices were not inserted at first
586  alugrid_assert ( vertices_.size() > vertices[ i ] );
587 
588  // get global coordinate and copy it
589  const VertexType &x = position( vertices[ i ] );
590  for( unsigned int j = 0; j < dimensionworld; ++j )
591  coords[ i ][ j ] = x[ j ];
592  }
593 
594  boundaryIds_.insert( makeBndPair( faceId, 1 ) );
595 
596  std::sort( faceId.begin(), faceId.end() );
597  if( boundaryProjections_.find( faceId ) != boundaryProjections_.end() )
598  DUNE_THROW( GridError, "Only one boundary projection can be attached to a face." );
599 
600  BoundarySegmentWrapperType* prj
601  = new BoundarySegmentWrapperType( type, coords, boundarySegment );
602  boundaryProjections_[ faceId ] = prj;
603 #ifdef ALUGRIDDEBUG
604  // consistency check
605  for( size_t i = 0; i < numVx; ++i )
606  {
607  CoordType global = (*prj)( coords [ i ] );
608  if( (global - coords[ i ]).two_norm() > 1e-6 )
609  DUNE_THROW(GridError,"BoundarySegment does not map face vertices to face vertices.");
610  }
611 #endif
612 
613  insertionOrder_.insert( std::make_pair( faceId, insertionOrder_.size() ) );
614  }
615 
616 
617  template< class ALUGrid >
618  inline void ALU3dGridFactory< ALUGrid >
619  ::generateFace ( const SubEntity &subEntity, FaceType &face ) const
620  {
621  generateFace( elements_[ subEntity.first ], subEntity.second, face );
622  }
623 
624 } // end namespace Dune
625 
626 #if COMPILE_ALUGRID_INLINE
627  #include "gridfactory.cc"
628 #endif
629 #endif
Dune::ALUGrid::ctype
BaseType::ctype ctype
Definition: alugrid.hh:48
Dune::ALU3dGridFactory::insertVertex
virtual void insertVertex(const VertexInputType &pos)
insert a vertex into the coarse grid
Definition: gridfactory.cc:38
Dune::ALU3dGridFactory::insertBoundarySegment
virtual void insertBoundarySegment(const std::vector< VertexId > &vertices)
insert a boundary segment into the macro grid
Definition: gridfactory.hh:538
Dune::ReferenceGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
Definition: gridfactory.hh:469
Dune::hexa
Definition: topology.hh:12
Dune::ALUGridTransformation
Definition: transformation.hh:11
Dune::ElementTopologyMapping
Definition: topology.hh:39
Dune::EntityCount
Definition: topology.hh:15
hsfc.hh
Dune::ALU3dGridFactory::ctype
Grid::ctype ctype
Definition: gridfactory.hh:35
Dune::ALU3dGridFactory::Transformation
ALUGridTransformation< ctype, dimensionworld > Transformation
Definition: gridfactory.hh:59
Dune::ALUGridTransformation::WorldMatrix
FieldMatrix< ctype, dimension, dimension > WorldMatrix
Definition: transformation.hh:16
gridfactory.cc
Dune::tetra
Definition: topology.hh:12
Dune::ALU3dGridFactory::ordering
const std::vector< unsigned int > & ordering() const
Definition: gridfactory.hh:341
Dune::ALU3dGridFactory::insertFaceTransformation
void insertFaceTransformation(const WorldMatrix &matrix, const WorldVector &shift)
add a face transformation (for periodic identification)
Definition: gridfactory.cc:233
Dune::ALU3dGridFactory::Grid
ALUGrid Grid
Definition: gridfactory.hh:33
Dune::ALU3dGridFactory::FaceLess
Definition: gridfactory.hh:404
Dune::ReferenceGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::MPICommunicatorType
BaseType::MPICommunicatorType MPICommunicatorType
Definition: gridfactory.hh:478
Dune::ALU3dGridFactory::elementType
static const ALU3dGridElementType elementType
Definition: gridfactory.hh:37
Dune::ALU3dGridFactory::insertionIndex
virtual unsigned int insertionIndex(const typename Codim< dimension >::Entity &entity) const
Definition: gridfactory.hh:287
Dune::ALU3dGridFactory::ALU3dGridFactory
ALU3dGridFactory(const bool verbose, const MPICommunicatorType &communicator)
constructor taking verbose flag
Definition: gridfactory.hh:524
alugrid.hh
Provides base classes for ALUGrid.
Dune::ALU3dGridFactory::VertexId
unsigned int VertexId
Definition: gridfactory.hh:56
Dune::ALU3dGridFactory::insertElement
virtual void insertElement(const GeometryType &geometry, const std::vector< VertexId > &vertices)
insert an element into the coarse grid
Definition: gridfactory.cc:102
Dune::ALU3dGridFactory::MPICommunicatorType
Grid::MPICommunicatorType MPICommunicatorType
Definition: gridfactory.hh:42
Dune::ALU3dGridFactory::DuneBoundaryProjectionType
DuneBoundaryProjection< dimensionworld > DuneBoundaryProjectionType
type of boundary projection class
Definition: gridfactory.hh:45
Dune::ALU3dGridFactory::GlobalIdType
unsigned int GlobalIdType
Definition: gridfactory.hh:57
Dune::ALU3dGridFactory::dimensionworld
static const unsigned int dimensionworld
Definition: gridfactory.hh:40
transformation.hh
Dune::GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::Grid
BaseType::Grid Grid
Definition: gridfactory.hh:448
Dune::SpaceFillingCurveOrdering::CurveType
CurveType
Definition: hsfc.hh:174
Dune::ALUGrid::dimension
Definition: alugrid.hh:47
Dune::ALU3dGridFactory::WorldMatrix
Transformation::WorldMatrix WorldMatrix
type of matrix from world coordinates to world coordinates
Definition: gridfactory.hh:64
Dune::ALU3dGridFactory::Codim::EntityPointer
Grid::template Codim< codim >::EntityPointer EntityPointer
Definition: gridfactory.hh:52
Dune::ALU3dGridFactory::Codim::Entity
Grid::template Codim< codim >::Entity Entity
Definition: gridfactory.hh:50
Dune::ALU3dGridFactory::insertionIndex
virtual unsigned int insertionIndex(const typename Grid::LeafIntersection &intersection) const
Definition: gridfactory.hh:300
Dune::ALU3dGridCommunications
Definition: 3d/grid.hh:137
alugrid_assert
#define alugrid_assert(EX)
Definition: alugrid_assert.hh:20
Dune::ALU3dGridFactory::dimension
static const unsigned int dimension
Definition: gridfactory.hh:39
Dune::ALU3dGridFactory::insertProcessBorder
void insertProcessBorder(int element, int face)
Definition: gridfactory.hh:215
Dune::GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::GridFactory
GridFactory(const MPICommunicatorType &communicator=Grid::defaultCommunicator())
Default constructor.
Definition: gridfactory.hh:453
Dune::ALUGridTransformation::WorldVector
FieldVector< ctype, dimension > WorldVector
Definition: transformation.hh:15
Dune::ReferenceGridFactory
Definition: gridfactory.hh:465
Dune::ALUGrid::dimensionworld
Definition: alugrid.hh:47
Dune::ALU3dGridFactory::WorldVector
Transformation::WorldVector WorldVector
type of vector for world coordinates
Definition: gridfactory.hh:62
Dune::ALU3dGridFactory::Codim
Definition: gridfactory.hh:48
Dune::ALU3dGridFactory
Factory class for ALUGrids.
Definition: 3d/grid.hh:84
Dune::SpaceFillingCurveOrdering
Definition: hsfc.hh:165
Dune::ALU3dGridFactory::insertBoundary
virtual void insertBoundary(const GeometryType &geometry, const std::vector< VertexId > &faceVertices, int boundaryId=1)
insert a boundary element into the coarse grid
Definition: gridfactory.cc:151
Dune::FaceTopologyMapping
Definition: topology.hh:151
ALU3DSPACE
#define ALU3DSPACE
Definition: alu3dinclude.hh:24
ALUGrid::ProcessorBoundary_t
static const int ProcessorBoundary_t
Definition: alu3dinclude.hh:54
Dune::FaceTopologyMapping::dune2aluVertex
static int dune2aluVertex(int index)
Maps vertex index from Dune onto ALU3dGrid reference face.
Definition: topology.hh:310
Dune::GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::MPICommunicatorType
BaseType::MPICommunicatorType MPICommunicatorType
Definition: gridfactory.hh:450
Dune::ReferenceGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::Grid
BaseType::Grid Grid
Definition: gridfactory.hh:476
ALUGrid
Definition: alu3dinclude.hh:49
Dune::ALUGrid
unstructured parallel implementation of the DUNE grid interface
Definition: alugrid.hh:29
Dune::ALU3dGridElementType
ALU3dGridElementType
Definition: topology.hh:12
Dune::GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >
Specialization of the generic GridFactory for ALUGrid.
Definition: gridfactory.hh:441
Dune::ALU3dGridFactory::~ALU3dGridFactory
virtual ~ALU3dGridFactory()
Destructor.
Definition: gridfactory.cc:32
Dune::ALU3dGridFactory::createGrid
Grid * createGrid()
finalize the grid creation and hand over the grid
Definition: gridfactory.cc:332
Dune::ALU3dGridFactory::insertBoundaryProjection
virtual void insertBoundaryProjection(const GeometryType &type, const std::vector< VertexId > &vertices, const DuneBoundaryProjectionType *projection)
insert a boundary projection into the macro grid
Definition: gridfactory.cc:213
Dune::GridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::GridFactory
GridFactory(const std::string &filename, const MPICommunicatorType &communicator=Grid::defaultCommunicator())
constructor taking filename
Definition: gridfactory.hh:458
Dune::ALU3dGridFactory::wasInserted
virtual bool wasInserted(const typename Grid::LeafIntersection &intersection) const
Definition: gridfactory.hh:335
Dune
Definition: alu3dinclude.hh:79
Dune::ReferenceGridFactory< ALUGrid< dim, dimw, eltype, refinementtype, Comm > >::ReferenceGridFactory
ReferenceGridFactory()
Default constructor.
Definition: gridfactory.hh:481
Dune::ALU3dGridFactory::insertionIndex
virtual unsigned int insertionIndex(const typename Codim< 0 >::Entity &entity) const
Definition: gridfactory.hh:280