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
22namespace Dune
23{
25 template< class ALUGrid >
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
79 typedef ElementTopologyMapping< elementType > ElementTopologyMappingType;
80 typedef FaceTopologyMapping< elementType > FaceTopologyMappingType;
81
82 // type of vertex coordinates put into the factory
83 typedef FieldVector< ctype, dimensionworld > VertexInputType;
84 typedef SpaceFillingCurveOrdering< VertexInputType > SpaceFillingCurveOrderingType;
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 {
217 insertBoundary( element, face, ALU3DSPACE ProcessorBoundary_t );
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 >
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
493 ALU3dGridFactory< ALUGrid >
494 :: ALU3dGridFactory ( const MPICommunicatorType &communicator,
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 >
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
#define alugrid_assert(EX)
Definition alugrid_assert.hh:20
#define ALU3DSPACE
Definition alu3dinclude.hh:24
Provides base classes for ALUGrid.
Definition alu3dinclude.hh:50
Definition alu3dinclude.hh:80
ALU3dGridElementType
Definition topology.hh:12
@ hexa
Definition topology.hh:12
@ tetra
Definition topology.hh:12
BaseType::ctype ctype
Definition alugrid.hh:48
@ dimension
Definition alugrid.hh:47
@ dimensionworld
Definition alugrid.hh:47
Factory class for ALUGrids.
Definition gridfactory.hh:28
unsigned int VertexId
Definition gridfactory.hh:56
static const unsigned int dimensionworld
Definition gridfactory.hh:40
virtual void insertVertex(const VertexInputType &pos)
insert a vertex into the coarse grid
Definition gridfactory.cc:38
Grid::MPICommunicatorType MPICommunicatorType
Definition gridfactory.hh:42
virtual unsigned int insertionIndex(const typename Codim< 0 >::Entity &entity) const
Definition gridfactory.hh:280
virtual bool wasInserted(const typename Grid::LeafIntersection &intersection) const
Definition gridfactory.hh:335
virtual void insertBoundarySegment(const std::vector< VertexId > &vertices, const shared_ptr< BoundarySegment< dimension, dimensionworld > > &boundarySegment)
insert a shaped boundary segment into the macro grid
Definition gridfactory.hh:567
void insertFaceTransformation(const WorldMatrix &matrix, const WorldVector &shift)
add a face transformation (for periodic identification)
Definition gridfactory.cc:233
virtual unsigned int insertionIndex(const typename Codim< dimension >::Entity &entity) const
Definition gridfactory.hh:287
ALU3dGridFactory(const MPICommunicatorType &communicator=Grid::defaultCommunicator(), bool removeGeneratedFile=true)
default constructor
Definition gridfactory.hh:494
ALUGrid Grid
Definition gridfactory.hh:33
const std::vector< unsigned int > & ordering() const
Definition gridfactory.hh:341
Transformation::WorldMatrix WorldMatrix
type of matrix from world coordinates to world coordinates
Definition gridfactory.hh:64
virtual void insertBoundarySegment(const std::vector< VertexId > &vertices)
insert a boundary segment into the macro grid
Definition gridfactory.hh:538
ALUGridTransformation< ctype, dimensionworld > Transformation
Definition gridfactory.hh:59
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
void insertProcessBorder(int element, int face)
Definition gridfactory.hh:215
DuneBoundaryProjection< dimensionworld > DuneBoundaryProjectionType
type of boundary projection class
Definition gridfactory.hh:45
Transformation::WorldVector WorldVector
type of vector for world coordinates
Definition gridfactory.hh:62
virtual void insertProcessBorder(const std::vector< VertexId > &vertices)
Definition gridfactory.hh:555
ALU3dGridFactory(const std::string &filename, const MPICommunicatorType &communicator=Grid::defaultCommunicator())
constructor taking filename for temporary outfile
Definition gridfactory.hh:509
static const unsigned int dimension
Definition gridfactory.hh:39
virtual void insertElement(const GeometryType &geometry, const std::vector< VertexId > &vertices)
insert an element into the coarse grid
Definition gridfactory.cc:102
Grid * createGrid()
finalize the grid creation and hand over the grid
Definition gridfactory.cc:332
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
unsigned int GlobalIdType
Definition gridfactory.hh:57
virtual ~ALU3dGridFactory()
Destructor.
Definition gridfactory.cc:32
Grid::ctype ctype
Definition gridfactory.hh:35
ALU3dGridFactory(const bool verbose, const MPICommunicatorType &communicator)
constructor taking verbose flag
Definition gridfactory.hh:524
static const ALU3dGridElementType elementType
Definition gridfactory.hh:37
virtual unsigned int insertionIndex(const typename Grid::LeafIntersection &intersection) const
Definition gridfactory.hh:300
Definition 3d/grid.hh:137
Definition gridfactory.hh:49
Grid::template Codim< codim >::EntityPointer EntityPointer
Definition gridfactory.hh:52
Grid::template Codim< codim >::Entity Entity
Definition gridfactory.hh:50
Definition gridfactory.hh:406
Specialization of the generic GridFactory for ALUGrid.
Definition gridfactory.hh:443
GridFactory(const MPICommunicatorType &communicator=Grid::defaultCommunicator())
Default constructor.
Definition gridfactory.hh:453
GridFactory(const std::string &filename, const MPICommunicatorType &communicator=Grid::defaultCommunicator())
constructor taking filename
Definition gridfactory.hh:458
BaseType::MPICommunicatorType MPICommunicatorType
Definition gridfactory.hh:450
Definition gridfactory.hh:465
BaseType::MPICommunicatorType MPICommunicatorType
Definition gridfactory.hh:478
ReferenceGridFactory()
Default constructor.
Definition gridfactory.hh:481
Definition topology.hh:15
Definition topology.hh:40
Definition topology.hh:151
Definition hsfc.hh:166
Definition transformation.hh:12
FieldMatrix< ctype, dimension, dimension > WorldMatrix
Definition transformation.hh:16
FieldVector< ctype, dimension > WorldVector
Definition transformation.hh:15