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>
#include <vector>
 
// dune-common includes
#include <dune/common/fvector.hh>
#include <dune/common/typetraits.hh>
#include <dune/common/deprecated.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< 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 TypesImp = std::vector< GeometryType > > 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
    };
 
    //===========================================================
    //===========================================================
 
    typedef typename GridFamily::Traits::LeafGridView LeafGridView;
    typedef typename GridFamily::Traits::LevelGridView LevelGridView;
 
 
    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>::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();
    }
 
    //===========================================================
    //===========================================================
 
    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();
    }
 
 
 
    //===========================================================
    //===========================================================
 
    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();
    }
 
 
    //===========================================================
    //===========================================================
 
    DUNE_DEPRECATED_MSG("overlapSize() is deprecated. Use the method on the LevelGridView instead.")
    int overlapSize (int level, int codim) const
    {
      return levelGridView(level).overlapSize(codim);
    }
 
    DUNE_DEPRECATED_MSG("overlapSize() is deprecated. Use the method on the LeafGridView instead.")
    int overlapSize (int codim) const
    {
      return leafGridView().overlapSize(codim);
    }
 
    DUNE_DEPRECATED_MSG("ghostSize() is deprecated. Use the method on the LevelGridView instead.")
    int ghostSize (int level, int codim) const
    {
      return levelGridView(level).ghostSize(codim);
    }
 
    DUNE_DEPRECATED_MSG("ghostSize() is deprecated. Use the method on the LeafGridView instead.")
    int ghostSize (int codim) const
    {
      return leafGridView().ghostSize(codim);
    }
 
    template<class DataHandleImp, class DataTypeImp>
    DUNE_DEPRECATED_MSG("communicate() is deprecated. Use the method on the LevelGridView instead.")
    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>
    DUNE_DEPRECATED_MSG("communicate() is deprecated. Use the method on the LeafGridView instead.")
    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 > :: Entity
    entity( const EntitySeed& seed ) const
    {
      //CHECK_INTERFACE_IMPLEMENTATION( asImp().entity( seed ) );
      return asImp().entity( 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>
  typename Grid<dim, dimworld, ct, GridFamily>::LevelGridView
  levelGridView(const Grid<dim, dimworld, ct, GridFamily>& grid, int level)
  {
    return grid.levelGridView(level);
  }
 
  template<int dim, int dimworld, class ct, class GridFamily>
  typename Grid<dim, dimworld, ct, GridFamily>::LeafGridView
  leafGridView(const Grid<dim, dimworld, ct, GridFamily>& grid)
  {
    return grid.leafGridView();
  }
 
  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;
 
    typename Traits::LevelGridView levelGridView(int level) const
    {
      typedef typename Traits::LevelGridView View;
      typedef typename View::GridViewImp ViewImp;
      return View(ViewImp(asImp(),level));
    }
 
    typename Traits::LeafGridView leafGridView() const
    {
      typedef typename Traits::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) {}
    };
 
    // This rather involved return type computation does the following:
    //
    // 1) It detects whether the function was passed an lvalue or an
    //    rvalue by checking whether InterfaceType is a reference (in which
    //    case the argument is an lvalue). This relies on the special template
    //    matching rules for unqualified rvalue references.
    // 2) If it is an lvalue, it
    //    - strips the reference from InterfaceType
    //    - uses the resulting type to extract the implementation type
    //    - re-adds an lvalue reference
    //    This procedure transfers a possible cv-qualification from the
    //    interface type to the implementation type
    // 3) If it is an lvalue, it
    //    - strips the reference anyway. This is required to make this TMP
    //      compile if the other branch (lvalue) is taken because in that
    //      case, the compiler still evaluates the rvalue result and without
    //      the reference stripping step, it would pass a reference into
    //      ReturnImplementationType, which would in turn cause a compiler
    //      error.
    //    - looks up the implementation type with the stripped interface type
    //    - removes a possible const from the result; the type is a temporary
    //      anyway, so there is no reason to keep the const qualifier around.
    template <class InterfaceType>
    static typename std::conditional<
      std::is_reference<
        InterfaceType
        >::value,
      typename std::add_lvalue_reference<
        typename ReturnImplementationType<
          typename std::remove_reference<
            InterfaceType
            >::type
          >::ImplementationType
        >::type,
      typename std::remove_const<
        typename ReturnImplementationType<
          typename std::remove_reference<
            InterfaceType
            >::type
          >::ImplementationType
        >::type
      >::type
    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,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> class LevelGridViewTraits,
      template<class> 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::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 Dune::GridView< LeafGridViewTraits< const GridImp > > LeafGridView;
    typedef Dune::GridView< LevelGridViewTraits< const GridImp > > LevelGridView;
 
    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 codim >
    struct hasEntity< Grid< dim, dimworld, ct, GridFamily >, codim >
    {
      static const bool v = hasEntity< typename GridFamily::Traits::Grid, codim >::v;
    };
 
    // 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