UniqueBorderPartition.hpp

#pragma once

#include <cassert>
#include <set>

#include <dune/common/unused.hh>
#include <dune/common/version.hh>
#include <dune/grid/common/datahandleif.hh>

namespace Dune
{
  // forward declaration
  template <int dim> class UGGrid;
}

namespace AMDiS
{

  template <class Grid>
  class UniqueBorderPartition
      : public Dune::CommDataHandleIF<UniqueBorderPartition<Grid>, int>
  {
    using IdSet = typename Grid::GlobalIdSet;
    using IdType = typename IdSet::IdType;

  public:
    using EntitySet = std::set<IdType>;

  public:

    UniqueBorderPartition(int rank, Grid const& grid)
      : myrank_(rank)
      , idSet_(grid.globalIdSet())
    {}

    // Communicate all entities
    bool contains(int /*dim*/, int /*codim*/) const { return true; }

    // communicate exactly one integer, the rank
    bool fixedSize(int /*dim*/, int /*codim*/) const { return true; }

    // Always contains one int, the rank
    template <class Entity>
    std::size_t size(Entity const& /*e*/) const { return 1; }

    template <class MessageBuffer, class Entity>
    void gather(MessageBuffer& buff, Entity const& /*e*/) const
    {
      buff.write(myrank_);
    }

    template <class MessageBuffer, class Entity>
    void scatter(MessageBuffer& buff, Entity const& e, std::size_t n)
    {
      scatterImpl(buff, e, n, int_t<Entity::codimension>{});
    }

    bool contains(IdType const& id) const
    {
      return notOwner_.count(id) == 0;
    }

    int numIterations() const
    {
      return 1;
    }

  private:

    template <class MessageBuffer, class Entity, int cd>
    void scatterImpl(MessageBuffer& buff, Entity const& e, [[maybe_unused]] std::size_t n, int_t<cd>)
    {
      assert(n == 1);

      int rank = 0;
      buff.read(rank);

      // insert only border entities that are owned by other processors, i.e. rank > myrank
      // Those entities are not owned by this rank.
      if (rank > myrank_)
        notOwner_.insert(idSet_.id(e));
    }

    template <class MessageBuffer, class Entity>
    void scatterImpl(MessageBuffer& buff, Entity const& e, [[maybe_unused]] std::size_t n, int_t<0>)
    {
      assert(n == 1);

      int rank = 0;
      buff.read(rank);

      // insert only border entities that are owned by other processors, i.e. rank > myrank
      // Those entities are not owned by this rank.
      if (rank > myrank_) {
        for (int codim = 1; codim <= Grid::dimension; ++codim) {
          for (int i = 0; i < int(e.subEntities(codim)); ++i) {
            notOwner_.insert(idSet_.subId(e, i, codim));
          }
        }
      }
    }

  private:
    int myrank_;
    EntitySet notOwner_;
    IdSet const& idSet_;
  };

} // end namespace AMDiS