generic.hh

#ifndef DUNE_FEM_SPACE_COMBINEDSPACE_GENERIC_HH
#define DUNE_FEM_SPACE_COMBINEDSPACE_GENERIC_HH
 
#include <algorithm>
#include <memory>
 
#include <dune/common/hybridutilities.hh>
 
#include <dune/fem/space/common/discretefunctionspace.hh>
#include <dune/fem/space/common/dofmanager.hh>
 
namespace Dune
{
 
  namespace Fem
  {
    // GenericCombinedDiscreteFunctionSpace
    // ------------------------------------
 
    template< class Traits >
    class GenericCombinedDiscreteFunctionSpace
      : public DiscreteFunctionSpaceDefault< Traits >
    {
      typedef GenericCombinedDiscreteFunctionSpace< Traits > ThisType;
      typedef DiscreteFunctionSpaceDefault< Traits > BaseType;
 
      typedef typename Traits::DiscreteFunctionSpaceTupleType DiscreteFunctionSpaceTupleType;
 
    public:
      // type of i-th contained sub space
      template< int i >
      using SubDiscreteFunctionSpace = typename Traits::template SubDiscreteFunctionSpace< i >;
 
      typedef typename Traits::GridPartType GridPartType;
      typedef typename Traits::GridType GridType;
      typedef typename GridPartType::IntersectionType IntersectionType;
      typedef typename Traits::IndexSetType IndexSetType;
      typedef typename Traits::IteratorType IteratorType;
      enum { dimension = GridType::dimension };
 
      typedef typename Traits::FunctionSpaceType FunctionSpaceType;
 
      typedef typename Traits::BasisFunctionSetType BasisFunctionSetType;
 
      typedef typename Traits::BlockMapperType BlockMapperType;
 
      typedef int IdentifierType;
      static const IdentifierType id = 669;
 
      typedef DofManager< GridType > DofManagerType;
 
      static const InterfaceType defaultInterface = InteriorBorder_All_Interface;
 
      static const CommunicationDirection defaultDirection = ForwardCommunication;
      // this ctor is problematic: assume that one space is a DynamicLS
      // then this constructor uses some default order (=1) silently.
      // Not sure if we want that.
      GenericCombinedDiscreteFunctionSpace ( GridPartType &gridPart,
                                             const InterfaceType commInterface = defaultInterface,
                                             const CommunicationDirection commDirection = defaultDirection )
        : BaseType( gridPart, commInterface, commDirection ),
          spaceTuple_( Traits::createSpaces( gridPart, commInterface, commDirection ) ),
          blockMapper_( Traits::getBlockMapper( spaceTuple_ ) )
      {}
 
    protected:
 
      GenericCombinedDiscreteFunctionSpace ( DiscreteFunctionSpaceTupleType &&spaceTuple )
        : BaseType(
            Traits::template SubDiscreteFunctionSpace< 0 >::subDiscreteFunctionSpace( spaceTuple ).gridPart(),
            Traits::template SubDiscreteFunctionSpace< 0 >::subDiscreteFunctionSpace( spaceTuple ).communicationInterface(),
            Traits::template SubDiscreteFunctionSpace< 0 >::subDiscreteFunctionSpace( spaceTuple ).communicationDirection() ),
          spaceTuple_( std::move( spaceTuple ) ),
          blockMapper_( Traits::getBlockMapper( spaceTuple_ ) )
      {}
 
    public:
 
      GenericCombinedDiscreteFunctionSpace ( const ThisType & ) = delete;
      ThisType &operator= ( const ThisType & ) = delete;
 
      using BaseType::gridPart;
 
      bool contains ( const int codim ) const
      {
        // forward to mapper since this information is held there
        return blockMapper().contains( codim );
      }
 
      bool continuous () const
      {
        return Traits::accumulate( spaceTuple_, true, [] ( bool c, const auto &s ) { return c && s.continuous(); } );
      }
 
      bool continuous ( const IntersectionType &intersection ) const
      {
        return Traits::accumulate( spaceTuple_, true, [ &intersection ] ( bool c, const auto &s ) { return c && s.continuous( intersection ); } );
      }
 
      DFSpaceIdentifier type () const
      {
        return DFSpaceIdentifier( -1 );
      }
 
      int order () const
      {
        return Traits::accumulate( spaceTuple_, int( 0 ), [] ( int o, const auto &s ) { return std::max( o, s.order() ); } );
      }
 
      template< class Entity >
      int order ( const Entity &entity ) const
      {
        return Traits::accumulate( spaceTuple_, int( 0 ), [ &entity ] ( int o, const auto &s ) { return std::max( o, s.order( entity ) ); } );
      }
 
      template< class EntityType >
      BasisFunctionSetType basisFunctionSet ( const EntityType &entity ) const
      {
        return Traits::getBasisFunctionSet( entity, spaceTuple_ );
      }
 
      BlockMapperType &blockMapper () const
      {
        return *blockMapper_;
      }
 
      template< int i >
      const typename SubDiscreteFunctionSpace< i >::Type& subDiscreteFunctionSpace() const
      {
        return SubDiscreteFunctionSpace< i >::subDiscreteFunctionSpace( spaceTuple_ );
      }
    private:
      DiscreteFunctionSpaceTupleType spaceTuple_;
 
      std::unique_ptr< BlockMapperType > blockMapper_;
    };
 
  } // namespace Fem
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_SPACE_COMBINEDSPACE_GENERIC_HH