shapefunctionsets.hh

#ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_SHAPEFUNCTIONSETS_HH
#define DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_SHAPEFUNCTIONSETS_HH
 
#include <algorithm>
#include <utility>
#include <vector>
 
#include <dune/common/documentation.hh>
 
#include <dune/geometry/type.hh>
 
#include <dune/fem/space/common/allgeomtypes.hh>
#include <dune/fem/space/common/basesetlocalkeystorage.hh>
#include <dune/fem/space/shapefunctionset/proxy.hh>
#include <dune/fem/space/shapefunctionset/selectcaching.hh>
#include <dune/fem/space/shapefunctionset/vectorial.hh>
#include <dune/fem/storage/singletonlist.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // ShapeFunctionSets
    // -----------------
 
    class ShapeFunctionSets
    {
    public:
      typedef ImplementationDefined ShapeFunctionSetType;
 
      ShapeFunctionSets ( ShapeFunctionSets && );
 
      ShapeFunctionSets ( const ShapeFunctionSets & ) = delete;
 
      ShapeFunctionSets &operator= ( const ShapeFunctionSets & ) = delete;
 
      const std::vector< Dune::GeometryType > &types () const;
 
      int order () const;
 
      int order ( Dune::GeometryType type ) const;
 
      ShapeFunctionSetType shapeFunctionSet ( const Dune::GeometryType &type ) const;
 
    };
 
 
 
    // CachedShapeFunctionSets
    // -----------------------
 
    template< class GridPart, class ShapeFunctionSet,
              class Factory = Dune::Fem::DefaultSingletonFactory< Dune::GeometryType, ShapeFunctionSet > >
    class CachedShapeFunctionSets
    {
      typedef CachedShapeFunctionSets< GridPart, ShapeFunctionSet, Factory > ThisType;
 
    public:
      typedef GridPart GridPartType;
      typedef Dune::Fem::ShapeFunctionSetProxy< ShapeFunctionSet > ShapeFunctionSetType;
 
    private:
      static const int dimension = GridPartType::dimension;
      static const int mydimension = ShapeFunctionSet::FunctionSpaceType::dimDomain;
      static const int codimension = dimension - mydimension;
 
      typedef Dune::Fem::SingletonList< Dune::GeometryType, ShapeFunctionSet, Factory > SingletonProviderType;
      typedef Dune::Fem::BaseSetLocalKeyStorage< ShapeFunctionSet > ShapeFunctionSetStorageType;
 
    public:
      explicit CachedShapeFunctionSets ( const GridPartType &gridPart )
        : types_( types( gridPart ) )
      {
        typedef typename std::vector< Dune::GeometryType >::const_iterator const_iterator;
        const const_iterator end = types_.end();
        for( const_iterator it = types_.begin(); it != end; ++it )
        {
          const Dune::GeometryType type = *it;
          shapeFunctionSets_.template insert< SingletonProviderType >( type );
        }
      }
 
      CachedShapeFunctionSets ( const ThisType & ) = delete;
 
      CachedShapeFunctionSets ( ThisType &&other )
        : types_( std::move( other.types_ ) ),
          shapeFunctionSets_( std::move( other.shapeFunctionSets_ ) )
      {}
 
      CachedShapeFunctionSets &operator= ( const ThisType & ) = delete;
 
      const std::vector< Dune::GeometryType > &types () const { return types_; }
 
      int order () const
      {
        int order = 0;
 
        typedef typename std::vector< Dune::GeometryType >::const_iterator const_iterator;
        const const_iterator end = types_.end();
        for( const_iterator it = types_.begin(); it != end; ++it )
        {
          const Dune::GeometryType type = *it;
          order = std::max( this->order( type ), order );
        }
 
        return order;
      }
 
      int order ( Dune::GeometryType type ) const
      {
        return shapeFunctionSet( type ).order();
      }
 
      ShapeFunctionSetType shapeFunctionSet ( const Dune::GeometryType &type ) const
      {
        return ShapeFunctionSetType( &shapeFunctionSets_[ type ] );
      }
 
    private:
      static std::vector< Dune::GeometryType > types ( const GridPartType &gridPart )
      {
        typedef typename GridPartType::GridType GridType;
        typedef typename GridPartType::IndexSetType IndexSetType;
        return Dune::Fem::AllGeomTypes< IndexSetType, GridType >( gridPart.indexSet() ).geomTypes( codimension );
      }
 
      std::vector< Dune::GeometryType > types_;
      ShapeFunctionSetStorageType shapeFunctionSets_;
    };
 
 
 
    // SelectCachingShapeFunctionSets
    // ------------------------------
 
    template< class GridPart, class ShapeFunctionSet, class Storage >
    class SelectCachingShapeFunctionSets
    {
      typedef SelectCachingShapeFunctionSets< GridPart, ShapeFunctionSet, Storage > ThisType;
 
      typedef SelectCachingShapeFunctionSet< ShapeFunctionSet, Storage > CachedShapeFunctionSetType;
 
      struct Factory
      {
        static CachedShapeFunctionSetType *createObject ( const Dune::GeometryType &type )
        {
          typedef typename CachedShapeFunctionSetType::ImplementationType ImplementationType;
          return new CachedShapeFunctionSetType( type, ImplementationType( type ) );
        }
 
        static void deleteObject ( CachedShapeFunctionSetType *object ) { delete object; }
      };
 
      typedef CachedShapeFunctionSets< GridPart, CachedShapeFunctionSetType, Factory > Implementation;
 
    public:
      typedef typename Implementation::ShapeFunctionSetType ShapeFunctionSetType;
 
      static constexpr bool codegenShapeFunctionSet = detail::IsCodegenShapeFunctionSet< CachedShapeFunctionSetType >::value;
 
      explicit SelectCachingShapeFunctionSets ( const GridPart &gridPart )
        : impl_( gridPart )
      {}
 
      SelectCachingShapeFunctionSets ( const ThisType & ) = delete;
 
      SelectCachingShapeFunctionSets ( ThisType &&other )
        : impl_( std::move( other.impl_ ) )
      {}
 
      SelectCachingShapeFunctionSets &operator= ( const ThisType & ) = delete;
 
      const std::vector< Dune::GeometryType > &types () const { return impl_.types(); }
 
      int order () const { return impl_.order(); }
 
      int order ( Dune::GeometryType type ) const { return impl_.order( type ); }
 
      ShapeFunctionSetType shapeFunctionSet ( const Dune::GeometryType &type ) const
      {
        return impl_.shapeFunctionSet( type );
      }
 
    private:
      Implementation impl_;
    };
 
 
 
    // VectorialShapeFunctionSets
    // --------------------------
 
    template< class Implementation, class Range >
    class VectorialShapeFunctionSets
    {
      typedef VectorialShapeFunctionSets< Implementation, Range > ThisType;
 
    public:
      static constexpr bool codegenShapeFunctionSet = detail::IsCodegenShapeFunctionSet< Implementation >::value;
 
      typedef VectorialShapeFunctionSet< typename Implementation::ShapeFunctionSetType, Range > ShapeFunctionSetType;
 
      explicit VectorialShapeFunctionSets ( Implementation &&impl )
        : impl_( impl )
      {}
 
      template< class... Args >
      explicit VectorialShapeFunctionSets ( Args &&...args )
        : impl_( std::forward< Args >( args )... )
      {}
 
      VectorialShapeFunctionSets ( const ThisType & ) = delete;
 
      VectorialShapeFunctionSets ( ThisType & ) = delete;
 
      VectorialShapeFunctionSets ( ThisType &&other )
        : impl_( std::move( other.impl_ ) )
      {}
 
      VectorialShapeFunctionSets &operator= ( const ThisType & ) = delete;
 
      const std::vector< Dune::GeometryType > &types () const { return impl().types(); }
 
      int order () const { return impl().order(); }
 
      int order ( Dune::GeometryType type ) const { return impl().order( type ); }
 
      ShapeFunctionSetType shapeFunctionSet ( const Dune::GeometryType &type ) const
      {
        return ShapeFunctionSetType( impl().shapeFunctionSet( type ) );
      }
 
    private:
      const Implementation &impl () const { return impl_; }
 
      Implementation impl_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_SHAPEFUNCTIONSETS_HH