generic.hh

#ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_GENERIC_HH
#define DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_GENERIC_HH
 
#include <utility>
 
#include <dune/fem/space/common/discretefunctionspace.hh>
#include <dune/fem/space/mapper/codimensionmapper.hh>
#include <dune/fem/storage/singletonlist.hh>
 
#include "localrestrictprolong.hh"
 
namespace Dune
{
 
  namespace Fem
  {
 
    // GenericDiscontinuousGalerkinSpace
    // ---------------------------------
 
    template< class Traits >
    class GenericDiscontinuousGalerkinSpace
    : public DiscreteFunctionSpaceDefault< Traits >
    {
      typedef GenericDiscontinuousGalerkinSpace< Traits > ThisType;
      typedef DiscreteFunctionSpaceDefault< Traits > BaseType;
 
    public:
      static const int codimension = Traits::codimension;
 
      typedef typename BaseType::GridPartType GridPartType;
      typedef typename BaseType::EntityType EntityType;
      typedef typename BaseType::IntersectionType IntersectionType;
 
      typedef typename Traits::BasisFunctionSetsType BasisFunctionSetsType;
      typedef typename BaseType::BasisFunctionSetType BasisFunctionSetType;
 
      typedef typename BaseType::BlockMapperType BlockMapperType;
 
    protected:
      typedef SingletonList< const typename GridPartType::IndexSetType*, BlockMapperType > BlockMapperProdiverType;
 
      typedef CachingQuadrature<GridPartType, EntityType::codimension> VolumeQuadratureType;
 
    public:
      typedef typename Traits :: DiscreteFunctionSpaceType  DiscreteFunctionSpaceType;
 
      typedef LocalMassMatrix< DiscreteFunctionSpaceType, VolumeQuadratureType > LocalMassMatrixType;
      typedef std::vector< typename BaseType::RangeType > VectorType;
      typedef std::pair< LocalMassMatrixType, VectorType >  LocalMassMatrixStorageType;
 
    protected:
      using BaseType::asImp;
    public:
      explicit GenericDiscontinuousGalerkinSpace ( GridPartType &gridPart, BasisFunctionSetsType &&basisFunctionSets,
                                                   const InterfaceType commInterface = InteriorBorder_All_Interface,
                                                   const CommunicationDirection commDirection = ForwardCommunication )
      : BaseType( gridPart, commInterface, commDirection ),
        basisFunctionSets_( std::move( basisFunctionSets ) ),
        // block mapper is a singleton so that the communication can be cached efficiently
        blockMapper_( &BlockMapperProdiverType::getObject( &(gridPart.indexSet() )))
      {}
 
      GenericDiscontinuousGalerkinSpace ( const ThisType & ) = delete;
 
      GenericDiscontinuousGalerkinSpace ( ThisType &&other ) = default;
 
      GenericDiscontinuousGalerkinSpace &operator= ( const ThisType & ) = default;
 
      static DFSpaceIdentifier type () { return DGSpace_id; }
 
      BasisFunctionSetType basisFunctionSet ( const EntityType &entity ) const
      {
        return basisFunctionSets().basisFunctionSet( entity );
      }
 
      static constexpr bool continuous () { return false; }
 
      static constexpr bool continuous ( const IntersectionType &intersection ) { return false; }
 
      int order () const { return basisFunctionSets().order(); }
 
      int order ( const EntityType &entity ) const { return basisFunctionSets().order( entity ); }
 
      BlockMapperType &blockMapper () const { assert( blockMapper_ ); return *blockMapper_; }
 
      const BasisFunctionSetsType &basisFunctionSets () const { return basisFunctionSets_; }
      BasisFunctionSetsType &basisFunctionSets () { return basisFunctionSets_; }
 
      LocalMassMatrixStorageType& localMassMatrixStorage() const
      {
        auto& localMassPtr = *localMassMatrixStorage_;
        if( ! localMassPtr )
        {
          localMassPtr.reset( new LocalMassMatrixStorageType( LocalMassMatrixType( asImp(), 2*order() ), VectorType() ) );
        }
 
        return *localMassPtr;
      }
 
    private:
      BasisFunctionSetsType basisFunctionSets_;
      std::unique_ptr< BlockMapperType, typename BlockMapperProdiverType::Deleter > blockMapper_;
 
      mutable ThreadSafeValue< std::shared_ptr< LocalMassMatrixStorageType > > localMassMatrixStorage_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_SPACE_DISCONTINUOUSGALERKIN_GENERIC_HH