discontinuousgalerkin.hh

#ifndef DUNE_FEM_SPACE_PADAPTIVE_DISCONTINUOUSGALERKIN_HH
#define DUNE_FEM_SPACE_PADAPTIVE_DISCONTINUOUSGALERKIN_HH
 
#include <dune/fem/common/hybrid.hh>
#include <dune/fem/space/common/defaultcommhandler.hh>
#include <dune/fem/space/mapper/nonblockmapper.hh>
 
#include "adaptmanager.hh"
#include "declaration.hh"
#include "generic.hh"
#include "lagrange.hh"
#include "mapper.hh"
#include "restrictprolong.hh"
 
#include <dune/fem/space/discontinuousgalerkin/interpolation.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // PAdaptiveDGSpaceTraits
    // ----------------------
 
    template< class FunctionSpace, class GridPart, int polOrder, class Storage >
    struct PAdaptiveDGSpaceTraits
    : public PAdaptiveLagrangeSpaceTraits< FunctionSpace, GridPart, polOrder, Storage >
    {
      typedef PAdaptiveDGSpace< FunctionSpace, GridPart, polOrder, Storage > DiscreteFunctionSpaceType;
 
      static const bool continuousSpace = false ;
      typedef Hybrid::IndexRange< int, FunctionSpace::dimRange > LocalBlockIndices;
 
      typedef PAdaptiveDGMapper< GridPart, polOrder > BlockMapperType;
 
      template< class DiscreteFunction,
                class Operation = DFCommunicationOperation :: Copy >
      struct CommDataHandle
      {
        typedef DefaultCommunicationHandler< DiscreteFunction, Operation > Type;
        typedef Operation OperationType;
      };
    };
 
 
 
    // PAdaptiveDGSpace
    // ----------------
 
    template< class FunctionSpace, class GridPart, int polOrder, class Storage = CachingStorage >
    class PAdaptiveDGSpace
    : public GenericDiscreteFunctionSpace< PAdaptiveDGSpaceTraits< FunctionSpace, GridPart, polOrder, Storage > >
    {
      typedef PAdaptiveDGSpace< FunctionSpace, GridPart, polOrder, Storage > ThisType;
      typedef GenericDiscreteFunctionSpace< PAdaptiveDGSpaceTraits< FunctionSpace, GridPart, polOrder, Storage > > BaseType;
 
    public:
      typedef ThisType PAdaptiveDGSpaceType;
 
      typedef typename BaseType::Traits Traits;
 
      typedef typename BaseType::GridPartType      GridPartType;
      typedef typename BaseType::IntersectionType  IntersectionType;
      typedef typename BaseType::EntityType        EntityType;
 
      typedef typename BaseType::BasisFunctionSetType  BasisFunctionSetType;
      typedef typename BaseType::CompiledLocalKeyType CompiledLocalKeyType;
      typedef CompiledLocalKeyType LagrangePointSetType;
 
      typedef DiscontinuousGalerkinLocalL2Projection< GridPartType, BasisFunctionSetType > InterpolationImplType;
      typedef LocalInterpolationWrapper< ThisType > InterpolationType;
 
    public:
      using BaseType::continuous;
      using BaseType::gridPart;
      using BaseType::blockMapper;
      using BaseType::compiledLocalKey;
      using BaseType::basisFunctionSet;
 
      // default communication interface
      static const InterfaceType defaultInterface = InteriorBorder_All_Interface;
      // default communication direction
      static const CommunicationDirection defaultDirection = ForwardCommunication;
 
      explicit PAdaptiveDGSpace ( GridPartType &gridPart,
                                  const int order,
                                  const InterfaceType commInterface = defaultInterface,
                                  const CommunicationDirection commDirection = defaultDirection )
      : BaseType( gridPart, order, commInterface, commDirection )
      {}
 
      explicit PAdaptiveDGSpace ( GridPartType &gridPart,
                                  const InterfaceType commInterface = defaultInterface,
                                  const CommunicationDirection commDirection = defaultDirection )
      : BaseType( gridPart, polOrder, commInterface, commDirection )
      {}
 
      // copy constructor needed for p-adaption
      PAdaptiveDGSpace ( const PAdaptiveDGSpace &other )
      : BaseType( other )
      {}
 
      inline bool continuous (const IntersectionType &intersection) const
      {
        return false;
      }
 
      inline const CompiledLocalKeyType &lagrangePointSet( const GeometryType &type, const int order = BaseType::polynomialOrder ) const
      {
        return compiledLocalKey( type, order );
      }
 
      InterpolationType interpolation() const
      {
        return InterpolationType( *this );
      }
 
      [[deprecated]]
      InterpolationImplType interpolation ( const EntityType &entity ) const
      {
        return localInterpolation( entity );
      }
 
      InterpolationImplType localInterpolation ( const EntityType &entity ) const
      {
        return InterpolationImplType( basisFunctionSet( entity ) );
      }
 
    };
 
  } // namespace Fem
 
} // Dune namespace
 
#endif // #ifndef DUNE_FEM_SPACE_PADAPTIVE_DISCONTINUOUSGALERKIN_HH