Dune::SPGrid< ct, dim, Ref, Comm > Class Template Reference

structured, parallel DUNE grid More...

#include <dune/grid/spgrid/grid.hh>

Public Member Functions
bool	mark (int refCount, const typename Traits ::template Codim< 0 >::Entity &e)
	Marks an entity to be refined/coarsened in a subsequent adapt. More...
int	getMark (const typename Traits::template Codim< 0 >::Entity &e) const
	returns adaptation mark for given entity, i.e. here the default implementation returns 0. More...
bool	loadBalance ()
	default implementation of load balance does nothing and returns false
bool	loadBalance ([[maybe_unused]] DataHandle &data)
	default implementation of load balance does nothing and returns false
Size methods
int	size (int level, GeometryType type) const
	Return number of entities per level and geometry type in this process.
int	size (GeometryType type) const
	Return number of leaf entities per geometry type in this process.
Adaptivity and grid refinement
void	globalRefine (int refCount)
	Refine the grid refCount times using the default refinement rule. More...

Exported types
typedef GridFamily::Traits::LeafIntersection	LeafIntersection
	A type that is a model of Dune::Intersection, an intersections of two codimension 1 of two codimension 0 entities in the leaf view.
typedef GridFamily::Traits::LevelIntersection	LevelIntersection
	A type that is a model of Dune::Intersection, an intersections of two codimension 1 of two codimension 0 entities in a level view.
typedef GridFamily::Traits::LeafIntersectionIterator	LeafIntersectionIterator
	A type that is a model of Dune::IntersectionIterator which is an iterator that allows to examine, but not to modify, the intersections of codimension 1 of an leaf element (entity of codimension 0) with other leaf elements.
typedef GridFamily::Traits::LevelIntersectionIterator	LevelIntersectionIterator
	A type that is a model of Dune::IntersectionIterator which is an iterator that allows to examine, but not to modify, the intersections of codimension 1 of an element (entity of codimension 0) with other elements on the same level.
typedef GridFamily::Traits::HierarchicIterator	HierarchicIterator
	A type that is a model of Dune::HierarchicIterator A type of iterator that allows to examine, but not to modify, entities of codimension 0 that result from refinement of an entity of codimension 0.
template<class T >
using	Communication_t = typename T::Communication
template<class T >
using	DeprecatedCollectiveCommunication_t = typename T::CollectiveCommunication

Parallel data distribution and communication
template<class DataHandle >
bool	loadBalance (DataHandle &data)
	Re-balances the load each process has to handle for a parallel grid and moves the data. More...
template<class EntitySeed >
Codim< EntitySeed ::codimension >::Entity	entity (const EntitySeed &seed) const
	obtain Entity from EntitySeed.
GridImp &	asImp ()
	Barton-Nackman trick.
const GridImp &	asImp () const
	Barton-Nackman trick.

Detailed Description

template<class ct, int dim, template< int > class Ref, class Comm>
class Dune::SPGrid< ct, dim, Ref, Comm >

structured, parallel DUNE grid

Template Parameters

ct	coordinate type (e.g., double)
dim	dimension of the grid
Ref	refinement (default is SPIsotropicRefinement)
Comm	type of communicator (default depends on HAVE_MPI)

Member Function Documentation

getMark()

int Dune::GridDefaultImplementation< dim, dimworld, ct, SPGridFamily< ct, dim, Ref, Comm > >::getMark ( const typename Traits::template Codim< 0 >::Entity &  e ) const

inlineinherited

returns adaptation mark for given entity, i.e. here the default implementation returns 0.

Parameters

[in]

e

Entity for which adaptation mark should be determined

Returns

int adaptation mark, here the default value 0 is returned

globalRefine()

template<int dim, int dimworld, class ct , class GridFamily >

void Dune::Grid< dim, dimworld, ct, GridFamily >::globalRefine ( int  refCount )

inlineinherited

Refine the grid refCount times using the default refinement rule.

This behaves like marking all elements for refinement and then calling preAdapt, adapt and postAdapt. The state after globalRefine is comparable to the state after postAdapt.

References Dune::Grid< dim, dimworld, ct, GridFamily >::asImp(), and CHECK_AND_CALL_INTERFACE_IMPLEMENTATION.

Referenced by checkGrid().

loadBalance()

template<int dim, int dimworld, class ct , class GridFamily >

template<class DataHandle >

bool Dune::Grid< dim, dimworld, ct, GridFamily >::loadBalance ( DataHandle &  data )

inlineinherited

Re-balances the load each process has to handle for a parallel grid and moves the data.

Parameters

data	A data handle telling the method which data should be communicated and how. Has to adhere to the interface describe by CommDataHandleIf just like the data handle for the communicate methods.

Returns

True if the grid has changed.

mark()

bool Dune::GridDefaultImplementation< dim, dimworld, ct, SPGridFamily< ct, dim, Ref, Comm > >::mark ( int  refCount, const typename Traits ::template Codim< 0 >::Entity &  e  )

inlineinherited

Marks an entity to be refined/coarsened in a subsequent adapt.

Parameters

[in]	refCount	Number of subdivisions that should be applied. Negative value means coarsening.
[in]	e	Entity to Entity that should be refined

Returns

true if Entity was marked, false otherwise.

Note

• default implementation is: return false; for grids with no adaptation.
• for the grid programmer: this method is implemented as a template method, because the Entity type is not defined when the class is instantiated You won't need this trick in the implementation. In your implementation you should use it as

  bool mark( int refCount,
             typename Traits::template Codim<0>::Entity & e ).

  This template method will vanish due to the inheritance rules.

---

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

• dune/grid/spgrid/declaration.hh
• dune/grid/spgrid/grid.hh