defaultlocalview.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTLOCALVIEW_HH
#define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTLOCALVIEW_HH
 
 
#include <tuple>
#include <optional>
 
#include <dune/common/concept.hh>
#include <dune/common/hybridutilities.hh>
#include <dune/common/reservedvector.hh>
 
#include <dune/functions/common/overflowarray.hh>
#include <dune/functions/common/multiindex.hh>
#include <dune/functions/functionspacebases/concepts.hh>
 
 
 
namespace Dune {
namespace Functions {
 
 
 
template<class GB>
class DefaultLocalView
{
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 = typename GlobalBasis::PreBasis::Node;
 
protected:
 
  using PreBasis = typename GlobalBasis::PreBasis;
 
  // Type used to store the multi indices of the basis vectors.
  // In contrast to MultiIndex this always has dynamic size.
  // It's guaranteed, that you can always cast it to MultiIndex
  using MultiIndexStorage =
      std::conditional_t<(PreBasis::minMultiIndexSize == PreBasis::maxMultiIndexSize),
        OverflowArray<StaticMultiIndex<size_type, PreBasis::maxMultiIndexSize>, PreBasis::multiIndexBufferSize>,
        Dune::ReservedVector<size_type, PreBasis::multiIndexBufferSize>>;
 
public:
 
  using MultiIndex =
      std::conditional_t<(PreBasis::minMultiIndexSize == PreBasis::maxMultiIndexSize),
        StaticMultiIndex<size_type, PreBasis::maxMultiIndexSize>,
        Dune::ReservedVector<size_type, PreBasis::multiIndexBufferSize>>;
 
 
  DefaultLocalView(const GlobalBasis& globalBasis) :
    globalBasis_(&globalBasis),
    tree_(globalBasis_->preBasis().makeNode())
  {
    static_assert(models<Concept::BasisTree<GridView>, Tree>(), "Tree type passed to DefaultLocalView does not model the BasisNode concept.");
    initializeTree(tree_);
  }
 
  void bind(const Element& e)
  {
    element_ = e;
    bindTree(tree_, *element_);
    indices_.resize(size());
    globalBasis_->preBasis().indices(tree_, indices_.begin());
  }
 
  [[deprecated("Use the bound() method instead")]]
  bool isBound() const {
    return static_cast<bool>(element_);
  }
 
  bool bound() const
  {
    return static_cast<bool>(element_);
  }
 
  const Element& element() const
  {
    return *element_;
  }
 
  void unbind()
  {
    element_.reset();
  }
 
  const Tree& tree() const
  {
    return tree_;
  }
 
  size_type size() const
  {
    return tree_.size();
  }
 
  size_type maxSize() const
  {
    return globalBasis_->preBasis().maxNodeSize();
  }
 
  const MultiIndex& index(size_type i) const
  {
    return indices_[i];
  }
 
  const GlobalBasis& globalBasis() const
  {
    return *globalBasis_;
  }
 
  const DefaultLocalView& rootLocalView() const
  {
    return *this;
  }
 
protected:
  const GlobalBasis* globalBasis_;
  std::optional<Element> element_;
  Tree tree_;
  std::vector<MultiIndexStorage> indices_;
};
 
 
 
} // end namespace Functions
} // end namespace Dune
 
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTLOCALVIEW_HH