DefaultGridView.hpp

#pragma once
 
#include <dune/common/typetraits.hh>
#include <dune/common/exceptions.hh>
#include <dune/common/std/type_traits.hh>
 
#include <dune/grid/common/capabilities.hh>
#include <dune/grid/common/gridview.hh>
 
namespace AMDiS
{
  /*
   * NOTE: this is a modification of dune/grid/common/defaultgridview.hh since we
   * want all implementation specific methods to be put into the grid class and not
   * into the entity class. See ibegin(), iend().
   */
 
  template <class GridImp>
  class DefaultLevelGridView;
 
  template <class GridImp>
  class DefaultLeafGridView;
 
 
  template <class GridImp>
  struct DefaultLevelGridViewTraits
  {
    using GridViewImp = DefaultLevelGridView<GridImp>;
 
    using Grid = std::remove_const_t<GridImp>;
 
    using IndexSet = typename Grid::Traits::LevelIndexSet;
 
    using Intersection = typename Grid::Traits::LevelIntersection;
 
    using IntersectionIterator = typename Grid::Traits::LevelIntersectionIterator;
 
    using Communication = typename Grid::Traits::Communication;
 
    template <int cd>
    struct Codim
    {
      using Entity = typename Grid::Traits::template Codim<cd>::Entity;
      using Geometry = typename Grid::template Codim<cd>::Geometry;
      using LocalGeometry = typename Grid::template Codim<cd>::LocalGeometry;
 
      template <Dune::PartitionIteratorType pit>
      struct Partition
      {
        using Iterator = typename Grid::template Codim<cd>::template Partition<pit>::LevelIterator;
      };
 
      using Iterator = typename Partition<Dune::All_Partition>::Iterator;
    };
 
    enum { conforming = Dune::Capabilities::isLevelwiseConforming<Grid>::v };
  };
 
 
  template <class GridImp>
  class DefaultLevelGridView
  {
  public:
    using Traits = DefaultLevelGridViewTraits<GridImp>;
    using Grid = typename Traits::Grid;
    using IndexSet = typename Traits::IndexSet;
    using Intersection = typename Traits::Intersection;
    using IntersectionIterator = typename Traits::IntersectionIterator;
    using Communication = typename Traits::Communication;
 
    template <int cd>
    using Codim = typename Traits::template Codim<cd>;
 
    enum { conforming = Traits::conforming };
 
  public:
    DefaultLevelGridView(Grid const& grid, int level)
      : grid_(&grid)
      , level_(level)
    {}
 
    Grid const& grid() const
    {
      assert(grid_);
      return *grid_;
    }
 
    IndexSet const& indexSet() const
    {
      return grid().levelIndexSet(level_);
    }
 
    int size(int codim) const
    {
      return grid().size(level_, codim);
    }
 
    int size(Dune::GeometryType const& type) const
    {
      return grid().size(level_, type);
    }
 
    template <int cd, Dune::PartitionIteratorType pit = Dune::All_Partition>
    typename Codim<cd>::template Partition<pit>::Iterator begin() const
    {
      return grid().template lbegin<cd, pit>(level_);
    }
 
    template <int cd, Dune::PartitionIteratorType pit = Dune::All_Partition>
    typename Codim<cd>::template Partition<pit>::Iterator end() const
    {
      return grid().template lend<cd, pit>(level_);
    }
 
    IntersectionIterator ibegin(typename Codim<0>::Entity const& entity) const
    {
      return grid().ilevelbegin(entity);
    }
 
    IntersectionIterator iend(typename Codim<0>::Entity const& entity) const
    {
      return grid().ilevelend(entity);
    }
 
    bool isConforming() const
    {
      return grid().isLevelwiseConforming(level_);
    }
 
    Communication const& 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(Dune::CommDataHandleIF<DataHandleImp, DataType>& data,
                     Dune::InterfaceType iftype,
                     Dune::CommunicationDirection dir) const
    {
      return grid().communicate(data, iftype, dir, level_);
    }
 
  private:
    Grid const* grid_;
    int level_;
  };
 
 
  template <class GridImp>
  struct DefaultLeafGridViewTraits
  {
    using GridViewImp = DefaultLeafGridView<GridImp>;
 
    using Grid = std::remove_const_t<GridImp>;
 
    using IndexSet = typename Grid::Traits::LeafIndexSet;
 
    using Intersection = typename Grid::Traits::LeafIntersection;
 
    using IntersectionIterator = typename Grid::Traits::LeafIntersectionIterator;
 
    using Communication = typename Grid::Traits::Communication;
 
    template <int cd>
    struct Codim
    {
      using Entity = typename Grid::Traits::template Codim<cd>::Entity;
      using Geometry = typename Grid::template Codim<cd>::Geometry;
      using LocalGeometry = typename Grid::template Codim<cd>::LocalGeometry;
 
      template <Dune::PartitionIteratorType pit>
      struct Partition
      {
        using Iterator = typename Grid::template Codim<cd>::template Partition<pit>::LeafIterator;
      };
 
      using Iterator = typename Partition<Dune::All_Partition>::Iterator;
    };
 
    enum { conforming = Dune::Capabilities::isLeafwiseConforming<Grid>::v };
  };
 
 
  template <class GridImp>
  class DefaultLeafGridView
  {
  public:
    using Traits = DefaultLeafGridViewTraits<GridImp>;
    using Grid = typename Traits::Grid;
    using IndexSet = typename Traits::IndexSet;
    using Intersection = typename Traits::Intersection;
    using IntersectionIterator = typename Traits::IntersectionIterator;
    using Communication = typename Traits::Communication;
 
    template <int cd>
    using Codim = typename Traits::template Codim<cd>;
 
    enum { conforming = Traits::conforming };
 
  public:
    DefaultLeafGridView(Grid const& grid)
      : grid_(&grid)
    {}
 
    Grid const& grid() const
    {
      assert(grid_);
      return *grid_;
    }
 
    IndexSet const& indexSet() const
    {
      return grid().leafIndexSet();
    }
 
    int size(int codim) const
    {
      return grid().size(codim);
    }
 
    int size(Dune::GeometryType const& type) const
    {
      return grid().size(type);
    }
 
 
    template <int cd, Dune::PartitionIteratorType pit = Dune::All_Partition>
    typename Codim<cd>::template Partition<pit>::Iterator begin() const
    {
      return grid().template leafbegin<cd, pit>();
    }
 
    template <int cd, Dune::PartitionIteratorType pit = Dune::All_Partition>
    typename Codim<cd>::template Partition<pit>::Iterator end() const
    {
      return grid().template leafend<cd, pit>();
    }
 
    IntersectionIterator ibegin(typename Codim<0>::Entity const& entity) const
    {
      return grid().ileafbegin(entity);
    }
 
    IntersectionIterator iend(typename Codim<0>::Entity const& entity) const
    {
      return grid().ileafend(entity);
    }
 
    bool isConforming() const
    {
      return grid().isLeafwiseConforming();
    }
 
    Communication const& comm() const
    {
      return grid().comm();
    }
 
    int overlapSize(int codim) const
    {
      return grid().overlapSize(codim);
    }
 
    int ghostSize(int codim) const
    {
      return grid().ghostSize(codim);
    }
 
    template <class DataHandleImp, class DataType>
    void communicate(Dune::CommDataHandleIF<DataHandleImp, DataType>& data,
                     Dune::InterfaceType iftype,
                     Dune::CommunicationDirection dir) const
    {
      return grid().communicate(data, iftype, dir);
    }
 
  private:
    Grid const* grid_;
  };
 
} // end namespace AMDiS