ProblemStatTraits.hpp

#pragma once

#include <tuple>

#include <dune/functions/functionspacebases/basistags.hh>
#include <dune/functions/functionspacebases/compositebasis.hh>
#include <dune/functions/functionspacebases/flatmultiindex.hh>
#include <dune/functions/functionspacebases/lagrangebasis.hh>
#include <dune/functions/functionspacebases/powerbasis.hh>
#include <dune/functions/functionspacebases/pqknodalbasis.hh>
#include <dune/grid/yaspgrid.hh>

namespace Dune {
namespace Functions {
namespace BasisFactory {

  // define the basis-build (factory-tag) for a given pre-basis
  template <class PreBasis>
  struct FactoryTag;

  template <class MultiIndex, class IndexMergingStrategy, class... ChildPreBasisFactory>
  struct FactoryTag<CompositePreBasis<MultiIndex, IndexMergingStrategy, ChildPreBasisFactory...>>
  {
    using type = Imp::CompositePreBasisFactory<IndexMergingStrategy, typename FactoryTag<ChildPreBasisFactory>::type...>;
  };

  template <class MultiIndex, class IndexMergingStrategy, class ChildPreBasisFactory, std::size_t C>
  struct FactoryTag<PowerPreBasis<MultiIndex, IndexMergingStrategy, ChildPreBasisFactory, C>>
  {
    using type = Imp::PowerPreBasisFactory<C, IndexMergingStrategy, typename FactoryTag<ChildPreBasisFactory>::type>;
  };

  template <class GridView, int k, class MultiIndex>
  struct FactoryTag<PQkPreBasis<GridView, k, MultiIndex>>
  {
    using type = Imp::PQkPreBasisFactory<k>;
  };

}}} // end namespace Dune::Functions::BasisFactory

namespace AMDiS
{
  namespace Impl
  {
    template <class GridView, bool same, int... deg>
    struct LagrangeBasisCreatorImpl;

    // specialization for composite basis
    template <class GridView, int... deg>
    struct LagrangeBasisCreatorImpl<GridView, false, deg...>
    {
      using MultiIndex = Dune::ReservedVector<std::size_t,1>;
      using IndexTag = Dune::Functions::BasisFactory::FlatLexicographic;

      using type = Dune::Functions::CompositePreBasis<MultiIndex, IndexTag,
        Dune::Functions::PQkPreBasis<GridView,deg,MultiIndex>...>;
    };

    // specialization for power basis
    template <class GridView, int deg, int... degs>
    struct LagrangeBasisCreatorImpl<GridView, true, deg, degs...>
    {
      using MultiIndex = Dune::ReservedVector<std::size_t,1>;
      using IndexTag = Dune::Functions::BasisFactory::FlatLexicographic;

      using type = Dune::Functions::PowerPreBasis<MultiIndex, IndexTag,
        Dune::Functions::PQkPreBasis<GridView,deg,MultiIndex>, 1 + sizeof...(degs)>;
    };

    // factory to construct a global basis of several lagrange bases, with flat indexing.
    template <class GridView, int deg, int... degs>
    struct LagrangeBasisCreator
    {
      using type = typename LagrangeBasisCreatorImpl<GridView, and_t<(deg == degs)...>::value, deg, degs...>::type;
    };


    template <class GridView, int k>
    struct TaylorHoodBasisCreator
    {
      using MultiIndex = Dune::ReservedVector<std::size_t,1>;
      using IndexTagV = Dune::Functions::BasisFactory::FlatInterleaved;

      using VelocityPreBasis = Dune::Functions::PowerPreBasis<MultiIndex, IndexTagV,
        Dune::Functions::PQkPreBasis<GridView,k+1,MultiIndex>, GridView::dimensionworld>;

      using PressurePreBasis = Dune::Functions::PQkPreBasis<GridView,k,MultiIndex>;

      using IndexTag = Dune::Functions::BasisFactory::FlatLexicographic;
      using type = Dune::Functions::CompositePreBasis<MultiIndex, IndexTag,
        VelocityPreBasis, PressurePreBasis>;
    };

  } // end namespace Impl

  /// An Exemplar for ProblemStatTraits
  template <class GlobalBasisType>
  class DefaultProblemTraits
  {
  public:
    /// A global-basis of type dune-functions DefaultGlobalBasis<NodeFactory>
    using GlobalBasis = GlobalBasisType;
  };

  /// \brief ProblemStatTraits for a (composite) basis composed of
  /// lagrange bases of different degree.
  template <class GridView, int... degrees>
  struct LagrangeBasis
      : public DefaultProblemTraits<
          Dune::Functions::DefaultGlobalBasis<
            typename Impl::LagrangeBasisCreator<GridView, degrees...>::type> >
  {};

  /// \brief Specialization of \ref LagrangeBasis for Grid type
  /// \ref Dune::YaspGrid for a given dimension.
  template <int dim, int... degrees>
  struct YaspGridBasis
      : public LagrangeBasis<typename Dune::YaspGrid<dim>::LeafGridView, degrees...>
  {};

  /// \brief ProblemStatTraits of Taylor-Hood basis of lagrange-type
  /// with pressure degree k
  template <class GridView, int k = 1>
  struct TaylorHoodBasis
      : public DefaultProblemTraits<
          Dune::Functions::DefaultGlobalBasis<
            typename Impl::TaylorHoodBasisCreator<GridView,k>::type> >
  {};

  using Dune::Functions::BasisFactory::makeBasis;
  using Dune::Functions::BasisFactory::lagrange;
  using Dune::Functions::BasisFactory::pq;

  template <std::size_t k, class ChildPBF>
  auto repeat(ChildPBF&& childPreBasisFactory)
  {
    return Dune::Functions::BasisFactory::power<k>(
      std::forward<ChildPBF>(childPreBasisFactory),
      Dune::Functions::BasisFactory::flatInterleaved());
  }

  template <class... Args>
  auto compose(Args&&... args)
  {
    return Dune::Functions::BasisFactory::composite(
      std::forward<Args>(args)...,
      Dune::Functions::BasisFactory::flatLexicographic());
  }

} // end namespace AMDiS