GlobalBasis.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/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/functions/FlatPreBasis.hpp>
#include <amdis/functions/LocalView.hpp>
#include <amdis/linearalgebra/Traits.hpp>
#include <amdis/typetree/MultiIndex.hpp>

namespace AMDiS
{
  template <class PreBasisFactory, class PBF = remove_cvref_t<PreBasisFactory>>
  using MultiIndex_t = std::conditional_t<(PBF::requiredMultiIndexSize == 1),
    Dune::Functions::FlatMultiIndex<std::size_t>,
    Dune::ReservedVector<std::size_t, PBF::requiredMultiIndexSize>>;


  template <class PB>
  class GlobalBasis
      : public Dune::Functions::DefaultGlobalBasis<PB>
      , public Notifier<event::adapt>
      , private Observer<event::adapt>
  {
    using Self = GlobalBasis<PB>;
    using Super = Dune::Functions::DefaultGlobalBasis<PB>;

  public:
    using PreBasis = PB;

    using GridView = typename PreBasis::GridView;
    using Grid = typename GridView::Grid;

    using LocalView = AMDiS::LocalView<Self>;

    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:

    template <class... Args,
      Dune::Functions::enableIfConstructible<PreBasis, Args...> = 0>
    GlobalBasis(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"))
    {}

    template <class PBF>
    GlobalBasis(std::string const& name, GridView const& gridView,
                PBF const& preBasisFactory)
      : GlobalBasis(name, gridView.grid(),
          flatPreBasis(preBasisFactory.template makePreBasis<MultiIndex_t<PBF>>(gridView)))
    {}

    template <class Arg, class... Args,
      REQUIRES(!std::is_same_v<std::string, remove_cvref_t<Arg>>)>
    GlobalBasis(Arg&& arg, Args&&... args)
      : GlobalBasis(std::string(""), FWD(arg), FWD(args)...)
    {}

    GlobalBasis(GlobalBasis const&) = delete;

    GlobalBasis(GlobalBasis&&) = default;

  public:

    void update(GridView const& gv)
    {
      Super::preBasis().update(gv);
      Super::preBasis().initializeIndices();
      comm_.update(*this);
    }

    LocalView localView() const
    {
      return LocalView(*this);
    }

    std::shared_ptr<LocalView> localViewPtr() const
    {
      return std::make_shared<LocalView>(*this);
    }

    GlobalBasis const& rootBasis() const
    {
      return *this;
    }


    Comm const& communicator() const  { return comm_; }
    Comm&       communicator()        { return comm_; }

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

  protected:
    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_;
  };


  // Deduction guides
  template <class GV, class PBF>
  GlobalBasis(std::string const& name, GV const& gridView, PBF const& preBasisFactory)
    -> GlobalBasis<decltype(flatPreBasis(
          preBasisFactory.template makePreBasis<MultiIndex_t<PBF>>(gridView)))>;

  template <class GV, class PBF>
  GlobalBasis(GV const& gridView, PBF const& preBasisFactory)
    -> GlobalBasis<decltype(flatPreBasis(
          preBasisFactory.template makePreBasis<MultiIndex_t<PBF>>(gridView)))>;

} // end namespace AMDiS