space.hh

#ifndef DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_SPACE_HH
#define DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_SPACE_HH
 
#include <cstddef>
 
#include <functional>
#include <memory>
#include <type_traits>
 
#include <dune/common/deprecated.hh>
#include <dune/common/exceptions.hh>
 
#include <dune/grid/common/gridenums.hh>
#include <dune/grid/common/partitionset.hh>
#include <dune/grid/common/rangegenerators.hh>
 
#include <dune/fem/space/common/allgeomtypes.hh>
#include <dune/fem/space/common/discretefunctionspace.hh>
#include <dune/fem/space/common/localinterpolation.hh>
 
#include <dune/fem/space/common/dataprojection.hh>
 
#include <dune/fem/space/discontinuousgalerkin/interpolation.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    namespace hpDG
    {
 
      // DiscontinuousGalerkinSpace
      // --------------------------
 
      template< class Traits >
      class DiscontinuousGalerkinSpace
      : public Dune::Fem::DiscreteFunctionSpaceDefault< Traits >
      {
        using BaseType = Dune::Fem::DiscreteFunctionSpaceDefault< Traits >;
 
      public:
        using GridPartType =  typename BaseType::GridPartType;
        using EntityType = typename BaseType::EntityType;
 
        using BasisFunctionSetsType = typename Traits::BasisFunctionSetsType;
        using KeyType = typename BasisFunctionSetsType::KeyType;
        using BasisFunctionSetType =  typename BaseType::BasisFunctionSetType;
 
        using BlockMapperType = typename BaseType::BlockMapperType;
 
        typedef typename BaseType::AuxiliaryDofsType AuxiliaryDofsType;
 
    protected:
      struct AuxiliaryDofsFactory
      {
        typedef std::pair< AuxiliaryDofsType, int > ObjectType;
 
        static ObjectType *createObject ( std::pair< GridPartType *, BlockMapperType * > key )
        {
          return new ObjectType( std::piecewise_construct, std::tie( *key.first, *key.second ), std::make_tuple( -1 ) );
        }
 
        static void deleteObject ( ObjectType *object ) { delete object; }
      };
 
      typedef SingletonList< std::pair< GridPartType *, BlockMapperType * >, std::pair< AuxiliaryDofsType, int >, AuxiliaryDofsFactory > AuxiliaryDofsProviderType;
 
 
 
      protected:
        using BaseType::asImp;
        using BaseType::gridPart_;
 
      private:
        template< class DataProjection >
        struct DataProjectionWrapper;
 
        typedef typename Traits::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
      public:
        using InterpolationImplType = DiscontinuousGalerkinLocalL2Projection< GridPartType, BasisFunctionSetType >;
 
        using InterpolationType = LocalInterpolationWrapper< DiscreteFunctionSpaceType >;
 
        template< class Function >
        DiscontinuousGalerkinSpace ( GridPartType &gridPart, const BasisFunctionSetsType &basisFunctionSets,
                                     const KeyType &value, Function function,
                                     const Dune::InterfaceType interface = Dune::InteriorBorder_All_Interface,
                                     const Dune::CommunicationDirection direction = Dune::ForwardCommunication )
          : BaseType( gridPart, interface, direction ),
            basisFunctionSets_( basisFunctionSets ),
            blockMapper_( gridPart_, basisFunctionSets_, value, function )
        {}
 
        DiscontinuousGalerkinSpace ( GridPartType &gridPart, const BasisFunctionSetsType &basisFunctionSets, const KeyType &value,
                                     const Dune::InterfaceType interface = Dune::InteriorBorder_All_Interface,
                                     const Dune::CommunicationDirection direction = Dune::ForwardCommunication )
          : DiscontinuousGalerkinSpace( gridPart, basisFunctionSets, value, [&value]( const EntityType &){ return value; }, interface, direction )
        {}
 
        DiscontinuousGalerkinSpace ( const DiscontinuousGalerkinSpace & ) = delete;
 
        const DiscontinuousGalerkinSpace &operator= ( const DiscontinuousGalerkinSpace & ) = delete;
 
        bool continuous () const { return false; }
 
        bool continuous ( const typename BaseType::IntersectionType &intersection ) const
        {
          return false;
        }
 
        bool multipleBasisFunctionSets () const { return true; }
 
        int order () const { return basisFunctionSets().order(); }
 
        int order ( const EntityType &entity ) const
        {
          return basisFunctionSet( entity ).order();
        }
 
        BasisFunctionSetType basisFunctionSet ( const EntityType &entity ) const
        {
          return basisFunctionSets().basisFunctionSet( entity, key( entity ) );
        }
 
        InterpolationType interpolation () const
        {
          return InterpolationType( static_cast< const DiscreteFunctionSpaceType& > (*this) );
        }
 
        InterpolationImplType interpolation ( const EntityType &entity ) const
        {
          return InterpolationImplType( basisFunctionSet( entity ) );
        }
 
        InterpolationImplType localInterpolation ( const EntityType &entity ) const
        {
          return InterpolationImplType( basisFunctionSet( entity ) );
        }
 
        BlockMapperType &blockMapper () const { return blockMapper_; }
 
        const KeyType &key ( const EntityType &entity ) const
        {
          return blockMapper().key( entity );
        }
 
        void mark ( const KeyType &key, const EntityType &entity )
        {
          return blockMapper_.mark( key, entity );
        }
 
        KeyType getMark ( const EntityType &entity ) const
        {
          return blockMapper().getMark( entity );
        }
 
        bool adapt () { return blockMapper_.adapt(); }
 
        template< class DiscreteFunctionSpace, class Implementation >
        bool adapt ( DataProjection< DiscreteFunctionSpace, Implementation > &projection )
        {
          DataProjectionWrapper< DataProjection< DiscreteFunctionSpace, Implementation > > wrapper( basisFunctionSets(), projection );
          return blockMapper_.adapt( wrapper );
        }
 
        /* \brief return space identitifier */
        DFSpaceIdentifier type () const
        {
          DUNE_THROW( NotImplemented, "Method type() not implemented" );
        }
 
        const BasisFunctionSetsType &basisFunctionSets () const
        {
          return basisFunctionSets_;
        }
 
      protected:
        BasisFunctionSetsType basisFunctionSets_;
        mutable BlockMapperType blockMapper_;
      };
 
 
 
      // DiscontinuousGalerkinSpace::DataProjectionWrapper
      // -------------------------------------------------
 
      template< class Traits >
      template< class DataProjection >
      struct DiscontinuousGalerkinSpace< Traits >::DataProjectionWrapper
      {
        explicit DataProjectionWrapper ( const BasisFunctionSetsType &basisFunctionSets,
                                         DataProjection &dataProjection )
          : basisFunctionSets_( basisFunctionSets ),
            dataProjection_( dataProjection )
        {}
 
        DataProjectionWrapper ( const DataProjectionWrapper & ) = default;
 
        DataProjectionWrapper &operator= ( const DataProjectionWrapper & ) = default;
 
        void operator() ( const EntityType &entity,
                          const KeyType &prior,
                          const KeyType &present,
                          const std::vector< std::size_t > &origin,
                          const std::vector< std::size_t > &destination )
        {
          dataProjection_.get()( entity, basisFunctionSet( entity, prior ), basisFunctionSet( entity, present ), origin, destination );
        }
 
      protected:
        BasisFunctionSetType basisFunctionSet ( const EntityType &entity, const KeyType &key ) const
        {
          return basisFunctionSets_.get().basisFunctionSet( entity, key );
        }
 
        std::reference_wrapper< const BasisFunctionSetsType > basisFunctionSets_;
        std::reference_wrapper< DataProjection > dataProjection_;
      };
 
    } // namespace hpDG
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_HPDG_SPACE_DISCONTINUOUSGALERKIN_SPACE_HH