QuadratureFactory.hpp

#pragma once

#include <dune/common/hybridutilities.hh>
#include <dune/common/std/type_traits.hh>
#include <dune/geometry/quadraturerules.hh>
#include <dune/geometry/type.hh>

#include <amdis/common/Order.hpp>

namespace AMDiS
{
  template <class ctype, int dim, class LocalFunction>
  class QuadratureFactory
  {
  protected:
    using QuadratureRule = Dune::QuadratureRule<ctype, dim>;

  public:
    virtual ~QuadratureFactory() = default;

    virtual void bind(LocalFunction const& localFct)
    {}

    virtual int order() const
    {
      return 0;
    }

    virtual QuadratureRule const& rule(Dune::GeometryType const& type, int degree) const
    {
      using QuadratureRules = Dune::QuadratureRules<ctype, dim>;
      return QuadratureRules::rule(type, degree);
    }
  };


  template <class ctype, int dim, class LocalFunction>
  class QuadFactoryFromLocalFunction
      : public QuadratureFactory<ctype, dim, LocalFunction>
  {
  public:
    void bind(LocalFunction const& localFct) final
    {
      using AMDiS::order;
      if constexpr (Concepts::Polynomial<LocalFunction>)
        order_ = order(localFct);
    }

    int order() const final { return order_; }

  private:
    int order_ = -1;
  };

  struct PreQuadFactoryFromLocalFunction {};

  inline auto makePreQuadratureFactory()
  {
    return PreQuadFactoryFromLocalFunction{};
  }

  template <class ctype, int dim, class LocalFunction>
  auto makeQuadratureFactory(PreQuadFactoryFromLocalFunction const& /*pre*/)
  {
    return QuadFactoryFromLocalFunction<ctype, dim, LocalFunction>{};
  }


  template <class ctype, int dim, class LocalFunction>
  class QuadFactoryFromOrder
      : public QuadratureFactory<ctype, dim, LocalFunction>
  {
    using Super = QuadratureFactory<ctype, dim, LocalFunction>;
    using QuadratureRule = typename Super::QuadratureRule;

  public:
    QuadFactoryFromOrder(int order, Dune::QuadratureType::Enum qt)
      : order_(order)
      , qt_(qt)
    {}

    int order() const final { return order_; }

    QuadratureRule const& rule(Dune::GeometryType const& type, int degree) const final
    {
      using QuadratureRules = Dune::QuadratureRules<ctype, dim>;
      return QuadratureRules::rule(type, degree, qt_);
    }

  private:
    int order_;
    Dune::QuadratureType::Enum qt_;
  };

  struct PreQuadFactoryFromOrder
  {
    int order;
    Dune::QuadratureType::Enum qt;
  };

  inline auto makePreQuadratureFactory(int order, Dune::QuadratureType::Enum qt = Dune::QuadratureType::GaussLegendre)
  {
    return PreQuadFactoryFromOrder{order, qt};
  }

  template <class ctype, int dim, class LocalFunction>
  auto makeQuadratureFactory(PreQuadFactoryFromOrder const& pre)
  {
    return QuadFactoryFromOrder<ctype, dim, LocalFunction>{pre.order, pre.qt};
  }


  template <class ctype, int dim, class LocalFunction>
  class QuadFactoryFromRule
      : public QuadratureFactory<ctype, dim, LocalFunction>
  {
    using Super = QuadratureFactory<ctype, dim, LocalFunction>;
    using QuadratureRule = typename Super::QuadratureRule;

  public:
    QuadFactoryFromRule(QuadratureRule const& rule)
      : rule_(rule)
    {}

    QuadratureRule const& rule(Dune::GeometryType const& /*type*/, int /*degree*/) const final
    {
      return rule_;
    }

  private:
    QuadratureRule const& rule_;
  };

  template <class QuadRule>
  struct PreQuadFactoryFromRule
  {
    QuadRule const& rule;
  };

  template <class ctype, int dim>
  auto makePreQuadratureFactory(Dune::QuadratureRule<ctype, dim> const& rule)
  {
    return PreQuadFactoryFromRule<Dune::QuadratureRule<ctype, dim>>{rule};
  }

  template <class ctype, int dim, class LocalFunction, class QuadRule>
  auto makeQuadratureFactory(PreQuadFactoryFromRule<QuadRule> const& pre)
  {
    return QuadFactoryFromRule<ctype, dim, LocalFunction>{pre.rule};
  }

} // end namespace AMDiS