macrogridview.hh

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=8 sw=2 sts=2:
#ifndef DUNE_ALUGRID_MACROGRIDVIEW_HH
#define DUNE_ALUGRID_MACROGRIDVIEW_HH
 
#include <type_traits>
 
#include <dune/common/version.hh>
#include <dune/common/exceptions.hh>
 
#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/gridview.hh>
 
namespace Dune
{
 
  template< class GridImp, PartitionIteratorType pitype >
  class MacroGridView;
 
  template< class GridImp, PartitionIteratorType pitype >
  struct MacroGridViewTraits
  {
    typedef MacroGridView< GridImp, pitype > GridViewImp;
 
    typedef typename std::remove_const<GridImp>::type Grid;
 
    typedef typename Grid :: Traits :: LevelIndexSet IndexSet;
 
    typedef typename Grid :: Traits :: LevelIntersection Intersection;
 
    typedef typename Grid :: Traits :: LevelIntersectionIterator
      IntersectionIterator;
 
    typedef typename Grid :: Traits :: Communication Communication;
 
    template< int cd >
    struct Codim
    {
      typedef typename Grid :: Traits
        :: template Codim< cd > :: template Partition< pitype > :: LevelIterator
        Iterator;
 
      typedef typename Grid :: Traits :: template Codim< cd > :: Entity Entity;
 
      typedef typename Grid :: template Codim< cd > :: Geometry Geometry;
      typedef typename Grid :: template Codim< cd > :: LocalGeometry
        LocalGeometry;
 
      template< PartitionIteratorType pit >
      struct Partition
      {
        typedef typename Grid :: template Codim< cd >
          :: template Partition< pit > :: LevelIterator
          Iterator;
      };
    };
 
    enum { conforming = Capabilities :: isLevelwiseConforming< Grid > :: v };
  };
 
 
  template< class GridImp, PartitionIteratorType pitype >
  class MacroGridView
  {
    typedef MacroGridView< GridImp, pitype > ThisType;
 
  public:
 
 
    typedef MacroGridViewTraits< GridImp, pitype > Traits;
 
    typedef typename Traits::Grid Grid;
 
    typedef typename Traits :: IndexSet IndexSet;
 
    typedef typename Traits :: Intersection Intersection;
 
    typedef typename Traits :: IntersectionIterator IntersectionIterator;
 
    typedef typename Traits :: Communication Communication;
 
    template< int cd >
    struct Codim : public Traits :: template Codim<cd> {};
 
    enum {
      conforming = Traits :: conforming
    };
 
    typedef typename Grid::ctype ctype;
 
    enum { 
      dimension = Grid :: dimension
    };
 
    enum { 
      dimensionworld = Grid :: dimensionworld
    };
 
    MacroGridView ( const Grid &grid )
    : grid_( &grid ),
      level_( 0 )
    {}
 
    const Grid &grid () const
    {
      assert( grid_ );
      return *grid_;
    }
 
    const IndexSet &indexSet () const
    {
      return grid().levelIndexSet( level_ );
    }
 
    bool isConforming() const
    {
      // the macro level is always conforming
      return true;
    }
 
    int size ( int codim ) const
    {
      return grid().size( level_, codim );
    }
 
    int size ( const GeometryType &type ) const
    {
      return grid().size( level_, type );
    }
 
    template< int cd >
    typename Codim< cd > :: Iterator begin () const
    {
      return grid().template lbegin< cd, pitype >( level_ );
    }
 
    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator begin () const
    {
      return grid().template lbegin< cd, pit >( level_ );
    }
 
    template< int cd >
    typename Codim< cd > :: Iterator end () const
    {
      return grid().template lend< cd, pitype >( level_ );
    }
 
    template< int cd, PartitionIteratorType pit >
    typename Codim< cd > :: template Partition< pit > :: Iterator end () const
    {
      return grid().template lend< cd, pit >( level_ );
    }
 
    IntersectionIterator
    ibegin ( const typename Codim< 0 > :: Entity &entity ) const
    {
      assert( entity.level() == level_ );
      return grid().ilevelbegin( entity );
    }
 
    IntersectionIterator
    iend ( const typename Codim< 0 > :: Entity &entity ) const
    {
      assert( entity.level() == level_ );
      return grid().ilevelend( entity );
    }
 
    const Communication &comm () const
    {
      return grid().comm();
    }
 
    int overlapSize(int codim) const
    {
      return grid().overlapSize(level_, codim);
    }
 
    int ghostSize(int codim) const
    {
      return grid().ghostSize(level_, codim);
    }
 
    template< class DataHandleImp, class DataType >
    void communicate ( CommDataHandleIF< DataHandleImp, DataType > &data,
                       InterfaceType iftype,
                       CommunicationDirection dir ) const
    {
      return grid().communicate( data, iftype, dir, level_ );
    }
 
    //
    // extra interface methods for load balancing
    //
 
    int master ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return entity.impl().master();
    }
 
    int macroId ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return entity.impl().macroId();
    }
 
    int weight ( const typename Codim< 0 > :: Entity &entity ) const
    {
      return entity.impl().weight();
    }
 
    int weight ( const Intersection &intersection ) const
    {
      return intersection.impl().weight();
    }
 
  protected:
    const Grid *grid_;
    const int level_;
  };
}
 
#endif