powerbasis.hh

Go to the documentation of this file.

// -*- 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_POWERBASIS_HH
#define DUNE_FUNCTIONS_FUNCTIONSPACEBASES_POWERBASIS_HH
 
#include <dune/common/reservedvector.hh>
#include <dune/common/typeutilities.hh>
#include <dune/common/indices.hh>
 
#include <dune/functions/common/utility.hh>
#include <dune/functions/common/type_traits.hh>
#include <dune/functions/functionspacebases/basistags.hh>
#include <dune/functions/functionspacebases/dynamicpowerbasis.hh>
#include <dune/functions/functionspacebases/nodes.hh>
#include <dune/functions/functionspacebases/concepts.hh>
#include <dune/functions/functionspacebases/containerdescriptors.hh>
#include <dune/functions/functionspacebases/defaultglobalbasis.hh>
 
 
 
namespace Dune {
namespace Functions {
 
 
// *****************************************************************************
// This is the reusable part of the power bases. It contains
//
//   PowerPreBasis
//
// The pre-basis allows to create the others and is the owner of possible shared
// state. These components do _not_ depend on the global basis and local view
// and can be used without a global basis.
// *****************************************************************************
 
template<class IMS, class SPB, std::size_t C>
class PowerPreBasis :
    public DynamicPowerPreBasis<IMS,SPB>
{
  using Base = DynamicPowerPreBasis<IMS,SPB>;
 
public:
 
  using SubPreBasis = SPB;
 
  using Node = PowerBasisNode<typename SubPreBasis::Node, C>;
 
  using size_type = typename Base::size_type;
 
  using IndexMergingStrategy = IMS;
 
  inline static constexpr std::integral_constant<std::size_t,C> children = {};
 
  template<class... SFArgs,
    disableCopyMove<PowerPreBasis, SFArgs...> = 0,
    enableIfConstructible<SubPreBasis, SFArgs...> = 0>
  explicit PowerPreBasis(SFArgs&&... sfArgs) :
    Base(std::size_t(C), std::forward<SFArgs>(sfArgs)...)
  {}
 
  Node makeNode() const
  {
    Node node{};
    for (std::size_t i=0; i<children(); ++i)
      node.setChild(i, Base::subPreBasis_.makeNode());
    return node;
  }
 
  size_type size() const
  {
    return size(Dune::ReservedVector<size_type, Base::multiIndexBufferSize>{});
  }
 
  template<class SizePrefix>
  size_type size(const SizePrefix& prefix) const
  {
    return Base::sizeImpl(prefix, children, IndexMergingStrategy{});
  }
 
  template<class NodeType, typename It,
    std::enable_if_t<NodeType::isPower, int> = 0>
  It indices(const NodeType& node, It it) const
  {
    return Base::indicesImpl(node, it, children, IndexMergingStrategy{});
  }
 
  auto containerDescriptor() const
  {
    return Base::containerDescriptorImpl(children);
  }
};
 
 
 
namespace BasisFactory {
 
template<std::size_t k, class ChildPreBasisFactory, class IndexMergingStrategy>
auto power(ChildPreBasisFactory&& childPreBasisFactory, const IndexMergingStrategy&)
{
  return [childPreBasisFactory](const auto& gridView) {
    auto childPreBasis = childPreBasisFactory(gridView);
    return PowerPreBasis<IndexMergingStrategy, decltype(childPreBasis), k>(std::move(childPreBasis));
  };
}
 
template<std::size_t k, class ChildPreBasisFactory>
auto power(ChildPreBasisFactory&& childPreBasisFactory)
{
  return [childPreBasisFactory](const auto& gridView) {
    auto childPreBasis = childPreBasisFactory(gridView);
    return PowerPreBasis<BlockedInterleaved, decltype(childPreBasis), k>(std::move(childPreBasis));
  };
}
 
} // end namespace BasisFactory
 
// Backward compatibility
namespace [[deprecated("Will be removed after Dune 2.10")]] BasisBuilder {
 
  using namespace BasisFactory;
 
}
 
 
} // end namespace Functions
} // end namespace Dune
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_POWERBASIS_HH