LocalView.hpp

#pragma once

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

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

#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 NodeIndexSet::MultiIndex;

  private:
    template <class NIS>
    using hasIndices = decltype(std::declval<NIS>().indices(std::declval<std::vector<typename NIS::MultiIndex>>().begin()));

  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_);
    }


    void bind (Element const& element)
    {
      element_ = element;
      bindTree(tree_, *element_);
      nodeIndexSet_.bind(tree_);
      indices_.resize(size());

      if constexpr (Dune::Std::is_detected<hasIndices,NodeIndexSet>{})
        nodeIndexSet_.indices(indices_.begin());
      else
        for (size_type i = 0; i < size(); ++i)
          indices_[i] = nodeIndexSet_.index(i);
    }

    bool isBound () const
    {
      return bool(element_);
    }

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


    void unbind ()
    {
      nodeIndexSet_.unbind();
      element_.reset();
    }

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

    TreeCache const& treeCache () const
    {
      return treeCache_;
    }

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


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

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

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

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

  protected:
    GlobalBasis const* globalBasis_;
    std::optional<Element> element_;
    Tree tree_;
    TreeCache treeCache_;
    NodeIndexSet nodeIndexSet_;
    std::vector<MultiIndex> indices_;
  };

} // end namespace AMDiS