diff --git a/Grid/algorithms/iterative/AdefGeneric.h b/Grid/algorithms/iterative/AdefGeneric.h
index cc9d2e10..e0b99fcb 100644
--- a/Grid/algorithms/iterative/AdefGeneric.h
+++ b/Grid/algorithms/iterative/AdefGeneric.h
@@ -538,139 +538,6 @@ class TwoLevelADEF2 : public TwoLevelCG<Field>
 
 };
 
-template<class Field, class CoarseField, class Aggregation>
-class TwoLevelADEF2mrhs : public TwoLevelADEF2<Field,CoarseField,Aggregation>
-{
-public:
-  GridBase *coarsegridmrhs;
-  LinearFunction<CoarseField> &_CoarseSolverMrhs;
-  LinearFunction<CoarseField> &_CoarseSolverPreciseMrhs;
-  LinearFunction<CoarseField> &_CoarseGuesser;
-  TwoLevelADEF2mrhs(RealD tol,
-		    Integer maxit,
-		    LinearOperatorBase<Field>    &FineLinop,
-		    LinearFunction<Field>        &Smoother,
-		    //		    LinearFunction<CoarseField>  &CoarseSolver,
-		    //		    LinearFunction<CoarseField>  &CoarseSolverPrecise,
-		    LinearFunction<CoarseField>  &CoarseSolverMrhs,
-		    LinearFunction<CoarseField>  &CoarseSolverPreciseMrhs,
-		    LinearFunction<CoarseField>  &CoarseGuesser,
-		    GridBase *rhsgrid,
-		    Aggregation &Aggregates) :
-    TwoLevelADEF2<Field,CoarseField,Aggregation>(tol, maxit,FineLinop,Smoother,CoarseSolverMrhs,CoarseSolverPreciseMrhs,Aggregates),
-    _CoarseSolverMrhs(CoarseSolverMrhs),
-    _CoarseSolverPreciseMrhs(CoarseSolverPreciseMrhs),
-    _CoarseGuesser(CoarseGuesser)
-  {
-    coarsegridmrhs = rhsgrid;
-  };
-
-  virtual void Vstart(std::vector<Field> & x,std::vector<Field> & src)
-  {
-    int nrhs=x.size();
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart for "<<nrhs<<" right hand sides" <<std::endl;
-    ///////////////////////////////////
-    // Choose x_0 such that 
-    // x_0 = guess +  (A_ss^inv) r_s = guess + Ass_inv [src -Aguess]
-    //                               = [1 - Ass_inv A] Guess + Assinv src
-    //                               = P^T guess + Assinv src 
-    //                               = Vstart  [Tang notation]
-    // This gives:
-    // W^T (src - A x_0) = src_s - A guess_s - r_s
-    //                   = src_s - (A guess)_s - src_s  + (A guess)_s 
-    //                   = 0 
-    ///////////////////////////////////
-    CoarseField PleftProj(this->coarsegrid);
-    CoarseField PleftMss_proj(this->coarsegrid);
-
-    CoarseField PleftProjMrhs(this->coarsegridmrhs);
-    CoarseField PleftMss_projMrhs(this->coarsegridmrhs);
-
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart Mrhs projecting "<<std::endl;
-
-    for(int rhs=0;rhs<nrhs;rhs++) {
-      this->_Aggregates.ProjectToSubspace(PleftProj,src[rhs]);     // can optimise later
-      InsertSliceFast(PleftProj,PleftProjMrhs,rhs,0);
-      this->_CoarseGuesser(PleftProj,PleftMss_proj);
-      InsertSliceFast(PleftMss_proj,PleftMss_projMrhs,rhs,0);
-    }
-    
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart Mrhs coarse solve "<<std::endl;
-    this->_CoarseSolverPreciseMrhs(PleftProjMrhs,PleftMss_projMrhs); // Ass^{-1} r_s
-
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart promote "<<std::endl;
-    for(int rhs=0;rhs<nrhs;rhs++) {
-      ExtractSliceFast(PleftMss_proj,PleftMss_projMrhs,rhs,0);
-      this->_Aggregates.PromoteFromSubspace(PleftMss_proj,x[rhs]);
-    }
-  }
-
-  virtual void PcgM1(std::vector<Field> & in,std::vector<Field> & out){
-
-    int nrhs=in.size();
-    std::cout << " mrhs PcgM1 for "<<nrhs<<" right hand sides"<<std::endl;
-    MemoryManager::Print();
-    // [PTM+Q] in = [1 - Q A] M in + Q in = Min + Q [ in -A Min]
-    Field tmp(this->grid);
-    std::vector<Field> Min(nrhs,this->grid);
-    std::cout << " mrhs PcgM1 Min "<<std::endl;
-    CoarseField PleftProj(this->coarsegrid);
-    CoarseField PleftMss_proj(this->coarsegrid);
-
-    CoarseField PleftProjMrhs(this->coarsegridmrhs);
-    CoarseField PleftMss_projMrhs(this->coarsegridmrhs);
-    std::cout << " mrhs Coarse ops "<<std::endl;
-
-    // Really want the coarse solver
-    // to do the guessing itself, knowing the eigenvectors.
-    // The projection to coarse space is in aggregates
-    // If the Aggregates have a layout change option
-    // they could formulate as a BLAS routine.
-    // Put the routines in this object
-    for(int rhs=0;rhs<nrhs;rhs++) {
-
-      std::cout << GridLogMessage<<" Smoother for "<<rhs<<std::endl;
-      this->_Smoother(in[rhs],Min[rhs]);
-
-      std::cout << GridLogMessage<<" HermOp for "<<rhs<<std::endl;
-      this->_FineLinop.HermOp(Min[rhs],out[rhs]);
-
-      axpy(tmp,-1.0,out[rhs],in[rhs]);          // tmp  = in - A Min
-
-      // Was
-      //      this->_Aggregates.ProjectToSubspace(PleftProj,tmp);     // can optimise later
-      // Now:
-      std::cout << GridLogMessage<<" blockProject for "<<rhs<<std::endl;
-      blockProjectFast(PleftProj,tmp,this->_Aggregates.subspace);
-      
-      std::cout << GridLogMessage<<" InsertSlice for "<<rhs<<std::endl;
-      InsertSlice(PleftProj,PleftProjMrhs,rhs,0);
-      
-      std::cout << GridLogMessage<<" CoarseGuesser for "<<rhs<<std::endl;
-      this->_CoarseGuesser(PleftProj,PleftMss_proj);
-
-      std::cout << GridLogMessage<<" InsertSlice for "<<rhs<<std::endl;
-      InsertSlice(PleftMss_proj,PleftMss_projMrhs,rhs,0);
-    }
-    MemoryManager::Print();
-
-    std::cout << " Coarse solve "<<std::endl;
-    this->_CoarseSolverMrhs(PleftProjMrhs,PleftMss_projMrhs); // Ass^{-1} [in - A Min]_s
-    std::cout << " Coarse solve done"<<std::endl;
-    MemoryManager::Print();
-
-    for(int rhs=0;rhs<nrhs;rhs++) {
-      std::cout << GridLogMessage<<" Extract for "<<rhs<<std::endl;
-      ExtractSlice(PleftMss_proj,PleftMss_projMrhs,rhs,0);
-      std::cout << GridLogMessage<<" Promote for "<<rhs<<std::endl;
-      this->_Aggregates.PromoteFromSubspace(PleftMss_proj,tmp);// tmp = Q[in - A Min]  
-								    //      std::cout << " add for "<<rhs<<std::endl;
-      axpy(out[rhs],1.0,Min[rhs],tmp); // Min+tmp
-    }
-    MemoryManager::Print();
-    std::cout << " Extracted "<<std::endl;
-  }
-};
   
 template<class Field>
 class TwoLevelADEF1defl : public TwoLevelCG<Field>