ParallelGlobalBasis.hpp

#pragma once


#include <algorithm>
#include <list>
#include <memory>
#include <type_traits>
#include <utility>

#include <dune/common/concept.hh>
#include <dune/common/reservedvector.hh>
#include <dune/common/shared_ptr.hh>
#include <dune/common/typeutilities.hh>
#include <dune/common/version.hh>

#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/defaultglobalbasis.hh>
#include <dune/functions/functionspacebases/defaultlocalview.hh>
#include <dune/functions/functionspacebases/flatmultiindex.hh>

#include <dune/grid/common/adaptcallback.hh>

#include <dune/typetree/treepath.hh>

#include <amdis/AdaptiveGrid.hpp>
#include <amdis/Observer.hpp>
#include <amdis/Output.hpp>
#include <amdis/common/Concepts.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/linearalgebra/Traits.hpp>
#include <amdis/typetree/MultiIndex.hpp>

#if DUNE_VERSION_LT(DUNE_FUNCTIONS,2,7)
#include <dune/functions/functionspacebases/defaultlocalindexset.hh>
#endif

namespace AMDiS
{
  /**
   * \brief Parallel global basis defined on a (sequential) pre-basis
   *
   * This class is an expansion to Dune::Functions::DefaultGlobalBasis<PB>. It adds a communicator
   * to use the basis in parallel as well as automatic update functionality.
   *
   * \tparam PB  Pre-basis providing the implementation details
   */
  template <class PB>
  class ParallelGlobalBasis
      : public Dune::Functions::DefaultGlobalBasis<PB>
      , public Notifier<event::adapt>
      , private Observer<event::adapt>
  {
    using Self = ParallelGlobalBasis<PB>;
    using Super = Dune::Functions::DefaultGlobalBasis<PB>;

  public:
    /// Pre-basis providing the implementation details
    using PreBasis = PB;

    /// The grid view that the FE space is defined on
    using GridView = typename PreBasis::GridView;
    using Grid = typename GridView::Grid;

    /// Type of the local view on the restriction of the basis to a single element
    using LocalView = Dune::Functions::DefaultLocalView<Self>;

    /// Type of the communicator
    using Comm = std::conditional_t<Traits::IsFlatIndex<typename Super::MultiIndex>::value,
      typename BackendTraits<Self>::Comm,
      SequentialCommunication>;

    struct DummyImpl {};
    using ADH = Dune::AdaptDataHandle<Grid, DummyImpl>;


  public:

    /// Construct this global basis with given name and grid, and constructing a preBasis.
    /**
     * \param name     Name associated with this basis for initfile parameter attachment.
     * \param grid     The Grid providing the GridView for this basis
     * \param args...  Argument list for PreBasis
     *
     * This will forward all arguments to the constructor of PreBasis
     */
    template <class... Args,
      Dune::Functions::enableIfConstructible<PreBasis, Args...> = 0>
    ParallelGlobalBasis(std::string const& name, Grid const& grid, Args&&... args)
      : Super(FWD(args)...)
      , Observer<event::adapt>(grid)
      , comm_(CommunicationCreator<Comm>::create(static_cast<Super const&>(*this), name + "->solver"))
    {}

    /// Construct this global basis with empty name
    template <class... Args,
      Dune::Functions::enableIfConstructible<PreBasis, Args...> = 0>
    ParallelGlobalBasis(Grid const& grid, Args&&... args)
      : ParallelGlobalBasis(std::string(""), grid, FWD(args)...)
    {}

    /// Converting constructor from dune-functions style basis.
    /**
     *  This will create a new ParallelGlobalBasis. The pre-basis is copied from the constructor
     *  argument and a new communication object is built.
     */
    template <class GB_,
      Dune::disableCopyMove<Self, GB_> = 0,
      REQUIRES(Concepts::GlobalBasis<GB_,GridView>)>
    ParallelGlobalBasis(GB_&& from)
      : ParallelGlobalBasis(std::string(""), from.gridView().grid(), from.preBasis())
    {}

    /// Copy constructor
    ParallelGlobalBasis(ParallelGlobalBasis const&) = delete;

    /// Move constructor
    ParallelGlobalBasis(ParallelGlobalBasis&&) = default;

  public:

    /// \brief Update the stored grid view
    /**
     * This will update the indexing information of the global basis as well as the communicator.
     * It is called automatically if the grid has changed.
     */
    void update(GridView const& gv)
    {
      Super::preBasis().update(gv);
      Super::preBasis().initializeIndices();
      comm_.update(*this);
    }

    /// Return local view for basis
    LocalView localView() const
    {
      return LocalView(*this);
    }

    /// Return *this because we are not embedded in a larger basis
    ParallelGlobalBasis const& rootBasis() const
    {
      return *this;
    }

    /// \brief Return the communicator.
    /**
     * This provides the means to communicate data associated to the basis with
     * other processes.
     **/
    Comm const& communicator() const  { return comm_; }
    Comm&       communicator()        { return comm_; }

    ADH globalRefineCallback() const
    {
      // TODO(FM): Implement
      error_exit("Not implemented: ParallelGlobalBasis::globalRefineCallback()");
      return ADH{};
    }

  protected:
    /// Updates the underlying basis when event::adapt is triggered by the observed grid
    void updateImpl(event::adapt e) override
    {
      if (e.value) {
        update(Super::gridView());
        Notifier<event::adapt>::notify(e);
      }
    }

    using Observer<event::adapt>::update;

  protected:
    Comm comm_;
  };


  template <class MultiIndex, class GV, class PBF>
  auto makeGlobalBasis(std::string const& name, GV const& gridView, PBF&& preBasisFactory)
  {
    auto preBasis = preBasisFactory.template makePreBasis<MultiIndex>(gridView);
    return ParallelGlobalBasis<TYPEOF(preBasis)>(name, gridView.grid(), std::move(preBasis));
  }

  template <class GV, class PBF>
  auto makeGlobalBasis(std::string const& name, GV const& gridView, PBF&& preBasisFactory)
  {
    using RawPreBasisFactory = remove_cvref_t<PBF>;
    using MultiIndex = std::conditional_t<
      (RawPreBasisFactory::requiredMultiIndexSize == 1),
      Dune::Functions::FlatMultiIndex<std::size_t>,
      Dune::ReservedVector<std::size_t, RawPreBasisFactory::requiredMultiIndexSize>>;

    return makeGlobalBasis<MultiIndex, GV, PBF>(name, gridView, FWD(preBasisFactory));
  }

  template <class GV, class PBF>
  auto makeGlobalBasis(GV const& gridView, PBF&& preBasisFactory)
  {
    return makeGlobalBasis(std::string(""), gridView, FWD(preBasisFactory));
  }

} // end namespace AMDiS