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/multiindex.hh>
#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/defaultglobalbasis.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/IndexDistribution.hpp>
#include <amdis/linearalgebra/Traits.hpp>
#include <amdis/typetree/MultiIndex.hpp>
 
namespace AMDiS
{
  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 IndexDist = BackendTraits::IndexDist<Self>;
 
    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)
      , indexDist_(static_cast<Super const&>(*this))
    {}
 
    template <class PBF>
    GlobalBasis(std::string const& name, GridView const& gridView,
                PBF const& preBasisFactory)
      : GlobalBasis(name, gridView.grid(), flatPreBasis(preBasisFactory(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();
      indexDist_.update(*this);
    }
 
    LocalView localView() const
    {
      return LocalView(*this);
    }
 
    std::shared_ptr<LocalView> localViewPtr() const
    {
      return std::make_shared<LocalView>(*this);
    }
 
    auto entitySet() const
    {
      return elements(this->gridView(), BackendTraits::PartitionSet{});
    }
 
    GlobalBasis const& rootBasis() const
    {
      return *this;
    }
 
 
    IndexDist const& indexDistribution() const  { return indexDist_; }
    IndexDist&       indexDistribution()        { return indexDist_; }
 
    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:
    IndexDist indexDist_;
  };
 
 
  // Deduction guides
  template <class GV, class PBF>
  GlobalBasis(std::string const& name, GV const& gridView, PBF const& preBasisFactory)
    -> GlobalBasis<std::decay_t<decltype(flatPreBasis(preBasisFactory(gridView)))>>;
 
  template <class GV, class PBF>
  GlobalBasis(GV const& gridView, PBF const& preBasisFactory)
    -> GlobalBasis<std::decay_t<decltype(flatPreBasis(preBasisFactory(gridView)))>>;
 
} // end namespace AMDiS