defaultglobalbasis.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#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/common/typetree/treepath.hh>
 
#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/defaultlocalview.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/containerdescriptors.hh>
 
 
 
namespace Dune {
namespace Functions {
 
 
 
template<class PB>
class DefaultGlobalBasis
{
 
public:
 
  using PreBasis = PB;
 
  using PrefixPath = TypeTree::TreePath<>;
 
  using GridView = typename PreBasis::GridView;
 
  using size_type = std::size_t;
 
  using LocalView = DefaultLocalView<DefaultGlobalBasis<PreBasis>>;
 
  using MultiIndex = typename LocalView::MultiIndex;
 
  using SizePrefix = Dune::ReservedVector<std::size_t, PreBasis::multiIndexBufferSize>;
 
  template<class... T,
    disableCopyMove<DefaultGlobalBasis, T...> = 0,
    enableIfConstructible<PreBasis, T...> = 0>
  DefaultGlobalBasis(T&&... t) :
    preBasis_(std::forward<T>(t)...),
    prefixPath_()
  {
    static_assert(models<Concept::PreBasis<GridView>, PreBasis>(), "Type passed to DefaultGlobalBasis does not model the PreBasis concept.");
    preBasis_.initializeIndices();
  }
 
  template<class PreBasisFactory,
    std::enable_if_t<Dune::IsCallable<PreBasisFactory(GridView), PreBasis>::value, int> = 0>
  DefaultGlobalBasis(const GridView& gridView, PreBasisFactory&& factory) :
    preBasis_(factory(gridView)),
    prefixPath_()
  {
    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_;
  }
 
  auto containerDescriptor() const
  {
    if constexpr (requires(PreBasis pb){ pb.containerDescriptor(); })
      return preBasis_.containerDescriptor();
    else
      return ContainerDescriptors::Unknown{};
  }
 
protected:
  PreBasis preBasis_;
  PrefixPath prefixPath_;
};
 
 
 
template<class PreBasis>
DefaultGlobalBasis(PreBasis&&) -> DefaultGlobalBasis<std::decay_t<PreBasis>>;
 
template<class GridView, class PreBasisFactory>
DefaultGlobalBasis(const GridView& gv, PreBasisFactory&& f) -> DefaultGlobalBasis<std::decay_t<decltype(f(gv))>>;
 
 
 
namespace BasisFactory {
 
template<class GridView, class PreBasisFactory>
auto makeBasis(const GridView& gridView, PreBasisFactory&& preBasisFactory)
{
  return DefaultGlobalBasis(preBasisFactory(gridView));
}
 
} // end namespace BasisFactory
 
 
} // end namespace Functions
} // end namespace Dune
 
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_DEFAULTGLOBALBASIS_HH