LocalView.hpp

#pragma once

#include <tuple>
#include <optional>
#include <vector>

#include <dune/common/concept.hh>
#include <dune/functions/functionspacebases/concepts.hh>

#include <amdis/common/OptionalNoCopy.hpp>
#include <amdis/common/TypeTraits.hpp>
#include <amdis/functions/NodeCache.hpp>
#include <amdis/functions/Nodes.hpp>

// NOTE: This is a variant of dune-functions DefaultLocalView

namespace AMDiS
{
  template <class GB>
  class LocalView
  {
    using PrefixPath = Dune::TypeTree::HybridTreePath<>;

    // Node index set provided by PreBasis
    using NodeIndexSet = NodeIndexSet_t<typename GB::PreBasis, PrefixPath>;

  public:
    using GlobalBasis = GB;

    using GridView = typename GlobalBasis::GridView;

    using Element = typename GridView::template Codim<0>::Entity;

    using size_type = std::size_t;

    using Tree = Node_t<typename GlobalBasis::PreBasis, PrefixPath>;

    using TreeCache = NodeCache_t<Tree>;

    using MultiIndex = typename GlobalBasis::PreBasis::MultiIndex;

  public:
    LocalView (GlobalBasis const& globalBasis)
      : globalBasis_(&globalBasis)
      , tree_(makeNode(globalBasis_->preBasis(), PrefixPath{}))
      , nodeIndexSet_(makeNodeIndexSet(globalBasis_->preBasis(), PrefixPath{}))
    {
      static_assert(Dune::models<Dune::Functions::Concept::BasisTree<GridView>, Tree>());
      initializeTree(tree_);
    }


    void bind (Element const& element)
    {
      element_ = element;
      bindTree(tree_, element_);
      indices_.resize(tree_.size());
      bindNodeIndexSet(globalBasis_->preBasis(), nodeIndexSet_, tree_, indices_.begin(), Dune::PriorityTag<5>{});
      bound_ = true;
    }

    // do not bind an rvalue-reference
    void bind (Element&& element)
    {
      static_assert(not std::is_rvalue_reference_v<Element&&>);
    }

    bool isBound () const
    {
      return bound_;
    }

    Element const& element () const
    {
      assert(isBound());
      return element_;
    }


    void unbind ()
    {
      unbindNodeIndexSet(nodeIndexSet_, Dune::PriorityTag<5>{});
      bound_ = false;
    }

    Tree const& tree () const
    {
      return tree_;
    }

    TreeCache const& treeCache () const
    {
      if (!treeCache_)
        treeCache_.emplace(makeNodeCache(tree_));

      return *treeCache_;
    }

    size_type size () const
    {
      assert(isBound());
      return tree_.size();
    }


    size_type maxSize () const
    {
      return globalBasis_->preBasis().maxNodeSize();
    }

    MultiIndex index (size_type i) const
    {
      assert(isBound());
      return indices_[i];
    }

    GlobalBasis const& globalBasis () const
    {
      return *globalBasis_;
    }

    LocalView const& rootLocalView () const
    {
      return *this;
    }

  private:
    template <class PB, class NIS, class Tree, class Iter,
      class = decltype(std::declval<PB>().indices(std::declval<Tree>(), std::declval<Iter>()))>
    static void bindNodeIndexSet(PB const& preBasis, NIS& /*nodeIndexSet*/, Tree const& tree, Iter it, Dune::PriorityTag<3>)
    {
      preBasis.indices(tree, it);
    }

    template <class PB, class NIS, class Tree, class Iter,
      class = decltype(std::declval<NIS>().bind(std::declval<Tree>())),
      class = decltype(std::declval<NIS>().indices(std::declval<Iter>()))>
    static void bindNodeIndexSet(PB const& /*preBasis*/, NIS& nodeIndexSet, Tree const& tree, Iter it, Dune::PriorityTag<2>)
    {
      nodeIndexSet.bind(tree);
      nodeIndexSet.indices(it);
    }

    template <class PB, class NIS, class Tree, class Iter,
      class = decltype(std::declval<NIS>().bind(std::declval<Tree>())),
      class = decltype(std::declval<NIS>().index(0u))>
    static void bindNodeIndexSet(PB const& /*preBasis*/, NIS& nodeIndexSet, Tree const& tree, Iter it, Dune::PriorityTag<1>)
    {
      nodeIndexSet.bind(tree);
      for (size_type i = 0; i < tree.size(); ++i)
        *it++ = nodeIndexSet.index(i);
    }

    template <class PB, class NIS, class Tree, class Iter>
    static void bindNodeIndexSet(PB const& /*preBasis*/, NIS& /*nodeIndexSet*/, Tree const& /*tree*/, Iter /*it*/, Dune::PriorityTag<0>)
    {
      /* do nothing */
    }

    template <class NIS,
      class = decltype(std::declval<NIS>().unbind())>
    static void unbindNodeIndexSet(NIS& nodeIndexSet, Dune::PriorityTag<1>)
    {
      nodeIndexSet.unbind();
    }

    template <class NIS>
    static void unbindNodeIndexSet(NIS& /*nodeIndexSet*/, Dune::PriorityTag<0>)
    {
      /* do nothing */
    }

  protected:
    GlobalBasis const* globalBasis_;
    Element element_;
    Tree tree_;
    NodeIndexSet nodeIndexSet_;

    mutable OptionalNoCopy<TreeCache> treeCache_ = std::nullopt;
    std::vector<MultiIndex> indices_ = {};
    bool bound_ = false;
  };

} // end namespace AMDiS