grid.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_HH
#define DUNE_GRID_HH
 
// system includes
#include <iostream>
#include <string>
 
// dune-common includes
#include <dune/common/fvector.hh>
#include <dune/common/typetraits.hh>
 
// dune-geometry includes
#include <dune/geometry/type.hh>
 
// local includes
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/common/exceptions.hh>
#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/datahandleif.hh>
#include <dune/grid/common/gridview.hh>
#include <dune/grid/common/defaultgridview.hh>
#include <dune/grid/common/entityseed.hh>
 
// include this file after all other, because other files might undef the
// macros that are defined in that file
#include <dune/common/bartonnackmanifcheck.hh>
 
namespace Dune {
 
  // Forward Declarations
  // --------------------
 
  template<int mydim, int cdim, class GridImp,template<int,int,class> class GeometryImp> class Geometry;
  template< int mydim, int cdim, class GridImp > class GlobalGeometryReference;
  template< int mydim, int cdim, class GridImp > class LocalGeometryReference;
  // dim is necessary because Entity will be specialized for codim==0 _and_ codim==dim
  // EntityImp gets GridImp as 3rd template parameter to distinguish between const and mutable grid
  template<int codim, int dim, class GridImp,template<int,int,class> class EntityImp> class Entity;
  template<class GridImp, class EntityPointerImp> class EntityPointer;
  template< int codim, class Grid, class IteratorImp > class EntityIterator;
  template<class GridImp, class EntitySeedImp> class EntitySeed;
  template< class GridImp, class IntersectionImp > class Intersection;
  template< class GridImp, class IntersectionIteratorImp, class IntersectionImp > class IntersectionIterator;
  template<class GridImp, class IndexSetImp, class IndexTypeImp=unsigned int> class IndexSet;
  template<class GridImp, class IdSetImp, class IdTypeImp> class IdSet;
 
 
  //************************************************************************
  // G R I D
  //************************************************************************
 
  template< int dim, int dimworld, class ct, class GridFamily>
  class Grid {
    typedef typename GridFamily::Traits::Grid GridImp;
    typedef Grid<dim,dimworld,ct,GridFamily> ThisType;
  public:
 
    //===========================================================
    //===========================================================
 
    enum {
      dimension=dim
    };
 
    enum {
      dimensionworld=dimworld
    };
 
    //===========================================================
    //===========================================================
 
    template <PartitionIteratorType pitype>
    struct Partition
    {
      typedef typename GridFamily::Traits::template Partition<pitype>::LevelGridView
      LevelGridView;
      typedef typename GridFamily::Traits::template Partition<pitype>::LeafGridView
      LeafGridView;
    };
    typedef typename Partition< All_Partition > :: LevelGridView LevelGridView;
    typedef typename Partition< All_Partition > :: LeafGridView LeafGridView;
 
 
    template <int cd>
    struct Codim
    {
      typedef typename GridFamily::Traits::template Codim<cd>::Geometry Geometry;
 
      typedef typename GridFamily::Traits::template Codim<cd>::LocalGeometry LocalGeometry;
 
      typedef typename GridFamily::Traits::template Codim<cd>::Entity Entity;
 
      typedef typename GridFamily::Traits::template Codim<cd>::EntityPointer EntityPointer;
 
      typedef typename GridFamily::Traits::template Codim<cd>::EntitySeed EntitySeed;
 
      template <PartitionIteratorType pitype>
      struct Partition
      {
        typedef typename GridFamily::Traits::template Codim<cd>::template Partition<pitype>::LevelIterator LevelIterator;
        typedef typename GridFamily::Traits::template Codim<cd>::template Partition<pitype>::LeafIterator LeafIterator;
      };
 
      typedef typename GridFamily::Traits::template Codim<cd>::LevelIterator LevelIterator;
 
      typedef typename GridFamily::Traits::template Codim<cd>::LeafIterator LeafIterator;
    };
 
    typedef typename GridFamily::Traits::LeafIntersection LeafIntersection;
 
    typedef typename GridFamily::Traits::LevelIntersection LevelIntersection;
 
    typedef typename GridFamily::Traits::LeafIntersectionIterator LeafIntersectionIterator;
 
    typedef typename GridFamily::Traits::LevelIntersectionIterator LevelIntersectionIterator;
 
    typedef typename GridFamily::Traits::HierarchicIterator HierarchicIterator;
 
    typedef typename GridFamily::Traits::LevelIndexSet LevelIndexSet;
 
    typedef typename GridFamily::Traits::LeafIndexSet LeafIndexSet;
 
    typedef typename GridFamily::Traits::GlobalIdSet GlobalIdSet;
 
    typedef typename GridFamily::Traits::LocalIdSet LocalIdSet;
 
    typedef typename GridFamily::Traits::CollectiveCommunication CollectiveCommunication;
 
    typedef ct ctype;
 
 
    //===========================================================
    //===========================================================
 
    int maxLevel() const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().maxLevel());
      return asImp().maxLevel();
    }
 
    int size (int level, int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().size(level,codim));
      return asImp().size(level,codim);
    }
 
    int size (int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().size(codim));
      return asImp().size(codim);
    }
 
    int size (int level, GeometryType type) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().size(level,type));
      return asImp().size(level,type);
    }
 
    int size (GeometryType type) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().size(type));
      return asImp().size(type);
    }
 
 
    size_t numBoundarySegments () const
    {
      CHECK_INTERFACE_IMPLEMENTATION( asImp().numBoundarySegments());
      return asImp().numBoundarySegments();
    }
 
    //===========================================================
    //===========================================================
 
    template<PartitionIteratorType pitype>
    typename Partition<pitype>::LevelGridView DUNE_DEPRECATED_MSG("The method levelView has been renamed to levelGridView.") levelView(int level) const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template levelView<pitype>(level)));
      return asImp().template levelView<pitype>(level);
    }
 
    template<PartitionIteratorType pitype>
    typename Partition<pitype>::LeafGridView DUNE_DEPRECATED_MSG("The method levelView has been renamed to leafGridView.") leafView() const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafView<pitype>()));
      return asImp().template leafView<pitype>();
    }
 
    LevelGridView levelView(int level) const DUNE_DEPRECATED_MSG("The method levelView has been renamed to levelGridView.") {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().levelView(level)));
      return asImp().levelView(level);
    }
 
    LeafGridView leafView() const DUNE_DEPRECATED_MSG("The method leafView has been renamed to leafGridView.") {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().leafView()));
      return asImp().leafView();
    }
 
    template<PartitionIteratorType pitype>
    typename Partition<pitype>::LevelGridView levelGridView(int level) const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template levelGridView<pitype>(level)));
      return asImp().template levelGridView<pitype>(level);
    }
 
    template<PartitionIteratorType pitype>
    typename Partition<pitype>::LeafGridView leafGridView() const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafGridView<pitype>()));
      return asImp().template leafGridView<pitype>();
    }
 
    LevelGridView levelGridView(int level) const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().levelGridView(level)));
      return asImp().levelGridView(level);
    }
 
    LeafGridView leafGridView() const {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().leafGridView()));
      return asImp().leafGridView();
    }
 
 
 
    //===========================================================
    //===========================================================
 
    template<int cd, PartitionIteratorType pitype>
    typename Codim<cd>::template Partition<pitype>::LevelIterator lbegin (int level) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template lbegin<cd,pitype>(level)));
      return asImp().template lbegin<cd,pitype>(level);
    }
 
    template<int cd, PartitionIteratorType pitype>
    typename Codim<cd>::template Partition<pitype>::LevelIterator lend (int level) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template lend<cd,pitype>(level)));
      return asImp().template lend<cd,pitype>(level);
    }
 
    template<int cd>
    typename Codim<cd>::template Partition<All_Partition>::LevelIterator lbegin (int level) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template lbegin<cd>(level)));
      return asImp().template lbegin<cd>(level);
    }
 
    template<int cd>
    typename Codim<cd>::template Partition<All_Partition>::LevelIterator lend (int level) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template lend<cd>(level)));
      return asImp().template lend<cd>(level);
    }
 
    template<int cd, PartitionIteratorType pitype>
    typename Codim<cd>::template Partition<pitype>::LeafIterator leafbegin () const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafbegin<cd,pitype>()));
      return asImp().template leafbegin<cd,pitype>();
    }
 
    template<int cd, PartitionIteratorType pitype>
    typename Codim<cd>::template Partition<pitype>::LeafIterator leafend () const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafend<cd,pitype>()));
      return asImp().template leafend<cd,pitype>();
    }
 
    template<int cd>
    typename Codim<cd>::template Partition<All_Partition>::LeafIterator leafbegin () const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafbegin<cd,All_Partition>()));
      return asImp().template leafbegin<cd,All_Partition>();
    }
 
    template<int cd>
    typename Codim<cd>::template Partition<All_Partition>::LeafIterator leafend () const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().template leafend<cd,All_Partition>()));
      return asImp().template leafend<cd,All_Partition>();
    }
 
 
    //===========================================================
    //===========================================================
 
    const GlobalIdSet &globalIdSet () const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().globalIdSet());
      return asImp().globalIdSet();
    }
 
    const LocalIdSet &localIdSet () const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().localIdSet());
      return asImp().localIdSet();
    }
 
    const LevelIndexSet &levelIndexSet ( int level ) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().levelIndexSet(level));
      return asImp().levelIndexSet(level);
    }
 
    const LeafIndexSet &leafIndexSet () const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().leafIndexSet());
      return asImp().leafIndexSet();
    }
 
 
    //===========================================================
    //===========================================================
 
    void globalRefine (int refCount)
    {
      CHECK_AND_CALL_INTERFACE_IMPLEMENTATION(asImp().globalRefine(refCount));
      return;
    }
 
    bool mark( int refCount, const typename Codim<0>::Entity & e )
    {
      return asImp().mark(refCount,e);
    }
 
    int getMark(const typename Codim<0>::Entity & e) const
    {
      return asImp().getMark(e);
    }
 
    bool preAdapt ()
    {
      return asImp().preAdapt();
    }
 
    bool adapt ()
    {
      return asImp().adapt();
    }
 
    void postAdapt()
    {
      return asImp().postAdapt();
    }
 
 
    //===========================================================
    //===========================================================
 
    int overlapSize (int level, int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().overlapSize(level,codim));
      return asImp().overlapSize(level,codim);
    }
 
    int overlapSize (int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().overlapSize(codim));
      return asImp().overlapSize(codim);
    }
 
    int ghostSize (int level, int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().ghostSize(level,codim));
      return asImp().ghostSize(level,codim);
    }
 
    int ghostSize (int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().ghostSize(codim));
      return asImp().ghostSize(codim);
    }
 
    template<class DataHandleImp, class DataTypeImp>
    void communicate (CommDataHandleIF<DataHandleImp,DataTypeImp> & data, InterfaceType iftype, CommunicationDirection dir, int level) const
    {
      CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().template communicate<DataHandleImp,DataTypeImp>(data,iftype,dir,level)));
      return;
    }
 
    template<class DataHandleImp, class DataTypeImp>
    void communicate (CommDataHandleIF<DataHandleImp,DataTypeImp> & data, InterfaceType iftype, CommunicationDirection dir) const
    {
      CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().template communicate<DataHandleImp,DataTypeImp>(data,iftype,dir)));
      return;
    }
 
    const CollectiveCommunication &comm () const
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().comm());
      return asImp().comm();
    }
 
    bool loadBalance()
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().loadBalance());
      return asImp().loadBalance();
    }
 
    template<class DataHandle>
    bool loadBalance (DataHandle& data)
    {
      CHECK_INTERFACE_IMPLEMENTATION(asImp().loadBalance(data));
      return asImp().loadBalance(data);
    }
 
    template < class EntitySeed >
    typename Codim< EntitySeed :: codimension > :: EntityPointer
    entityPointer( const EntitySeed& seed ) const
    {
      CHECK_INTERFACE_IMPLEMENTATION( asImp().entityPointer( seed ) );
      return asImp().entityPointer( seed );
    }
  protected:
    GridImp& asImp () {return static_cast<GridImp &> (*this);}
    const GridImp& asImp () const {return static_cast<const GridImp &>(*this);}
  };
 
#undef CHECK_INTERFACE_IMPLEMENTATION
#undef CHECK_AND_CALL_INTERFACE_IMPLEMENTATION
 
 
  template<int dim,
      int dimworld,
      class ct,
      class GridFamily>
  class GridDefaultImplementation : public Grid <dim,dimworld,ct,GridFamily>
  {
    typedef typename GridFamily::Traits::Grid GridImp;
 
  public:
    typedef typename GridFamily::Traits Traits;
 
    template<PartitionIteratorType pitype>
    typename Traits::template Partition<pitype>::LevelGridView DUNE_DEPRECATED_MSG("The method levelView has been renamed to levelGridView.")
    levelView(int level) const {
      typedef typename Traits::template Partition<pitype>::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp(),level));
    }
 
    template<PartitionIteratorType pitype>
    typename Traits::template Partition<pitype>::LeafGridView DUNE_DEPRECATED_MSG("The method levelView has been renamed to leafGridView.") leafView() const {
      typedef typename Traits::template Partition<pitype>::LeafGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp()));
    }
 
    typename Traits::template Partition<All_Partition>::LevelGridView
    levelView(int level) const DUNE_DEPRECATED_MSG("The method levelView has been renamed to levelGridView.") {
      typedef typename Traits::template Partition<All_Partition>::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp(),level));
    }
 
    typename Traits::template Partition<All_Partition>::LeafGridView
    leafView() const  DUNE_DEPRECATED_MSG("The method leafView has been renamed to leafGridView.") {
      typedef typename Traits::template Partition<All_Partition>::LeafGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp()));
    }
 
    template<PartitionIteratorType pitype>
    typename Traits::template Partition<pitype>::LevelGridView
    levelGridView(int level) const {
      typedef typename Traits::template Partition<pitype>::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp(),level));
    }
 
    template<PartitionIteratorType pitype>
    typename Traits::template Partition<pitype>::LeafGridView
    leafGridView() const {
      typedef typename Traits::template Partition<pitype>::LeafGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp()));
    }
 
    typename Traits::template Partition<All_Partition>::LevelGridView
    levelGridView(int level) const {
      typedef typename Traits::template Partition<All_Partition>::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp(),level));
    }
 
    typename Traits::template Partition<All_Partition>::LeafGridView
    leafGridView() const {
      typedef typename Traits::template Partition<All_Partition>::LeafGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp()));
    }
 
    //***************************************************************
    //  Interface for Adaptation
    //***************************************************************
 
    bool mark( int refCount, const typename Traits :: template Codim<0>::Entity & e )
    {
      return false;
    }
 
    int getMark ( const typename Traits::template Codim< 0 >::Entity &e ) const
    {
      return 0;
    }
 
    bool adapt ()    { return false; }
 
    bool preAdapt () { return false; }
 
    void postAdapt() {}
 
    int ghostSize (int level, int codim) const { return 0; }
 
    int overlapSize (int level, int codim) const { return 0; }
 
    int ghostSize (int codim) const { return 0; }
 
    int overlapSize (int codim) const { return 0; }
 
    template<class DataHandleImp, class DataTypeImp>
    void communicate (CommDataHandleIF<DataHandleImp,DataTypeImp> & data,
                      InterfaceType iftype, CommunicationDirection dir, int level) const
    {}
 
    template<class DataHandleImp, class DataTypeImp>
    void communicate (CommDataHandleIF<DataHandleImp,DataTypeImp> & data,
                      InterfaceType iftype, CommunicationDirection dir) const
    {}
 
    bool loadBalance()
    {
      return false;
    }
 
    template<class DataHandle>
    bool loadBalance (DataHandle& data)
    {
      return false;
    }
 
  protected:
    template<class T>
    class ReturnImplementationType
      : public T // implement friendship via subclassing
    {
    public:
      typedef typename T::Implementation ImplementationType;
    private:
      // constructor in only need to compile
      ReturnImplementationType(const T& t) : T(t) {}
    };
 
    template<class T>
    class ReturnImplementationType<const T>
      : public T // implement friendship via subclassing
    {
    public:
      typedef const typename T::Implementation ImplementationType;
    private:
      // constructor in only need to compile
      ReturnImplementationType(const T& t) : T(t) {}
    };
 
    template <class InterfaceType>
    static typename ReturnImplementationType<InterfaceType>::ImplementationType &
    getRealImplementation (InterfaceType &i) { return i.impl(); }
 
  protected:
    using Grid< dim, dimworld, ct, GridFamily >::asImp;
  };
 
  template <int dim, int dimw, class GridImp,
      template<int,int,class> class GeometryImp,
      template<int,int,class> class EntityImp,
      template<int,class> class EntityPointerImp,
      template<int,PartitionIteratorType,class> class LevelIteratorImp,
      template<class> class LeafIntersectionImp,
      template<class> class LevelIntersectionImp,
      template<class> class LeafIntersectionIteratorImp,
      template<class> class LevelIntersectionIteratorImp,
      template<class> class HierarchicIteratorImp,
      template<int,PartitionIteratorType,class> class LeafIteratorImp,
      class LevelIndexSetImp, class LeafIndexSetImp,
      class GlobalIdSetImp, class GIDType, class LocalIdSetImp, class LIDType, class CCType,
      template<class,PartitionIteratorType> class LevelGridViewTraits,
      template<class,PartitionIteratorType> class LeafGridViewTraits,
      template<int,class> class EntitySeedImp,
      template<int,int,class> class LocalGeometryImp = GeometryImp
      >
  struct GridTraits
  {
    typedef GridImp Grid;
 
    typedef Dune::Intersection< const GridImp, LeafIntersectionImp< const GridImp > >  LeafIntersection;
    typedef Dune::Intersection< const GridImp, LevelIntersectionImp< const GridImp > > LevelIntersection;
    typedef Dune::IntersectionIterator< const GridImp, LeafIntersectionIteratorImp< const GridImp >, LeafIntersectionImp< const GridImp > > LeafIntersectionIterator;
    typedef Dune::IntersectionIterator< const GridImp, LevelIntersectionIteratorImp< const GridImp >, LevelIntersectionImp< const GridImp > > LevelIntersectionIterator;
 
    typedef Dune::EntityIterator< 0, const GridImp, HierarchicIteratorImp< const GridImp > > HierarchicIterator;
 
    template <int cd>
    struct Codim
    {
    public:
      typedef GeometryImp<dim-cd, dimw, const GridImp> GeometryImpl;
      typedef LocalGeometryImp<dim-cd, dim, const GridImp> LocalGeometryImpl;
 
      typedef Dune::Geometry<dim-cd, dimw, const GridImp, GeometryImp> Geometry;
      typedef Dune::Geometry<dim-cd, dim, const GridImp, LocalGeometryImp> LocalGeometry;
      // we could - if needed - introduce another struct for dimglobal of Geometry
      typedef Dune::Entity<cd, dim, const GridImp, EntityImp> Entity;
 
      typedef Dune::EntityPointer<const GridImp,EntityPointerImp<cd,const GridImp> > EntityPointer;
 
      typedef Dune::EntitySeed<const GridImp, EntitySeedImp<cd, const GridImp> > EntitySeed;
 
      template <PartitionIteratorType pitype>
      struct Partition
      {
        typedef Dune::EntityIterator< cd, const GridImp, LevelIteratorImp< cd, pitype, const GridImp > > LevelIterator;
        typedef Dune::EntityIterator< cd, const GridImp, LeafIteratorImp< cd, pitype, const GridImp > > LeafIterator;
      };
 
      typedef typename Partition< All_Partition >::LeafIterator LeafIterator;
 
      typedef typename Partition< All_Partition >::LevelIterator LevelIterator;
 
    private:
      friend class Dune::Entity<cd, dim, const GridImp, EntityImp>;
      typedef EntityPointerImp<cd,const GridImp> EntityPointerImpl;
    };
 
    template <PartitionIteratorType pitype>
    struct Partition
    {
      typedef Dune::GridView<LevelGridViewTraits<const GridImp,pitype> >
      LevelGridView;
 
      typedef Dune::GridView<LeafGridViewTraits<const GridImp,pitype> >
      LeafGridView;
    };
 
    typedef IndexSet<const GridImp,LevelIndexSetImp> LevelIndexSet;
    typedef IndexSet<const GridImp,LeafIndexSetImp> LeafIndexSet;
    typedef IdSet<const GridImp,GlobalIdSetImp,GIDType> GlobalIdSet;
    typedef IdSet<const GridImp,LocalIdSetImp,LIDType> LocalIdSet;
 
    typedef CCType CollectiveCommunication;
  };
 
  // Definition of capabilities for the interface class
  namespace Capabilities
  {
    // capabilities for the interface class depend on the implementation
    template< int dim, int dimworld, typename ct, class GridFamily , int cdim >
    struct hasEntity< GridDefaultImplementation<dim,dimworld,ct,GridFamily>, cdim >
    {
      typedef GridDefaultImplementation<dim,dimworld,ct,GridFamily> GridType;
      typedef typename GridType::Traits::Grid GridImp;
      static const bool v = hasEntity<GridImp,cdim>::v;
    };
 
  } // end namespace Capabilities
 
  template <class InterfaceType>
  struct MakeableInterfaceObject : public InterfaceType
  {
    typedef typename InterfaceType::Implementation ImplementationType;
    explicit MakeableInterfaceObject ( const ImplementationType &realImp )
      : InterfaceType( realImp )
    {}
  };
}
 
#include "geometry.hh"
#include "entity.hh"
#include "entitypointer.hh"
#include "intersection.hh"
#include "intersectioniterator.hh"
#include "entityiterator.hh"
#include "indexidset.hh"
 
#endif // #ifndef DUNE_GRID_HH