Refinement

Modules
	Refinement implementation for hypercubes
	Refinement implementation for triangulating hypercubes
	Refinement implementation for simplices
	Virtual Refinement

Namespaces
namespace	Dune::RefinementImp
	This namespace contains the implementation of Refinement.

Classes
class	Dune::StaticRefinement< topologyId, CoordType, coerceToId, dimension_ >
	Wrap each Refinement implementation to get a consistent interface. More...

Detailed Description

General

The Refinement system allows to temporarily refine a grid or single entities without changing the grid itself. You may want to do this because you want to write your data to a file and have to do subsampling, but want to continue the calculation with the unmodified grid afterwards.

What Refinement can do for you

template<unsigned topologyId, class CoordType,
         unsigned coerceToId, int dimension>
class StaticRefinement
{
public:
  enum { dimension };
 
  template<int codimension>
  struct codim
  {
    class SubEntityIterator;
  };
  typedef ImplementationDefined VertexIterator;  // These are aliases for codim<codim>::SubEntityIterator
  typedef ImplementationDefined ElementIterator;
 
  typedef ImplementationDefined IndexVector; // These are FieldVectors
  typedef ImplementationDefined CoordVector;
 
  static int nVertices(int level);
  static VertexIterator vBegin(int level);
  static VertexIterator vEnd(int level);
 
  static int nElements(int level);
  static ElementIterator eBegin(int level);
  static ElementIterator eEnd(int level);
}

The Iterators can do all the usual things that Iterators can do, except dereferencing. In addition, to do something useful, they support some additional methods:

template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
class VertexIterator
{
public:
  typedef ImplementationDefined Refinement;
 
  int index() const;
  Refinement::CoordVector coords() const;
}
 
template<unsigned topologyId, class CoordType, unsigned coerceToId, int dimension>
class ElementIterator
{
public:
  typedef ImplementationDefined Refinement;
 
  int index() const;
  // Coords of the center of mass of the element
  Refinement::CoordVector coords() const;
  Refinement::IndexVector vertexIndices() const;
}

How to use it

If you want to write a Refinement implementation for a particular geometry type, e.g. SquaringTheCircle (or a particular set of geometry types) here is how:

• create a file refinement/squaringthecircle.cc and #include "base.cc". Your file will be included by others, so don't forget to protect against double inclusion.
• implement a class (or template class) RefinementImp conforming exactly to the user interface above.
• put it (and it's helper stuff as apropriate) into it's own namespace Dune::RefinementImp::SquaringTheCircle.
• define the mapping of topologyId, CoordType and coerceToId to your implementation by specialising template struct RefinementImp::Traits. It should look like this:

  namespace Dune::RefinementImp {
    // we're only implementing this for dim=2
    template<class CoordType>
    struct Traits<sphereTopologyId, CoordType,
                GenericGeometry::CubeTopology<2>::type::id, 2>
  {
      typedef SquaringTheCircle::RefinementImp<CoordType> Imp;
    };
  }

  If you implement a template class, you have to specialise struct RefinementImp::Traits for every possible combination of topologyId and coerceToId that your implementation supports.
• #include "refinement/squaringthecircle.cc" from refinement.hh.

This is enough to integrate your implementation into the Refinement system. You probably want to include it into VirtualRefinement also.

Namespaces