DefaultGridView.hpp

#pragma once

#include <dune/common/typetraits.hh>
#include <dune/common/exceptions.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 CollectiveCommunication = typename Grid::Traits::CollectiveCommunication;

    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 CollectiveCommunication = typename Traits::CollectiveCommunication;

    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);
    }

    CollectiveCommunication 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 CollectiveCommunication = typename Grid::Traits::CollectiveCommunication;

    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 CollectiveCommunication = typename Traits::CollectiveCommunication;

    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);
    }

    CollectiveCommunication 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