capabilities.hh

#ifndef DUNE_FEM_SPACE_COMMON_CAPABILITIES_HH
#define DUNE_FEM_SPACE_COMMON_CAPABILITIES_HH
 
#include <type_traits>
 
#include <dune/fem/quadrature/defaultquadratures.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    namespace Capabilities
    {
 
      template< class DiscreteFunctionSpace >
      struct hasFixedPolynomialOrder
      {
        static const bool v = false;
      };
 
 
 
      template< class DiscreteFunctionSpace >
      struct hasStaticPolynomialOrder
      {
        static const bool v = false;
        static const int order = -1;
      };
 
 
 
      template< class DiscreteFunctionSpace >
      struct isContinuous
      {
        static const bool v = false;
      };
 
 
 
      template< class DiscreteFunctionSpace >
      struct isLocalized
      {
        static const bool v = false;
      };
 
 
 
      template< class DiscreteFunctionSpace >
      struct isAdaptive
      {
        static const bool v = false;
      };
 
 
      template< class DiscreteFunctionSpace >
      struct isPAdaptiveSpace
      {
        static const bool v = false;
      };
 
 
      template< class DiscreteFunctionSpace >
      struct threadSafe
      {
        static const bool v = false;
      };
 
 
 
      template< class DiscreteFunctionSpace >
      struct viewThreadSafe
      {
        static const bool v = false;
      };
 
 
      template< class DiscreteFunctionSpace >
      struct isHierarchic
      {
        static const bool v = false;
      };
 
 
      template< class DiscreteFunctionSpace >
      struct DefaultQuadrature
      {
        // traits specifying the quadrature points used for CachingQuadrature or ElementQuadrature.
        template <class F, int d>
        using DefaultQuadratureTraits = Dune::Fem::DefaultQuadratureTraits< F, d >;
 
        static int volumeOrder( const int k ) {  return 2 * k; }
        static int surfaceOrder( const int k )   {  return 2 * k + 1; }
      };
 
 
      namespace Impl
      {
 
        template< class DFS >
        std::true_type hasInterpolation ( const DFS &, decltype( std::declval< const DFS & >().interpolation() ) * = nullptr );
 
        std::false_type hasInterpolation ( ... );
 
      } // namespace Impl
 
 
      template< class DiscreteFunctionSpace >
      struct hasInterpolation
      {
        static const bool v = decltype( Impl::hasInterpolation( std::declval< const DiscreteFunctionSpace & >() ) )::value;
      };
 
 
 
      // const specialization
      // --------------------
 
      template< class DiscreteFunctionSpace >
      struct hasFixedPolynomialOrder< const DiscreteFunctionSpace >
      {
        static const bool v = hasFixedPolynomialOrder< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct hasStaticPolynomialOrder< const DiscreteFunctionSpace >
      {
        static const bool v = hasStaticPolynomialOrder< DiscreteFunctionSpace >::v;
        static const int order = hasStaticPolynomialOrder< DiscreteFunctionSpace >::order;
      };
 
      template< class DiscreteFunctionSpace >
      struct isContinuous < const DiscreteFunctionSpace >
      {
        static const bool v = isContinuous< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct isLocalized< const DiscreteFunctionSpace >
      {
        static const bool v = isLocalized< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct isAdaptive< const DiscreteFunctionSpace >
      {
        static const bool v = isAdaptive< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct isPAdaptiveSpace< const DiscreteFunctionSpace >
      {
        static const bool v = isPAdaptiveSpace< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct threadSafe< const DiscreteFunctionSpace >
      {
        static const bool v = threadSafe< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct viewThreadSafe< const DiscreteFunctionSpace >
      {
        static const bool v = viewThreadSafe< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct isHierarchic< const DiscreteFunctionSpace >
      {
        static const bool v = isHierarchic< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct hasInterpolation< const DiscreteFunctionSpace >
      {
        static const bool v = hasInterpolation< DiscreteFunctionSpace >::v;
      };
 
      template< class DiscreteFunctionSpace >
      struct DefaultQuadrature< const DiscreteFunctionSpace >
        : public DefaultQuadrature< DiscreteFunctionSpace >
      {};
 
    } // namespace Capabilities
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_SPACE_COMMON_CAPABILITIES_HH