vectorial.hh

#ifndef DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_VECTORIAL_HH
#define DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_VECTORIAL_HH
 
#include <cstddef>
 
#include <dune/common/exceptions.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/fem/space/basisfunctionset/vectorial.hh>
 
#include "basisfunctionsets.hh"
 
namespace Dune
{
 
  namespace Fem
  {
 
    namespace hpDG
    {
 
      // Internal forward declaration
      // ----------------------------
 
      template< class BasisFunctionSets, class Range >
      class VectorialBasisFunctionSets;
 
 
 
#ifndef DOXYGEN
 
      // VectorialBasisFunctionSetTraits
      // -------------------------------
 
      template< class BasisFunctionSets, class Range >
      class VectorialBasisFunctionSetsTraits
      {
      public:
        using ImplementationType = VectorialBasisFunctionSets< BasisFunctionSets, Range >;
 
        using GridPartType = typename BasisFunctionSets::GridPartType;
        using Types = typename BasisFunctionSets::Types;
 
        using KeyType = typename BasisFunctionSets::KeyType;
        using BasisFunctionSetType = Dune::Fem::VectorialBasisFunctionSet< typename BasisFunctionSets::BasisFunctionSetType, Range >;
        static const int localBlockSize = Range::dimension * BasisFunctionSets::localBlockSize;
 
        using DataType = void *;
      };
 
#endif // #ifndef DOXYGEN
 
 
 
      // VectorialBasisFunctionSet
      // -------------------------
 
      template< class BasisFunctionSets, class Range >
      class VectorialBasisFunctionSets
        : public Dune::Fem::hpDG::BasisFunctionSets< VectorialBasisFunctionSetsTraits< BasisFunctionSets, Range > >
      {
        using BaseType = Dune::Fem::hpDG::BasisFunctionSets< VectorialBasisFunctionSetsTraits< BasisFunctionSets, Range > >;
 
      public:
        using KeyType = typename BaseType::KeyType;
 
        using BasisFunctionSetType = typename BaseType::BasisFunctionSetType;
        using EntityType = typename BaseType::EntityType;
 
        using DataType = typename BaseType::DataType;
 
        explicit VectorialBasisFunctionSets ( const BasisFunctionSets &basisFunctionSets )
          : basisFunctionSets_( basisFunctionSets )
        {}
 
        typename BaseType::Types types () const { return impl().types(); }
 
        std::size_t maxBlocks () const { return impl().maxBlocks(); }
 
        std::size_t maxBlocks ( GeometryType type ) const { return impl().maxBlocks(); }
 
        std::size_t blocks ( GeometryType type, const KeyType &key ) const { return impl().maxBlocks(); }
 
        DataType encode ( const KeyType &key ) const
        {
          DUNE_THROW( NotImplemented, "Method encode() not implemented yet" );
        }
 
        KeyType decode ( const DataType &data ) const
        {
          DUNE_THROW( NotImplemented, "Method decode() not implemented yet" );
        }
 
        static constexpr bool orthogonal () noexcept { return BasisFunctionSets::orthogonal(); }
 
        int order () const { return impl().order(); }
 
        int order ( GeometryType type ) const { return impl().order( type ); }
 
        int order ( GeometryType type, const KeyType &key ) const { return impl().order( type, key ); }
 
        std::size_t size ( GeometryType type, const KeyType &key ) const
        {
          return static_cast< std::size_t >( Range::dimension ) * impl().order( type, key );
        }
 
        BasisFunctionSetType basisFunctionSet ( const EntityType &entity, const KeyType &key ) const
        {
          return BasisFunctionSetType( impl().basisFunctionSet( entity, key ) );
        }
 
        const BasisFunctionSets &impl() const { return basisFunctionSets_; }
 
      private:
        BasisFunctionSets basisFunctionSets_;
      };
 
    } // namespace hpDG
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_HPDG_SPACE_BASISFUNCTIONSETS_VECTORIAL_HH