dune-grid
2.2.1
|
![]() |
Modules | |
The Grid Interface | |
Interfaces needed when working with a Dune::Grid. | |
Mappers | |
Grid Implementations | |
A list of the different Implementations of the Dune Grid Interface. | |
I/O | |
Grid Developer API | |
Interfaces needed to implement a new Dune::Grid. | |
Refinement |
Functions | |
template<class G > | |
void | Dune::gridinfo (const G &grid, std::string prefix="") |
A function to print some information about the grid as a whole. | |
template<class G > | |
void | Dune::gridlevellist (const G &grid, int level, std::string prefix) |
A function to print info about a grid level and its entities. | |
template<class G > | |
void | Dune::gridleaflist (const G &grid, std::string prefix) |
A function to print info about a leaf grid and its entities. |
The Dune Grid module defines a general interface to a parallel, in general
nonconforming, locally refined and hierarchical finite element mesh. The interface is independent of dimension and element type.
An entity is a geometric object that is part of a grid. It is generalized polytope that has the same dimensionality as the grid or a lower dimension.
@subsection subs20 Dimension A grid has a fixed dimension \form#27 which is the number of coordinates
required to specify any point in the grid. The dimension is a template parameter of a grid.
@subsection subs21 Codimension of an entity Each entity has a codimension \form#28 where \form#29 (the dimension of the grid). An entity with codimension \form#30 in a grid of dimension \form#31 is a \form#32-dimensional object. @subsection subs5 Subentity Entities are hierarchically constructed in the sense that entities of codimension 0 are made up of entities of codimension 1 which are themselves made up of entities of codimension 2 etc. until entities of codimension \form#33 which consist of entities of codimension \form#31. @subsection subs3 Element An element is an entity of codimension 0. @subsection subs4 Vertex A vertex is an entity of codimension \form#31 (the same as the grid's dimension). @subsection subs22 World dimension Each grid has a world dimension \form#34 with \form#35. This is the number
of coordinates of the positions of the grid's vertices.
@subsection subs33 Hierarchical grid The %Dune grid interface describes not only a single grid but a sequence of grids with different resolution. This is achieved by beginning with an intentionally coarse grid, the so-called macro grid. Then each
element may be individually subdivided to yield new (smaller) elements. This construction is recursive such that each macro element and all the elements that resulted from subdividing it form a tree structure.
The grid can only be modified in special phases, the so-called refinement phase. In between refinement phases the entities of the grid can not be modified in any way. During refinement currently only the hierachic subdivision can be modified.
All elements of the macro grid form level 0 of the grid structure. All elements that are obtained from an -fold subdivision of a macro element form level
of the grid structure.
All elements of a grid that are not subdivided any further make up the leaf grid. The leaf grid is the mesh with the finest resolution.
A type is said to be assignable if it has a (public) copy constructor and assignment operator. Note that this definition requires always both methods.
A type is said to be default-constructible if it has a constructor without arguments.
A type is said to be copy constructible from some other type X if it has a copy constructor that takes a reference to an object of type X.
A type is said to be equality-comparable if it has an operator==.
A type is lessthan-comparable if it has an operator<.
A type is dereferenceable if it has an operator* that delivers a reference to a value type.
An iterator is a type that can be dereferenced to yield an object of its value type, i.e. it behaves like a pointer, and that can be incremented to point to the next element in a linear sequence. In that respect it is comparable to ForwardIterator in the Standard Template Library.
An iterator is called mutable if the value it refers to can be changed, i.e. it is assignable.
An iterator is called immutable if the value referenced by the iterator can not be changed, i. e. the value is not assignable and only methods marked const on the value can be called.
A type M is called a model of another type X if it implements all the methods of X with the intended semantics. Typically X is a type that describes an interface.
Each implementation of the Dune grid interface consist of a number of related types which together form a model of the grid interface. These types are the following:
Class | Assignable | DefaultConstructible | EqualityComparable | LessThanComparable |
Grid | no | no | no | no |
Entity | no | no | no | no |
GeometryType | yes | yes | yes | yes |
Geometry | no | no | no | no |
EntityPointer | yes | no | yes | no |
LevelIterator | yes | no | yes | no |
LeafIterator | yes | no | yes | no |
HierarchicIterator | yes | no | yes | no |
Intersection | yes | no | yes | no |
IntersectionIterator | yes | no | yes | no |
IndexSet | no | no | no | no |
IdSet | no | no | no | no |
void Dune::gridinfo | ( | const G & | grid, |
std::string | prefix = "" |
||
) |
A function to print some information about the grid as a whole.
void Dune::gridleaflist | ( | const G & | grid, |
std::string | prefix | ||
) |
A function to print info about a leaf grid and its entities.
References Dune::Entity< cd, dim, GridImp, EntityImp >::level(), and Dune::PartitionName().
void Dune::gridlevellist | ( | const G & | grid, |
int | level, | ||
std::string | prefix | ||
) |
A function to print info about a grid level and its entities.
References Dune::Entity< cd, dim, GridImp, EntityImp >::level(), and Dune::PartitionName().