diff --git a/dune-solvers/iterationsteps/mmgstep.cc b/dune-solvers/iterationsteps/mmgstep.cc
index 78bf45890e0af59f2543537d0554bee805201792..958949e4d5d84ef46c066537d47ae8aa580d428f 100644
--- a/dune-solvers/iterationsteps/mmgstep.cc
+++ b/dune-solvers/iterationsteps/mmgstep.cc
@@ -131,13 +131,15 @@ void MonotoneMGStep<OperatorType, DiscFuncType>::iterate()
     } else {
     
         // Presmoothing
-        this->presmoother_->setProblem(*(this->mat_[level]), x[level], rhs[level]);
-        dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->presmoother_)->obstacles_ = &(obstacles[level]);
-        dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->presmoother_)->hasObstacle_ = &((*hasObstacle_)[level]);
-        this->presmoother_->ignoreNodes_ = this->ignoreNodesHierarchy_[level];
+        ProjectedBlockGSStep<OperatorType,DiscFuncType>* presmoother = dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->presmoother_[level]);
+        assert(presmoother);
+        presmoother->setProblem(*(this->mat_[level]), x[level], rhs[level]);
+        presmoother->obstacles_ = &(obstacles[level]);
+        presmoother->hasObstacle_ = &((*hasObstacle_)[level]);
+        presmoother->ignoreNodes_ = this->ignoreNodesHierarchy_[level];
         
         for (int i=0; i<this->nu1_; i++)
-            this->presmoother_->iterate();
+            presmoother->iterate();
         
         // First, a backup of the obstacles for postsmoothing
         std::vector<BoxConstraint<field_type,dim> > obstacleBackup = obstacles[level];
@@ -222,13 +224,15 @@ void MonotoneMGStep<OperatorType, DiscFuncType>::iterate()
 #endif
         
         // Postsmoothing
-        this->postsmoother_->setProblem(*(mat[level]), x[level], rhs[level]);
-        dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->postsmoother_)->obstacles_ = &obstacles[level];
-        dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->postsmoother_)->hasObstacle_ = &((*hasObstacle_)[level]);
-        this->postsmoother_->ignoreNodes_ = this->ignoreNodesHierarchy_[level];
+        ProjectedBlockGSStep<OperatorType,DiscFuncType>* postsmoother = dynamic_cast<ProjectedBlockGSStep<OperatorType, DiscFuncType>*>(this->postsmoother_[level]);
+        assert(postsmoother);
+        postsmoother->setProblem(*(mat[level]), x[level], rhs[level]);
+        postsmoother->obstacles_ = &obstacles[level];
+        postsmoother->hasObstacle_ = &((*hasObstacle_)[level]);
+        postsmoother->ignoreNodes_ = this->ignoreNodesHierarchy_[level];
         
         for (int i=0; i<this->nu2_; i++)
-            this->postsmoother_->iterate();
+            postsmoother->iterate();
         
     }
     
diff --git a/dune-solvers/iterationsteps/multigridstep.cc b/dune-solvers/iterationsteps/multigridstep.cc
index 906ed2c7f756d2aa6da73be5cdbce80b01ddc718..1edc6273a932bcf138b07500d659e1909ff06114 100644
--- a/dune-solvers/iterationsteps/multigridstep.cc
+++ b/dune-solvers/iterationsteps/multigridstep.cc
@@ -184,11 +184,12 @@ void MultigridStep<OperatorType, VectorType, BitVectorType>::iterate()
     }
     
     // Presmoothing
-    presmoother_->setProblem(*(this->mat_[level]), x[level], rhs[level]);
-    presmoother_->ignoreNodes_ = ignoreNodesHierarchy_[level];
+
+    presmoother_[level]->setProblem(*(this->mat_[level]), x[level], rhs[level]);
+    presmoother_[level]->ignoreNodes_ = ignoreNodesHierarchy_[level];
 
     for (int i=0; i<this->nu1_; i++)
-        presmoother_->iterate();
+        presmoother_[level]->iterate();
 
     // /////////////////////////
     // Restriction
@@ -223,10 +224,10 @@ void MultigridStep<OperatorType, VectorType, BitVectorType>::iterate()
     x[level] += tmp;
 
     // Postsmoothing
-    postsmoother_->setProblem(*(mat[level]), x[level], rhs[level]);
-    postsmoother_->ignoreNodes_ = ignoreNodesHierarchy_[level];
+    postsmoother_[level]->setProblem(*(mat[level]), x[level], rhs[level]);
+    postsmoother_[level]->ignoreNodes_ = ignoreNodesHierarchy_[level];
 
     for (int i=0; i<this->nu2_; i++)
-        postsmoother_->iterate();
+        postsmoother_[level]->iterate();
 
 }
diff --git a/dune-solvers/iterationsteps/multigridstep.hh b/dune-solvers/iterationsteps/multigridstep.hh
index 2ce4cf9e26d2045d5c789a52a84ff2bcf0142ea7..95b3d508cfccadbbfa6875414269d91e379beae2 100644
--- a/dune-solvers/iterationsteps/multigridstep.hh
+++ b/dune-solvers/iterationsteps/multigridstep.hh
@@ -9,7 +9,7 @@
 
 #include "lineariterationstep.hh"
 
-
+/** \brief A linear multigrid step */
     template<
         class OperatorType,
         class VectorType,
@@ -39,6 +39,7 @@
                       Solver* baseSolver,
                       const BitVectorType* ignoreNodes) :
             LinearIterationStep<OperatorType, VectorType>(mat, x, rhs),
+            presmoother_(numLevels), postsmoother_(numLevels),
             mat_(numLevels),
             ignoreNodesHierarchy_(numLevels),
             x_(numLevels),
@@ -56,8 +57,8 @@
             nu1_ = nu1;
             nu2_ = nu2;
 
-            presmoother_  = preSmoother;
-            postsmoother_ = postSmoother;
+            setSmoother(preSmoother,postSmoother);
+
             basesolver_   = baseSolver;
 
             this->ignoreNodes_ = ignoreNodes;
@@ -67,8 +68,7 @@
                       VectorType& x, 
                       VectorType& rhs, int numLevels) :
             LinearIterationStep<OperatorType, VectorType>(mat, x, rhs),
-            presmoother_(0),
-            postsmoother_(0),
+            presmoother_(numLevels),postsmoother_(numLevels),
             basesolver_(0),
             mat_(numLevels),
             ignoreNodesHierarchy_(numLevels),
@@ -124,6 +124,9 @@
                 ignoreNodesHierarchy_[i] = NULL;
             }
 
+            presmoother_.resize(numLevels);
+            postsmoother_.resize(numLevels);
+
             x_.resize(numLevels);
             rhs_.resize(numLevels);
         }
@@ -171,22 +174,28 @@
 
         /** \brief Set the smoother iteration step */
         virtual void setSmoother(LinearIterationStep<OperatorType, VectorType>* smoother) {
-            presmoother_ = postsmoother_ = smoother;
+            for (size_t i=0; i<presmoother_.size(); i++)
+                presmoother_[i] = postsmoother_[i] = smoother;
         }
 
         /** \brief Set pre- and post smoothers individually */
         virtual void setSmoother(LinearIterationStep<OperatorType, VectorType>* preSmoother,
                                  LinearIterationStep<OperatorType, VectorType>* postSmoother) {
-            presmoother_  = preSmoother;
-            postsmoother_ = postSmoother;
+            for (size_t i=0; i<presmoother_.size(); i++) {
+                presmoother_[i]  = preSmoother;
+                postsmoother_[i] = postSmoother;
+            }
         }
 
     protected:
-        LinearIterationStep<OperatorType, VectorType>* presmoother_;
+        /** \brief The presmoothers, one for each level */
+        std::vector<LinearIterationStep<OperatorType, VectorType>*> presmoother_;
 
-        LinearIterationStep<OperatorType, VectorType>* postsmoother_;
+        /** \brief The postsmoothers, one for each level */
+        std::vector<LinearIterationStep<OperatorType, VectorType>*> postsmoother_;
 
     public:
+        /** \brief The base solver */
         Solver* basesolver_;
 
     protected: