dune-grid  2.4.1
Public Member Functions | Protected Types | Static Protected Attributes | List of all members
Dune::GridFactory< UGGrid< dimworld > > Class Template Referenceabstract

Specialization of the generic GridFactory for UGGrid. More...

#include <dune/grid/uggrid/uggridfactory.hh>

Inheritance diagram for Dune::GridFactory< UGGrid< dimworld > >:
Inheritance graph

Public Member Functions

virtual void insertVertex (const FieldVector< ctype, dimworld > &pos)=0
 Insert a vertex into the coarse grid. More...
 
virtual void insertElement (const GeometryType &type, const std::vector< unsigned int > &vertices)=0
 Insert an element into the coarse grid. More...
 
virtual void insertElement (const GeometryType &type, const std::vector< unsigned int > &vertices, const shared_ptr< VirtualFunction< FieldVector< ctype, dimension >, FieldVector< ctype, dimworld > > > &elementParametrization)
 Insert a parametrized element into the coarse grid. More...
 
virtual void insertBoundarySegment (const std::vector< unsigned int > &vertices)=0
 insert a boundary segment More...
 
virtual void insertBoundarySegment (const std::vector< unsigned int > &vertices, const shared_ptr< BoundarySegment< dimension, dimworld > > &boundarySegment)
 insert an arbitrarily shaped boundary segment More...
 
virtual UGGrid< dimworld > * createGrid ()=0
 Finalize grid creation and hand over the grid. More...
 
virtual unsigned int insertionIndex (const typename Codim< 0 >::Entity &entity) const
 obtain an element's insertion index More...
 
virtual unsigned int insertionIndex (const typename Codim< dimension >::Entity &entity) const
 obtain a vertex' insertion index More...
 
virtual unsigned int insertionIndex (const typename UGGrid< dimworld >::LeafIntersection &intersection) const
 obtain a boundary's insertion index More...
 
virtual bool wasInserted (const typename UGGrid< dimworld >::LeafIntersection &intersection) const
 determine whether an intersection was inserted More...
 

Protected Types

enum  
 The grid world dimension. More...
 

Static Protected Attributes

static const int dimension
 dimension of the grid More...
 

Detailed Description

template<int dimworld>
class Dune::GridFactory< UGGrid< dimworld > >

Specialization of the generic GridFactory for UGGrid.

If you want to write a routine that reads a grid from some file into a Dune UGGrid object you have to know how to use the UGGrid grid factory. In the following we assume that you have a grid in some file format and an empty UGGrid object, created by one of its constructors. Hence, your file reader method signature may look like this:

UGGrid<3>* readMyFileFormat(const std::string& filename)

Now, in order to create a valid UGGrid object do the following steps:

1) Create a GridFactory Object

Get a new GridFactory object by calling

GridFactory<UGGrid<dim> > factory;

2) Enter the Vertices

Insert the grid vertices by calling

factory.insertVertex(const FieldVector<double,dimworld>& position);

for each vertex. The order of insertion determines the level- and leaf indices of your level 0 vertices.

3) Enter the elements

For each element call

factory.insertElement(Dune::GeometryType type, const std::vector<int>& vertices);

The parameters are

The numbering of the vertices of each element is expected to follow the DUNE conventions. Refer to the page on reference elements for the details.

4) Parametrized Domains

UGGrid supports parametrized domains. That means that you can provide a smooth description of your grid boundary. The actual grid will always be piecewise linear; however, as you refine, the grid will approach your prescribed boundary. You don't have to do this. If your coarse grid boundary describes your domain well read on at Section 5.

In order to create curved boundary segments, for each segment you have to write a class which implements the correct geometry. These classes are then handed over to the UGGrid object. Boundary segment implementations must be derived from

template <int dimworld> Dune::BoundarySegment

This is an abstract base class which requires you to overload the method

virtual FieldVector< double, dimworld > operator() (const FieldVector< double, dimworld-1 > &local)

This methods must compute the world coordinates from the local ones on the boundary segment. Give these classes to your grid factory by calling

factory.insertBoundarySegment(const std::vector<int>& vertices,
                        const BoundarySegment<dimworld> *boundarySegment);

Control over the allocated objects is taken from you, and the grid object will take care of their destruction.

5) Finish construction

To finish off the construction of the UGGrid object call

UGGrid<dim>* grid = factory.createGrid();

This time it is you who gets full responsibility for the allocated object.

Loading a Grid on a Parallel Machine

If you're working on a parallel machine, and you want to set up a parallel grid, proceed as described only on the rank-0 process. On the other processes just create a GridFactory and call createGrid() to obtain the grid object. This will create the grid on the master process and set up UG correctly on all other process. Call loadBalance() to actually distribute the grid.

Warning
To use a parametrized boundary on a parallel machine you need to hand over the boundary segments to the grid factory on all processes. This behavior violates the Dune grid interface specification and will be corrected in the future.

Member Enumeration Documentation

anonymous enum
protectedinherited

The grid world dimension.

Member Function Documentation

virtual UGGrid< dimworld > * Dune::GridFactoryInterface< UGGrid< dimworld > >::createGrid ( )
pure virtualinherited

Finalize grid creation and hand over the grid.

The receiver takes responsibility of the memory allocated for the grid

virtual void Dune::GridFactoryInterface< UGGrid< dimworld > >::insertBoundarySegment ( const std::vector< unsigned int > &  vertices)
pure virtualinherited

insert a boundary segment

This method inserts a boundary segment into the coarse grid. Using this method has two advantages over not using it:

  • The boundary segment gets an insertion index.
  • The grid factory can verify that this is actually a boundary segment
Note
You are not forced to insert all boundary segments. The grid factory will find the remaining boundary segments itself.
Parameters
[in]verticesthe indices of the vertices of the segment
virtual void Dune::GridFactoryInterface< UGGrid< dimworld > >::insertBoundarySegment ( const std::vector< unsigned int > &  vertices,
const shared_ptr< BoundarySegment< dimension, dimworld > > &  boundarySegment 
)
inlinevirtualinherited

insert an arbitrarily shaped boundary segment

This method inserts a boundary segment into the coarse grid.

Parameters
[in]verticesthe indices of the vertices of the segment
[in]boundarySegmentuser defined implementation of the boundary segment's geometry
virtual void Dune::GridFactoryInterface< UGGrid< dimworld > >::insertElement ( const GeometryType &  type,
const std::vector< unsigned int > &  vertices 
)
pure virtualinherited

Insert an element into the coarse grid.

Parameters
typeThe GeometryType of the new element
verticesThe vertices of the new element, using the DUNE numbering

Make sure the inserted element is not inverted (this holds even for simplices). There are grids that can't handle inverted elements.

virtual void Dune::GridFactoryInterface< UGGrid< dimworld > >::insertElement ( const GeometryType &  type,
const std::vector< unsigned int > &  vertices,
const shared_ptr< VirtualFunction< FieldVector< ctype, dimension >, FieldVector< ctype, dimworld > > > &  elementParametrization 
)
inlinevirtualinherited

Insert a parametrized element into the coarse grid.

Parameters
typeThe GeometryType of the new element
verticesThe vertices of the new element, using the DUNE numbering
elementParametrizationA function prescribing the shape of this element

Make sure the inserted element is not inverted (this holds even for simplices). There are grids that can't handle inverted elements.

virtual unsigned int Dune::GridFactoryInterface< UGGrid< dimworld > >::insertionIndex ( const typename Codim< 0 >::Entity entity) const
inlinevirtualinherited

obtain an element's insertion index

Data can be associated to the created macro grid using the insertion index of each entity that has been inserted during the grid creation process.

Between grid construction (createGrid) and the first grid modification, this method allows to obtain this insertion index from the grid factory. This way, data can be stored using the index maps provided by the grid.

Parameters
[in]entityentity whose insertion index is requested
Returns
insertion index of the entity
virtual unsigned int Dune::GridFactoryInterface< UGGrid< dimworld > >::insertionIndex ( const typename Codim< dimension >::Entity entity) const
inlinevirtualinherited

obtain a vertex' insertion index

Data can be associated to the created macro grid using the insertion index of each entity that has been inserted during the grid creation process.

Between grid construction (createGrid) and the first grid modification, this method allows to obtain this insertion index from the grid factory. This way, data can be stored using the index maps provided by the grid.

Parameters
[in]entityentity whose insertion index is requested
Returns
insertion index of the entity
virtual unsigned int Dune::GridFactoryInterface< UGGrid< dimworld > >::insertionIndex ( const typename UGGrid< dimworld > ::LeafIntersection &  intersection) const
inlinevirtualinherited

obtain a boundary's insertion index

Data can be associated to the created macro grid using the insertion index of each entity that has been inserted during the grid creation process.

Between grid construction (createGrid) and the first grid modification, this method allows to obtain this insertion index from the grid factory. This way, data can be stored using the index maps provided by the grid.

Parameters
[in]intersectionintersection whose insertion index is requested
Returns
insertion index of the intersection
Note
The insertion index can only be obtained for boundary intersections that were actually inserted (see also wasInserted).
virtual void Dune::GridFactoryInterface< UGGrid< dimworld > >::insertVertex ( const FieldVector< ctype, dimworld > &  pos)
pure virtualinherited

Insert a vertex into the coarse grid.

virtual bool Dune::GridFactoryInterface< UGGrid< dimworld > >::wasInserted ( const typename UGGrid< dimworld > ::LeafIntersection &  intersection) const
inlinevirtualinherited

determine whether an intersection was inserted

This method allows checking wheter an intersection was actually inserted into the grid factory.

Note
Not all boundary segments need to be inserted into the grid factory.
This method returns false for all interior intersections
Parameters
[in]intersectionintersection in question
Returns
true, if the intersection was inserted

Member Data Documentation

const int Dune::GridFactoryInterface< UGGrid< dimworld > >::dimension
staticprotectedinherited

dimension of the grid


The documentation for this class was generated from the following file: