diff --git a/fem/discretefunction/adaptivefunction.cc b/fem/discretefunction/adaptivefunction.cc
index ed97056fd08e177596987c43fd457b5ce5f2e311..ba0c61babb9b66d6583fb61714bf6957aee3fe4d 100644
--- a/fem/discretefunction/adaptivefunction.cc
+++ b/fem/discretefunction/adaptivefunction.cc
@@ -8,10 +8,9 @@ namespace Dune {
 
   //- AdaptiveDiscreteFunction (specialisation)
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveDiscreteFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   ~AdaptiveDiscreteFunction()
   {
     for (int i = 0; i < subSpaces_.size(); ++i) {
@@ -20,13 +19,12 @@ namespace Dune {
     }
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveDiscreteFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   SubDiscreteFunctionType
   AdaptiveDiscreteFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   subFunction(int component)
   {
     SubSpaceType* subSpace = new SubSpaceType(this->space(), component);
@@ -39,8 +37,8 @@ namespace Dune {
   }
 
   //- AdaptiveLocalFunction
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   AdaptiveLocalFunction(const DiscreteFunctionSpaceType& spc,
                         DofStorageType& dofVec) :
     spc_(spc),
@@ -50,8 +48,8 @@ namespace Dune {
     tmpGrad_(0.0)
   {}
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   AdaptiveLocalFunction(const ThisType& other) :
     spc_(other.spc_),
     dofVec_(other.dofVec_),
@@ -60,39 +58,39 @@ namespace Dune {
     tmpGrad_(0.0)
   {}
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   ~AdaptiveLocalFunction() {}
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::DofType&
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::DofType&
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   operator[] (int num)
   {
     assert(num >= 0 && num < numberOfDofs());
     return (* (values_[num]));
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   const AdaptiveLocalFunction<
-      DiscreteFunctionSpaceImp, DofManagerImp>::DofType&
-  AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+      DiscreteFunctionSpaceImp >::DofType&
+  AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   operator[] (int num) const
   {
     assert(num >= 0 && num < numberOfDofs());
     return (* (values_[num]));
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  int AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  int AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   numberOfDofs() const
   {
     return values_.size();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType>
-  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   evaluateLocal(EntityType& en, const DomainType& x, RangeType& ret) const
   {
     ret *= 0.0;
@@ -106,9 +104,9 @@ namespace Dune {
     }
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType, class QuadratureType>
-  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   evaluate(EntityType& en,
            QuadratureType& quad,
            int quadPoint,
@@ -117,9 +115,9 @@ namespace Dune {
     evaluateLocal(en, quad.point(quadPoint), ret);
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType>
-  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   jacobianLocal(EntityType& en,
                 const DomainType& x,
                 JacobianRangeType& ret) const
@@ -140,9 +138,9 @@ namespace Dune {
     }
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType, class QuadratureType>
-  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   jacobian(EntityType& en,
            QuadratureType& quad,
            int quadPoint,
@@ -151,9 +149,9 @@ namespace Dune {
     jacobianLocal(en, quad.point(quadPoint), ret);
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType>
-  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>::
+  void AdaptiveLocalFunction<DiscreteFunctionSpaceImp >::
   init(EntityType& en)
   {
     int numOfDof =
@@ -167,10 +165,9 @@ namespace Dune {
 
   //- AdaptiveLocalFunction (Specialisation for CombinedSpace)
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   AdaptiveLocalFunction(const DiscreteFunctionSpaceType& spc,
                         DofStorageType& dofVec) :
     spc_(spc),
@@ -182,10 +179,9 @@ namespace Dune {
     tmpGrad_(0.0)
   {}
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   AdaptiveLocalFunction(const ThisType& other) :
     spc_(other.spc_),
     dofVec_(other.dofVec_),
@@ -196,48 +192,43 @@ namespace Dune {
     tmpGrad_(0.0)
   {}
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   ~AdaptiveLocalFunction() {}
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::DofType&
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::DofType&
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   operator[] (int num)
   {
     return *values_[num/N][num%N];
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   const AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::DofType&
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::DofType&
   AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   operator[] (int num) const
   {
     return *values_[num/N][num%N];
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   int AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   numberOfDofs() const
   {
     return values_.size()*N;
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   template <class EntityType>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   evaluateLocal(EntityType& en,
                 const DomainType& x,
                 RangeType& result) const
@@ -255,11 +246,10 @@ namespace Dune {
     }
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   template <class EntityType, class QuadratureType>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   evaluate(EntityType& en,
            QuadratureType& quad,
            int quadPoint,
@@ -268,11 +258,10 @@ namespace Dune {
     evaluateLocal(en, quad.point(quadPoint), ret);
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   template <class EntityType>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   jacobianLocal(EntityType& en,
                 const DomainType& x,
                 JacobianRangeType& result) const
@@ -295,11 +284,10 @@ namespace Dune {
 
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   template<class EntityType, class QuadratureType>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   jacobian(EntityType& en,
            QuadratureType& quad,
            int quadPoint,
@@ -308,10 +296,9 @@ namespace Dune {
     jacobianLocal(en, quad.point(quadPoint), ret);
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   assign(int dofNum, const DofVectorType& dofs) {
     for (int i = 0; i < N; ++i) {
       // Assumption: the local ordering is point based
@@ -319,19 +306,17 @@ namespace Dune {
     }
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   int AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   numberOfBaseFunctions() const {
     return values_.size();
   }
 
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   template <class EntityType>
   void AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>::
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >::
   init(EntityType& en) {
     int numOfDof =
       spc_.getBaseFunctionSet(en).numContainedFunctions();
diff --git a/fem/discretefunction/adaptivefunction.hh b/fem/discretefunction/adaptivefunction.hh
index c181c19872d83955d65b6795e64234127b72deaf..c5c5791ed8a41fdcfc4dd65252c6c75dcc3e107f 100644
--- a/fem/discretefunction/adaptivefunction.hh
+++ b/fem/discretefunction/adaptivefunction.hh
@@ -19,22 +19,21 @@
 namespace Dune {
 
   //- Forward declarations
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveDiscreteFunction;
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveLocalFunction;
 
   //- Class definitions
   //! Traits class for AdaptiveDiscreteFunction and AdaptiveLocalFunction
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   struct AdaptiveDiscreteFunctionTraits {
     typedef DiscreteFunctionSpaceImp DiscreteFunctionSpaceType;
-    typedef DofManagerImp DofManagerType;
 
-    typedef AdaptiveDiscreteFunction<DiscreteFunctionSpaceImp, DofManagerImp>
-    DiscreteFunctionType;
-    typedef AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp>
-    LocalFunctionType;
+    typedef AdaptiveDiscreteFunction<
+        DiscreteFunctionSpaceImp> DiscreteFunctionType;
+    typedef AdaptiveLocalFunction<
+        DiscreteFunctionSpaceImp> LocalFunctionType;
 
     typedef typename DiscreteFunctionSpaceType::RangeFieldType DofType;
     typedef typename DiscreteFunctionSpaceType::RangeFieldType RangeFieldType;
@@ -42,13 +41,15 @@ namespace Dune {
     typedef typename DiscreteFunctionSpaceType::DomainType DomainType;
     typedef typename DiscreteFunctionSpaceType::JacobianRangeType JacobianRangeType;
     typedef typename DiscreteFunctionSpaceType::MapperType MapperType;
+    typedef typename DiscreteFunctionSpaceType::GridType GridType;
 
     typedef DofArray<DofType> DofStorageType;
-    typedef typename DofManagerType::template Traits<MapperType, DofStorageType>::MemObjectType MemObjectType;
 
     typedef typename DofStorageType::DofIteratorType DofIteratorType;
     typedef typename DofStorageType::ConstDofIteratorType ConstDofIteratorType;
 
+    typedef DofManager<GridType> DofManagerType;
+
   }; // end class AdaptiveDiscreteFunctionTraits
 
 
@@ -56,23 +57,23 @@ namespace Dune {
   //! This class is comparable to DFAdapt, except that it provides a
   //! specialisation for CombinedSpace objects which provides enriched
   //! functionality (access to subfunctions) and runtime optimisations
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveDiscreteFunction :
     public DiscreteFunctionDefault<
-        AdaptiveDiscreteFunctionTraits<DiscreteFunctionSpaceImp, DofManagerImp> >,
+        AdaptiveDiscreteFunctionTraits<DiscreteFunctionSpaceImp > >,
     private AdaptiveFunctionImplementation<
-        DiscreteFunctionSpaceImp, DofManagerImp>
+        DiscreteFunctionSpaceImp >
   {
   public:
     //- friends
 
   private:
     typedef AdaptiveDiscreteFunction<
-        DiscreteFunctionSpaceImp, DofManagerImp> MyType;
+        DiscreteFunctionSpaceImp > MyType;
     typedef AdaptiveFunctionImplementation<
-        DiscreteFunctionSpaceImp, DofManagerImp> Imp;
+        DiscreteFunctionSpaceImp > Imp;
     typedef AdaptiveDiscreteFunctionTraits<
-        DiscreteFunctionSpaceImp, DofManagerImp> MyTraits;
+        DiscreteFunctionSpaceImp > MyTraits;
     typedef DiscreteFunctionDefault<MyTraits> BaseType;
 
   public:
@@ -103,8 +104,6 @@ namespace Dune {
 
     //! Container class type for the dofs (managed by the DofManager)
     typedef typename Traits::DofStorageType DofStorageType;
-    //! Memory management class for DofStorageType (manager by the DofManager)
-    typedef typename Traits::MemObjectType MemObjectType;
 
     //! Iterator over dof container
     typedef typename Traits::DofIteratorType DofIteratorType;
@@ -153,30 +152,30 @@ namespace Dune {
 
   // Note: could use Traits class for Barton-Nackman instead
   //! Local function belonging to AdaptiveDiscreteFunction
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveLocalFunction :
     public LocalFunctionDefault<
         DiscreteFunctionSpaceImp,
-        AdaptiveLocalFunction<DiscreteFunctionSpaceImp, DofManagerImp> >
+        AdaptiveLocalFunction<DiscreteFunctionSpaceImp > >
   {
   public:
     friend class AdaptiveFunctionImplementation<
-        DiscreteFunctionSpaceImp, DofManagerImp>;
+        DiscreteFunctionSpaceImp >;
 
   private:
     typedef AdaptiveLocalFunction<
-        DiscreteFunctionSpaceImp, DofManagerImp> ThisType;
+        DiscreteFunctionSpaceImp > ThisType;
   public:
     //- Public typedefs and enums
     //! The discrete function space this local function belongs to
     typedef DiscreteFunctionSpaceImp DiscreteFunctionSpaceType;
     //! The discrete function this local function belongs to
     typedef AdaptiveDiscreteFunction<
-        DiscreteFunctionSpaceImp, DofManagerImp> DiscreteFunctionType;
+        DiscreteFunctionSpaceImp > DiscreteFunctionType;
     //! Traits class with type definitions for AdaptiveDiscreteFunction and
     //! AdaptiveLocalFunction
     typedef AdaptiveDiscreteFunctionTraits<
-        DiscreteFunctionSpaceType, DofManagerImp> Traits;
+        DiscreteFunctionSpaceType > Traits;
     //! Traits class of DiscreteFunctionSpaceType
     typedef typename DiscreteFunctionSpaceType::Traits SpaceTraits;
 
@@ -273,22 +272,18 @@ namespace Dune {
 
   //- Specialisations
   //! Specialised version of AdaptiveDiscreteFunction for CombinedSpace
-  template <class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp>
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   class AdaptiveDiscreteFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp> :
-    public DiscreteFunctionDefault<AdaptiveDiscreteFunctionTraits<CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp > >,
-    private AdaptiveFunctionImplementation<CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> > :
+    public DiscreteFunctionDefault<AdaptiveDiscreteFunctionTraits<CombinedSpace<ContainedFunctionSpaceImp, N, p> > >,
+    private AdaptiveFunctionImplementation<CombinedSpace<ContainedFunctionSpaceImp, N, p> >
   {
   private:
     typedef CombinedSpace<
         ContainedFunctionSpaceImp, N, p> DiscreteFunctionSpaceImp;
-    typedef AdaptiveDiscreteFunction<
-        DiscreteFunctionSpaceImp, DofManagerImp> MyType;
-    typedef AdaptiveFunctionImplementation<
-        DiscreteFunctionSpaceImp, DofManagerImp> Imp;
-    typedef AdaptiveDiscreteFunctionTraits<
-        DiscreteFunctionSpaceImp, DofManagerImp> MyTraits;
+    typedef AdaptiveDiscreteFunction<DiscreteFunctionSpaceImp> MyType;
+    typedef AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp> Imp;
+    typedef AdaptiveDiscreteFunctionTraits<DiscreteFunctionSpaceImp> MyTraits;
     typedef DiscreteFunctionDefault<MyTraits> BaseType;
 
   public:
@@ -307,7 +302,6 @@ namespace Dune {
     typedef typename Traits::MapperType MapperType;
 
     typedef typename Traits::DofStorageType DofStorageType;
-    typedef typename Traits::MemObjectType MemObjectType;
 
     typedef typename Traits::DofIteratorType DofIteratorType;
     typedef typename Traits::ConstDofIteratorType ConstDofIteratorType;
@@ -315,7 +309,7 @@ namespace Dune {
     //- Additional typedefs
     typedef SubSpace<DiscreteFunctionSpaceType> SubSpaceType;
     typedef AdaptiveDiscreteFunction<
-        SubSpaceType, DofManagerImp> SubDiscreteFunctionType;
+        SubSpaceType > SubDiscreteFunctionType;
 
   public:
     //- Public methods
@@ -369,33 +363,28 @@ namespace Dune {
 
   //- class AdaptiveLocalFunction (specialised)
   //! Specialised version of AdaptiveLocalFunction for CombinedSpace
-  template <
-      class ContainedFunctionSpaceImp, int N,
-      DofStoragePolicy p, class DofManagerImp
-      >
+  template <class ContainedFunctionSpaceImp, int N, DofStoragePolicy p>
   class AdaptiveLocalFunction<
-      CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>
+      CombinedSpace<ContainedFunctionSpaceImp, N, p> >
     : public LocalFunctionDefault<
-          CombinedSpace<ContainedFunctionSpaceImp, N, p>,
-          AdaptiveLocalFunction<CombinedSpace<ContainedFunctionSpaceImp, N, p>,
-              DofManagerImp>
-          >
+      CombinedSpace<ContainedFunctionSpaceImp, N, p>,
+      AdaptiveLocalFunction<CombinedSpace<ContainedFunctionSpaceImp, N, p> >
   {
   public:
     //- Friends
     friend class AdaptiveFunctionImplementation<
-        CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>;
+        CombinedSpace<ContainedFunctionSpaceImp, N, p> >;
     //friend class AdaptiveDiscreteFunction<
-    //  CombinedSpace<ContainedFunctionSpaceImp, N, p>, DofManagerImp>;
+    //  CombinedSpace<ContainedFunctionSpaceImp, N, p> >;
 
   public:
     //- Public typedefs and enums
     typedef CombinedSpace<
         ContainedFunctionSpaceImp, N, p> DiscreteFunctionSpaceType;
     typedef AdaptiveLocalFunction<
-        DiscreteFunctionSpaceType, DofManagerImp> ThisType;
+        DiscreteFunctionSpaceType > ThisType;
     typedef AdaptiveDiscreteFunctionTraits<
-        DiscreteFunctionSpaceType, DofManagerImp> Traits;
+        DiscreteFunctionSpaceType > Traits;
     typedef typename DiscreteFunctionSpaceType::Traits SpaceTraits;
 
     enum { dimRange = DiscreteFunctionSpaceType::DimRange };
diff --git a/fem/discretefunction/adaptiveimp.cc b/fem/discretefunction/adaptiveimp.cc
index 8e9bf07314a381c53ebb87f2153261f8b34c0747..3a30c51d7f79ade3361b017f41f95b58f3ef412f 100644
--- a/fem/discretefunction/adaptiveimp.cc
+++ b/fem/discretefunction/adaptiveimp.cc
@@ -3,123 +3,123 @@
 
 
 namespace Dune {
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   AdaptiveFunctionImplementation(std::string name,
                                  const DiscreteFunctionSpaceType& spc) :
     spc_(spc),
     name_(name),
     dm_(DofManagerFactory<DofManagerType>::getDofManager(spc.grid())),
-    memObj_(&dm_.addDofSet(&dofVec_, spc.mapper(), name_)),
-    dofVec_(memObj_->getArray())
+    memPair_(dm_.addDofSet(&dofVec_, spc.mapper(), name_)),
+    dofVec_(*memPair_.second)
   {}
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   AdaptiveFunctionImplementation(std::string name,
                                  const DiscreteFunctionSpaceType& spc,
                                  DofStorageType& dofVec) :
     spc_(spc),
     name_(name),
     dm_(DofManagerFactory<DofManagerType>::getDofManager(spc.grid())),
-    memObj_(0),
+    memObj_(std::pair<MemObjectInterface*, DofStorageType*>(0, 0)),
     dofVec_(dofVec)
   {}
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   AdaptiveFunctionImplementation(const ThisType& other) :
     spc_(other.spc_),
     name_(std::string("copy of")+other.name_),
     dm_(other.dm_),
-    memObj_(&dm_.addDofSet(&dofVec_, other.spc_.mapper(), name_)),
-    dofVec_(memObj_->getArray())
+    memPair_(dm_.addDofSet(&dofVec_, other.spc_.mapper(), name_)),
+    dofVec_(*memPair_.second)
   {
     // copy values
     dofVec_ = other.dofVec_;
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   ~AdaptiveFunctionImplementation()
   {
-    if (memObj_) {
-      bool removed = dm_.removeDofSet(*memObj_);
+    if (memPair_.first) {
+      bool removed = dm_.removeDofSet(*memPair_.first);
       assert(removed);
     }
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   std::string
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   name() const
   {
     return name_;
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  int AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  int AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   size() const
   {
     return dofVec_.size();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   DofIteratorType
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   dbegin()
   {
     return dofVec_.begin();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   DofIteratorType
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   dend()
   {
     return dofVec_.end();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   ConstDofIteratorType
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   dbegin() const
   {
     return dofVec_.begin();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   ConstDofIteratorType
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   dend() const
   {
     return dofVec_.end();
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   LocalFunctionType
-  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp, DofManagerImp>::
+  AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   newLocalFunction()
   {
     return LocalFunctionType(spc_, dofVec_);
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   template <class EntityType>
-  void AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  void AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   localFunction(const EntityType& en, LocalFunctionType& lf)
   {
     lf.init(en);
   }
 
   //- Read/write methods
-  template<class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template<class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   write_xdr(std::string fn)
   {
     FILE  *file;
@@ -141,8 +141,8 @@ namespace Dune {
     return true;
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   read_xdr(std::string fn)
   {
     FILE   *file;
@@ -165,8 +165,8 @@ namespace Dune {
     return true;
   }
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template <class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   write_ascii(std::string fn)
   {
     std::fstream outfile( fn.c_str() , std::ios::out );
@@ -193,8 +193,8 @@ namespace Dune {
   }
 
 
-  template<class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template<class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   read_ascii(std::string fn)
   {
     FILE *infile=0;
@@ -215,8 +215,8 @@ namespace Dune {
     return true;
   }
 
-  template<class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template<class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   write_pgm(std::string fn)
   {
     std::ofstream out( fn.c_str() );
@@ -239,8 +239,8 @@ namespace Dune {
     return true;
   }
 
-  template<class DiscreteFunctionSpaceImp, class DofManagerImp>
-  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp,DofManagerImp>::
+  template<class DiscreteFunctionSpaceImp>
+  bool AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp>::
   read_pgm(std::string fn)
   {
     FILE *in;
diff --git a/fem/discretefunction/adaptiveimp.hh b/fem/discretefunction/adaptiveimp.hh
index d84d08e3e29b30cb3504aa442f6838ffaaf2809f..a9262dfe0e50811ffe1c89704cf92e8785559c33 100644
--- a/fem/discretefunction/adaptiveimp.hh
+++ b/fem/discretefunction/adaptiveimp.hh
@@ -11,26 +11,23 @@
 namespace Dune {
 
   //- Forward declarations
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveDiscreteFunction;
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveLocalFunction;
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveDiscreteFunctionTraits;
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveLocalFunctionTraits;
 
 
-  template <class DiscreteFunctionSpaceImp, class DofManagerImp>
+  template <class DiscreteFunctionSpaceImp>
   class AdaptiveFunctionImplementation {
   private:
     typedef DiscreteFunctionSpaceImp DiscreteFunctionSpaceType;
-    typedef DofManagerImp DofManagerType;
 
-    typedef AdaptiveFunctionImplementation<
-        DiscreteFunctionSpaceImp, DofManagerImp> ThisType;
-    typedef AdaptiveDiscreteFunctionTraits<
-        DiscreteFunctionSpaceImp, DofManagerImp> Traits;
+    typedef AdaptiveFunctionImplementation<DiscreteFunctionSpaceImp> ThisType;
+    typedef AdaptiveDiscreteFunctionTraits<DiscreteFunctionSpaceImp> Traits;
 
     typedef typename Traits::DofIteratorType DofIteratorType;
     typedef typename Traits::ConstDofIteratorType ConstDofIteratorType;
@@ -41,7 +38,8 @@ namespace Dune {
     typedef typename SpaceTraits::RangeFieldType RangeFieldType;
 
     typedef typename Traits::DofStorageType DofStorageType;
-    typedef typename Traits::MemObjectType MemObjectType;
+    typedef typename Traits::GridType GridType;
+    typedef DofManager<GridType> DofManagerType;
 
   public:
     std::string name() const;
@@ -92,7 +90,7 @@ namespace Dune {
     const DiscreteFunctionSpaceType& spc_;
     std::string name_;
     DofManagerType& dm_;
-    MemObjectType* memObj_; // might be NULL (for SubSpaces)
+    std::pair<MemObjectInterface*, DofStorageType*> memPair_;
     DofStorageType& dofVec_;
   }; // end class AdaptiveFunctionImplementation