discretefunctionspace.hh

#ifndef DUNE_FEM_DISCRETEFUNCTIONSPACE_HH
#define DUNE_FEM_DISCRETEFUNCTIONSPACE_HH
 
// C++ includes
#include <cassert>
 
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
 
// dune-common includes
#include <dune/common/bartonnackmanifcheck.hh>
#include <dune/common/dynvector.hh>
 
// dune-fem includes
#include <dune/fem/common/hybrid.hh>
#include <dune/fem/common/stackallocator.hh>
#include <dune/fem/function/blockvectors/defaultblockvectors.hh>
#include <dune/fem/function/localfunction/temporary.hh>
#include <dune/fem/misc/threads/threadsafevalue.hh>
#include <dune/fem/space/common/commoperations.hh>
#include <dune/fem/space/common/communicationmanager.hh>
#include <dune/fem/space/common/dofmanager.hh>
#include <dune/fem/space/common/functionspace.hh>
#include <dune/fem/space/common/auxiliarydofs.hh>
#include <dune/fem/storage/singletonlist.hh>
#include <dune/fem/version.hh>
 
// local includes
#include "allgeomtypes.hh"
#include "dofstorage.hh"
 
 
namespace Dune
{
 
  namespace Fem
  {
 
    // ExportsDiscreteFunctionSpaceType
    // --------------------------------
 
    template< class T >
    class ExportsDiscreteFunctionSpaceType
    {
      typedef char Small;
      struct Big { char dummy[ 2 ]; };
 
      template< class U >
      static Small test ( const U &, typename U::DiscreteFunctionSpaceType * = nullptr );
      static Big test ( ... );
 
      static const T &makeT ();
 
      template< class U, bool >
      struct GetDiscreteFunctionSpaceType;
 
      template< class U >
      struct GetDiscreteFunctionSpaceType< U, true >
      {
        typedef typename U::DiscreteFunctionSpaceType Type;
      };
 
      template< class U >
      struct GetDiscreteFunctionSpaceType< U, false >
      {
        typedef void Type;
      };
 
    public:
      static const bool v = (sizeof( test( makeT() ) ) == sizeof( Small ));
      typedef typename GetDiscreteFunctionSpaceType< T, v >::Type Type;
    };
 
 
 
    // DFSpaceIdentifier
    // -----------------
 
    enum DFSpaceIdentifier {
      CombinedSpace_id,             
      DFAdapter_id,                 
      DGSpace_id,                   
      FiniteVolumeSpace_id,         
      FourierSpace_id,              
      GenericSpace_id,              
      LagrangeSpace_id,             
      RannacherTurekSpace_id,       
      LegendreDGSpace_id,           
      HierarchicLegendreDGSpace_id, 
      LagrangeDGSpace_id,           
      LocalFiniteElementSpace_id         
    };
 
    inline std::string spaceName( const DFSpaceIdentifier id )
    {
      switch( id )
      {
        case CombinedSpace_id             : return "CombinedSpace";
        case DFAdapter_id                 : return "DFAdapter";
        case DGSpace_id                   : return "DiscontinuousGalerkinSpace";
        case FiniteVolumeSpace_id         : return "FiniteVolumeSpace";
        case FourierSpace_id              : return "FourierSpace";
        case GenericSpace_id              : return "GenericSpace";
        case LagrangeSpace_id             : return "LagrangeSpace";
        case RannacherTurekSpace_id       : return "RannacherTurekSpace";
        case LegendreDGSpace_id           : return "LegendreDGSpace";
        case HierarchicLegendreDGSpace_id : return "HierarchicLegendreDGSpace";
        case LagrangeDGSpace_id           : return "LagrangeDGSpace";
        default                           : return "unknown space";
      }
    }
 
    struct isGenericDiscreteFunctionSpace
    {};
 
    template< class DiscreteFunctionSpaceImp,
              class NewFunctionSpace>
    struct DifferentDiscreteFunctionSpace;
 
    template <class FunctionSpaceImp,
              class GridPartImp,
              int polOrd,
              class StorageImp,
              template <class,class,int,class> class DiscreteFunctionSpaceImp,
              class NewFunctionSpace>
    struct DifferentDiscreteFunctionSpace<
        DiscreteFunctionSpaceImp<FunctionSpaceImp,GridPartImp,polOrd,StorageImp>,
            NewFunctionSpace>
    {
      typedef DiscreteFunctionSpaceImp< NewFunctionSpace, GridPartImp, polOrd, StorageImp > Type;
    };
 
    template <class FunctionSpaceImp,
              class GridPartImp,
              int polOrd,
              bool caching,
              template <class,class,int,bool> class DiscreteFunctionSpaceImp,
              class NewFunctionSpace>
    struct DifferentDiscreteFunctionSpace<
        DiscreteFunctionSpaceImp<FunctionSpaceImp,GridPartImp,polOrd,caching>,
            NewFunctionSpace>
    {
      typedef DiscreteFunctionSpaceImp< NewFunctionSpace, GridPartImp, polOrd, caching > Type;
    };
 
 
    //**************************************************************************
    //
    //  --DiscreteFunctionSpaceInterface
    //
    template< class FunctionSpaceTraits >
    class DiscreteFunctionSpaceInterface
    : public FunctionSpaceTraits :: FunctionSpaceType
    {
    public:
      typedef FunctionSpaceTraits Traits;
 
      typedef typename Traits :: DiscreteFunctionSpaceType
        DiscreteFunctionSpaceType;
      typedef typename Traits :: FunctionSpaceType FunctionSpaceType;
 
    private:
      typedef FunctionSpaceType BaseType;
 
    public:
      typedef typename Traits :: BasisFunctionSetType BasisFunctionSetType;
      typedef typename Traits :: BlockMapperType BlockMapperType;
 
      typedef typename Traits::LocalBlockIndices LocalBlockIndices;
 
      static constexpr std::size_t localBlockSize = Hybrid::size( LocalBlockIndices() );
 
      typedef typename Traits :: GridPartType GridPartType;
 
      typedef typename GridPartType :: GridType GridType;
      typedef typename GridPartType :: IndexSetType IndexSetType;
      typedef typename GridPartType :: template Codim< Traits::codimension > :: IteratorType
        IteratorType;
      typedef typename GridPartType :: template Codim< Traits::codimension > :: EntityType EntityType;
      typedef typename GridPartType :: IntersectionType IntersectionType;
      typedef AuxiliaryDofs< GridPartType, BlockMapperType > AuxiliaryDofsType;
 
      [[deprecated("Use AuxiliaryDofsType instead!")]]
      typedef AuxiliaryDofsType SlaveDofsType;
 
      template< class DiscreteFunction,
                class Operation =  // get default type from traits
                  typename Traits :: template CommDataHandle< DiscreteFunction > :: OperationType
              >
      struct CommDataHandle
      {
        typedef typename Traits
          :: template CommDataHandle< DiscreteFunction, Operation > :: Type
          Type;
 
        typedef typename Traits
          :: template CommDataHandle< DiscreteFunction, Operation > :: OperationType
          OperationType;
      };
 
      typedef CommunicationManager< DiscreteFunctionSpaceType > CommunicationManagerType;
 
      template< class NewFunctionSpace >
      struct ToNewFunctionSpace
      {
        typedef typename DifferentDiscreteFunctionSpace< DiscreteFunctionSpaceType, NewFunctionSpace> :: Type Type;
      };
 
      template< int newDimRange >
      struct ToNewDimRange
      {
        typedef typename ToNewDimRangeFunctionSpace< FunctionSpaceType, newDimRange > :: Type NewFunctionSpaceType;
 
        typedef typename ToNewFunctionSpace< NewFunctionSpaceType > :: Type  Type;
      };
 
    private:
      static_assert( std::is_same<typename BaseType::DomainFieldType, typename GridType::ctype>::value,
                     "Domain field type of function space must equal field type of grid." );
 
    protected:
      DiscreteFunctionSpaceInterface ()
      {}
 
    public:
 
      // Methods Provided by the Implementation
      // --------------------------------------
 
      DFSpaceIdentifier type () const
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().type());
        return asImp().type();
      }
 
      inline const BasisFunctionSetType basisFunctionSet ( const EntityType &entity ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().basisFunctionSet( entity ) );
        return asImp().basisFunctionSet( entity );
      }
 
      inline bool continuous () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().continuous() );
        return asImp().continuous();
      }
 
      inline int sequence () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().sequence() );
        return asImp().sequence();
      }
 
      inline int order () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().order() );
        return asImp().order();
      }
 
      inline bool continuous (const IntersectionType &intersection) const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().continuous(intersection) );
        return asImp().continuous(intersection);
      }
 
      inline BlockMapperType &blockMapper () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().blockMapper() );
        return asImp().blockMapper();
      }
 
      inline const GridType &grid () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().grid() );
        return asImp().grid();
      }
 
      inline GridType &grid ()
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().grid() );
        return asImp().grid();
      }
 
      inline GridPartType &gridPart ()
      {
        CHECK_INTERFACE_IMPLEMENTATION(asImp().gridPart());
        return asImp().gridPart();
      }
 
      inline const IndexSetType &indexSet () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().indexSet() );
        return asImp().indexSet();
      }
 
      inline int size () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().size() );
        return asImp().size();
      }
 
      inline int primarySize () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().primarySize() );
        return asImp().primarySize();
      }
 
      inline int auxiliarySize () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().auxiliarySize() );
        return asImp().auxiliarySize();
      }
 
      inline IteratorType begin () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().begin() );
        return asImp().begin();
      }
 
      inline IteratorType end () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().end() );
        return asImp().end();
      }
 
      template< class FunctorType >
      inline void forEach ( FunctorType &f ) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().forEach( f ) );
      }
 
      inline bool multipleGeometryTypes () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().multipleGeometryTypes() );
        return asImp().multipleGeometryTypes();
      }
 
 
      inline bool multipleBasisFunctionSets () const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().multipleBasisFunctionSets() );
        return asImp().multipleBasisFunctionSets();
      }
 
      InterfaceType communicationInterface() const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().communicationInterface() );
        return asImp().communicationInterface();
      }
 
      CommunicationDirection communicationDirection() const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().communicationDirection() );
        return asImp().communicationDirection();
      }
 
      const CommunicationManagerType& communicator() const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().communicator() );
        return asImp().communicator();
      }
 
      template <class DiscreteFunction>
      void communicate(DiscreteFunction& discreteFunction) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION(
            asImp().communicate( discreteFunction ) );
      }
 
      template <class DiscreteFunction, class Operation>
      void communicate(DiscreteFunction& discreteFunction, const Operation& op) const
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION(
            asImp().communicate( discreteFunction , op ) );
      }
 
      template< class DiscreteFunction, class Operation >
      inline typename CommDataHandle< DiscreteFunction, Operation > :: Type
      createDataHandle ( DiscreteFunction& discreteFunction,
                        const Operation &operation ) const
      {
        CHECK_INTERFACE_IMPLEMENTATION
          ( asImp().createDataHandle( discreteFunction, operation ) );
        return asImp().createDataHandle( discreteFunction, operation );
      }
 
      const AuxiliaryDofsType& auxiliaryDofs() const
      {
        CHECK_INTERFACE_IMPLEMENTATION( asImp().auxiliaryDofs() );
        return asImp().auxiliaryDofs();
      }
 
      [[deprecated("Use auxiliaryDofs instead!")]]
      const AuxiliaryDofsType& slaveDofs() const
      {
        return auxiliaryDofs();
      }
 
    protected:
      // Barton-Nackman trick
      inline const DiscreteFunctionSpaceType &asImp () const
      {
        return static_cast< const DiscreteFunctionSpaceType & >( *this );
      }
 
      // Barton-Nackman trick
      inline DiscreteFunctionSpaceType &asImp()
      {
        return static_cast< DiscreteFunctionSpaceType & >( *this );
      }
    }; // end class DiscreteFunctionSpaceInterface
 
 
 
    template< class Traits >
    inline bool operator== ( const DiscreteFunctionSpaceInterface< Traits > &X,
                             const DiscreteFunctionSpaceInterface< Traits > &Y )
    {
      return &(X.blockMapper()) == &(Y.blockMapper());
    }
 
 
 
    //---------------------------------------------------------------------------
    //-
    //-  --DiscreteFunctionSpaceDefault
    //-
    //-
    //---------------------------------------------------------------------------
    template< class FunctionSpaceTraits >
    class DiscreteFunctionSpaceDefault
      : public DiscreteFunctionSpaceInterface< FunctionSpaceTraits >,
        public std::enable_shared_from_this< typename FunctionSpaceTraits::DiscreteFunctionSpaceType >
    {
    public:
      typedef FunctionSpaceTraits Traits;
 
    private:
      typedef DiscreteFunctionSpaceDefault< Traits > ThisType;
      typedef DiscreteFunctionSpaceInterface< Traits > BaseType;
 
    public:
      typedef typename Traits :: DiscreteFunctionSpaceType
        DiscreteFunctionSpaceType;
 
      typedef typename BaseType :: GridPartType GridPartType;
      typedef typename BaseType :: GridType GridType;
      typedef typename BaseType :: IndexSetType IndexSetType;
      typedef typename BaseType :: IteratorType IteratorType;
      typedef typename BaseType :: EntityType EntityType;
 
    protected:
      using BaseType :: asImp;
 
    public:
      using BaseType::localBlockSize;
      using BaseType :: blockMapper;
      using BaseType :: order ;
 
      typedef DofManager< GridType > DofManagerType;
 
      typedef CommunicationManager< DiscreteFunctionSpaceType > CommunicationManagerType;
 
      typedef typename BaseType::BlockMapperType 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:
      GridPartType &gridPart_;
 
      typedef ThreadSafeValue< UninitializedObjectStack > LocalDofVectorStackType;
      typedef StackAllocator< typename BaseType::RangeFieldType, LocalDofVectorStackType* > LocalDofVectorAllocatorType;
      typedef Dune::DynamicVector< typename BaseType::RangeFieldType, LocalDofVectorAllocatorType > LocalDofVectorType;
 
      mutable LocalDofVectorStackType ldvStack_;
      mutable LocalDofVectorAllocatorType ldvAllocator_;
 
      typedef BasicTemporaryLocalFunction< ThisType, LocalDofVectorType > LocalFunctionType;
 
      // set of all geometry types possible
      typedef AllGeomTypes< IndexSetType, GridType > AllGeometryTypes;
      const AllGeometryTypes allGeomTypes_;
 
      // reference to dof manager
      DofManagerType& dofManager_;
 
      // communication manager
      const InterfaceType commInterface_;
      const CommunicationDirection commDirection_;
      mutable std::unique_ptr< CommunicationManagerType > communicator_;
 
    public:
      explicit DiscreteFunctionSpaceDefault( GridPartType &gridPart,
          const InterfaceType commInterface = InteriorBorder_All_Interface,
          const CommunicationDirection commDirection = ForwardCommunication )
      : BaseType(),
        gridPart_( gridPart ),
        ldvStack_( 0 ),
        ldvAllocator_( &ldvStack_ ),
        allGeomTypes_( gridPart.indexSet() ),
        dofManager_( DofManagerType :: instance( gridPart.grid() ) ),
        commInterface_( commInterface ),
        commDirection_( commDirection )
      {}
 
      inline int sequence () const
      {
        return dofManager_.sequence();
      }
 
      inline int order ( const EntityType& entity ) const
      {
        return asImp().basisFunctionSet( entity ).order();
      }
 
      inline const GridType &grid () const
      {
        return asImp().gridPart().grid();
      }
 
      inline GridType &grid ()
      {
        return asImp().gridPart().grid();
      }
 
      inline GridPartType &gridPart () const
      {
        return gridPart_;
      }
 
      inline const IndexSetType &indexSet () const
      {
        return asImp().gridPart().indexSet();
      }
 
      inline int size () const
      {
        return blockMapper().size() * localBlockSize ;
      }
 
      inline int primarySize () const
      {
        return auxiliaryDofs().primarySize() * localBlockSize;
      }
 
      inline int auxiliarySize () const
      {
        // total size minus primary dofs
        return size() - primarySize();
      }
 
      inline int maxNumDofs () const
      {
        return blockMapper().maxNumDofs() * localBlockSize;
      }
 
      inline IteratorType begin () const
      {
        return asImp().gridPart().template begin< 0 >();
      }
 
      inline IteratorType end () const
      {
        return asImp().gridPart().template end< 0 >();
      }
 
      template< class FunctorType >
      inline void forEach ( FunctorType &f ) const
      {
        const IteratorType end = asImp().end();
        for( IteratorType it = asImp().begin(); it != end; ++it )
          f( *it );
      }
 
      inline bool multipleGeometryTypes () const
      {
        return allGeomTypes_.multipleGeomTypes();
      }
 
      inline bool multipleBasisFunctionSets () const
      {
        return false;
      }
 
      InterfaceType communicationInterface () const
      {
        return commInterface_;
      }
 
      CommunicationDirection communicationDirection () const
      {
        return commDirection_;
      }
 
      const CommunicationManagerType& communicator() const
      {
        if( !communicator_ )
          communicator_.reset( new CommunicationManagerType( asImp(), commInterface_, commDirection_ ) );
        assert( communicator_ != 0 );
        return *communicator_;
      }
 
      template <class DiscreteFunction>
      void communicate(DiscreteFunction& discreteFunction) const
      {
        // get type of default operation
        typedef typename DiscreteFunction :: DiscreteFunctionSpaceType :: template
          CommDataHandle< DiscreteFunction > :: OperationType  DefaultOperationType;
 
        // default communication operation
        DefaultOperationType operation;
 
        // exchange data
        communicate( discreteFunction, operation );
      }
 
      template <class DiscreteFunction, class Operation>
      void communicate(DiscreteFunction& discreteFunction, const Operation& op ) const
      {
        if constexpr ( std::is_base_of< IsDiscreteFunction, DiscreteFunction >::value )
        {
          static_assert( std::is_same< typename DiscreteFunctionSpaceType::BlockMapperType,
              typename DiscreteFunction::DiscreteFunctionSpaceType::BlockMapperType >::value &&
              localBlockSize == static_cast< std::size_t >(DiscreteFunction::DiscreteFunctionSpaceType::localBlockSize),
              "DiscreteFunctionSpaceDefault::communicate cannot be called with discrete functions defined over a different space" );
          communicator().exchange( discreteFunction, op );
        }
        else
        {
          static_assert( std::is_base_of< IsBlockVector, DiscreteFunction> :: value, "DiscreteFunctionSpaceDefault::communicate needs at least a BlockVectorInterface and derived");
          communicator().exchange( asImp(), discreteFunction, op );
        }
      }
 
      template< class DiscreteFunction, class Operation >
      inline typename BaseType
        :: template CommDataHandle< DiscreteFunction, Operation > :: Type
      createDataHandle( DiscreteFunction &discreteFunction,
                        const Operation& operation ) const
      {
        static_assert( std::is_same< typename DiscreteFunctionSpaceType::BlockMapperType,
            typename DiscreteFunction::DiscreteFunctionSpaceType::BlockMapperType >::value &&
            localBlockSize == static_cast< std::size_t >(DiscreteFunction::DiscreteFunctionSpaceType::localBlockSize),
            "DiscreteFunctionSpaceDefault::createDataHandle cannot be called with discrete functions defined over a different space" );
        return typename BaseType
          :: template CommDataHandle< DiscreteFunction, Operation >
          :: Type( discreteFunction, operation );
      }
 
      const AuxiliaryDofsType& auxiliaryDofs() const
      {
        if ( !auxiliaryDofs_ )
          auxiliaryDofs_.reset( &(AuxiliaryDofsProviderType::getObject( std::make_pair( &this->gridPart(), &this->blockMapper() ) )) );
        const int sequence = asImp().sequence();
        if( auxiliaryDofs_->second != sequence )
        {
          auxiliaryDofs_->first.rebuild();
          auxiliaryDofs_->second = sequence;
        }
        return auxiliaryDofs_->first;
      }
 
      template <class DiscreteFunction>
      void addFunction( DiscreteFunction& df ) const
      {
      }
 
      template <class DiscreteFunction>
      void removeFunction( DiscreteFunction& df ) const
      {
      }
 
      template <class Vector>
      void adapt( const Vector& polynomialOrders, const int polOrderShift = 0 ) const
      {
      }
 
      inline const std::vector<GeometryType>& geomTypes(int codim) const
      {
        return allGeomTypes_.geomTypes(codim);
      }
    protected:
 
      // only combined space should use geomTypes
      template <class , int , DofStoragePolicy> friend class CombinedSpace;
      mutable std::unique_ptr< std::pair< AuxiliaryDofsType, int >, typename AuxiliaryDofsProviderType::Deleter > auxiliaryDofs_;
    };
 
 
 
    //
    //  DiscreteFunctionSpaceAdapter
    //
 
    template< class FunctionSpaceImp, class GridPartImp >
    class DiscreteFunctionSpaceAdapter
    : public FunctionSpaceImp
    , public std::enable_shared_from_this< DiscreteFunctionSpaceAdapter<FunctionSpaceImp,GridPartImp> >
    {
    public:
      // type of the underlying function space
      typedef FunctionSpaceImp FunctionSpaceType;
      typedef GridPartImp GridPartType;
 
    private:
      typedef DiscreteFunctionSpaceAdapter< FunctionSpaceType, GridPartType >
        ThisType;
      typedef FunctionSpaceType BaseType;
 
    public:
      enum { polynomialOrder = 6 }; // default polynomial order basically for determination of quadrature orders
 
      typedef typename GridPartType :: GridType GridType;
      typedef typename GridPartType :: IndexSetType IndexSetType;
      typedef typename GridPartType :: template Codim< 0 > :: IteratorType
        IteratorType;
      //- type of used entity
      typedef typename GridType :: template Codim< 0 > :: Entity EntityType;
      //- type of intersections
      typedef typename GridPartType :: IntersectionType IntersectionType;
 
      typedef DefaultCommunicationManager< ThisType > CommunicationManagerType;
 
    protected:
      const GridPartType &gridPart_;
      const unsigned int order_;
 
    public:
      inline explicit DiscreteFunctionSpaceAdapter
        ( const GridPartType &gridPart,
          unsigned int order = polynomialOrder )
      : BaseType(),
        gridPart_( gridPart ),
        order_( order )
      {
      }
 
      inline DiscreteFunctionSpaceAdapter( const ThisType &other )
      : BaseType( other ),
        gridPart_( other.gridPart_ ),
        order_( other.order_ )
      {
      }
 
      inline IteratorType begin () const
      {
        return gridPart_.template begin< 0 >();
      }
 
      inline IteratorType end () const
      {
        return gridPart_.template end< 0 >();
      }
 
      template< class FunctorType >
      inline void forEach ( FunctorType &f ) const
      {
        const IteratorType endit = end();
        for( IteratorType it = begin(); it != endit; ++it )
          f( *it );
      }
 
      inline const GridPartType &gridPart () const
      {
        return gridPart_;
      }
 
      inline const IndexSetType &indexSet () const
      {
        return gridPart_.indexSet();
      }
 
      inline const GridType& grid () const
      {
        return gridPart_.grid();
      }
 
      inline bool continuous () const
      {
        return true;
      }
      inline bool continuous (const IntersectionType &intersection) const
      {
        return true;
      }
 
      inline int order () const
      {
        return order_;
      }
 
      inline int order ( const EntityType& ) const
      {
        return order();
      }
 
      inline DFSpaceIdentifier type () const
      {
        return DFAdapter_id;
      }
    };
 
 
    template <class KeyImp, class ObjectImp, class ObjectFactoryImp>
    class BaseFunctionSetSingletonFactory
    {
    public:
      static ObjectImp * createObject( const KeyImp & key )
      {
        ObjectFactoryImp fac(key);
        return new ObjectImp(fac);
      }
 
      static void deleteObject( ObjectImp * obj )
      {
        delete obj;
      }
    };
 
  } // namespace Fem
 
} // namespace Dune
#endif // #ifndef DUNE_FEM_DISCRETEFUNCTIONSPACE_HH