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/common/typetree/nodeconcepts.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>
  requires Dune::TypeTree::Concept::UniformInnerTreeNode<NodeType>
  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>
[[deprecated("Using the method `power` without an explicit index merging strategy"
  " will change its meaning after the release of dune-functions 2.11."
  " Previously, the default merging strategy was `BlockedInterleaved`,"
  " but this will change to `FlatInterleaved`."
  " Change the call to `power(..., blockedInterleaved())` to retain the old behavior.")]]
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
 
 
} // end namespace Functions
} // end namespace Dune
 
 
#endif // DUNE_FUNCTIONS_FUNCTIONSPACEBASES_POWERBASIS_HH