LocalView.hpp

#pragma once

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

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

#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{}))
      , treeCache_(makeNodeCache(tree_))
      , nodeIndexSet_(makeNodeIndexSet(globalBasis_->preBasis(), PrefixPath{}))
    {
      static_assert(Dune::models<Dune::Functions::Concept::BasisTree<GridView>, Tree>());
      initializeTree(tree_);
    }

    // NOTE: needs to be implemented manually, because of the reference dependency
    // between members tree_ and treeCache_
    LocalView (LocalView const& other)
      : globalBasis_(other.globalBasis_)
      , element_(other.element_)
      , tree_(other.tree_)
      , treeCache_(makeNodeCache(tree_))
      , nodeIndexSet_(other.nodeIndexSet_)
      , indices_(other.indices_)
    {}

    // Move constructor
    // NOTE: needs to be implemented manually, because of the reference dependency
    // between members tree_ and treeCache_
    LocalView (LocalView&& other)
      : globalBasis_(other.globalBasis_)
      , element_(other.element_)
      , tree_(std::move(other.tree_))
      , treeCache_(makeNodeCache(tree_))
      , nodeIndexSet_(std::move(other.nodeIndexSet_))
      , indices_(std::move(other.indices_))
    {}


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

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

    bool isBound () const
    {
      return element_ != nullptr;
    }

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


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

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

    TreeCache const& treeCache () const
    {
      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 const* element_ = nullptr;
    Tree tree_;
    TreeCache treeCache_;
    NodeIndexSet nodeIndexSet_;
    std::vector<MultiIndex> indices_;
  };

} // end namespace AMDiS