IndexDistribution.hpp

#pragma once
 
#include <memory>
#include <optional>
#include <string>
 
#include <dune/istl/owneroverlapcopy.hh>
#include <dune/istl/solvercategory.hh>
#include <dune/istl/paamg/pinfo.hh>
 
#include <amdis/Environment.hpp>
#include <amdis/functions/GlobalIdSet.hpp>
#include <amdis/linearalgebra/IndexDistribution.hpp>
#include <amdis/linearalgebra/ParallelIndexSet.hpp>
 
namespace AMDiS
{
  class SequentialISTLIndexDistribution
  {
    using Impl = Dune::Amg::SequentialInformation;
 
  public:
    using Sequential = SequentialISTLIndexDistribution;
 
    SequentialISTLIndexDistribution() = default;
 
    template <class Basis>
    SequentialISTLIndexDistribution(Basis const&)
    {}
 
    typename Dune::SolverCategory::Category category() const
    {
      return Dune::SolverCategory::sequential;
    }
 
    Impl const& impl() const
    {
      return impl_;
    }
 
    Sequential const& sequential() const
    {
      return *this;
    }
 
    template <class Basis>
    void update(Basis const&) { /* do nothing */ }
 
  private:
    Impl impl_;
  };
 
 
  template <class G, class L, class Comm>
  struct ISTLIndexDistributionType
  {
    using type = SequentialISTLIndexDistribution;
  };
 
#if HAVE_MPI
  template <class GlobalId, class LocalIndex>
  class ISTLIndexDistribution
  {
    using Impl = Dune::OwnerOverlapCopyCommunication<GlobalId, LocalIndex>;
 
  public:
    using Sequential = SequentialISTLIndexDistribution;
    using IndexSet = typename Impl::ParallelIndexSet;
    using RemoteIndices = typename Impl::RemoteIndices;
 
  public:
    template <class Basis>
    ISTLIndexDistribution(Basis const& basis);
 
    IndexSet const& indexSet() const
    {
      assert(bool(impl_));
      return impl_->indexSet();
    }
 
    RemoteIndices const& remoteIndices() const
    {
      assert(bool(impl_));
      return impl_->remoteIndices();
    }
 
    typename Dune::SolverCategory::Category category() const
    {
      return cat_;
    }
 
    Impl const& impl() const
    {
      assert(bool(impl_));
      return *impl_;
    }
 
    Sequential sequential() const
    {
      return Sequential{};
    }
 
    template <class Basis>
    void update(Basis const& basis)
    {
      impl_ = std::make_unique<Impl>(MPI_Comm(basis.gridView().comm()), cat_);
 
      auto& pis = impl_->indexSet();
      buildParallelIndexSet(basis, pis);
 
      auto& ris = impl_->remoteIndices();
      ris.setIndexSets(pis, pis, impl_->communicator());
      ris.template rebuild<true>();
    }
 
  private:
    typename Dune::SolverCategory::Category cat_;
    std::unique_ptr<Impl> impl_ = nullptr;
  };
 
  template <class G, class L>
  struct ISTLIndexDistributionType<G,L,Dune::Communication<MPI_Comm>>
  {
    using type = ISTLIndexDistribution<G,L>;
  };
 
#endif
 
  template <class B>
  using ISTLIndexDistribution_t
    = typename ISTLIndexDistributionType<GlobalIdType_t<B>, typename B::size_type, typename B::GridView::CollectiveCommunication>::type;
 
} // end namespace AMDiS
 
#include <amdis/linearalgebra/istl/IndexDistribution.inc.hpp>