flatprebasis.hh

Go to the documentation of this file.

// Original File: https://gitlab.mn.tu-dresden.de/amdis/amdis-core/-/blob/master/amdis/functions/FlatPreBasis.hpp
// SPDX-FileCopyrightText: 2023 Copyright (c)  AMDiS
// SPDX-License-Identifier: MIT
// Modifications:
// SPDX-FileCopyrightText: 2021-2026 The Ikarus Developers ikarus@ibb.uni-stuttgart.de
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <cstddef>
#include <utility>
 
#include <dune/common/indices.hh>
#include <dune/functions/functionspacebases/basistags.hh>
#include <dune/functions/functionspacebases/compositebasis.hh>
#include <dune/functions/functionspacebases/powerbasis.hh>
 
#include <Eigen/Core>
 
namespace Ikarus {
template <class PreBasis>
struct FlatPreBasis
{
  using type = PreBasis;
 
  template <class PB>
  static type create(PB const& preBasis) {
    return type(preBasis.gridView());
  }
 
  static const PreBasis& create(const PreBasis& preBasis) { return preBasis; }
};
 
template <class PreBasis>
using FlatPreBasis_t = typename FlatPreBasis<PreBasis>::type;
 
template <class IMS>
struct FlatIndexMergingStrategy
{
  using type = IMS;
};
 
// specialization for BlockedInterleaved
template <>
struct FlatIndexMergingStrategy<Dune::Functions::BasisFactory::BlockedInterleaved>
{
  using type = Dune::Functions::BasisFactory::FlatInterleaved;
};
 
// specialization for BlockedLexicographic
template <>
struct FlatIndexMergingStrategy<Dune::Functions::BasisFactory::BlockedLexicographic>
{
  using type = Dune::Functions::BasisFactory::FlatLexicographic;
};
 
// specialization for composite bases
template <class IMS, class... SPB>
struct FlatPreBasis<Dune::Functions::CompositePreBasis<IMS, SPB...>>
{
  using FIMS = typename FlatIndexMergingStrategy<IMS>::type;
  using type = Dune::Functions::CompositePreBasis<FIMS, FlatPreBasis_t<SPB>...>;
 
  template <class PreBasis>
  static type create(const PreBasis& preBasis) {
    return create(preBasis, std::index_sequence_for<SPB...>{});
  }
 
  template <class PreBasis, std::size_t... I>
  static type create(const PreBasis& preBasis, std::index_sequence<I...>) {
    return type(FlatPreBasis<SPB>::create(preBasis.subPreBasis(Dune::index_constant<I>{}))...);
  }
};
 
// specialization for power bases
template <class IMS, class SPB, std::size_t C>
struct FlatPreBasis<Dune::Functions::PowerPreBasis<IMS, SPB, C>>
{
  using FIMS = typename FlatIndexMergingStrategy<IMS>::type;
  using type = Dune::Functions::PowerPreBasis<FIMS, FlatPreBasis_t<SPB>, C>;
 
  template <class PreBasis>
  static type create(const PreBasis& preBasis) {
    return type(FlatPreBasis<SPB>::create(preBasis.subPreBasis()));
  }
};
 
template <class PreBasis>
decltype(auto) flatPreBasis(const PreBasis& preBasis) {
  return FlatPreBasis<PreBasis>::create(preBasis);
}
 
namespace utils {
  namespace Impl {
    template <typename Tree>
    struct PreBasisInfo
    {
    };
 
    template <typename Tree>
    requires(Tree::isLeaf)
    struct PreBasisInfo<Tree>
    {
      static constexpr std::size_t size = 0;
      using NodalSolutionType           = double;
    };
 
    template <typename Tree>
    requires(Tree::isPower)
    struct PreBasisInfo<Tree>
    {
      static constexpr std::size_t size = Tree::degree();
      using NodalSolutionType           = Eigen::Vector<double, size>;
    };
 
    template <typename Tree>
    requires(Tree::isComposite)
    struct PreBasisInfo<Tree>
    {
      using ChildTreeType = Tree::template Child<0>::Type;
      static_assert(not ChildTreeType::isComposite, "Cannot handle a composite basis within a composite basis.");
 
      static constexpr std::size_t size = PreBasisInfo<ChildTreeType>::size;
      using NodalSolutionType           = PreBasisInfo<ChildTreeType>::NodalSolutionType;
    };
  } // namespace Impl
} // namespace utils
 
} // end namespace Ikarus