defaultglobalbasis.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_DEFAULTGLOBALBASIS_HH
#define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTGLOBALBASIS_HH
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#include <dune/common/reservedvector.hh>
#include <dune/common/typeutilities.hh>
#include <dune/common/concept.hh>
 
#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/defaultlocalview.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/flatmultiindex.hh>
 
 
 
namespace Dune {
namespace Functions {
 
 
 
template<class PB>
class DefaultGlobalBasis
{
 
  [[deprecated("Warning: Using a PreBasis that does not provide an indices(node, iterator) method but only a NodeIndexSet is deprecated!")]]
  static auto indicesInterfaceDeprecationWarning() {}
 
public:
 
  using PreBasis = PB;
 
  using PrefixPath = TypeTree::HybridTreePath<>;
 
  using GridView = typename PreBasis::GridView;
 
  using MultiIndex = typename PreBasis::MultiIndex;
 
  using size_type = std::size_t;
 
  using LocalView = DefaultLocalView<DefaultGlobalBasis<PreBasis>>;
 
  using SizePrefix = typename PreBasis::SizePrefix;
 
  template<class... T,
    disableCopyMove<DefaultGlobalBasis, T...> = 0,
    enableIfConstructible<PreBasis, T...> = 0>
  DefaultGlobalBasis(T&&... t) :
    preBasis_(std::forward<T>(t)...),
    prefixPath_()
  {
    if constexpr (not Impl::preBasisHasIndices<PreBasis>{})
      indicesInterfaceDeprecationWarning();
    static_assert(models<Concept::PreBasis<GridView>, PreBasis>(), "Type passed to DefaultGlobalBasis does not model the PreBasis concept.");
    preBasis_.initializeIndices();
  }
 
  const GridView& gridView() const
  {
    return preBasis_.gridView();
  }
 
  const PreBasis& preBasis() const
  {
    return preBasis_;
  }
 
  PreBasis& preBasis()
  {
    return preBasis_;
  }
 
  void update(const GridView & gv)
  {
    preBasis_.update(gv);
    preBasis_.initializeIndices();
  }
 
  size_type dimension() const
  {
    return preBasis_.dimension();
  }
 
  size_type size() const
  {
    return preBasis_.size();
  }
 
  size_type size(const SizePrefix& prefix) const
  {
    return preBasis_.size(prefix);
  }
 
  LocalView localView() const
  {
    return LocalView(*this);
  }
 
  const DefaultGlobalBasis& rootBasis() const
  {
    return *this;
  }
 
  const PrefixPath& prefixPath() const
  {
    return prefixPath_;
  }
 
protected:
  PreBasis preBasis_;
  PrefixPath prefixPath_;
};
 
 
 
namespace BasisFactory {
 
template<class GridView, class PreBasisFactory>
auto makeBasis(const GridView& gridView, PreBasisFactory&& preBasisFactory)
{
  using RawPreBasisFactory = std::decay_t<PreBasisFactory>;
  using MultiIndex = std::conditional_t<
    (RawPreBasisFactory::requiredMultiIndexSize == 1),
    FlatMultiIndex<std::size_t>,
    Dune::ReservedVector<std::size_t, RawPreBasisFactory::requiredMultiIndexSize>>;
  auto preBasis = preBasisFactory.template makePreBasis<MultiIndex>(gridView);
  using PreBasis = std::decay_t<decltype(preBasis)>;
 
  return DefaultGlobalBasis<PreBasis>(std::move(preBasis));
}
 
template<class MultiIndex, class GridView, class PreBasisFactory>
auto makeBasis(const GridView& gridView, PreBasisFactory&& preBasisFactory)
{
  auto preBasis = preBasisFactory.template makePreBasis<MultiIndex>(gridView);
  using PreBasis = std::decay_t<decltype(preBasis)>;
 
  return DefaultGlobalBasis<PreBasis>(std::move(preBasis));
}
 
} // end namespace BasisFactory
 
// Backward compatibility
namespace BasisBuilder {
 
  using namespace BasisFactory;
 
}
 
 
} // end namespace Functions
} // end namespace Dune
 
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTGLOBALBASIS_HH