basisfunctionsets.hh

#ifndef DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_BASISFUNCTIONSETS_HH
#define DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_BASISFUNCTIONSETS_HH
 
#include <cstddef>
 
#include <dune/common/bartonnackmanifcheck.hh>
 
#include <dune/geometry/type.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    namespace hpDG
    {
 
      // BasisFunctionSets
      // -----------------
 
      template< class T >
      class BasisFunctionSets
      {
      protected:
        using Traits = T;
 
      public:
        using GridPartType = typename Traits::GridPartType;
 
        using KeyType = typename Traits::KeyType;
 
        using BasisFunctionSetType = typename Traits::BasisFunctionSetType;
        using EntityType = typename BasisFunctionSetType::EntityType;
 
        using Types = typename Traits::Types;
 
        static const int localBlockSize = Traits::localBlockSize;
 
        using DataType = typename Traits::DataType;
 
      protected:
        BasisFunctionSets () = default;
 
      public:
        Types types () const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().types() );
          return impl().types();
        }
 
        std::size_t maxBlocks () const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().maxBlocks() );
          return impl().maxBlocks();
        }
 
        std::size_t maxBlocks ( GeometryType type ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().maxBlocks( type ) );
          return impl().maxBlocks( type );
        }
 
        std::size_t blocks ( GeometryType type, const KeyType &key ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().blocks( type, key ) );
          return impl().blocks( type, key );
        }
 
        DataType encode ( const KeyType &key ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().encode( key ) );
          return impl().encode( key );
        }
 
        KeyType decode ( const DataType &data ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().decode( data ) );
          return impl().decode( data );
        }
 
        static constexpr bool orthogonal () noexcept
        {
          return Traits::ImplementationType::orthogonal();
        }
 
        int order () const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().order() );
          return impl().order();
        }
 
        int order ( GeometryType type ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().order( type ) );
          return impl().order( type );
        }
 
        int order ( GeometryType type, const KeyType &key ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().order( type, key ) );
          return impl().order( type, key );
        }
 
        BasisFunctionSetType basisFunctionSet ( const EntityType &entity, const KeyType &key ) const
        {
          CHECK_INTERFACE_IMPLEMENTATION( impl().basisFunctionSet( entity, key ) );
          return impl().basisFunctionSet( entity, key );
        }
 
      protected:
        const typename Traits::ImplementationType &impl () const
        {
          return static_cast< const typename Traits::ImplementationType & >( *this );
        }
      };
 
    } // namespace hpDG
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_BASISFUNCTIONSETS_HH