FiniteElementType.hpp

#pragma once

#include <cmath>

#include <dune/amdis/common/Loops.hpp>
#include <dune/amdis/common/Mpl.hpp>
#include <dune/amdis/common/Tags.hpp>

namespace AMDiS
{
  namespace Impl
  {
    template <class Node, bool isLeaf, bool isPower, bool isComposite>
    struct FiniteElementTypeImpl
    {
      static_assert( isLeaf || isPower || isComposite, "Unknown node-type for range definition" );

      // polynomial degree of finite-element basis functions
      static int order(Node const&) { return 0; }
    };
  }

  template <class Node>
  using FiniteElementType =
    Impl::FiniteElementTypeImpl<Node, Node::isLeaf, Node::isPower, Node::isComposite>;

  template <class Node>
  using FiniteElementType_t = typename FiniteElementType<Node>::type;

  template <class Node>
  int polynomialDegree(Node const& node)
  {
    return FiniteElementType<Node>::order(node);
  }


  namespace Impl
  {
    // Leaf node
    template <class Node>
    struct FiniteElementTypeImpl<Node, true, false, false>
    {
      using type = typename Node::FiniteElement;

      static int order(Node const& node)
      {
        return node.finiteElement().localBasis().order();
      }
    };

    // Power node
    template <class Node>
    struct FiniteElementTypeImpl<Node, false, true, false>
    {
      using ChildNode = typename Node::template Child<0>::type;
      using type = FiniteElementType_t<ChildNode>;

      static int order(Node const& node)
      {
        return FiniteElementType<ChildNode>::order(node.child(0));
      }
    };

    // Composite node
    template <class Node>
    struct FiniteElementTypeImpl<Node, false, false, true>
    {
      using type = tag::unknown; // no common FiniteElement type

      static int order(Node const& node)
      {
        int degree = 0;
        forEach(range_<0,Node::CHILDREN>, [&](auto const _i) {
          degree = std::max(degree, polynomialDegree(node.child(_i)));
        });
        return degree;
      }
    };

  } // end namespace Impl

} // end namespace AMDiS