discretefunction.hh

#ifndef DUNE_FEM_DISCRETEFUNCTION_HH
#define DUNE_FEM_DISCRETEFUNCTION_HH
 
#include <cassert>
 
#include <complex>
#include <memory>
#include <ostream>
#include <string>
#include <typeindex>
 
#include <dune/common/dynvector.hh>
 
#include <dune/fem/function/common/dofiterator.hh>
#include <dune/fem/function/common/function.hh>
#include <dune/fem/function/common/functor.hh>
#include <dune/fem/function/common/scalarproducts.hh>
#include <dune/fem/function/common/rangegenerators.hh>
#include <dune/fem/function/localfunction/temporary.hh>
#include <dune/fem/gridpart/common/entitysearch.hh>
#include <dune/fem/io/file/persistencemanager.hh>
#include <dune/fem/io/streams/streams.hh>
#include <dune/fem/misc/functor.hh>
#include <dune/fem/misc/mpimanager.hh>
#include <dune/fem/space/common/discretefunctionspace.hh>
#include <dune/fem/storage/envelope.hh>
#include <dune/fem/storage/referencevector.hh>
#include <dune/fem/version.hh>
 
 
namespace Dune
{
 
  namespace Fem
  {
 
    class IsDiscreteFunction
    {};
 
    class HasLocalFunction
    {};
 
 
    template< class DiscreteFunction >
    struct DiscreteFunctionTraits;
 
    template< class Traits >
    class DiscreteFunctionDefault;
 
    //----------------------------------------------------------------------
    //-
    //-  --DiscreteFunctionInterface
    //-
    //----------------------------------------------------------------------
    template< class Impl >
    class DiscreteFunctionInterface
    : public Fem::Function< typename DiscreteFunctionTraits< Impl >::DiscreteFunctionSpaceType::FunctionSpaceType, Impl >,
      public IsDiscreteFunction,
      public HasLocalFunction
    {
      typedef DiscreteFunctionInterface< Impl > ThisType;
      typedef Fem::Function< typename DiscreteFunctionTraits< Impl >::DiscreteFunctionSpaceType::FunctionSpaceType, Impl > BaseType;
 
    public:
      typedef DiscreteFunctionTraits< Impl > Traits;
 
      typedef typename Traits :: DiscreteFunctionType DiscreteFunctionType;
 
      typedef typename Traits :: DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      typedef typename DiscreteFunctionSpaceType :: FunctionSpaceType FunctionSpaceType;
 
      typedef DiscreteFunctionInterface< Impl > DiscreteFunctionInterfaceType;
 
      typedef typename DiscreteFunctionSpaceType :: DomainFieldType DomainFieldType;
      typedef typename DiscreteFunctionSpaceType :: RangeFieldType RangeFieldType;
      typedef typename DiscreteFunctionSpaceType :: DomainType DomainType;
      typedef typename DiscreteFunctionSpaceType :: RangeType RangeType;
      typedef typename DiscreteFunctionSpaceType :: JacobianRangeType JacobianRangeType;
 
      typedef typename DiscreteFunctionSpaceType::GridPartType GridPartType;
      typedef typename GridPartType::GridViewType GridView;
 
      typedef typename DiscreteFunctionSpaceType :: GridType GridType;
 
      typedef typename Traits :: LocalFunctionType LocalFunctionType;
 
      typedef typename Traits :: DofVectorType  DofVectorType;
 
      typedef typename Traits :: DofIteratorType DofIteratorType;
 
      typedef typename Traits :: ConstDofIteratorType ConstDofIteratorType;
 
      typedef typename Traits :: DofType DofType;
      typedef typename Traits :: DofBlockType DofBlockType;
      typedef typename Traits :: ConstDofBlockType ConstDofBlockType;
      typedef typename Traits :: DofBlockPtrType DofBlockPtrType;
      typedef typename Traits :: ConstDofBlockPtrType ConstDofBlockPtrType;
 
      typedef typename BaseType :: MappingType MappingType;
 
      typedef typename DiscreteFunctionSpaceType::LocalBlockIndices BlockIndices;
 
      static constexpr std::size_t blockSize = Hybrid::size( BlockIndices() );
 
      template< class Operation >
      struct CommDataHandle
      {
        typedef typename DiscreteFunctionSpaceType
          :: template CommDataHandle< DiscreteFunctionType, Operation > :: Type
          Type;
      };
 
      typedef typename DiscreteFunctionSpaceType :: EntityType  EntityType;
 
    protected:
      using BaseType::asImp;
 
      DiscreteFunctionInterface () = default;
 
      DiscreteFunctionInterface ( const ThisType& ) = default;
      DiscreteFunctionInterface ( ThisType && ) = default;
    public:
      ThisType& operator= ( ThisType&& ) = delete;
      ThisType &operator= ( const ThisType& ) = delete;
 
      DofVectorType &dofVector()
      {
        return asImp().dofVector();
      }
      const DofVectorType &dofVector() const
      {
        return asImp().dofVector();
      }
 
      const std::string &name () const
      {
        return asImp().name();
      }
 
      std::string &name ()
      {
        return asImp().name();
      }
 
      const std::string &order () const
      {
        return asImp().order();
      }
 
      bool continuous() const
      {
        return asImp().continuous();
      }
 
      const DiscreteFunctionSpaceType &space () const
      {
        return asImp().space();
      }
 
      const GridPartType &gridPart () const
      {
        return asImp().gridPart();
      }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      LocalFunctionType localFunction ( const EntityType &entity )
      {
        return asImp().localFunction( entity );
      }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      const LocalFunctionType localFunction ( const EntityType &entity ) const
      {
        return asImp().localFunction( entity );
      }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      LocalFunctionType localFunction ()
      {
        return asImp().localFunction();
      }
 
 
      template< class LocalDofs >
      void addScaledLocalDofs ( const EntityType &entity, const RangeFieldType &s, const LocalDofs &localDofs )
      {
        asImp().addScaledLocalDofs( entity, s, localDofs );
      }
 
      template< class LocalDofs >
      void addLocalDofs ( const EntityType &entity, const LocalDofs &localDofs )
      {
        asImp().addLocalDofs( entity, localDofs );
      }
 
      template< class LocalDofs >
      void setLocalDofs ( const EntityType &entity, const LocalDofs &localDofs )
      {
        asImp().setLocalDofs( entity, localDofs );
      }
 
      template< class Vector >
      void getLocalDofs ( const EntityType &entity, Vector &localDofs ) const
      {
        asImp().getLocalDofs( entity, localDofs );
      }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      const LocalFunctionType localFunction () const
      {
        return asImp().localFunction();
      }
 
      void clear()
      {
        asImp().clear();
      }
 
      int size() const
      {
        return asImp().size();
      }
 
      int blocks() const
      {
        return asImp().blocks();
      }
 
      ConstDofIteratorType dbegin () const
      {
        return asImp().dbegin ();
      }
 
      ConstDofIteratorType dend () const
      {
        return asImp().dend ();
      }
 
      DofIteratorType dbegin ()
      {
        return asImp().dbegin ();
      }
 
      DofIteratorType dend ()
      {
        return asImp().dend ();
      }
 
      void axpy( const RangeFieldType &s, const DiscreteFunctionInterfaceType &g )
      {
        asImp().axpy( s, g );
      }
 
      template <class DFType>
      RangeFieldType scalarProductDofs ( const DiscreteFunctionInterface< DFType > &other ) const
      {
        return asImp().scalarProductDofs( other.asImp() );
      }
 
      typename Dune::FieldTraits< RangeFieldType >::real_type normSquaredDofs ( ) const
      {
        return asImp().normSquaredDofs( );
      }
 
      void print( std :: ostream &out ) const
      {
        asImp().print( out );
      }
 
      bool dofsValid () const
      {
        return asImp().dofsValid();
      }
 
      template < class DFType >
      void assign( const DiscreteFunctionInterface< DFType > &g )
      {
        asImp().assign( g );
      }
 
      template< class Operation >
      typename CommDataHandle< Operation >::Type dataHandle( const Operation &operation )
      {
        return asImp().dataHandle( operation );
      }
 
      void communicate()
      {
        CHECK_AND_CALL_INTERFACE_IMPLEMENTATION( asImp().communicate() );
      }
 
      template <class DFType>
      inline bool compare ( const DiscreteFunctionInterface<DFType> &g ) const
      {
        return asImp().compare( g );
      }
 
      template < class DFType >
      DiscreteFunctionType &operator+=(const DiscreteFunctionInterface< DFType > &g)
      {
        return asImp().operator+=( g );
      }
 
      template < class DFType >
      DiscreteFunctionType &operator-=(const DiscreteFunctionInterface< DFType > &g)
      {
        return asImp().operator-=( g );
      }
 
      DiscreteFunctionType &operator*= ( const RangeFieldType &scalar )
      {
        return asImp() *= scalar;
      }
 
      DiscreteFunctionType &operator/= ( const RangeFieldType &scalar )
      {
        return asImp() /= scalar;
      }
 
      template< class StreamTraits >
      void read ( InStreamInterface< StreamTraits > &in )
      {
        asImp().read( in );
      }
 
      template< class StreamTraits >
      void write ( OutStreamInterface< StreamTraits > &out ) const
      {
        asImp().write( out );
      }
 
      void enableDofCompression()
      {
        asImp().enableDofCompression();
      }
 
      //TODO: this needs to be revised, the definition should be in GridPart
      typedef LoadBalanceLeafData< ThisType > DefaultLoadBalanceContainsCheckType;
      DefaultLoadBalanceContainsCheckType defaultLoadBalanceContainsCheck() const
      {
        return DefaultLoadBalanceContainsCheckType( *this );
      }
    };
 
 
 
    //*************************************************************************
    //
    //  --DiscreteFunctionDefault
    //
    //*************************************************************************
    template< class Impl >
    class DiscreteFunctionDefault
    : public DiscreteFunctionInterface< Impl > ,
      public PersistentObject
    {
      typedef DiscreteFunctionDefault< Impl > ThisType;
      typedef DiscreteFunctionInterface< Impl > BaseType;
 
    public:
      typedef typename BaseType :: Traits Traits;
 
      typedef Impl DiscreteFunctionType;
 
      typedef typename BaseType::DiscreteFunctionInterfaceType DiscreteFunctionInterfaceType;
 
    private:
      typedef DiscreteFunctionDefault< Impl > DiscreteFunctionDefaultType;
 
      enum { myId_ = 0 };
 
    protected:
      typedef ParallelScalarProduct< DiscreteFunctionInterfaceType > ScalarProductType;
 
    public:
      typedef typename BaseType::DiscreteFunctionSpaceType DiscreteFunctionSpaceType;
 
      typedef typename BaseType::GridPartType GridPartType;
 
      typedef typename DiscreteFunctionSpaceType :: DomainType DomainType;
      typedef typename DiscreteFunctionSpaceType :: RangeType RangeType;
      typedef typename DiscreteFunctionSpaceType :: JacobianRangeType JacobianRangeType;
      typedef typename DiscreteFunctionSpaceType :: HessianRangeType HessianRangeType;
 
      typedef typename DiscreteFunctionSpaceType :: DomainFieldType DomainFieldType;
      typedef typename DiscreteFunctionSpaceType :: RangeFieldType RangeFieldType;
 
      typedef typename Traits :: DofIteratorType DofIteratorType;
      typedef typename Traits :: ConstDofIteratorType ConstDofIteratorType;
 
      typedef typename Traits :: DofVectorType     DofVectorType;
 
      typedef typename Traits :: LocalDofVectorType LocalDofVectorType;
      typedef typename Traits :: LocalDofVectorAllocatorType LocalDofVectorAllocatorType;
 
      typedef typename BaseType :: LocalFunctionType LocalFunctionType;
      typedef typename LocalFunctionType::LocalCoordinateType LocalCoordinateType;
 
      typedef typename BaseType :: DofBlockType DofBlockType;
      typedef typename BaseType :: ConstDofBlockType ConstDofBlockType;
      typedef typename BaseType :: DofBlockPtrType DofBlockPtrType;
      typedef typename BaseType :: ConstDofBlockPtrType ConstDofBlockPtrType;
 
      typedef typename BaseType :: EntityType EntityType ;
 
      typedef typename BaseType :: DofType DofType;
 
      typedef typename DofVectorType::SizeType SizeType;
 
      using BaseType::blockSize;
 
      template< class Operation >
      struct CommDataHandle
      : public BaseType :: template CommDataHandle< Operation >
      {};
 
    protected:
      using BaseType :: asImp;
 
      typedef TemporaryLocalFunction< DiscreteFunctionSpaceType > TemporaryLocalFunctionType;
 
      DiscreteFunctionDefault ( const std::string &name, const DiscreteFunctionSpaceType &dfSpace );
 
      DiscreteFunctionDefault ( std::string name, std::shared_ptr< const DiscreteFunctionSpaceType > dfSpace );
 
      DiscreteFunctionDefault ( const ThisType& );
      DiscreteFunctionDefault ( ThisType && other );
 
    public:
      ThisType& operator= ( ThisType&& ) = delete;
      ThisType &operator= ( const ThisType& ) = delete;
 
      // Default Implementations
      // -----------------------
 
      const std::string &name () const { return name_; }
 
      std::string &name () { return name_; }
 
      constexpr int order() const
      {
        return space().order();
      }
 
      bool continuous() const
      {
        return space().continuous();
      }
 
      const DiscreteFunctionSpaceType &space () const { return *dfSpace_; }
 
      const GridPartType &gridPart () const { return space().gridPart(); }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      LocalFunctionType localFunction ( const EntityType &entity ) { return LocalFunctionType( asImp(), entity ); }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      const LocalFunctionType localFunction ( const EntityType &entity ) const { return LocalFunctionType( asImp(), entity ); }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      LocalFunctionType localFunction () { return LocalFunctionType( asImp() ); }
 
      [[deprecated("Use {Const,Temporary,Mutable}LocalFunction and LocalContribution instead!")]]
      const LocalFunctionType localFunction () const { return LocalFunctionType( asImp() ); }
 
      void clear() { dofVector().clear(); }
 
      DofVectorType &dofVector() { return asImp().dofVector(); }
      const DofVectorType &dofVector() const { return asImp().dofVector(); }
 
      int blocks() const { return dofVector().size(); }
 
      DofBlockPtrType block ( unsigned int index )
      {
        return dofVector().blockPtr( index );
      }
 
      ConstDofBlockPtrType block ( unsigned int index ) const
      {
        return dofVector().blockPtr( index );
      }
 
      SizeType size () const { return dofVector().size() * blockSize; }
 
      ConstDofIteratorType dbegin () const { return dofVector().begin(); }
 
      DofIteratorType dbegin () { return dofVector().begin(); }
 
      ConstDofIteratorType dend () const { return dofVector().end(); }
 
      DofIteratorType dend () { return dofVector().end(); }
 
      template <class DFType>
      void axpy ( const RangeFieldType &s, const DiscreteFunctionInterface< DFType > &g );
 
      void axpy ( const RangeFieldType &s, const DiscreteFunctionInterfaceType& g )
      {
        dofVector().axpy( s, g.dofVector() );
      }
 
      template <class DFType>
      RangeFieldType scalarProductDofs ( const DiscreteFunctionInterface< DFType > &other ) const
      {
        return scalarProduct_.scalarProductDofs( *this, other );
      }
 
      typename Dune::FieldTraits< RangeFieldType >::real_type normSquaredDofs ( ) const
      {
        return std::real( (*this).scalarProductDofs( *this ));
      }
 
      void print ( std :: ostream &out ) const;
 
      inline bool dofsValid () const;
 
      template <class DFType>
      void assign ( const DiscreteFunctionInterface< DFType > &g );
 
      void assign ( const DiscreteFunctionType &g )
      {
        dofVector() = g.dofVector();
      }
 
      template< class Operation >
      typename CommDataHandle< Operation >::Type dataHandle ( const Operation &operation );
 
      void communicate()
      {
        // only call in single thread mode
        if( ! Fem :: MPIManager :: singleThreadMode() )
        {
          assert( Fem :: MPIManager :: singleThreadMode() );
          DUNE_THROW(InvalidStateException,"DiscreteFunctionInterface::communicate: only call in single thread mode!");
        }
 
        this->space().communicate( asImp() );
      }
 
      void evaluate ( const DomainType &x, RangeType &value ) const
      {
        asImp().evaluateGlobal( x, [ &value ] ( const LocalCoordinateType &x, const TemporaryLocalFunctionType &localFunction )
                                              { localFunction.evaluate( x, value ); } );
      }
 
      void jacobian ( const DomainType &x, JacobianRangeType &jacobian ) const
      {
        asImp().evaluateGlobal( x, [ &jacobian ] ( const LocalCoordinateType &x, const TemporaryLocalFunctionType &localFunction )
                                                 { localFunction.jacobian( x, jacobian ); } );
 
      }
 
      void hessian ( const DomainType &x, HessianRangeType &hessian ) const
      {
        asImp().evaluateGlobal( x, [ &hessian ] ( const LocalCoordinateType &x, const TemporaryLocalFunctionType &localFunction )
                                                { localFunction.hessian( x, hessian ); } );
      }
 
      template <class DFType>
      DiscreteFunctionType &operator+=(const DiscreteFunctionInterface< DFType > &g);
 
      DiscreteFunctionType &operator+=(const DiscreteFunctionType &g)
      {
        dofVector() += g.dofVector();
        return asImp();
      }
 
      template <class DFType>
      DiscreteFunctionType &operator-=(const DiscreteFunctionInterface< DFType > &g);
 
      DiscreteFunctionType &operator-=(const DiscreteFunctionType& g)
      {
        dofVector() -= g.dofVector();
        return asImp();
      }
 
      DiscreteFunctionType &operator*= ( const RangeFieldType &scalar )
      {
        dofVector() *= scalar;
        return asImp();
      }
 
      DiscreteFunctionType &operator/= ( const RangeFieldType &scalar )
      {
        return BaseType :: operator*=( RangeFieldType(1 ) / scalar );
      }
 
      template< class StreamTraits >
      inline void read ( InStreamInterface< StreamTraits > &in );
 
      template< class StreamTraits >
      inline void write ( OutStreamInterface< StreamTraits > &out ) const;
 
      void enableDofCompression ()
      {}
 
 
      template< class LocalDofs >
      void addScaledLocalDofs ( const EntityType &entity, const RangeFieldType &s, const LocalDofs &localDofs )
      {
        LeftAddScaled< const LocalDofs, const RangeFieldType > assignFunctor( localDofs, s );
        space().blockMapper().mapEach( entity, dofBlockFunctor( dofVector(), assignFunctor ) );
      }
 
      template< class LocalDofs >
      void addLocalDofs ( const EntityType &entity, const LocalDofs &localDofs )
      {
        LeftAdd< const LocalDofs > assignFunctor( localDofs );
        space().blockMapper().mapEach( entity, dofBlockFunctor( dofVector(), assignFunctor ) );
      }
 
      template< class LocalDofs >
      void setLocalDofs ( const EntityType &entity, const LocalDofs &localDofs )
      {
        LeftAssign< const LocalDofs > assignFunctor( localDofs );
        space().blockMapper().mapEach( entity, dofBlockFunctor( dofVector(), assignFunctor ) );
      }
 
      template< class Vector >
      void getLocalDofs ( const EntityType &entity, Vector &localDofs ) const
      {
        AssignFunctor< Vector > assignFunctor( localDofs );
        space().blockMapper().mapEach( entity, dofBlockFunctor( dofVector(), assignFunctor ) );
      }
 
      template <class DFType>
      inline bool compare ( const DiscreteFunctionInterface< DFType> &g ) const;
 
      // Non-Interface Methods
      // ---------------------
 
      LocalDofVectorAllocatorType &localDofVectorAllocator () const
      {
        return ldvAllocator_;
      }
 
      template< class AssembleOperation >
      void beginAssemble ()
      {
        const std::type_index id( typeid( AssembleOperation ) );
        if( assembleOperation_ != id )
        {
          if( assembleOperation_ != std::type_index( typeid( void ) ) )
            DUNE_THROW( InvalidStateException, "Another assemble operation in progress" );
          assembleOperation_ = id;
          assert( assembleCount_ == 0 );
          AssembleOperation::begin( asImp() );
        }
        ++assembleCount_;
      }
 
      template< class AssembleOperation >
      void endAssemble ( const bool communicate = true )
      {
        const std::type_index id( typeid( AssembleOperation ) );
        if( assembleOperation_ != id )
          DUNE_THROW( InvalidStateException, "Assemble operation not in progress" );
        assert( assembleCount_ > 0 );
        if( --assembleCount_ == 0 )
        {
          AssembleOperation::end( asImp(), communicate );
          assembleOperation_ = std::type_index( typeid( void ) );
        }
      }
 
      void getLocalDofReferences ( const EntityType &entity, LocalDofVectorType &localDofs )
      {
        AssignVectorReference< LocalDofVectorType > assignFunctor( localDofs );
        space().blockMapper().mapEach( entity, dofBlockFunctor( dofVector(), assignFunctor ) );
      }
 
    protected:
      virtual void backup() const
      {
        // get backup stream from persistence manager and write to it
        write( PersistenceManager :: backupStream() );
      }
 
      virtual void restore()
      {
        // get restore stream from persistence manager and read from it
        read( PersistenceManager :: restoreStream() );
      }
 
      virtual void insertSubData();
 
      virtual void removeSubData();
 
      template< class Functor >
      void evaluateGlobal ( const DomainType &x, Functor functor ) const;
 
      // only PersistenceManager should call backup and restore
      friend class PersistenceManager;
 
      std::shared_ptr< const DiscreteFunctionSpaceType > dfSpace_;
 
      // the local function storage
      typename Traits :: LocalDofVectorStackType ldvStack_;
      mutable LocalDofVectorAllocatorType ldvAllocator_;
 
      mutable TemporaryLocalFunctionType localFunction_;
 
      std::string name_;
      ScalarProductType scalarProduct_;
 
      std::type_index assembleOperation_ = std::type_index( typeid( void ) );;
      std::size_t assembleCount_ = 0;
    }; // end class DiscreteFunctionDefault
 
    template< class ImplX, class ImplY >
    inline bool operator== ( const DiscreteFunctionInterface< ImplX > &x,
                             const DiscreteFunctionInterface< ImplY > &y )
    {
      return x.compare(y);
    }
    template< class ImplX, class ImplY >
    inline bool operator!= ( const DiscreteFunctionInterface< ImplX > &x,
                             const DiscreteFunctionInterface< ImplY > &y )
    {
      return !x.compare(y);
    }
 
    template< class DiscreteFunction >
    class ManagedDiscreteFunction;
 
    template< class DiscreteFunction >
    struct DiscreteFunctionTraits< ManagedDiscreteFunction< DiscreteFunction > >
    : public DiscreteFunctionTraits< DiscreteFunction > {};
 
 
    template< typename DiscreteFunctionSpace, typename DofVector >
    struct DefaultDiscreteFunctionTraits
    {
      typedef DofVector DofVectorType;
 
      typedef DiscreteFunctionSpace                           DiscreteFunctionSpaceType;
      typedef typename DiscreteFunctionSpaceType::DomainType  DomainType;
      typedef typename DiscreteFunctionSpaceType::RangeType   RangeType;
 
      typedef typename DofVectorType::IteratorType            DofIteratorType;
      typedef typename DofVectorType::ConstIteratorType       ConstDofIteratorType;
      typedef typename DofVectorType::DofBlockType            DofBlockType;
      typedef typename DofVectorType::ConstDofBlockType       ConstDofBlockType;
      typedef typename DofVectorType::DofBlockPtrType         DofBlockPtrType;
      typedef typename DofVectorType::ConstDofBlockPtrType    ConstDofBlockPtrType;
 
      typedef typename DiscreteFunctionSpaceType::BlockMapperType MapperType;
      typedef typename DofVectorType::FieldType DofType;
 
      typedef ThreadSafeValue< UninitializedObjectStack >         LocalDofVectorStackType;
      typedef StackAllocator< DofType, LocalDofVectorStackType* > LocalDofVectorAllocatorType;
      typedef DynamicReferenceVector< DofType, LocalDofVectorAllocatorType > LocalDofVectorType;
    };
 
 
 
  } // end namespace Fem
 
} // end namespace Dune
 
#include "discretefunction_inline.hh"
 
#include "gridfunctionadapter.hh"
#endif // #ifndef DUNE_FEM_DISCRETEFUNCTION_HH