diff --git a/Grid/algorithms/Algorithms.h b/Grid/algorithms/Algorithms.h
index f1ac1c81..48ea194b 100644
--- a/Grid/algorithms/Algorithms.h
+++ b/Grid/algorithms/Algorithms.h
@@ -35,17 +35,22 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 
 #include <Grid/algorithms/approx/Zolotarev.h>
 #include <Grid/algorithms/approx/Chebyshev.h>
+#include <Grid/algorithms/approx/JacobiPolynomial.h>
 #include <Grid/algorithms/approx/Remez.h>
 #include <Grid/algorithms/approx/MultiShiftFunction.h>
 #include <Grid/algorithms/approx/Forecast.h>
+#include <Grid/algorithms/approx/RemezGeneral.h>
+#include <Grid/algorithms/approx/ZMobius.h>
 
 #include <Grid/algorithms/iterative/Deflation.h>
 #include <Grid/algorithms/iterative/ConjugateGradient.h>
+#include <Grid/algorithms/iterative/BiCGSTAB.h>
 #include <Grid/algorithms/iterative/ConjugateResidual.h>
 #include <Grid/algorithms/iterative/NormalEquations.h>
 #include <Grid/algorithms/iterative/SchurRedBlack.h>
 #include <Grid/algorithms/iterative/ConjugateGradientMultiShift.h>
 #include <Grid/algorithms/iterative/ConjugateGradientMixedPrec.h>
+#include <Grid/algorithms/iterative/BiCGSTABMixedPrec.h>
 #include <Grid/algorithms/iterative/BlockConjugateGradient.h>
 #include <Grid/algorithms/iterative/ConjugateGradientReliableUpdate.h>
 #include <Grid/algorithms/iterative/MinimalResidual.h>
diff --git a/Grid/algorithms/CoarsenedMatrix.h b/Grid/algorithms/CoarsenedMatrix.h
index 913f5c0c..a6b01986 100644
--- a/Grid/algorithms/CoarsenedMatrix.h
+++ b/Grid/algorithms/CoarsenedMatrix.h
@@ -1,3 +1,14 @@
+    // blockZaxpy in bockPromote - 3s, 5%
+    // noncoalesced linalg in Preconditionoer ~ 3s 5%
+    // Lancos tuning or replace 10-20s ~ 25%, open ended
+    // setup tuning   5s  ~  8%
+    //    -- e.g. ordermin, orderstep tunables.
+    // MdagM path without norm in LinOp code.     few seconds
+
+    // Mdir calc blocking kernels
+    // Fuse kernels in blockMaskedInnerProduct
+    // preallocate Vectors in Cayley 5D ~ few percent few seconds
+
 /*************************************************************************************
 
     Grid physics library, www.github.com/paboyle/Grid 
@@ -34,15 +45,36 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 
 NAMESPACE_BEGIN(Grid);
 
+template<class vobj,class CComplex>
+inline void blockMaskedInnerProduct(Lattice<CComplex> &CoarseInner,
+				    const Lattice<decltype(innerProduct(vobj(),vobj()))> &FineMask,
+				    const Lattice<vobj> &fineX,
+				    const Lattice<vobj> &fineY)
+{
+  typedef decltype(innerProduct(vobj(),vobj())) dotp;
+
+  GridBase *coarse(CoarseInner.Grid());
+  GridBase *fine  (fineX.Grid());
+
+  Lattice<dotp> fine_inner(fine); fine_inner.Checkerboard() = fineX.Checkerboard();
+  Lattice<dotp> fine_inner_msk(fine);
+
+  // Multiply could be fused with innerProduct
+  // Single block sum kernel could do both masks.
+  fine_inner = localInnerProduct(fineX,fineY);
+  mult(fine_inner_msk, fine_inner,FineMask);
+  blockSum(CoarseInner,fine_inner_msk);
+}
+
+
 class Geometry {
-  //    int dimension;
 public:
   int npoint;
   std::vector<int> directions   ;
   std::vector<int> displacements;
 
   Geometry(int _d)  {
-  
+    
     int base = (_d==5) ? 1:0;
 
     // make coarse grid stencil for 4d , not 5d
@@ -52,10 +84,10 @@ public:
     directions.resize(npoint);
     displacements.resize(npoint);
     for(int d=0;d<_d;d++){
-      directions[2*d  ] = d+base;
-      directions[2*d+1] = d+base;
-      displacements[2*d  ] = +1;
-      displacements[2*d+1] = -1;
+      directions[d   ] = d+base;
+      directions[d+_d] = d+base;
+      displacements[d  ] = +1;
+      displacements[d+_d]= -1;
     }
     directions   [2*_d]=0;
     displacements[2*_d]=0;
@@ -63,7 +95,7 @@ public:
     //// report back
     std::cout<<GridLogMessage<<"directions    :";
     for(int d=0;d<npoint;d++) std::cout<< directions[d]<< " ";
-    std::cout <<std::endl;
+    std::cout<<std::endl;
     std::cout<<GridLogMessage<<"displacements :";
     for(int d=0;d<npoint;d++) std::cout<< displacements[d]<< " ";
     std::cout<<std::endl;
@@ -115,10 +147,10 @@ public:
   
   void Orthogonalise(void){
     CoarseScalar InnerProd(CoarseGrid); 
-    std::cout << GridLogMessage <<" Gramm-Schmidt pass 1"<<std::endl;
-    blockOrthogonalise(InnerProd,subspace);
-    std::cout << GridLogMessage <<" Gramm-Schmidt pass 2"<<std::endl;
+    std::cout << GridLogMessage <<" Block Gramm-Schmidt pass 1"<<std::endl;
     blockOrthogonalise(InnerProd,subspace);
+    //    std::cout << GridLogMessage <<" Block Gramm-Schmidt pass 2"<<std::endl; // Really have to do twice? Yuck
+    //    blockOrthogonalise(InnerProd,subspace);
     //      std::cout << GridLogMessage <<" Gramm-Schmidt checking orthogonality"<<std::endl;
     //      CheckOrthogonal();
   } 
@@ -128,7 +160,7 @@ public:
     for(int i=0;i<nbasis;i++){
       blockProject(iProj,subspace[i],subspace);
       eProj=Zero(); 
-      thread_for(ss, CoarseGrid->oSites(),{
+      accelerator_for(ss, CoarseGrid->oSites(),1,{
 	eProj[ss](i)=CComplex(1.0);
       });
       eProj=eProj - iProj;
@@ -146,61 +178,9 @@ public:
   void CreateSubspaceRandom(GridParallelRNG &RNG){
     for(int i=0;i<nbasis;i++){
       random(RNG,subspace[i]);
-      std::cout<<GridLogMessage<<" norm subspace["<<i<<"] "<<norm2(subspace[i])<<std::endl;
     }
-    Orthogonalise();
   }
 
-  /*
-    virtual void CreateSubspaceLanczos(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,int nn=nbasis) 
-    {
-    // Run a Lanczos with sloppy convergence
-    const int Nstop = nn;
-    const int Nk = nn+20;
-    const int Np = nn+20;
-    const int Nm = Nk+Np;
-    const int MaxIt= 10000;
-    RealD resid = 1.0e-3;
-
-    Chebyshev<FineField> Cheb(0.5,64.0,21);
-    ImplicitlyRestartedLanczos<FineField> IRL(hermop,Cheb,Nstop,Nk,Nm,resid,MaxIt);
-    //	IRL.lock = 1;
-
-    FineField noise(FineGrid); gaussian(RNG,noise);
-    FineField tmp(FineGrid); 
-    std::vector<RealD>     eval(Nm);
-    std::vector<FineField> evec(Nm,FineGrid);
-
-    int Nconv;
-    IRL.calc(eval,evec,
-    noise,
-    Nconv);
-
-    // pull back nn vectors
-    for(int b=0;b<nn;b++){
-
-    subspace[b]   = evec[b];
-
-    std::cout << GridLogMessage <<"subspace["<<b<<"] = "<<norm2(subspace[b])<<std::endl;
-
-    hermop.Op(subspace[b],tmp); 
-    std::cout<<GridLogMessage << "filtered["<<b<<"] <f|MdagM|f> "<<norm2(tmp)<<std::endl;
-
-    noise = tmp -  sqrt(eval[b])*subspace[b] ;
-
-    std::cout<<GridLogMessage << " lambda_"<<b<<" = "<< eval[b] <<"  ;  [ M - Lambda ]_"<<b<<" vec_"<<b<<"  = " <<norm2(noise)<<std::endl;
-
-    noise = tmp +  eval[b]*subspace[b] ;
-
-    std::cout<<GridLogMessage << " lambda_"<<b<<" = "<< eval[b] <<"  ;  [ M - Lambda ]_"<<b<<" vec_"<<b<<"  = " <<norm2(noise)<<std::endl;
-
-    }
-    Orthogonalise();
-    for(int b=0;b<nn;b++){
-    std::cout << GridLogMessage <<"subspace["<<b<<"] = "<<norm2(subspace[b])<<std::endl;
-    }
-    }
-  */
   virtual void CreateSubspace(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,int nn=nbasis) {
 
     RealD scale;
@@ -232,54 +212,316 @@ public:
       subspace[b]   = noise;
 
     }
-
-    Orthogonalise();
-
   }
 
-  virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,int nn=nbasis) {
+  ////////////////////////////////////////////////////////////////////////////////////////////////
+  // World of possibilities here. But have tried quite a lot of experiments (250+ jobs run on Summit)
+  // and this is the best I found
+  ////////////////////////////////////////////////////////////////////////////////////////////////
+#if 1
+  virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
+				       int nn,
+				       double hi,
+				       double lo,
+				       int orderfilter,
+				       int ordermin,
+				       int orderstep,
+				       double filterlo
+				       ) {
 
     RealD scale;
 
+    FineField noise(FineGrid);
+    FineField Mn(FineGrid);
+    FineField tmp(FineGrid);
 
-    Chebyshev<FineField> Cheb(0.1,64.0,900);
+    // New normalised noise
+    gaussian(RNG,noise);
+    scale = std::pow(norm2(noise),-0.5); 
+    noise=noise*scale;
+
+    // Initial matrix element
+    hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
+
+    int b =0;
+    {
+      // Filter
+      Chebyshev<FineField> Cheb(lo,hi,orderfilter);
+      Cheb(hermop,noise,Mn);
+      // normalise
+      scale = std::pow(norm2(Mn),-0.5); 	Mn=Mn*scale;
+      subspace[b]   = Mn;
+      hermop.Op(Mn,tmp); 
+      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
+      b++;
+    }
+
+    // Generate a full sequence of Chebyshevs
+    {
+      lo=filterlo;
+      noise=Mn;
+
+      FineField T0(FineGrid); T0 = noise;  
+      FineField T1(FineGrid); 
+      FineField T2(FineGrid);
+      FineField y(FineGrid);
+      
+      FineField *Tnm = &T0;
+      FineField *Tn  = &T1;
+      FineField *Tnp = &T2;
+
+      // Tn=T1 = (xscale M + mscale)in
+      RealD xscale = 2.0/(hi-lo);
+      RealD mscale = -(hi+lo)/(hi-lo);
+      hermop.HermOp(T0,y);
+      T1=y*xscale+noise*mscale;
+
+      for(int n=2;n<=ordermin+orderstep*(nn-2);n++){
+	
+	hermop.HermOp(*Tn,y);
+
+	auto y_v = y.View();
+	auto Tn_v = Tn->View();
+	auto Tnp_v = Tnp->View();
+	auto Tnm_v = Tnm->View();
+	const int Nsimd = CComplex::Nsimd();
+	accelerator_forNB(ss, FineGrid->oSites(), Nsimd, {
+	  coalescedWrite(y_v[ss],xscale*y_v(ss)+mscale*Tn_v(ss));
+	  coalescedWrite(Tnp_v[ss],2.0*y_v(ss)-Tnm_v(ss));
+        });
+
+	// Possible more fine grained control is needed than a linear sweep,
+	// but huge productivity gain if this is simple algorithm and not a tunable
+	int m =1;
+	if ( n>=ordermin ) m=n-ordermin;
+	if ( (m%orderstep)==0 ) { 
+	  Mn=*Tnp;
+	  scale = std::pow(norm2(Mn),-0.5);         Mn=Mn*scale;
+	  subspace[b] = Mn;
+	  hermop.Op(Mn,tmp); 
+	  std::cout<<GridLogMessage << n<<" filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
+	  b++;
+	}
+
+	// Cycle pointers to avoid copies
+	FineField *swizzle = Tnm;
+	Tnm    =Tn;
+	Tn     =Tnp;
+	Tnp    =swizzle;
+	  
+      }
+    }
+    assert(b==nn);
+  }
+#endif
+#if 0
+  virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
+				       int nn,
+				       double hi,
+				       double lo,
+				       int orderfilter,
+				       int ordermin,
+				       int orderstep,
+				       double filterlo
+				       ) {
+
+    RealD scale;
 
     FineField noise(FineGrid);
     FineField Mn(FineGrid);
+    FineField tmp(FineGrid);
+    FineField combined(FineGrid);
 
-    for(int b=0;b<nn;b++){
-	
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
+    // New normalised noise
+    gaussian(RNG,noise);
+    scale = std::pow(norm2(noise),-0.5); 
+    noise=noise*scale;
 
-      hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise   ["<<b<<"] <n|MdagM|n> "<<norm2(Mn)<<std::endl;
+    // Initial matrix element
+    hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
 
-      Cheb(hermop,noise,Mn);
+    int b =0;
+#define FILTERb(llo,hhi,oorder)						\
+    {									\
+      Chebyshev<FineField> Cheb(llo,hhi,oorder);			\
+      Cheb(hermop,noise,Mn);						\
+      scale = std::pow(norm2(Mn),-0.5); Mn=Mn*scale;			\
+      subspace[b]   = Mn;						\
+      hermop.Op(Mn,tmp);						\
+      std::cout<<GridLogMessage << oorder<< " Cheb filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl; \
+      b++;								\
+    }									
 
-      scale = std::pow(norm2(Mn),-0.5); 
-      Mn=Mn*scale;
-      subspace[b]   = Mn;
+    //      JacobiPolynomial<FineField> Cheb(0.002,60.0,1500,-0.5,3.5);	\
 
-      hermop.Op(Mn,noise); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|MdagM|f> "<<norm2(noise)<<std::endl;
-
-    }
-
-    Orthogonalise();
+    RealD alpha=-0.8;
+    RealD beta =-0.8;
+#define FILTER(llo,hhi,oorder)						\
+    {									\
+      Chebyshev<FineField> Cheb(llo,hhi,oorder);			\
+      /* JacobiPolynomial<FineField> Cheb(0.0,60.0,oorder,alpha,beta);*/\
+      Cheb(hermop,noise,Mn);						\
+      scale = std::pow(norm2(Mn),-0.5); Mn=Mn*scale;			\
+      subspace[b]   = Mn;						\
+      hermop.Op(Mn,tmp);						\
+      std::cout<<GridLogMessage << oorder<< "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl; \
+      b++;								\
+    }									
+    
+#define FILTERc(llo,hhi,oorder)				\
+    {							\
+      Chebyshev<FineField> Cheb(llo,hhi,oorder);	\
+      Cheb(hermop,noise,combined);			\
+    }									
 
+    double node = 0.000;
+    FILTERb(lo,hi,orderfilter);// 0
+    //    FILTERc(node,hi,51);// 0
+    noise = Mn;
+    int base = 0;
+    int mult = 100;
+    FILTER(node,hi,base+1*mult);
+    FILTER(node,hi,base+2*mult);
+    FILTER(node,hi,base+3*mult);
+    FILTER(node,hi,base+4*mult);
+    FILTER(node,hi,base+5*mult);
+    FILTER(node,hi,base+6*mult);
+    FILTER(node,hi,base+7*mult);
+    FILTER(node,hi,base+8*mult);
+    FILTER(node,hi,base+9*mult);
+    FILTER(node,hi,base+10*mult);
+    FILTER(node,hi,base+11*mult);
+    FILTER(node,hi,base+12*mult);
+    FILTER(node,hi,base+13*mult);
+    FILTER(node,hi,base+14*mult);
+    FILTER(node,hi,base+15*mult);
+    assert(b==nn);
   }
+#endif
+
+#if 0
+  virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
+				       int nn,
+				       double hi,
+				       double lo,
+				       int orderfilter,
+				       int ordermin,
+				       int orderstep,
+				       double filterlo
+				       ) {
+
+    RealD scale;
+
+    FineField noise(FineGrid);
+    FineField Mn(FineGrid);
+    FineField tmp(FineGrid);
+    FineField combined(FineGrid);
+
+    // New normalised noise
+    gaussian(RNG,noise);
+    scale = std::pow(norm2(noise),-0.5); 
+    noise=noise*scale;
+
+    // Initial matrix element
+    hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
+
+    int b =0;
+    {						
+      Chebyshev<FineField> JacobiPoly(0.005,60.,1500);
+      //      JacobiPolynomial<FineField> JacobiPoly(0.002,60.0,1500,-0.5,3.5);
+      //JacobiPolynomial<FineField> JacobiPoly(0.03,60.0,500,-0.5,3.5);
+      //      JacobiPolynomial<FineField> JacobiPoly(0.00,60.0,1000,-0.5,3.5);
+      JacobiPoly(hermop,noise,Mn);
+      scale = std::pow(norm2(Mn),-0.5); Mn=Mn*scale;
+      subspace[b]   = Mn;
+      hermop.Op(Mn,tmp);
+      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl; 
+      b++;
+      //      scale = std::pow(norm2(tmp),-0.5);     tmp=tmp*scale;
+      //      subspace[b]   = tmp;      b++;
+      //    }									
+    }									
+
+#define FILTER(lambda)						\
+    {								\
+      hermop.HermOp(subspace[0],tmp);				\
+      tmp = tmp - lambda *subspace[0];				\
+      scale = std::pow(norm2(tmp),-0.5);			\
+      tmp=tmp*scale;							\
+      subspace[b]   = tmp;						\
+      hermop.Op(subspace[b],tmp);					\
+      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl; \
+      b++;								\
+    }									
+    //      scale = std::pow(norm2(tmp),-0.5);     tmp=tmp*scale;
+    //      subspace[b]   = tmp;      b++;
+    //    }									
+
+    FILTER(2.0e-5);
+    FILTER(2.0e-4);
+    FILTER(4.0e-4);
+    FILTER(8.0e-4);
+    FILTER(8.0e-4);
+
+    FILTER(2.0e-3);
+    FILTER(3.0e-3);
+    FILTER(4.0e-3);
+    FILTER(5.0e-3);
+    FILTER(6.0e-3);
+
+    FILTER(2.5e-3);
+    FILTER(3.5e-3);
+    FILTER(4.5e-3);
+    FILTER(5.5e-3);
+    FILTER(6.5e-3);
+
+    //    FILTER(6.0e-5);//6
+    //    FILTER(7.0e-5);//8
+    //    FILTER(8.0e-5);//9
+    //    FILTER(9.0e-5);//3
+
+    /*
+    //    FILTER(1.0e-4);//10
+    FILTER(2.0e-4);//11
+    //   FILTER(3.0e-4);//12
+    //    FILTER(4.0e-4);//13
+    FILTER(5.0e-4);//14
+
+    FILTER(6.0e-3);//4
+    FILTER(7.0e-4);//1
+    FILTER(8.0e-4);//7
+    FILTER(9.0e-4);//15
+    FILTER(1.0e-3);//2
+
+    FILTER(2.0e-3);//2
+    FILTER(3.0e-3);//2
+    FILTER(4.0e-3);//2
+    FILTER(5.0e-3);//2
+    FILTER(6.0e-3);//2
+
+    FILTER(7.0e-3);//2
+    FILTER(8.0e-3);//2
+    FILTER(1.0e-2);//2
+    */
+    std::cout << GridLogMessage <<"Jacobi filtering done" <<std::endl;
+    assert(b==nn);
+  }
+#endif
+
 
 };
+
 // Fine Object == (per site) type of fine field
 // nbasis      == number of deflation vectors
 template<class Fobj,class CComplex,int nbasis>
 class CoarsenedMatrix : public SparseMatrixBase<Lattice<iVector<CComplex,nbasis > > >  {
 public:
     
-  typedef iVector<CComplex,nbasis >             siteVector;
+  typedef iVector<CComplex,nbasis >           siteVector;
+  typedef Lattice<CComplex >                  CoarseComplexField;
   typedef Lattice<siteVector>                 CoarseVector;
   typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-
+  typedef iMatrix<CComplex,nbasis >  Cobj;
   typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
   typedef Lattice<Fobj >        FineField;
 
@@ -293,7 +535,6 @@ public:
   CartesianStencil<siteVector,siteVector,int> Stencil; 
 
   std::vector<CoarseMatrix> A;
-
       
   ///////////////////////
   // Interface
@@ -305,33 +546,71 @@ public:
     conformable(_grid,in.Grid());
     conformable(in.Grid(),out.Grid());
 
-    RealD Nin = norm2(in);
+    //    RealD Nin = norm2(in);
     SimpleCompressor<siteVector> compressor;
+
+    double comms_usec = -usecond();
     Stencil.HaloExchange(in,compressor);
+    comms_usec += usecond();
+
     auto in_v = in.View();
     auto out_v = out.View();
-    thread_for(ss,Grid()->oSites(),{
-      siteVector res = Zero();
-      siteVector nbr;
+    typedef LatticeView<Cobj> Aview;
+
+    Vector<Aview> AcceleratorViewContainer;
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View());
+    Aview *Aview_p = & AcceleratorViewContainer[0];
+
+    const int Nsimd = CComplex::Nsimd();
+    typedef decltype(coalescedRead(in_v[0])) calcVector;
+    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
+
+    GridStopWatch ArithmeticTimer;
+    int osites=Grid()->oSites();
+    //    double flops = osites*Nsimd*nbasis*nbasis*8.0*geom.npoint;
+    //    double bytes = osites*nbasis*nbasis*geom.npoint*sizeof(CComplex);
+    double usecs =-usecond();
+    // assert(geom.npoint==9);
+
+    accelerator_for(sss, Grid()->oSites()*nbasis, Nsimd, {
+      int ss = sss/nbasis;
+      int b  = sss%nbasis;
+      calcComplex res = Zero();
+      calcVector nbr;
       int ptype;
       StencilEntry *SE;
+
+      int lane=SIMTlane(Nsimd);
       for(int point=0;point<geom.npoint;point++){
 
 	SE=Stencil.GetEntry(ptype,point,ss);
 	  
-	if(SE->_is_local&&SE->_permute) { 
-	  permute(nbr,in_v[SE->_offset],ptype);
-	} else if(SE->_is_local) { 
-	  nbr = in_v[SE->_offset];
+	if(SE->_is_local) { 
+	  nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute,lane);
 	} else {
-	  nbr = Stencil.CommBuf()[SE->_offset];
+	  nbr = coalescedRead(Stencil.CommBuf()[SE->_offset],lane);
+	}
+	synchronise();
+
+	for(int bb=0;bb<nbasis;bb++) {
+	  res = res + coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
 	}
-	auto A_point = A[point].View();
-	res = res + A_point[ss]*nbr;
       }
-      vstream(out_v[ss],res);
+      coalescedWrite(out_v[ss](b),res,lane);
     });
+    usecs +=usecond();
+
+    double nrm_usec=-usecond();
     RealD Nout= norm2(out);
+    nrm_usec+=usecond();
+
+    /*
+        std::cout << GridLogMessage << "\tNorm        " << nrm_usec << " us" <<std::endl;
+        std::cout << GridLogMessage << "\tHalo        " << comms_usec << " us" <<std::endl;
+        std::cout << GridLogMessage << "\tMatrix      " << usecs << " us" <<std::endl;
+        std::cout << GridLogMessage << "\t  mflop/s   " << flops/usecs<<std::endl;
+        std::cout << GridLogMessage << "\t  MB/s      " << bytes/usecs<<std::endl;
+    */
     return Nout;
   };
 
@@ -349,25 +628,54 @@ public:
       return norm2(out);
     }
   };
-
-  void Mdir(const CoarseVector &in, CoarseVector &out, int dir, int disp){
-    
-    conformable(_grid,in.Grid());
-    conformable(in.Grid(),out.Grid());
-    
+  void MdirComms(const CoarseVector &in)
+  {
     SimpleCompressor<siteVector> compressor;
     Stencil.HaloExchange(in,compressor);
-    
-    auto point = [dir, disp](){
-      if(dir == 0 and disp == 0)
-	return 8;
-      else
-	return (4 * dir + 1 - disp) / 2;
-    }();
+  }
+  void MdirCalc(const CoarseVector &in, CoarseVector &out, int point)
+  {
+    conformable(_grid,in.Grid());
+    conformable(_grid,out.Grid());
+
+    typedef LatticeView<Cobj> Aview;
+    Vector<Aview> AcceleratorViewContainer;
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View());
+    Aview *Aview_p = & AcceleratorViewContainer[0];
 
     auto out_v = out.View();
     auto in_v  = in.View();
-    thread_for(ss,Grid()->oSites(),{
+
+    const int Nsimd = CComplex::Nsimd();
+    typedef decltype(coalescedRead(in_v[0])) calcVector;
+    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
+
+    accelerator_for(sss, Grid()->oSites()*nbasis, Nsimd, {
+      int ss = sss/nbasis;
+      int b  = sss%nbasis;
+      calcComplex res = Zero();
+      calcVector nbr;
+      int ptype;
+      StencilEntry *SE;
+
+      int lane=SIMTlane(Nsimd);
+      SE=Stencil.GetEntry(ptype,point,ss);
+	  
+      if(SE->_is_local) { 
+	nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute,lane);
+      } else {
+	nbr = coalescedRead(Stencil.CommBuf()[SE->_offset],lane);
+      }
+      synchronise();
+
+      for(int bb=0;bb<nbasis;bb++) {
+	res = res + coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
+      }
+      coalescedWrite(out_v[ss](b),res,lane);
+    });
+#if 0
+    accelerator_for(ss,Grid()->oSites(),1,{
+
       siteVector res = Zero();
       siteVector nbr;
       int ptype;
@@ -382,16 +690,65 @@ public:
       } else {
 	nbr = Stencil.CommBuf()[SE->_offset];
       }
+      synchronise();
 
-      auto A_point = A[point].View();
-      res = res + A_point[ss]*nbr;
+      res = res + Aview_p[point][ss]*nbr;
       
-      vstream(out_v[ss],res);
+      out_v[ss]=res;
     });
+#endif
+  }
+  void MdirAll(const CoarseVector &in,std::vector<CoarseVector> &out)
+  {
+    this->MdirComms(in);
+    int ndir=geom.npoint-1;
+    if ((out.size()!=ndir)&&(out.size()!=ndir+1)) { 
+      std::cout <<"MdirAll out size "<< out.size()<<std::endl;
+      std::cout <<"MdirAll ndir "<< ndir<<std::endl;
+      assert(0);
+    }
+    for(int p=0;p<ndir;p++){
+      MdirCalc(in,out[p],p);
+    }
+  };
+  void Mdir(const CoarseVector &in, CoarseVector &out, int dir, int disp){
+
+    this->MdirComms(in);
+
+    int ndim = in.Grid()->Nd();
+
+    //////////////
+    // 4D action like wilson
+    // 0+ => 0 
+    // 0- => 1
+    // 1+ => 2 
+    // 1- => 3
+    // etc..
+    //////////////
+    // 5D action like DWF
+    // 1+ => 0 
+    // 1- => 1
+    // 2+ => 2 
+    // 2- => 3
+    // etc..
+    auto point = [dir, disp, ndim](){
+      if(dir == 0 and disp == 0)
+	return 8;
+      else if ( ndim==4 ) { 
+	return (4 * dir + 1 - disp) / 2;
+      } else { 
+	return (4 * (dir-1) + 1 - disp) / 2;
+      }
+    }();
+
+    MdirCalc(in,out,point);
+
   };
 
-  void Mdiag(const CoarseVector &in, CoarseVector &out){
-    Mdir(in, out, 0, 0); // use the self coupling (= last) point of the stencil
+  void Mdiag(const CoarseVector &in, CoarseVector &out)
+  {
+    int point=geom.npoint-1;
+    MdirCalc(in, out, point); // No comms
   };
 
   
@@ -401,25 +758,44 @@ public:
     geom(CoarseGrid._ndimension),
     hermitian(hermitian_),
     Stencil(&CoarseGrid,geom.npoint,Even,geom.directions,geom.displacements,0),
-    A(geom.npoint,&CoarseGrid)
+      A(geom.npoint,&CoarseGrid)
   {
   };
 
   void CoarsenOperator(GridBase *FineGrid,LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & Subspace){
+		       Aggregation<Fobj,CComplex,nbasis> & Subspace)
+  {
+    typedef Lattice<typename Fobj::tensor_reduced> FineComplexField;
+    typedef typename Fobj::scalar_type scalar_type;
 
-    FineField iblock(FineGrid); // contributions from within this block
-    FineField oblock(FineGrid); // contributions from outwith this block
+    FineComplexField one(FineGrid); one=scalar_type(1.0,0.0);
+    FineComplexField zero(FineGrid); zero=scalar_type(0.0,0.0);
+
+    std::vector<FineComplexField> masks(geom.npoint,FineGrid);
+    FineComplexField imask(FineGrid); // contributions from within this block
+    FineComplexField omask(FineGrid); // contributions from outwith this block
+
+    FineComplexField evenmask(FineGrid);
+    FineComplexField oddmask(FineGrid); 
 
     FineField     phi(FineGrid);
     FineField     tmp(FineGrid);
     FineField     zz(FineGrid); zz=Zero();
     FineField    Mphi(FineGrid);
+    FineField    Mphie(FineGrid);
+    FineField    Mphio(FineGrid);
+    std::vector<FineField>     Mphi_p(geom.npoint,FineGrid);
 
-    Lattice<iScalar<vInteger> > coor(FineGrid);
+    Lattice<iScalar<vInteger> > coor (FineGrid);
+    Lattice<iScalar<vInteger> > bcoor(FineGrid);
+    Lattice<iScalar<vInteger> > bcb  (FineGrid); bcb = Zero();
 
     CoarseVector iProj(Grid()); 
     CoarseVector oProj(Grid()); 
+    CoarseVector SelfProj(Grid()); 
+    CoarseComplexField iZProj(Grid()); 
+    CoarseComplexField oZProj(Grid()); 
+
     CoarseScalar InnerProd(Grid()); 
 
     // Orthogonalise the subblocks over the basis
@@ -428,69 +804,117 @@ public:
     // Compute the matrix elements of linop between this orthonormal
     // set of vectors.
     int self_stencil=-1;
-    for(int p=0;p<geom.npoint;p++){ 
+    for(int p=0;p<geom.npoint;p++)
+    { 
+      int dir   = geom.directions[p];
+      int disp  = geom.displacements[p];
       A[p]=Zero();
       if( geom.displacements[p]==0){
 	self_stencil=p;
       }
+
+      Integer block=(FineGrid->_rdimensions[dir])/(Grid()->_rdimensions[dir]);
+
+      LatticeCoordinate(coor,dir);
+
+      ///////////////////////////////////////////////////////
+      // Work out even and odd block checkerboarding for fast diagonal term
+      ///////////////////////////////////////////////////////
+      if ( disp==1 ) {
+	bcb   = bcb + div(coor,block);
+      }
+	
+      if ( disp==0 ) {
+	  masks[p]= Zero();
+      } else if ( disp==1 ) {
+	masks[p] = where(mod(coor,block)==(block-1),one,zero);
+      } else if ( disp==-1 ) {
+	masks[p] = where(mod(coor,block)==(Integer)0,one,zero);
+      }
     }
+    evenmask = where(mod(bcb,2)==(Integer)0,one,zero);
+    oddmask  = one-evenmask;
+
     assert(self_stencil!=-1);
 
     for(int i=0;i<nbasis;i++){
+
       phi=Subspace.subspace[i];
-	
-      std::cout<<GridLogMessage<<"("<<i<<").."<<std::endl;
+
+      //      std::cout << GridLogMessage<< "CoarsenMatrix vector "<<i << std::endl;
+      linop.OpDirAll(phi,Mphi_p);
+      linop.OpDiag  (phi,Mphi_p[geom.npoint-1]);
 
       for(int p=0;p<geom.npoint;p++){ 
 
+	Mphi = Mphi_p[p];
+
 	int dir   = geom.directions[p];
 	int disp  = geom.displacements[p];
 
-	Integer block=(FineGrid->_rdimensions[dir])/(Grid()->_rdimensions[dir]);
+	if ( (disp==-1) || (!hermitian ) ) {
 
-	LatticeCoordinate(coor,dir);
-
-	if ( disp==0 ){
-	  linop.OpDiag(phi,Mphi);
-	}
-	else  {
-	  linop.OpDir(phi,Mphi,dir,disp); 
-	}
-
-	////////////////////////////////////////////////////////////////////////
-	// Pick out contributions coming from this cell and neighbour cell
-	////////////////////////////////////////////////////////////////////////
-	if ( disp==0 ) {
-	  iblock = Mphi;
-	  oblock = Zero();
-	} else if ( disp==1 ) {
-	  oblock = where(mod(coor,block)==(block-1),Mphi,zz);
-	  iblock = where(mod(coor,block)!=(block-1),Mphi,zz);
-	} else if ( disp==-1 ) {
-	  oblock = where(mod(coor,block)==(Integer)0,Mphi,zz);
-	  iblock = where(mod(coor,block)!=(Integer)0,Mphi,zz);
-	} else {
-	  assert(0);
-	}
-
-	Subspace.ProjectToSubspace(iProj,iblock);
-	Subspace.ProjectToSubspace(oProj,oblock);
-	//	  blockProject(iProj,iblock,Subspace.subspace);
-	//	  blockProject(oProj,oblock,Subspace.subspace);
-	auto iProj_v = iProj.View() ;
-	auto oProj_v = oProj.View() ;
-	auto A_p     =  A[p].View();
-	auto A_self  = A[self_stencil].View();
-	thread_for(ss, Grid()->oSites(),{
+	  ////////////////////////////////////////////////////////////////////////
+	  // Pick out contributions coming from this cell and neighbour cell
+	  ////////////////////////////////////////////////////////////////////////
+	  omask = masks[p];
+	  imask = one-omask;
+	
 	  for(int j=0;j<nbasis;j++){
-	    if( disp!= 0 ) {
-	      A_p[ss](j,i) = oProj_v[ss](j);
-	    }
-	    A_self[ss](j,i) =	A_self[ss](j,i) + iProj_v[ss](j);
+	    
+	    blockMaskedInnerProduct(oZProj,omask,Subspace.subspace[j],Mphi);
+	    
+	    auto iZProj_v = iZProj.View() ;
+	    auto oZProj_v = oZProj.View() ;
+	    auto A_p     =  A[p].View();
+	    auto A_self  = A[self_stencil].View();
+
+	    accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{ coalescedWrite(A_p[ss](j,i),oZProj_v(ss)); });
+	    //      if( disp!= 0 ) { accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{ coalescedWrite(A_p[ss](j,i),oZProj_v(ss)); });}
+	    //	    accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{ coalescedWrite(A_self[ss](j,i),A_self(ss)(j,i)+iZProj_v(ss)); });
+
+	  }
+	}
+      }
+
+      ///////////////////////////////////////////
+      // Faster alternate self coupling.. use hermiticity to save 2x
+      ///////////////////////////////////////////
+      {
+	mult(tmp,phi,evenmask);  linop.Op(tmp,Mphie);
+	mult(tmp,phi,oddmask );  linop.Op(tmp,Mphio);
+
+	{
+	  auto tmp_      = tmp.View();
+	  auto evenmask_ = evenmask.View();
+	  auto oddmask_  =  oddmask.View();
+	  auto Mphie_    =  Mphie.View();
+	  auto Mphio_    =  Mphio.View();
+	  accelerator_for(ss, FineGrid->oSites(), Fobj::Nsimd(),{ 
+	      coalescedWrite(tmp_[ss],evenmask_(ss)*Mphie_(ss) + oddmask_(ss)*Mphio_(ss));
+	    });
+	}
+
+	blockProject(SelfProj,tmp,Subspace.subspace);
+
+	auto SelfProj_ = SelfProj.View();
+	auto A_self  = A[self_stencil].View();
+
+	accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{
+	  for(int j=0;j<nbasis;j++){
+	    coalescedWrite(A_self[ss](j,i), SelfProj_(ss)(j));
 	  }
 	});
+
       }
     }
+    if(hermitian) {
+      std::cout << GridLogMessage << " ForceHermitian, new code "<<std::endl;
+      ForceHermitian();
+    }
+      // AssertHermitian();
+      // ForceDiagonal();
+  }
 
 #if 0
     ///////////////////////////
@@ -513,17 +937,26 @@ public:
     std::cout<<GridLogMessage<< iProj <<std::endl;
     std::cout<<GridLogMessage<<"Computed Coarse Operator"<<std::endl;
 #endif
-      //      ForceHermitian();
-      // AssertHermitian();
-      // ForceDiagonal();
-  }
+
 
   void ForceHermitian(void) {
-    for(int d=0;d<4;d++){
-      int dd=d+1;
-      A[2*d] = adj(Cshift(A[2*d+1],dd,1));
+    CoarseMatrix Diff  (Grid());
+    for(int p=0;p<geom.npoint;p++){
+      int dir   = geom.directions[p];
+      int disp  = geom.displacements[p];
+      if(disp==-1) {
+	// Find the opposite link
+	for(int pp=0;pp<geom.npoint;pp++){
+	  int dirp   = geom.directions[pp];
+	  int dispp  = geom.displacements[pp];
+	  if ( (dirp==dir) && (dispp==1) ){
+	    //	    Diff = adj(Cshift(A[p],dir,1)) - A[pp]; 
+	    //	    std::cout << GridLogMessage<<" Replacing stencil leg "<<pp<<" with leg "<<p<< " diff "<<norm2(Diff) <<std::endl;
+	    A[pp] = adj(Cshift(A[p],dir,1));
+	  }
+	}
+      }
     }
-    //      A[8] = 0.5*(A[8] + adj(A[8]));
   }
   void AssertHermitian(void) {
     CoarseMatrix AA    (Grid());
diff --git a/Grid/algorithms/LinearOperator.h b/Grid/algorithms/LinearOperator.h
index a768f431..50600d2d 100644
--- a/Grid/algorithms/LinearOperator.h
+++ b/Grid/algorithms/LinearOperator.h
@@ -47,6 +47,7 @@ public:
   // Support for coarsening to a multigrid
   virtual void OpDiag (const Field &in, Field &out) = 0; // Abstract base
   virtual void OpDir  (const Field &in, Field &out,int dir,int disp) = 0; // Abstract base
+  virtual void OpDirAll  (const Field &in, std::vector<Field> &out) = 0; // Abstract base
 
   virtual void Op     (const Field &in, Field &out) = 0; // Abstract base
   virtual void AdjOp  (const Field &in, Field &out) = 0; // Abstract base
@@ -83,6 +84,9 @@ public:
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
     _Mat.Mdir(in,out,dir,disp);
   }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){
+    _Mat.MdirAll(in,out);
+  };
   void Op     (const Field &in, Field &out){
     _Mat.M(in,out);
   }
@@ -93,8 +97,7 @@ public:
     _Mat.MdagM(in,out,n1,n2);
   }
   void HermOp(const Field &in, Field &out){
-    RealD n1,n2;
-    HermOpAndNorm(in,out,n1,n2);
+    _Mat.MdagM(in,out);
   }
 };
 
@@ -116,6 +119,9 @@ public:
     _Mat.Mdir(in,out,dir,disp);
     assert(0);
   }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){
+    assert(0);
+  };
   void Op     (const Field &in, Field &out){
     _Mat.M(in,out);
     assert(0);
@@ -154,6 +160,9 @@ public:
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
     _Mat.Mdir(in,out,dir,disp);
   }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){
+    _Mat.MdirAll(in,out);
+  };
   void Op     (const Field &in, Field &out){
     _Mat.M(in,out);
   }
@@ -162,7 +171,6 @@ public:
   }
   void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
     _Mat.M(in,out);
-	
     ComplexD dot= innerProduct(in,out); n1=real(dot);
     n2=norm2(out);
   }
@@ -183,6 +191,9 @@ public:
   void OpDir  (const Field &in, Field &out,int dir,int disp) {
     _Mat.Mdir(in,out,dir,disp);
   }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){
+    _Mat.MdirAll(in,out);
+  };
   void Op     (const Field &in, Field &out){
     _Mat.M(in,out);
   }
@@ -234,6 +245,9 @@ public:
       void OpDir  (const Field &in, Field &out,int dir,int disp) {
 	assert(0);
       }
+      void OpDirAll  (const Field &in, std::vector<Field> &out){
+	assert(0);
+      };
     };
     template<class Matrix,class Field>
     class SchurDiagMooeeOperator :  public SchurOperatorBase<Field> {
@@ -320,9 +334,135 @@ public:
 	return axpy_norm(out,-1.0,tmp,in);
       }
     };
+
+    template<class Field>
+    class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field> 
+    {
+      public:
+        virtual RealD Mpc      (const Field& in, Field& out) = 0;
+        virtual RealD MpcDag   (const Field& in, Field& out) = 0;
+        virtual void  MpcDagMpc(const Field& in, Field& out, RealD& ni, RealD& no) {
+          Field tmp(in.Grid());
+          tmp.Checkerboard() = in.Checkerboard();
+	        ni = Mpc(in,tmp);
+	        no = MpcDag(tmp,out);
+        }
+        virtual void HermOpAndNorm(const Field& in, Field& out, RealD& n1, RealD& n2) {
+          assert(0);
+        }
+        virtual void HermOp(const Field& in, Field& out) {
+          assert(0);
+        }
+        void Op(const Field& in, Field& out) {
+          Mpc(in, out);
+        }
+        void AdjOp(const Field& in, Field& out) { 
+          MpcDag(in, out);
+        }
+        // Support for coarsening to a multigrid
+        void OpDiag(const Field& in, Field& out) {
+          assert(0); // must coarsen the unpreconditioned system
+        }
+        void OpDir(const Field& in, Field& out, int dir, int disp) {
+          assert(0);
+        }
+    };
+
+    template<class Matrix, class Field>
+    class NonHermitianSchurDiagMooeeOperator :  public NonHermitianSchurOperatorBase<Field> 
+    {
+      public:
+        Matrix& _Mat;
+        NonHermitianSchurDiagMooeeOperator(Matrix& Mat): _Mat(Mat){};
+        virtual RealD Mpc(const Field& in, Field& out) {
+          Field tmp(in.Grid());
+          tmp.Checkerboard() = !in.Checkerboard();
+
+  	      _Mat.Meooe(in, tmp);
+	        _Mat.MooeeInv(tmp, out);
+	        _Mat.Meooe(out, tmp);
+
+	        _Mat.Mooee(in, out);
+	
+          return axpy_norm(out, -1.0, tmp, out);
+        }
+        virtual RealD MpcDag(const Field& in, Field& out) {
+	        Field tmp(in.Grid());
+
+	        _Mat.MeooeDag(in, tmp);
+          _Mat.MooeeInvDag(tmp, out);
+	        _Mat.MeooeDag(out, tmp);
+
+	        _Mat.MooeeDag(in, out);
+	
+          return axpy_norm(out, -1.0, tmp, out);
+      }
+    };
+    
+    template<class Matrix,class Field>
+    class NonHermitianSchurDiagOneOperator : public NonHermitianSchurOperatorBase<Field> 
+    {
+      protected:
+        Matrix &_Mat;
+    
+      public:
+        NonHermitianSchurDiagOneOperator (Matrix& Mat): _Mat(Mat){};
+        virtual RealD Mpc(const Field& in, Field& out) {
+	        Field tmp(in.Grid());
+
+	        _Mat.Meooe(in, out);
+	        _Mat.MooeeInv(out, tmp);
+	        _Mat.Meooe(tmp, out);
+	        _Mat.MooeeInv(out, tmp);
+
+	        return axpy_norm(out, -1.0, tmp, in);
+        }
+        virtual RealD MpcDag(const Field& in, Field& out) {
+	        Field tmp(in.Grid());
+
+	        _Mat.MooeeInvDag(in, out);
+	        _Mat.MeooeDag(out, tmp);
+	        _Mat.MooeeInvDag(tmp, out);
+	        _Mat.MeooeDag(out, tmp);
+
+	        return axpy_norm(out, -1.0, tmp, in);
+        }
+    };
+
+    template<class Matrix, class Field>
+    class NonHermitianSchurDiagTwoOperator : public NonHermitianSchurOperatorBase<Field> 
+    {
+      protected:
+        Matrix& _Mat;
+    
+      public:
+        NonHermitianSchurDiagTwoOperator(Matrix& Mat): _Mat(Mat){};
+
+        virtual RealD Mpc(const Field& in, Field& out) {
+          Field tmp(in.Grid());
+
+	        _Mat.MooeeInv(in, out);
+	        _Mat.Meooe(out, tmp);
+	        _Mat.MooeeInv(tmp, out);
+	        _Mat.Meooe(out, tmp);
+
+	        return axpy_norm(out, -1.0, tmp, in);
+        }
+        virtual RealD MpcDag(const Field& in, Field& out) {
+	        Field tmp(in.Grid());
+
+          _Mat.MeooeDag(in, out);
+          _Mat.MooeeInvDag(out, tmp);
+          _Mat.MeooeDag(tmp, out);
+          _Mat.MooeeInvDag(out, tmp);
+
+          return axpy_norm(out, -1.0, tmp, in);
+        }
+    };
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // Left  handed Moo^-1 ; (Moo - Moe Mee^-1 Meo) psi = eta  -->  ( 1 - Moo^-1 Moe Mee^-1 Meo ) psi = Moo^-1 eta
-    // Right handed Moo^-1 ; (Moo - Moe Mee^-1 Meo) Moo^-1 Moo psi = eta  -->  ( 1 - Moe Mee^-1 Meo ) Moo^-1 phi=eta ; psi = Moo^-1 phi
+    // Right handed Moo^-1 ; (Moo - Moe Mee^-1 Meo) Moo^-1 Moo psi = eta  -->  ( 1 - Moe Mee^-1 Meo Moo^-1) phi=eta ; psi = Moo^-1 phi
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     template<class Matrix,class Field> using SchurDiagOneRH = SchurDiagTwoOperator<Matrix,Field> ;
     template<class Matrix,class Field> using SchurDiagOneLH = SchurDiagOneOperator<Matrix,Field> ;
diff --git a/Grid/algorithms/SparseMatrix.h b/Grid/algorithms/SparseMatrix.h
index ffed7527..b959f53c 100644
--- a/Grid/algorithms/SparseMatrix.h
+++ b/Grid/algorithms/SparseMatrix.h
@@ -45,8 +45,13 @@ public:
     ni=M(in,tmp);
     no=Mdag(tmp,out);
   }
+  virtual void  MdagM(const Field &in, Field &out) {
+    RealD ni, no;
+    MdagM(in,out,ni,no);
+  }
   virtual  void Mdiag    (const Field &in, Field &out)=0;
   virtual  void Mdir     (const Field &in, Field &out,int dir, int disp)=0;
+  virtual  void MdirAll  (const Field &in, std::vector<Field> &out)=0;
 };
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -56,12 +61,12 @@ template<class Field> class CheckerBoardedSparseMatrixBase : public SparseMatrix
 public:
   virtual GridBase *RedBlackGrid(void)=0;
 
-      //////////////////////////////////////////////////////////////////////
-      // Query the even even properties to make algorithmic decisions
-      //////////////////////////////////////////////////////////////////////
-      virtual RealD  Mass(void)        { return 0.0; };
-      virtual int    ConstEE(void)     { return 1; }; // Disable assumptions unless overridden
-      virtual int    isTrivialEE(void) { return 0; }; // by a derived class that knows better
+  //////////////////////////////////////////////////////////////////////
+  // Query the even even properties to make algorithmic decisions
+  //////////////////////////////////////////////////////////////////////
+  virtual RealD  Mass(void)        { return 0.0; };
+  virtual int    ConstEE(void)     { return 1; }; // Disable assumptions unless overridden
+  virtual int    isTrivialEE(void) { return 0; }; // by a derived class that knows better
 
   // half checkerboard operaions
   virtual  void Meooe    (const Field &in, Field &out)=0;
diff --git a/Grid/algorithms/approx/Chebyshev.h b/Grid/algorithms/approx/Chebyshev.h
index 97e0e807..133db2b4 100644
--- a/Grid/algorithms/approx/Chebyshev.h
+++ b/Grid/algorithms/approx/Chebyshev.h
@@ -94,6 +94,24 @@ public:
     Coeffs.assign(0.,order);
     Coeffs[order-1] = 1.;
   };
+  
+  // PB - more efficient low pass drops high modes above the low as 1/x uses all Chebyshev's.
+  // Similar kick effect below the threshold as Lanczos filter approach
+  void InitLowPass(RealD _lo,RealD _hi,int _order)
+  {
+    lo=_lo;
+    hi=_hi;
+    order=_order;
+      
+    if(order < 2) exit(-1);
+    Coeffs.resize(order);
+    for(int j=0;j<order;j++){
+      RealD k=(order-1.0);
+      RealD s=std::cos( j*M_PI*(k+0.5)/order );
+      Coeffs[j] = s * 2.0/order;
+    }
+    
+  };
 
   void Init(RealD _lo,RealD _hi,int _order, RealD (* func)(RealD))
   {
@@ -234,20 +252,20 @@ public:
     RealD xscale = 2.0/(hi-lo);
     RealD mscale = -(hi+lo)/(hi-lo);
     Linop.HermOp(T0,y);
-    T1=y*xscale+in*mscale;
+    axpby(T1,xscale,mscale,y,in);
 
     // sum = .5 c[0] T0 + c[1] T1
-    out = (0.5*Coeffs[0])*T0 + Coeffs[1]*T1;
+    //    out = ()*T0 + Coeffs[1]*T1;
+    axpby(out,0.5*Coeffs[0],Coeffs[1],T0,T1);
     for(int n=2;n<order;n++){
 	
       Linop.HermOp(*Tn,y);
-
-      y=xscale*y+mscale*(*Tn);
-
-      *Tnp=2.0*y-(*Tnm);
-
-      out=out+Coeffs[n]* (*Tnp);
-
+      //     y=xscale*y+mscale*(*Tn);
+      //      *Tnp=2.0*y-(*Tnm);
+      //      out=out+Coeffs[n]* (*Tnp);
+      axpby(y,xscale,mscale,y,(*Tn));
+      axpby(*Tnp,2.0,-1.0,y,(*Tnm));
+      axpy(out,Coeffs[n],*Tnp,out);
       // Cycle pointers to avoid copies
       Field *swizzle = Tnm;
       Tnm    =Tn;
diff --git a/Grid/algorithms/approx/JacobiPolynomial.h b/Grid/algorithms/approx/JacobiPolynomial.h
new file mode 100644
index 00000000..e68d1dd7
--- /dev/null
+++ b/Grid/algorithms/approx/JacobiPolynomial.h
@@ -0,0 +1,129 @@
+#ifndef GRID_JACOBIPOLYNOMIAL_H
+#define GRID_JACOBIPOLYNOMIAL_H
+
+#include <Grid/algorithms/LinearOperator.h>
+
+NAMESPACE_BEGIN(Grid);
+
+template<class Field>
+class JacobiPolynomial : public OperatorFunction<Field> {
+ private:
+  using OperatorFunction<Field>::operator();
+
+  int order;
+  RealD hi;
+  RealD lo;
+  RealD alpha;
+  RealD beta;
+
+ public:
+  void csv(std::ostream &out){
+    csv(out,lo,hi);
+  }
+  void csv(std::ostream &out,RealD llo,RealD hhi){
+    RealD diff = hhi-llo;
+    RealD delta = diff*1.0e-5;
+    for (RealD x=llo-delta; x<=hhi; x+=delta) {
+      RealD f = approx(x);
+      out<< x<<" "<<f <<std::endl;
+    }
+    return;
+  }
+
+  JacobiPolynomial(){};
+  JacobiPolynomial(RealD _lo,RealD _hi,int _order,RealD _alpha, RealD _beta)
+  {
+      lo=_lo;
+      hi=_hi;
+      alpha=_alpha;
+      beta=_beta;
+      order=_order;
+  };
+
+  RealD approx(RealD x) // Convenience for plotting the approximation                                                       
+  {
+    RealD Tn;
+    RealD Tnm;
+    RealD Tnp;
+
+    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));
+
+    RealD T0=1.0;
+    RealD T1=(alpha-beta)*0.5+(alpha+beta+2.0)*0.5*y;
+
+    Tn =T1;
+    Tnm=T0;
+    for(int n=2;n<=order;n++){
+      RealD cnp = 2.0*n*(n+alpha+beta)*(2.0*n-2.0+alpha+beta);
+      RealD cny = (2.0*n-2.0+alpha+beta)*(2.0*n-1.0+alpha+beta)*(2.0*n+alpha+beta);
+      RealD cn1 = (2.0*n+alpha+beta-1.0)*(alpha*alpha-beta*beta);
+      RealD cnm = - 2.0*(n+alpha-1.0)*(n+beta-1.0)*(2.0*n+alpha+beta);
+      Tnp= ( cny * y *Tn + cn1 * Tn + cnm * Tnm )/ cnp;
+      Tnm=Tn;
+      Tn =Tnp;
+    }
+    return Tnp;
+  };
+
+  // Implement the required interface                                                                                       
+  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
+    GridBase *grid=in.Grid();
+
+    int vol=grid->gSites();
+
+    Field T0(grid);
+    Field T1(grid);
+    Field T2(grid);
+    Field y(grid);
+
+
+    Field *Tnm = &T0;
+    Field *Tn  = &T1;
+    Field *Tnp = &T2;
+
+    //    RealD T0=1.0;                                                                                                     
+    T0=in;
+
+    //    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));                                                                           
+    //           = x * 2/(hi-lo) - (hi+lo)/(hi-lo)                                                                          
+    Linop.HermOp(T0,y);
+    RealD xscale = 2.0/(hi-lo);
+    RealD mscale = -(hi+lo)/(hi-lo);
+    Linop.HermOp(T0,y);
+    y=y*xscale+in*mscale;
+
+    // RealD T1=(alpha-beta)*0.5+(alpha+beta+2.0)*0.5*y;
+    RealD halfAmB  = (alpha-beta)*0.5;
+    RealD halfApBp2= (alpha+beta+2.0)*0.5;
+    T1 = halfAmB * in + halfApBp2*y;
+
+    for(int n=2;n<=order;n++){
+
+      Linop.HermOp(*Tn,y);
+      y=xscale*y+mscale*(*Tn);
+
+      RealD cnp = 2.0*n*(n+alpha+beta)*(2.0*n-2.0+alpha+beta);
+      RealD cny = (2.0*n-2.0+alpha+beta)*(2.0*n-1.0+alpha+beta)*(2.0*n+alpha+beta);
+      RealD cn1 = (2.0*n+alpha+beta-1.0)*(alpha*alpha-beta*beta);
+      RealD cnm = - 2.0*(n+alpha-1.0)*(n+beta-1.0)*(2.0*n+alpha+beta);
+
+      //      Tnp= ( cny * y *Tn + cn1 * Tn + cnm * Tnm )/ cnp;                                                             
+      cny=cny/cnp;
+      cn1=cn1/cnp;
+      cn1=cn1/cnp;
+      cnm=cnm/cnp;
+
+      *Tnp=cny*y + cn1 *(*Tn) + cnm * (*Tnm);
+
+      // Cycle pointers to avoid copies                                                                                     
+      Field *swizzle = Tnm;
+      Tnm    =Tn;
+      Tn     =Tnp;
+      Tnp    =swizzle;
+    }
+    out=*Tnp;
+
+  }
+};
+NAMESPACE_END(Grid);
+#endif
diff --git a/Grid/algorithms/approx/RemezGeneral.cc b/Grid/algorithms/approx/RemezGeneral.cc
new file mode 100644
index 00000000..e41b4ed2
--- /dev/null
+++ b/Grid/algorithms/approx/RemezGeneral.cc
@@ -0,0 +1,473 @@
+#include<math.h>
+#include<stdio.h>
+#include<stdlib.h>
+#include<string>
+#include<iostream>
+#include<iomanip>
+#include<cassert>
+
+#include<Grid/algorithms/approx/RemezGeneral.h>
+
+
+// Constructor
+AlgRemezGeneral::AlgRemezGeneral(double lower, double upper, long precision,
+				 bigfloat (*f)(bigfloat x, void *data), void *data): f(f), 
+										     data(data), 
+										     prec(precision),
+										     apstrt(lower), apend(upper), apwidt(upper - lower),
+										     n(0), d(0), pow_n(0), pow_d(0)
+{
+  bigfloat::setDefaultPrecision(prec);
+
+  std::cout<<"Approximation bounds are ["<<apstrt<<","<<apend<<"]\n";
+  std::cout<<"Precision of arithmetic is "<<precision<<std::endl;
+}
+
+//Determine the properties of the numerator and denominator polynomials
+void AlgRemezGeneral::setupPolyProperties(int num_degree, int den_degree, PolyType num_type_in, PolyType den_type_in){
+  pow_n = num_degree;
+  pow_d = den_degree;
+
+  if(pow_n % 2 == 0 && num_type_in == PolyType::Odd) assert(0);
+  if(pow_n % 2 == 1 && num_type_in == PolyType::Even) assert(0);
+
+  if(pow_d % 2 == 0 && den_type_in == PolyType::Odd) assert(0);
+  if(pow_d % 2 == 1 && den_type_in == PolyType::Even) assert(0);
+
+  num_type = num_type_in;
+  den_type = den_type_in;
+
+  num_pows.resize(pow_n+1);
+  den_pows.resize(pow_d+1);
+
+  int n_in = 0;
+  bool odd = num_type == PolyType::Full || num_type == PolyType::Odd;
+  bool even = num_type == PolyType::Full || num_type == PolyType::Even;
+  for(int i=0;i<=pow_n;i++){
+    num_pows[i] = -1;
+    if(i % 2 == 0 && even) num_pows[i] = n_in++;
+    if(i % 2 == 1 && odd) num_pows[i] = n_in++;
+  }
+
+  std::cout << n_in << " terms in numerator" << std::endl;
+  --n_in; //power is 1 less than the number of terms, eg  pow=1   a x^1  + b x^0
+
+  int d_in = 0;
+  odd = den_type == PolyType::Full || den_type == PolyType::Odd;
+  even = den_type == PolyType::Full || den_type == PolyType::Even;
+  for(int i=0;i<=pow_d;i++){
+    den_pows[i] = -1;
+    if(i % 2 == 0 && even) den_pows[i] = d_in++;
+    if(i % 2 == 1 && odd) den_pows[i] = d_in++;
+  }
+
+  std::cout << d_in << " terms in denominator" << std::endl;
+  --d_in;
+
+  n = n_in;
+  d = d_in;
+}
+
+//Setup algorithm
+void AlgRemezGeneral::reinitializeAlgorithm(){
+  spread = 1.0e37;
+  iter = 0;
+
+  neq = n + d + 1; //not +2 because highest-power term in denominator is fixed to 1
+
+  param.resize(neq);
+  yy.resize(neq+1);
+
+  //Initialize linear equation temporaries
+  A.resize(neq*neq);
+  B.resize(neq);
+  IPS.resize(neq);
+
+  //Initialize maximum and minimum errors
+  xx.resize(neq+2);
+  mm.resize(neq+1);
+  initialGuess();
+
+  //Initialize search steps
+  step.resize(neq+1);
+  stpini();
+}
+
+double AlgRemezGeneral::generateApprox(const int num_degree, const int den_degree, 
+				       const PolyType num_type_in, const PolyType den_type_in, 
+				       const double _tolerance, const int report_freq){
+  //Setup the properties of the polynomial
+  setupPolyProperties(num_degree, den_degree, num_type_in, den_type_in);
+
+  //Setup the algorithm
+  reinitializeAlgorithm();
+
+  bigfloat tolerance = _tolerance;
+
+  //Iterate until convergance
+  while (spread > tolerance) { 
+    if (iter++ % report_freq==0)
+      std::cout<<"Iteration " <<iter-1<<" spread "<<(double)spread<<" delta "<<(double)delta << std::endl; 
+
+    equations();
+    if (delta < tolerance) {
+      std::cout<<"Iteration " << iter-1 << " delta too small (" << delta << "<" << tolerance << "), try increasing precision\n";
+      assert(0);
+    };    
+    assert( delta>= tolerance );
+
+    search();
+  }
+
+  int sign;
+  double error = (double)getErr(mm[0],&sign);
+  std::cout<<"Converged at "<<iter<<" iterations; error = "<<error<<std::endl;
+
+  // Return the maximum error in the approximation
+  return error;
+}
+
+
+// Initial values of maximal and minimal errors
+void AlgRemezGeneral::initialGuess(){
+  // Supply initial guesses for solution points
+  long ncheb = neq;			// Degree of Chebyshev error estimate
+
+  // Find ncheb+1 extrema of Chebyshev polynomial
+  bigfloat a = ncheb;
+  bigfloat r;
+
+  mm[0] = apstrt;
+  for (long i = 1; i < ncheb; i++) {
+    r = 0.5 * (1 - cos((M_PI * i)/(double) a));
+    //r *= sqrt_bf(r);
+    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
+    mm[i] = apstrt + r * apwidt;
+  }
+  mm[ncheb] = apend;
+
+  a = 2.0 * ncheb;
+  for (long i = 0; i <= ncheb; i++) {
+    r = 0.5 * (1 - cos(M_PI * (2*i+1)/(double) a));
+    //r *= sqrt_bf(r); // Squeeze to low end of interval
+    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
+    xx[i] = apstrt + r * apwidt;
+  }
+}
+
+// Initialise step sizes
+void AlgRemezGeneral::stpini(){
+  xx[neq+1] = apend;
+  delta = 0.25;
+  step[0] = xx[0] - apstrt;
+  for (int i = 1; i < neq; i++) step[i] = xx[i] - xx[i-1];
+  step[neq] = step[neq-1];
+}
+
+// Search for error maxima and minima
+void AlgRemezGeneral::search(){
+  bigfloat a, q, xm, ym, xn, yn, xx1;
+  int emsign, ensign, steps;
+
+  int meq = neq + 1;
+
+  bigfloat eclose = 1.0e30;
+  bigfloat farther = 0l;
+
+  bigfloat xx0 = apstrt;
+
+  for (int i = 0; i < meq; i++) {
+    steps = 0;
+    xx1 = xx[i]; // Next zero
+    if (i == meq-1) xx1 = apend;
+    xm = mm[i];
+    ym = getErr(xm,&emsign);
+    q = step[i];
+    xn = xm + q;
+    if (xn < xx0 || xn >= xx1) {	// Cannot skip over adjacent boundaries
+      q = -q;
+      xn = xm;
+      yn = ym;
+      ensign = emsign;
+    } else {
+      yn = getErr(xn,&ensign);
+      if (yn < ym) {
+	q = -q;
+	xn = xm;
+	yn = ym;
+	ensign = emsign;
+      }
+    }
+  
+    while(yn >= ym) {		// March until error becomes smaller.
+      if (++steps > 10)
+      	break;
+      
+      ym = yn;
+      xm = xn;
+      emsign = ensign;
+      a = xm + q;
+      if (a == xm || a <= xx0 || a >= xx1)
+	break;// Must not skip over the zeros either side.      
+
+      xn = a;
+      yn = getErr(xn,&ensign);
+    }
+
+    mm[i] = xm;			// Position of maximum
+    yy[i] = ym;			// Value of maximum
+
+    if (eclose > ym) eclose = ym;
+    if (farther < ym) farther = ym;
+
+    xx0 = xx1; // Walk to next zero.
+  } // end of search loop
+
+  q = (farther - eclose);	// Decrease step size if error spread increased
+
+  if (eclose != 0.0) q /= eclose; // Relative error spread
+
+  if (q >= spread)
+    delta *= 0.5; // Spread is increasing; decrease step size
+  
+  spread = q;
+
+  for (int i = 0; i < neq; i++) {
+    q = yy[i+1];
+    if (q != 0.0) q = yy[i] / q  - (bigfloat)1l;
+    else q = 0.0625;
+    if (q > (bigfloat)0.25) q = 0.25;
+    q *= mm[i+1] - mm[i];
+    step[i] = q * delta;
+  }
+  step[neq] = step[neq-1];
+  
+  for (int i = 0; i < neq; i++) {	// Insert new locations for the zeros.
+    xm = xx[i] - step[i];
+
+    if (xm <= apstrt)
+      continue;
+
+    if (xm >= apend)
+      continue;
+
+    if (xm <= mm[i])
+      xm = (bigfloat)0.5 * (mm[i] + xx[i]);    
+
+    if (xm >= mm[i+1])
+      xm = (bigfloat)0.5 * (mm[i+1] + xx[i]);
+    
+    xx[i] = xm;
+  }
+}
+
+// Solve the equations
+void AlgRemezGeneral::equations(){
+  bigfloat x, y, z;
+  bigfloat *aa;
+  
+  for (int i = 0; i < neq; i++) {	// set up the equations for solution by simq()
+    int ip = neq * i;		// offset to 1st element of this row of matrix
+    x = xx[i];			// the guess for this row
+    y = func(x);		// right-hand-side vector
+
+    z = (bigfloat)1l;
+    aa = A.data()+ip;
+    int t = 0;
+    for (int j = 0; j <= pow_n; j++) {
+      if(num_pows[j] != -1){ *aa++ = z; t++; }
+      z *= x;
+    }
+    assert(t == n+1);
+
+    z = (bigfloat)1l;
+    t = 0;
+    for (int j = 0; j < pow_d; j++) {
+      if(den_pows[j] != -1){ *aa++ = -y * z; t++; }
+      z *= x;
+    }
+    assert(t == d);
+
+    B[i] = y * z;		// Right hand side vector
+  }
+
+  // Solve the simultaneous linear equations.
+  if (simq()){
+    std::cout<<"simq failed\n";
+    exit(0);
+  }
+}
+
+
+// Evaluate the rational form P(x)/Q(x) using coefficients
+// from the solution vector param
+bigfloat AlgRemezGeneral::approx(const bigfloat x) const{
+  // Work backwards toward the constant term.
+  int c = n;
+  bigfloat yn = param[c--];		// Highest order numerator coefficient
+  for (int i = pow_n-1; i >= 0; i--) yn = x * yn  +  (num_pows[i] != -1 ? param[c--] : bigfloat(0l));  
+
+  c = n+d;
+  bigfloat yd = 1l; //Highest degree coefficient is 1.0
+  for (int i = pow_d-1; i >= 0; i--) yd = x * yd  +  (den_pows[i] != -1 ? param[c--] : bigfloat(0l)); 
+
+  return(yn/yd);
+}
+
+// Compute size and sign of the approximation error at x
+bigfloat AlgRemezGeneral::getErr(bigfloat x, int *sign) const{
+  bigfloat f = func(x);
+  bigfloat e = approx(x) - f;
+  if (f != 0) e /= f;
+  if (e < (bigfloat)0.0) {
+    *sign = -1;
+    e = -e;
+  }
+  else *sign = 1;
+  
+  return(e);
+}
+
+// Solve the system AX=B
+int AlgRemezGeneral::simq(){
+
+  int ip, ipj, ipk, ipn;
+  int idxpiv;
+  int kp, kp1, kpk, kpn;
+  int nip, nkp;
+  bigfloat em, q, rownrm, big, size, pivot, sum;
+  bigfloat *aa;
+  bigfloat *X = param.data();
+
+  int n = neq;
+  int nm1 = n - 1;
+  // Initialize IPS and X
+  
+  int ij = 0;
+  for (int i = 0; i < n; i++) {
+    IPS[i] = i;
+    rownrm = 0.0;
+    for(int j = 0; j < n; j++) {
+      q = abs_bf(A[ij]);
+      if(rownrm < q) rownrm = q;
+      ++ij;
+    }
+    if (rownrm == (bigfloat)0l) {
+      std::cout<<"simq rownrm=0\n";
+      return(1);
+    }
+    X[i] = (bigfloat)1.0 / rownrm;
+  }
+  
+  for (int k = 0; k < nm1; k++) {
+    big = 0.0;
+    idxpiv = 0;
+    
+    for (int i = k; i < n; i++) {
+      ip = IPS[i];
+      ipk = n*ip + k;
+      size = abs_bf(A[ipk]) * X[ip];
+      if (size > big) {
+	big = size;
+	idxpiv = i;
+      }
+    }
+    
+    if (big == (bigfloat)0l) {
+      std::cout<<"simq big=0\n";
+      return(2);
+    }
+    if (idxpiv != k) {
+      int j = IPS[k];
+      IPS[k] = IPS[idxpiv];
+      IPS[idxpiv] = j;
+    }
+    kp = IPS[k];
+    kpk = n*kp + k;
+    pivot = A[kpk];
+    kp1 = k+1;
+    for (int i = kp1; i < n; i++) {
+      ip = IPS[i];
+      ipk = n*ip + k;
+      em = -A[ipk] / pivot;
+      A[ipk] = -em;
+      nip = n*ip;
+      nkp = n*kp;
+      aa = A.data()+nkp+kp1;
+      for (int j = kp1; j < n; j++) {
+	ipj = nip + j;
+	A[ipj] = A[ipj] + em * *aa++;
+      }
+    }
+  }
+  kpn = n * IPS[n-1] + n - 1;	// last element of IPS[n] th row
+  if (A[kpn] == (bigfloat)0l) {
+    std::cout<<"simq A[kpn]=0\n";
+    return(3);
+  }
+
+  
+  ip = IPS[0];
+  X[0] = B[ip];
+  for (int i = 1; i < n; i++) {
+    ip = IPS[i];
+    ipj = n * ip;
+    sum = 0.0;
+    for (int j = 0; j < i; j++) {
+      sum += A[ipj] * X[j];
+      ++ipj;
+    }
+    X[i] = B[ip] - sum;
+  }
+  
+  ipn = n * IPS[n-1] + n - 1;
+  X[n-1] = X[n-1] / A[ipn];
+  
+  for (int iback = 1; iback < n; iback++) {
+    //i goes (n-1),...,1
+    int i = nm1 - iback;
+    ip = IPS[i];
+    nip = n*ip;
+    sum = 0.0;
+    aa = A.data()+nip+i+1;
+    for (int j= i + 1; j < n; j++) 
+      sum += *aa++ * X[j];
+    X[i] = (X[i] - sum) / A[nip+i];
+  }
+  
+  return(0);
+}
+
+void AlgRemezGeneral::csv(std::ostream & os) const{
+  os << "Numerator" << std::endl;
+  for(int i=0;i<=pow_n;i++){
+    os << getCoeffNum(i) << "*x^" << i;
+    if(i!=pow_n) os << " + ";
+  }
+  os << std::endl;
+
+  os << "Denominator" << std::endl;
+  for(int i=0;i<=pow_d;i++){
+    os << getCoeffDen(i) << "*x^" << i;
+    if(i!=pow_d) os << " + ";
+  }
+  os << std::endl;
+
+  //For a true minimax solution the errors should all be equal and the signs should oscillate +-+-+- etc
+  int sign;
+  os << "Errors at maxima: coordinate, error, (sign)" << std::endl;
+  for(int i=0;i<neq+1;i++){ 
+    os << mm[i] << " " << getErr(mm[i],&sign) << " (" << sign << ")" << std::endl;
+  }
+
+  os << "Scan over range:" << std::endl;
+  int npt = 60;
+  bigfloat dlt = (apend - apstrt)/bigfloat(npt-1);
+
+  for (bigfloat x=apstrt; x<=apend; x = x + dlt) {
+    double f = evaluateFunc(x);
+    double r = evaluateApprox(x);
+    os<< x<<","<<r<<","<<f<<","<<r-f<<std::endl;
+  }
+  return;
+}
diff --git a/Grid/algorithms/approx/RemezGeneral.h b/Grid/algorithms/approx/RemezGeneral.h
new file mode 100644
index 00000000..92553ca5
--- /dev/null
+++ b/Grid/algorithms/approx/RemezGeneral.h
@@ -0,0 +1,170 @@
+/*
+  C.Kelly Jan 2020 based on implementation by M. Clark May 2005
+
+  AlgRemezGeneral is an implementation of the Remez algorithm for approximating an arbitrary function by a rational polynomial 
+  It includes optional restriction to odd/even polynomials for the numerator and/or denominator
+*/
+
+#ifndef INCLUDED_ALG_REMEZ_GENERAL_H
+#define INCLUDED_ALG_REMEZ_GENERAL_H
+
+#include <stddef.h>
+#include <Grid/GridStd.h>
+
+#ifdef HAVE_LIBGMP
+#include "bigfloat.h"
+#else
+#include "bigfloat_double.h"
+#endif
+
+
+class AlgRemezGeneral{
+ public:
+  enum PolyType { Even, Odd, Full };
+
+ private:
+
+  // In GSL-style, pass the function as a function pointer. Any data required to evaluate the function is passed in as a void pointer
+  bigfloat (*f)(bigfloat x, void *data);
+  void *data;
+
+  // The approximation parameters
+  std::vector<bigfloat> param;
+  bigfloat norm;
+
+  // The number of non-zero terms in the numerator and denominator
+  int n, d;
+  // The numerator and denominator degree (i.e.  the largest power)
+  int pow_n, pow_d;
+  
+  // Specify if the numerator and/or denominator are odd/even polynomials
+  PolyType num_type;
+  PolyType den_type;
+  std::vector<int> num_pows; //contains the mapping, with -1 if not present
+  std::vector<int> den_pows;
+
+  // The bounds of the approximation
+  bigfloat apstrt, apwidt, apend;
+
+  // Variables used to calculate the approximation
+  int nd1, iter;
+  std::vector<bigfloat> xx;
+  std::vector<bigfloat> mm;
+  std::vector<bigfloat> step;
+
+  bigfloat delta, spread;
+  
+  // Variables used in search
+  std::vector<bigfloat> yy;
+
+  // Variables used in solving linear equations
+  std::vector<bigfloat> A;
+  std::vector<bigfloat> B;
+  std::vector<int> IPS;
+
+  // The number of equations we must solve at each iteration (n+d+1)
+  int neq;
+
+  // The precision of the GNU MP library
+  long prec;
+
+  // Initialize member variables associated with the polynomial's properties
+  void setupPolyProperties(int num_degree, int den_degree, PolyType num_type_in, PolyType den_type_in);
+
+  // Initial values of maximal and minmal errors
+  void initialGuess();
+
+  // Initialise step sizes
+  void stpini();
+
+  // Initialize the algorithm
+  void reinitializeAlgorithm();
+
+  // Solve the equations
+  void equations();
+
+  // Search for error maxima and minima
+  void search(); 
+
+  // Calculate function required for the approximation
+  inline bigfloat func(bigfloat x) const{
+    return f(x, data);
+  }
+
+  // Compute size and sign of the approximation error at x
+  bigfloat getErr(bigfloat x, int *sign) const;
+
+  // Solve the system AX=B   where X = param
+  int simq();
+
+  // Evaluate the rational form P(x)/Q(x) using coefficients from the solution vector param
+  bigfloat approx(bigfloat x) const;
+
+ public:
+  
+  AlgRemezGeneral(double lower, double upper, long prec,
+		  bigfloat (*f)(bigfloat x, void *data), void *data);
+
+  inline int getDegree(void) const{ 
+    assert(n==d);
+    return n;
+  }
+  // Reset the bounds of the approximation
+  inline void setBounds(double lower, double upper) {
+    apstrt = lower;
+    apend = upper;
+    apwidt = apend - apstrt;
+  }
+
+  // Get the bounds of the approximation
+  inline void getBounds(double &lower, double &upper) const{ 
+    lower=(double)apstrt;
+    upper=(double)apend;
+  }
+
+  // Run the algorithm to generate the rational approximation
+  double generateApprox(int num_degree, int den_degree, 
+			PolyType num_type, PolyType den_type,
+			const double tolerance = 1e-15, const int report_freq = 1000);
+  
+  inline double generateApprox(int num_degree, int den_degree, 
+			       const double tolerance = 1e-15, const int report_freq = 1000){
+    return generateApprox(num_degree, den_degree, Full, Full, tolerance, report_freq);
+  }
+  
+  // Evaluate the rational form P(x)/Q(x) using coefficients from the
+  // solution vector param
+  inline double evaluateApprox(double x) const{
+    return (double)approx((bigfloat)x);
+  }
+
+  // Evaluate the rational form Q(x)/P(x) using coefficients from the solution vector param
+  inline double evaluateInverseApprox(double x) const{
+    return 1.0/(double)approx((bigfloat)x);
+  }  
+
+  // Calculate function required for the approximation
+  inline double evaluateFunc(double x) const{
+    return (double)func((bigfloat)x);
+  }
+
+  // Calculate inverse function required for the approximation
+  inline double evaluateInverseFunc(double x) const{
+    return 1.0/(double)func((bigfloat)x);
+  }
+
+  // Dump csv of function, approx and error
+  void csv(std::ostream &os = std::cout) const;
+
+  // Get the coefficient of the term x^i in the numerator
+  inline double getCoeffNum(const int i) const{    
+    return num_pows[i] == -1 ? 0. : double(param[num_pows[i]]);
+  }
+  // Get the coefficient of the term x^i in the denominator
+  inline double getCoeffDen(const int i) const{ 
+    if(i == pow_d) return 1.0;
+    else return den_pows[i] == -1 ? 0. : double(param[den_pows[i]+n+1]); 
+  }
+};
+
+#endif
diff --git a/Grid/algorithms/approx/ZMobius.cc b/Grid/algorithms/approx/ZMobius.cc
new file mode 100644
index 00000000..65af901f
--- /dev/null
+++ b/Grid/algorithms/approx/ZMobius.cc
@@ -0,0 +1,183 @@
+/*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./lib/algorithms/approx/ZMobius.cc
+
+    Copyright (C) 2015
+
+Author: Christopher Kelly <ckelly@phys.columbia.edu>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#include <Grid/algorithms/approx/ZMobius.h>
+#include <Grid/algorithms/approx/RemezGeneral.h>
+
+NAMESPACE_BEGIN(Grid);
+NAMESPACE_BEGIN(Approx);
+
+//Compute the tanh approximation
+inline double epsilonMobius(const double x, const std::vector<ComplexD> &w){
+  int Ls = w.size();
+
+  ComplexD fxp = 1., fmp = 1.;
+  for(int i=0;i<Ls;i++){
+    fxp = fxp * ( w[i] + x );
+    fmp = fmp * ( w[i] - x );
+  }
+  return ((fxp - fmp)/(fxp + fmp)).real();
+}
+inline double epsilonMobius(const double x, const std::vector<RealD> &w){
+  int Ls = w.size();
+
+  double fxp = 1., fmp = 1.;
+  for(int i=0;i<Ls;i++){
+    fxp = fxp * ( w[i] + x );
+    fmp = fmp * ( w[i] - x );
+  }
+  return (fxp - fmp)/(fxp + fmp);
+}
+
+
+
+//Compute the tanh approximation in a form suitable for the Remez
+bigfloat epsilonMobius(bigfloat x, void* data){
+  const std::vector<RealD> &omega = *( (std::vector<RealD> const*)data );
+  bigfloat fxp(1.0);
+  bigfloat fmp(1.0);
+
+  for(int i=0;i<omega.size();i++){
+    fxp = fxp * ( bigfloat(omega[i]) + x);
+    fmp = fmp * ( bigfloat(omega[i]) - x);
+  }
+  return (fxp - fmp)/(fxp + fmp);
+}
+
+//Compute the Zmobius Omega parameters suitable for eigenvalue range   -lambda_bound <= lambda <= lambda_bound
+//Note omega_i = 1/(b_i + c_i)   where b_i and c_i are the Mobius parameters
+void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out,
+			 const std::vector<RealD> &omega_in, const int Ls_in,
+			 const RealD lambda_bound){
+  assert(omega_in.size() == Ls_in);
+  omega_out.resize(Ls_out);
+
+  //Use the Remez algorithm to generate the appropriate rational polynomial
+  //For odd polynomial, to satisfy Haar condition must take either positive or negative half of range (cf https://arxiv.org/pdf/0803.0439.pdf page 6)  
+  AlgRemezGeneral remez(0, lambda_bound, 64, &epsilonMobius, (void*)&omega_in); 
+  remez.generateApprox(Ls_out-1, Ls_out,AlgRemezGeneral::Odd, AlgRemezGeneral::Even, 1e-15, 100);
+  remez.csv(std::cout);
+
+  //The rational approximation has the form  [ f(x) - f(-x) ] / [ f(x) + f(-x) ]  where  f(x) = \Prod_{i=0}^{L_s-1} ( \omega_i + x )
+  //cf https://academiccommons.columbia.edu/doi/10.7916/D8T72HD7  pg 102
+  //omega_i are therefore the negative of the complex roots of f(x)
+
+  //We can find the roots by recognizing that the eigenvalues of a matrix A are the roots of the characteristic polynomial
+  // \rho(\lambda) = det( A - \lambda I )    where I is the unit matrix
+  //The matrix whose characteristic polynomial is an arbitrary monic polynomial a0 + a1 x + a2 x^2 + ... x^n   is the companion matrix 
+  // A = | 0    1   0    0 0 .... 0 |
+  //     | 0    0   1    0 0 .... 0 |
+  //     | :    :   :    : :      : |
+  //     | 0    0   0    0 0      1
+  //     | -a0 -a1 -a2  ...  ... -an|
+
+
+  //Note the Remez defines the largest power to have unit coefficient
+  std::vector<RealD> coeffs(Ls_out+1);
+  for(int i=0;i<Ls_out+1;i+=2) coeffs[i] = coeffs[i] = remez.getCoeffDen(i); //even powers
+  for(int i=1;i<Ls_out+1;i+=2) coeffs[i] = coeffs[i] = remez.getCoeffNum(i); //odd powers
+
+  std::vector<std::complex<RealD> > roots(Ls_out);
+
+  //Form the companion matrix
+  Eigen::MatrixXd compn(Ls_out,Ls_out);
+  for(int i=0;i<Ls_out-1;i++) compn(i,0) = 0.;
+  compn(Ls_out - 1, 0) = -coeffs[0];
+  
+  for(int j=1;j<Ls_out;j++){
+    for(int i=0;i<Ls_out-1;i++) compn(i,j) = i == j-1 ? 1. : 0.;
+    compn(Ls_out - 1, j) = -coeffs[j];
+  }
+
+  //Eigensolve
+  Eigen::EigenSolver<Eigen::MatrixXd> slv(compn, false);
+
+  const auto & ev = slv.eigenvalues();
+  for(int i=0;i<Ls_out;i++)
+    omega_out[i] = -ev(i);
+
+  //Sort ascending (smallest at start of vector!)
+  std::sort(omega_out.begin(), omega_out.end(), 
+	    [&](const ComplexD &a, const ComplexD &b){ return a.real() < b.real() || (a.real() == b.real() && a.imag() < b.imag()); });
+
+  //McGlynn thesis pg 122 suggest improved iteration counts if magnitude of omega diminishes towards the center of the 5th dimension
+  std::vector<ComplexD> omega_tmp = omega_out;
+  int s_low=0, s_high=Ls_out-1, ss=0;
+  for(int s_from = Ls_out-1; s_from >= 0; s_from--){ //loop from largest omega
+    int s_to;
+    if(ss % 2 == 0){
+      s_to = s_low++;
+    }else{
+      s_to = s_high--;
+    }
+    omega_out[s_to] = omega_tmp[s_from];
+    ++ss;
+  }
+  
+  std::cout << "Resulting omega_i:" << std::endl;  
+  for(int i=0;i<Ls_out;i++)
+    std::cout << omega_out[i] << std::endl;
+
+  std::cout << "Test result matches the approximate polynomial found by the Remez" << std::endl;
+  std::cout << "<x> <remez approx> <poly approx> <diff poly approx remez approx> <exact> <diff poly approx exact>\n";
+  
+  int npt = 60;
+  double dlt = lambda_bound/double(npt-1);
+
+  for (int i =0; i<npt; i++){
+    double x = i*dlt;
+    double r = remez.evaluateApprox(x);
+    double p = epsilonMobius(x, omega_out);
+    double e = epsilonMobius(x, omega_in);
+
+    std::cout << x<< " " << r << " " << p <<" " <<r-p << " " << e << " " << e-p << std::endl;
+  }
+
+}
+  
+//mobius_param = b+c   with b-c=1
+void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound){
+  std::vector<RealD> omega_in(Ls_in, 1./mobius_param);
+  computeZmobiusOmega(omega_out, Ls_out, omega_in, Ls_in, lambda_bound);
+}
+
+//ZMobius class takes  gamma_i = (b+c) omega_i as its input, where b, c are factored out
+void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, 
+			 const RealD mobius_param_out, const int Ls_out, 
+			 const RealD mobius_param_in, const int Ls_in,
+			 const RealD lambda_bound){
+  computeZmobiusOmega(gamma_out, Ls_out, mobius_param_in, Ls_in, lambda_bound);
+  for(int i=0;i<Ls_out;i++) gamma_out[i] = gamma_out[i] * mobius_param_out;
+}
+//Assumes mobius_param_out == mobius_param_in
+void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound){
+  computeZmobiusGamma(gamma_out, mobius_param, Ls_out, mobius_param, Ls_in, lambda_bound);
+}
+
+NAMESPACE_END(Approx);
+NAMESPACE_END(Grid);
diff --git a/Grid/algorithms/approx/ZMobius.h b/Grid/algorithms/approx/ZMobius.h
new file mode 100644
index 00000000..f3e97634
--- /dev/null
+++ b/Grid/algorithms/approx/ZMobius.h
@@ -0,0 +1,57 @@
+/*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./lib/algorithms/approx/ZMobius.h
+
+    Copyright (C) 2015
+
+Author: Christopher Kelly <ckelly@phys.columbia.edu>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_ZMOBIUS_APPROX_H
+#define GRID_ZMOBIUS_APPROX_H
+
+#include <Grid/GridCore.h>
+
+NAMESPACE_BEGIN(Grid);
+NAMESPACE_BEGIN(Approx);
+
+//Compute the Zmobius Omega parameters suitable for eigenvalue range   -lambda_bound <= lambda <= lambda_bound
+//Note omega_i = 1/(b_i + c_i)   where b_i and c_i are the Mobius parameters
+void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out,
+			 const std::vector<RealD> &omega_in, const int Ls_in,
+			 const RealD lambda_bound);
+  
+//mobius_param = b+c   with b-c=1
+void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound);
+
+//ZMobius class takes  gamma_i = (b+c) omega_i as its input, where b, c are factored out
+void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, 
+			 const RealD mobius_param_out, const int Ls_out, 
+			 const RealD mobius_param_in, const int Ls_in,
+			 const RealD lambda_bound);
+
+//Assumes mobius_param_out == mobius_param_in
+void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound);
+
+NAMESPACE_END(Approx);
+NAMESPACE_END(Grid);
+
+#endif
diff --git a/Grid/algorithms/approx/bigfloat_double.h b/Grid/algorithms/approx/bigfloat_double.h
index 4a7a02b8..26dd6b02 100644
--- a/Grid/algorithms/approx/bigfloat_double.h
+++ b/Grid/algorithms/approx/bigfloat_double.h
@@ -25,6 +25,10 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
     See the full license in the file "LICENSE" in the top level distribution directory
     *************************************************************************************/
     /*  END LEGAL */
+
+#ifndef INCLUDED_BIGFLOAT_DOUBLE_H
+#define INCLUDED_BIGFLOAT_DOUBLE_H
+
 #include <math.h>
 
 typedef double mfloat; 
@@ -186,4 +190,6 @@ public:
   //  friend bigfloat& random(void);
 };
 
+#endif
+
 
diff --git a/Grid/algorithms/iterative/BiCGSTAB.h b/Grid/algorithms/iterative/BiCGSTAB.h
new file mode 100644
index 00000000..3a7be1ef
--- /dev/null
+++ b/Grid/algorithms/iterative/BiCGSTAB.h
@@ -0,0 +1,222 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/algorithms/iterative/BiCGSTAB.h
+
+Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: paboyle <paboyle@ph.ed.ac.uk>
+Author: juettner <juettner@soton.ac.uk>
+Author: David Murphy <djmurphy@mit.edu>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#ifndef GRID_BICGSTAB_H
+#define GRID_BICGSTAB_H
+
+NAMESPACE_BEGIN(Grid);
+
+/////////////////////////////////////////////////////////////
+// Base classes for iterative processes based on operators
+// single input vec, single output vec.
+/////////////////////////////////////////////////////////////
+
+template <class Field>
+class BiCGSTAB : public OperatorFunction<Field> 
+{
+  public:
+    using OperatorFunction<Field>::operator();
+    
+    bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
+                             // Defaults true.
+    RealD Tolerance;
+    Integer MaxIterations;
+    Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
+  
+    BiCGSTAB(RealD tol, Integer maxit, bool err_on_no_conv = true) : 
+      Tolerance(tol), MaxIterations(maxit), ErrorOnNoConverge(err_on_no_conv){};
+
+    void operator()(LinearOperatorBase<Field>& Linop, const Field& src, Field& psi) 
+    {
+      psi.Checkerboard() = src.Checkerboard();
+      conformable(psi, src);
+
+      RealD cp(0), rho(1), rho_prev(0), alpha(1), beta(0), omega(1);
+      RealD a(0), bo(0), b(0), ssq(0);
+
+      Field p(src);
+      Field r(src);
+      Field rhat(src);
+      Field v(src);
+      Field s(src);
+      Field t(src);
+      Field h(src);
+
+      v = Zero();
+      p = Zero();
+
+      // Initial residual computation & set up
+      RealD guess = norm2(psi);
+      assert(std::isnan(guess) == 0);
+    
+      Linop.Op(psi, v);
+      b = norm2(v);
+
+      r = src - v;
+      rhat = r;
+      a = norm2(r);
+      ssq = norm2(src);
+
+      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB: guess " << guess << std::endl;
+      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:   src " << ssq << std::endl;
+      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:    mp " << b << std::endl;
+      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:     r " << a << std::endl;
+
+      RealD rsq = Tolerance * Tolerance * ssq;
+
+      // Check if guess is really REALLY good :)
+      if(a <= rsq){ return; }
+
+      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB: k=0 residual " << a << " target " << rsq << std::endl;
+
+      GridStopWatch LinalgTimer;
+      GridStopWatch InnerTimer;
+      GridStopWatch AxpyNormTimer;
+      GridStopWatch LinearCombTimer;
+      GridStopWatch MatrixTimer;
+      GridStopWatch SolverTimer;
+
+      SolverTimer.Start();
+      int k;
+      for (k = 1; k <= MaxIterations; k++) 
+      {
+        rho_prev = rho;
+
+        LinalgTimer.Start();
+        InnerTimer.Start();
+        ComplexD Crho  = innerProduct(rhat,r);
+        InnerTimer.Stop();
+        rho = Crho.real();
+
+        beta = (rho / rho_prev) * (alpha / omega);
+
+        LinearCombTimer.Start();
+        bo = beta * omega;
+        auto p_v = p.View();
+        auto r_v = r.View();
+        auto v_v = v.View();
+        accelerator_for(ss, p_v.size(), Field::vector_object::Nsimd(),{
+          coalescedWrite(p_v[ss], beta*p_v(ss) - bo*v_v(ss) + r_v(ss));
+        });
+        LinearCombTimer.Stop();
+        LinalgTimer.Stop();
+
+        MatrixTimer.Start();
+        Linop.Op(p,v);
+        MatrixTimer.Stop();
+
+        LinalgTimer.Start();
+        InnerTimer.Start();
+        ComplexD Calpha = innerProduct(rhat,v);
+        InnerTimer.Stop();
+        alpha = rho / Calpha.real();
+
+        LinearCombTimer.Start();
+        auto h_v = h.View();
+        auto psi_v = psi.View();
+        accelerator_for(ss, h_v.size(), Field::vector_object::Nsimd(),{
+          coalescedWrite(h_v[ss], alpha*p_v(ss) + psi_v(ss));
+        });
+        
+        auto s_v = s.View();
+        accelerator_for(ss, s_v.size(), Field::vector_object::Nsimd(),{
+          coalescedWrite(s_v[ss], -alpha*v_v(ss) + r_v(ss));
+        });
+        LinearCombTimer.Stop();
+        LinalgTimer.Stop();
+
+        MatrixTimer.Start();
+        Linop.Op(s,t);
+        MatrixTimer.Stop();
+
+        LinalgTimer.Start();
+        InnerTimer.Start();
+        ComplexD Comega = innerProduct(t,s);
+        InnerTimer.Stop();
+        omega = Comega.real() / norm2(t);
+
+        LinearCombTimer.Start();
+        auto t_v = t.View();
+        accelerator_for(ss, psi_v.size(), Field::vector_object::Nsimd(),{
+          coalescedWrite(psi_v[ss], h_v(ss) + omega * s_v(ss));
+          coalescedWrite(r_v[ss], -omega * t_v(ss) + s_v(ss));
+        });
+        LinearCombTimer.Stop();
+
+        cp = norm2(r);
+        LinalgTimer.Stop();
+
+        std::cout << GridLogIterative << "BiCGSTAB: Iteration " << k << " residual " << sqrt(cp/ssq) << " target " << Tolerance << std::endl;
+
+        // Stopping condition
+        if(cp <= rsq) 
+        {
+          SolverTimer.Stop();
+          Linop.Op(psi, v);
+          p = v - src;
+
+          RealD srcnorm = sqrt(norm2(src));
+          RealD resnorm = sqrt(norm2(p));
+          RealD true_residual = resnorm / srcnorm;
+
+          std::cout << GridLogMessage << "BiCGSTAB Converged on iteration " << k << std::endl;
+          std::cout << GridLogMessage << "\tComputed residual " << sqrt(cp/ssq) << std::endl;
+          std::cout << GridLogMessage << "\tTrue residual " << true_residual << std::endl;
+          std::cout << GridLogMessage << "\tTarget " << Tolerance << std::endl;
+
+          std::cout << GridLogMessage << "Time breakdown " << std::endl;
+          std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed() << std::endl;
+          std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() << std::endl;
+          std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() << std::endl;
+          std::cout << GridLogMessage << "\tInner      " << InnerTimer.Elapsed() << std::endl;
+          std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() << std::endl;
+          std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() << std::endl;
+
+          if(ErrorOnNoConverge){ assert(true_residual / Tolerance < 10000.0); }
+
+          IterationsToComplete = k;	
+
+          return;
+        }
+      }
+      
+      std::cout << GridLogMessage << "BiCGSTAB did NOT converge" << std::endl;
+
+      if(ErrorOnNoConverge){ assert(0); }
+      IterationsToComplete = k;
+    }
+};
+
+NAMESPACE_END(Grid);
+
+#endif
diff --git a/Grid/algorithms/iterative/BiCGSTABMixedPrec.h b/Grid/algorithms/iterative/BiCGSTABMixedPrec.h
new file mode 100644
index 00000000..d9b2a9d7
--- /dev/null
+++ b/Grid/algorithms/iterative/BiCGSTABMixedPrec.h
@@ -0,0 +1,158 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: ./lib/algorithms/iterative/BiCGSTABMixedPrec.h
+
+Copyright (C) 2015
+
+Author: Christopher Kelly <ckelly@phys.columbia.edu>
+Author: David Murphy <djmurphy@mit.edu>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#ifndef GRID_BICGSTAB_MIXED_PREC_H
+#define GRID_BICGSTAB_MIXED_PREC_H
+
+NAMESPACE_BEGIN(Grid);
+
+// Mixed precision restarted defect correction BiCGSTAB
+template<class FieldD, class FieldF, typename std::enable_if< getPrecision<FieldD>::value == 2, int>::type = 0, typename std::enable_if< getPrecision<FieldF>::value == 1, int>::type = 0> 
+class MixedPrecisionBiCGSTAB : public LinearFunction<FieldD> 
+{
+  public:                                                
+    RealD   Tolerance;
+    RealD   InnerTolerance; // Initial tolerance for inner CG. Defaults to Tolerance but can be changed
+    Integer MaxInnerIterations;
+    Integer MaxOuterIterations;
+    GridBase* SinglePrecGrid; // Grid for single-precision fields
+    RealD OuterLoopNormMult; // Stop the outer loop and move to a final double prec solve when the residual is OuterLoopNormMult * Tolerance
+    LinearOperatorBase<FieldF> &Linop_f;
+    LinearOperatorBase<FieldD> &Linop_d;
+
+    Integer TotalInnerIterations; //Number of inner CG iterations
+    Integer TotalOuterIterations; //Number of restarts
+    Integer TotalFinalStepIterations; //Number of CG iterations in final patch-up step
+
+    //Option to speed up *inner single precision* solves using a LinearFunction that produces a guess
+    LinearFunction<FieldF> *guesser;
+    
+    MixedPrecisionBiCGSTAB(RealD tol, Integer maxinnerit, Integer maxouterit, GridBase* _sp_grid, 
+        LinearOperatorBase<FieldF>& _Linop_f, LinearOperatorBase<FieldD>& _Linop_d) : 
+      Linop_f(_Linop_f), Linop_d(_Linop_d), Tolerance(tol), InnerTolerance(tol), MaxInnerIterations(maxinnerit), 
+      MaxOuterIterations(maxouterit), SinglePrecGrid(_sp_grid), OuterLoopNormMult(100.), guesser(NULL) {};
+
+    void useGuesser(LinearFunction<FieldF>& g){
+      guesser = &g;
+    }
+  
+    void operator() (const FieldD& src_d_in, FieldD& sol_d)
+    {
+      TotalInnerIterations = 0;
+    
+      GridStopWatch TotalTimer;
+      TotalTimer.Start();
+      
+      int cb = src_d_in.Checkerboard();
+      sol_d.Checkerboard() = cb;
+      
+      RealD src_norm = norm2(src_d_in);
+      RealD stop = src_norm * Tolerance*Tolerance;
+
+      GridBase* DoublePrecGrid = src_d_in.Grid();
+      FieldD tmp_d(DoublePrecGrid);
+      tmp_d.Checkerboard() = cb;
+      
+      FieldD tmp2_d(DoublePrecGrid);
+      tmp2_d.Checkerboard() = cb;
+      
+      FieldD src_d(DoublePrecGrid);
+      src_d = src_d_in; //source for next inner iteration, computed from residual during operation
+      
+      RealD inner_tol = InnerTolerance;
+      
+      FieldF src_f(SinglePrecGrid);
+      src_f.Checkerboard() = cb;
+      
+      FieldF sol_f(SinglePrecGrid);
+      sol_f.Checkerboard() = cb;
+      
+      BiCGSTAB<FieldF> CG_f(inner_tol, MaxInnerIterations);
+      CG_f.ErrorOnNoConverge = false;
+
+      GridStopWatch InnerCGtimer;
+
+      GridStopWatch PrecChangeTimer;
+      
+      Integer &outer_iter = TotalOuterIterations; //so it will be equal to the final iteration count
+        
+      for(outer_iter = 0; outer_iter < MaxOuterIterations; outer_iter++)
+      {
+        // Compute double precision rsd and also new RHS vector.
+        Linop_d.Op(sol_d, tmp_d);
+        RealD norm = axpy_norm(src_d, -1., tmp_d, src_d_in); //src_d is residual vector
+        
+        std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Outer iteration " << outer_iter << " residual " << norm << " target " << stop << std::endl;
+
+        if(norm < OuterLoopNormMult * stop){
+          std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Outer iteration converged on iteration " << outer_iter << std::endl;
+          break;
+        }
+        while(norm * inner_tol * inner_tol < stop){ inner_tol *= 2; } // inner_tol = sqrt(stop/norm) ??
+
+        PrecChangeTimer.Start();
+        precisionChange(src_f, src_d);
+        PrecChangeTimer.Stop();
+        
+        sol_f = Zero();
+
+        //Optionally improve inner solver guess (eg using known eigenvectors)
+        if(guesser != NULL){ (*guesser)(src_f, sol_f); }
+
+        //Inner CG
+        CG_f.Tolerance = inner_tol;
+        InnerCGtimer.Start();
+        CG_f(Linop_f, src_f, sol_f);
+        InnerCGtimer.Stop();
+        TotalInnerIterations += CG_f.IterationsToComplete;
+        
+        //Convert sol back to double and add to double prec solution
+        PrecChangeTimer.Start();
+        precisionChange(tmp_d, sol_f);
+        PrecChangeTimer.Stop();
+        
+        axpy(sol_d, 1.0, tmp_d, sol_d);
+      }
+      
+      //Final trial CG
+      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Starting final patch-up double-precision solve" << std::endl;
+      
+      BiCGSTAB<FieldD> CG_d(Tolerance, MaxInnerIterations);
+      CG_d(Linop_d, src_d_in, sol_d);
+      TotalFinalStepIterations = CG_d.IterationsToComplete;
+
+      TotalTimer.Stop();
+      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Inner CG iterations " << TotalInnerIterations << " Restarts " << TotalOuterIterations << " Final CG iterations " << TotalFinalStepIterations << std::endl;
+      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Total time " << TotalTimer.Elapsed() << " Precision change " << PrecChangeTimer.Elapsed() << " Inner CG total " << InnerCGtimer.Elapsed() << std::endl;
+  }
+};
+
+NAMESPACE_END(Grid);
+
+#endif
diff --git a/Grid/algorithms/iterative/BlockConjugateGradient.h b/Grid/algorithms/iterative/BlockConjugateGradient.h
index 0bd7cf51..75a8be06 100644
--- a/Grid/algorithms/iterative/BlockConjugateGradient.h
+++ b/Grid/algorithms/iterative/BlockConjugateGradient.h
@@ -52,6 +52,7 @@ class BlockConjugateGradient : public OperatorFunction<Field> {
   Integer MaxIterations;
   Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
   Integer PrintInterval; //GridLogMessages or Iterative
+  RealD TrueResidual;
   
   BlockConjugateGradient(BlockCGtype cgtype,int _Orthog,RealD tol, Integer maxit, bool err_on_no_conv = true)
     : Tolerance(tol), CGtype(cgtype),   blockDim(_Orthog),  MaxIterations(maxit), ErrorOnNoConverge(err_on_no_conv),PrintInterval(100)
@@ -306,7 +307,8 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
 
       Linop.HermOp(X, AD);
       AD = AD-B;
-      std::cout << GridLogMessage <<"\t True residual is " << std::sqrt(norm2(AD)/norm2(B)) <<std::endl;
+      TrueResidual = std::sqrt(norm2(AD)/norm2(B));
+      std::cout << GridLogMessage <<"\tTrue residual is " << TrueResidual <<std::endl;
 
       std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
       std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
@@ -442,7 +444,8 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
 
       Linop.HermOp(Psi, AP);
       AP = AP-Src;
-      std::cout <<GridLogMessage << "\tTrue residual is " << std::sqrt(norm2(AP)/norm2(Src)) <<std::endl;
+      TrueResidual = std::sqrt(norm2(AP)/norm2(Src));
+      std::cout <<GridLogMessage << "\tTrue residual is " << TrueResidual <<std::endl;
 
       std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
       std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
@@ -653,7 +656,7 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
       if ( rr > max_resid ) max_resid = rr;
     }
 
-    std::cout << GridLogIterative << "\t Block Iteration "<<k<<" ave resid "<< sqrt(rrsum/sssum) << " max "<< sqrt(max_resid) <<std::endl;
+    std::cout << GridLogIterative << "\t Block Iteration "<<k<<" ave resid "<< std::sqrt(rrsum/sssum) << " max "<< std::sqrt(max_resid) <<std::endl;
 
     if ( max_resid < Tolerance*Tolerance ) { 
 
@@ -668,7 +671,8 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
 
       for(int b=0;b<Nblock;b++) Linop.HermOp(X[b], AD[b]);
       for(int b=0;b<Nblock;b++) AD[b] = AD[b]-B[b];
-      std::cout << GridLogMessage <<"\t True residual is " << std::sqrt(normv(AD)/normv(B)) <<std::endl;
+      TrueResidual = std::sqrt(normv(AD)/normv(B));
+      std::cout << GridLogMessage << "\tTrue residual is " << TrueResidual <<std::endl;
 
       std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
       std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
diff --git a/Grid/algorithms/iterative/ConjugateGradient.h b/Grid/algorithms/iterative/ConjugateGradient.h
index 398f578f..3a2544b5 100644
--- a/Grid/algorithms/iterative/ConjugateGradient.h
+++ b/Grid/algorithms/iterative/ConjugateGradient.h
@@ -49,6 +49,7 @@ public:
   RealD Tolerance;
   Integer MaxIterations;
   Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
+  RealD TrueResidual;
   
   ConjugateGradient(RealD tol, Integer maxit, bool err_on_no_conv = true)
     : Tolerance(tol),
@@ -71,7 +72,6 @@ public:
     // Initial residual computation & set up
     RealD guess = norm2(psi);
     assert(std::isnan(guess) == 0);
-
     
     Linop.HermOpAndNorm(psi, mmp, d, b);
     
@@ -82,6 +82,14 @@ public:
     cp = a;
     ssq = norm2(src);
 
+    // Handle trivial case of zero src
+    if (ssq == 0.){
+      psi = Zero();
+      IterationsToComplete = 1;
+      TrueResidual = 0.;
+      return;
+    }
+
     std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient: guess " << guess << std::endl;
     std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:   src " << ssq << std::endl;
     std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:    mp " << d << std::endl;
@@ -93,6 +101,7 @@ public:
 
     // Check if guess is really REALLY good :)
     if (cp <= rsq) {
+      TrueResidual = std::sqrt(a/ssq);
       std::cout << GridLogMessage << "ConjugateGradient guess is converged already " << std::endl;
       IterationsToComplete = 0;	
       return;
@@ -142,7 +151,7 @@ public:
       LinalgTimer.Stop();
 
       std::cout << GridLogIterative << "ConjugateGradient: Iteration " << k
-                << " residual^2 " << sqrt(cp/ssq) << " target " << Tolerance << std::endl;
+                << " residual " << sqrt(cp/ssq) << " target " << Tolerance << std::endl;
 
       // Stopping condition
       if (cp <= rsq) {
@@ -154,26 +163,33 @@ public:
         RealD resnorm = std::sqrt(norm2(p));
         RealD true_residual = resnorm / srcnorm;
 
-        std::cout << GridLogMessage << "ConjugateGradient Converged on iteration " << k << std::endl;
-        std::cout << GridLogMessage << "\tComputed residual " << std::sqrt(cp / ssq)<<std::endl;
-	std::cout << GridLogMessage << "\tTrue residual " << true_residual<<std::endl;
-	std::cout << GridLogMessage << "\tTarget " << Tolerance << std::endl;
+        std::cout << GridLogMessage << "ConjugateGradient Converged on iteration " << k 
+		  << "\tComputed residual " << std::sqrt(cp / ssq)
+		  << "\tTrue residual " << true_residual
+		  << "\tTarget " << Tolerance << std::endl;
 
-        std::cout << GridLogMessage << "Time breakdown "<<std::endl;
-	std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tInner      " << InnerTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
+        std::cout << GridLogIterative << "Time breakdown "<<std::endl;
+	std::cout << GridLogIterative << "\tElapsed    " << SolverTimer.Elapsed() <<std::endl;
+	std::cout << GridLogIterative << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
+	std::cout << GridLogIterative << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
+	std::cout << GridLogIterative << "\tInner      " << InnerTimer.Elapsed() <<std::endl;
+	std::cout << GridLogIterative << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
+	std::cout << GridLogIterative << "\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
 
         if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);
 
 	IterationsToComplete = k;	
+	TrueResidual = true_residual;
 
         return;
       }
     }
+    // Failed. Calculate true residual before giving up                                                         
+    Linop.HermOpAndNorm(psi, mmp, d, qq);
+    p = mmp - src;
+
+    TrueResidual = sqrt(norm2(p)/ssq);
+
     std::cout << GridLogMessage << "ConjugateGradient did NOT converge "<<k<<" / "<< MaxIterations<< std::endl;
 
     if (ErrorOnNoConverge) assert(0);
diff --git a/Grid/algorithms/iterative/ConjugateGradientMultiShift.h b/Grid/algorithms/iterative/ConjugateGradientMultiShift.h
index 7e8d01e2..63a6c55f 100644
--- a/Grid/algorithms/iterative/ConjugateGradientMultiShift.h
+++ b/Grid/algorithms/iterative/ConjugateGradientMultiShift.h
@@ -46,15 +46,19 @@ public:
 
   RealD   Tolerance;
   Integer MaxIterations;
-    Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
+  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
+  std::vector<int> IterationsToCompleteShift;  // Iterations for this shift
   int verbose;
   MultiShiftFunction shifts;
+  std::vector<RealD> TrueResidualShift;
 
   ConjugateGradientMultiShift(Integer maxit,MultiShiftFunction &_shifts) : 
     MaxIterations(maxit),
     shifts(_shifts)
   { 
     verbose=1;
+    IterationsToCompleteShift.resize(_shifts.order);
+    TrueResidualShift.resize(_shifts.order);
   }
 
   void operator() (LinearOperatorBase<Field> &Linop, const Field &src, Field &psi)
@@ -125,6 +129,17 @@ public:
     // Residuals "r" are src
     // First search direction "p" is also src
     cp = norm2(src);
+
+    // Handle trivial case of zero src.
+    if( cp == 0. ){
+      for(int s=0;s<nshift;s++){
+	psi[s] = Zero();
+	IterationsToCompleteShift[s] = 1;
+	TrueResidualShift[s] = 0.;
+      }
+      return;
+    }
+
     for(int s=0;s<nshift;s++){
       rsq[s] = cp * mresidual[s] * mresidual[s];
       std::cout<<GridLogMessage<<"ConjugateGradientMultiShift: shift "<<s
@@ -270,6 +285,7 @@ public:
       for(int s=0;s<nshift;s++){
       
 	if ( (!converged[s]) ){
+	  IterationsToCompleteShift[s] = k;
 	
 	  RealD css  = c * z[s][iz]* z[s][iz];
 	
@@ -299,7 +315,8 @@ public:
 	  axpy(r,-alpha[s],src,tmp);
 	  RealD rn = norm2(r);
 	  RealD cn = norm2(src);
-	  std::cout<<GridLogMessage<<"CGMultiShift: shift["<<s<<"] true residual "<<std::sqrt(rn/cn)<<std::endl;
+	  TrueResidualShift[s] = std::sqrt(rn/cn);
+	  std::cout<<GridLogMessage<<"CGMultiShift: shift["<<s<<"] true residual "<< TrueResidualShift[s] <<std::endl;
 	}
 
       std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
diff --git a/Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h b/Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h
index e5573c8e..8bee43cc 100644
--- a/Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h
+++ b/Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h
@@ -43,6 +43,11 @@ NAMESPACE_BEGIN(Grid);
 template<class Field>
 void basisOrthogonalize(std::vector<Field> &basis,Field &w,int k) 
 {
+  // If assume basis[j] are already orthonormal,
+  // can take all inner products in parallel saving 2x bandwidth
+  // Save 3x bandwidth on the second line of loop.
+  // perhaps 2.5x speed up.
+  // 2x overall in Multigrid Lanczos  
   for(int j=0; j<k; ++j){
     auto ip = innerProduct(basis[j],w);
     w = w - ip*basis[j];
@@ -54,16 +59,15 @@ void basisRotate(std::vector<Field> &basis,Eigen::MatrixXd& Qt,int j0, int j1, i
 {
   typedef decltype(basis[0].View()) View;
   auto tmp_v = basis[0].View();
-  std::vector<View> basis_v(basis.size(),tmp_v);
+  Vector<View> basis_v(basis.size(),tmp_v);
   typedef typename Field::vector_object vobj;
   GridBase* grid = basis[0].Grid();
-      
+
   for(int k=0;k<basis.size();k++){
     basis_v[k] = basis[k].View();
   }
-
+#if 0
   std::vector < vobj , commAllocator<vobj> > Bt(thread_max() * Nm); // Thread private
-
   thread_region
   {
     vobj* B = Bt.data() + Nm * thread_num();
@@ -81,24 +85,89 @@ void basisRotate(std::vector<Field> &basis,Eigen::MatrixXd& Qt,int j0, int j1, i
       }
     });
   }
+#else
+
+  int nrot = j1-j0;
+
+
+  uint64_t oSites   =grid->oSites();
+  uint64_t siteBlock=(grid->oSites()+nrot-1)/nrot; // Maximum 1 additional vector overhead
+
+  //  printf("BasisRotate %d %d nrot %d siteBlock %d\n",j0,j1,nrot,siteBlock);
+
+  Vector <vobj> Bt(siteBlock * nrot); 
+  auto Bp=&Bt[0];
+
+  // GPU readable copy of Eigen matrix
+  Vector<double> Qt_jv(Nm*Nm);
+  double *Qt_p = & Qt_jv[0];
+  for(int k=0;k<Nm;++k){
+    for(int j=0;j<Nm;++j){
+      Qt_p[j*Nm+k]=Qt(j,k);
+    }
+  }
+
+  // Block the loop to keep storage footprint down
+  vobj zz=Zero();
+  for(uint64_t s=0;s<oSites;s+=siteBlock){
+
+    // remaining work in this block
+    int ssites=MIN(siteBlock,oSites-s);
+
+    // zero out the accumulators
+    accelerator_for(ss,siteBlock*nrot,vobj::Nsimd(),{
+	auto z=coalescedRead(zz);
+	coalescedWrite(Bp[ss],z);
+    });
+
+    accelerator_for(sj,ssites*nrot,vobj::Nsimd(),{
+	
+      int j =sj%nrot;
+      int jj  =j0+j;
+      int ss =sj/nrot;
+      int sss=ss+s;
+
+      for(int k=k0; k<k1; ++k){
+	auto tmp = coalescedRead(Bp[ss*nrot+j]);
+	coalescedWrite(Bp[ss*nrot+j],tmp+ Qt_p[jj*Nm+k] * coalescedRead(basis_v[k][sss]));
+      }
+    });
+
+    accelerator_for(sj,ssites*nrot,vobj::Nsimd(),{
+      int j =sj%nrot;
+      int jj  =j0+j;
+      int ss =sj/nrot;
+      int sss=ss+s;
+      coalescedWrite(basis_v[jj][sss],coalescedRead(Bp[ss*nrot+j]));
+    });
+  }
+#endif
 }
 
 // Extract a single rotated vector
 template<class Field>
 void basisRotateJ(Field &result,std::vector<Field> &basis,Eigen::MatrixXd& Qt,int j, int k0,int k1,int Nm) 
 {
+  typedef decltype(basis[0].View()) View;
   typedef typename Field::vector_object vobj;
   GridBase* grid = basis[0].Grid();
 
   result.Checkerboard() = basis[0].Checkerboard();
   auto result_v=result.View();
-  thread_for(ss, grid->oSites(),{
-    vobj B = Zero();
+  Vector<View> basis_v(basis.size(),result_v);
+  for(int k=0;k<basis.size();k++){
+    basis_v[k] = basis[k].View();
+  }
+  vobj zz=Zero();
+  Vector<double> Qt_jv(Nm);
+  double * Qt_j = & Qt_jv[0];
+  for(int k=0;k<Nm;++k) Qt_j[k]=Qt(j,k);
+  accelerator_for(ss, grid->oSites(),vobj::Nsimd(),{
+    auto B=coalescedRead(zz);
     for(int k=k0; k<k1; ++k){
-      auto basis_k = basis[k].View();
-      B +=Qt(j,k) * basis_k[ss];
+      B +=Qt_j[k] * coalescedRead(basis_v[k][ss]);
     }
-    result_v[ss] = B;
+    coalescedWrite(result_v[ss], B);
   });
 }
 
@@ -282,7 +351,7 @@ public:
 			    RealD _eresid, // resid in lmdue deficit 
 			    int _MaxIter, // Max iterations
 			    RealD _betastp=0.0, // if beta(k) < betastp: converged
-			    int _MinRestart=1, int _orth_period = 1,
+			    int _MinRestart=0, int _orth_period = 1,
 			    IRLdiagonalisation _diagonalisation= IRLdiagonaliseWithEigen) :
     SimpleTester(HermOp), _PolyOp(PolyOp),      _HermOp(HermOp), _Tester(Tester),
     Nstop(_Nstop)  ,      Nk(_Nk),      Nm(_Nm),
@@ -298,7 +367,7 @@ public:
 			       RealD _eresid, // resid in lmdue deficit 
 			       int _MaxIter, // Max iterations
 			       RealD _betastp=0.0, // if beta(k) < betastp: converged
-			       int _MinRestart=1, int _orth_period = 1,
+			       int _MinRestart=0, int _orth_period = 1,
 			       IRLdiagonalisation _diagonalisation= IRLdiagonaliseWithEigen) :
     SimpleTester(HermOp),  _PolyOp(PolyOp),      _HermOp(HermOp), _Tester(SimpleTester),
     Nstop(_Nstop)  ,      Nk(_Nk),      Nm(_Nm),
@@ -347,7 +416,7 @@ until convergence
     GridBase *grid = src.Grid();
     assert(grid == evec[0].Grid());
     
-    GridLogIRL.TimingMode(1);
+    //    GridLogIRL.TimingMode(1);
     std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
     std::cout << GridLogIRL <<" ImplicitlyRestartedLanczos::calc() starting iteration 0 /  "<< MaxIter<< std::endl;
     std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
@@ -372,14 +441,17 @@ until convergence
     {
       auto src_n = src;
       auto tmp = src;
+      std::cout << GridLogIRL << " IRL source norm " << norm2(src) << std::endl;
       const int _MAX_ITER_IRL_MEVAPP_ = 50;
       for (int i=0;i<_MAX_ITER_IRL_MEVAPP_;i++) {
 	normalise(src_n);
 	_HermOp(src_n,tmp);
+	//	std::cout << GridLogMessage<< tmp<<std::endl; exit(0);
+	//	std::cout << GridLogIRL << " _HermOp " << norm2(tmp) << std::endl;
 	RealD vnum = real(innerProduct(src_n,tmp)); // HermOp.
 	RealD vden = norm2(src_n);
 	RealD na = vnum/vden;
-	if (fabs(evalMaxApprox/na - 1.0) < 0.05)
+	if (fabs(evalMaxApprox/na - 1.0) < 0.0001)
 	  i=_MAX_ITER_IRL_MEVAPP_;
 	evalMaxApprox = na;
 	std::cout << GridLogIRL << " Approximation of largest eigenvalue: " << evalMaxApprox << std::endl;
@@ -577,11 +649,11 @@ until convergence
 /* Saad PP. 195
 1. Choose an initial vector v1 of 2-norm unity. Set β1 ≡ 0, v0 ≡ 0
 2. For k = 1,2,...,m Do:
-3. wk:=Avk−βkv_{k−1}      
-4. αk:=(wk,vk)       // 
-5. wk:=wk−αkvk       // wk orthog vk 
-6. βk+1 := ∥wk∥2. If βk+1 = 0 then Stop
-7. vk+1 := wk/βk+1
+3. wk:=Avk - b_k v_{k-1}      
+4. ak:=(wk,vk)       // 
+5. wk:=wk-akvk       // wk orthog vk 
+6. bk+1 := ||wk||_2. If b_k+1 = 0 then Stop
+7. vk+1 := wk/b_k+1
 8. EndDo
  */
   void step(std::vector<RealD>& lmd,
@@ -589,6 +661,7 @@ until convergence
 	    std::vector<Field>& evec,
 	    Field& w,int Nm,int k)
   {
+    std::cout<<GridLogIRL << "Lanczos step " <<k<<std::endl;
     const RealD tiny = 1.0e-20;
     assert( k< Nm );
 
@@ -600,20 +673,20 @@ until convergence
 
     if(k>0) w -= lme[k-1] * evec[k-1];
 
-    ComplexD zalph = innerProduct(evec_k,w); // 4. αk:=(wk,vk)
+    ComplexD zalph = innerProduct(evec_k,w);
     RealD     alph = real(zalph);
 
-    w = w - alph * evec_k;// 5. wk:=wk−αkvk
+    w = w - alph * evec_k;
 
-    RealD beta = normalise(w); // 6. βk+1 := ∥wk∥2. If βk+1 = 0 then Stop
-    // 7. vk+1 := wk/βk+1
+    RealD beta = normalise(w); 
 
     lmd[k] = alph;
     lme[k] = beta;
 
-    if (k>0 && k % orth_period == 0) {
+    if ( (k>0) && ( (k % orth_period) == 0 )) {
+      std::cout<<GridLogIRL << "Orthogonalising " <<k<<std::endl;
       orthogonalize(w,evec,k); // orthonormalise
-      std::cout<<GridLogIRL << "Orthogonalised " <<std::endl;
+      std::cout<<GridLogIRL << "Orthogonalised " <<k<<std::endl;
     }
 
     if(k < Nm-1) evec[k+1] = w;
@@ -621,6 +694,8 @@ until convergence
     std::cout<<GridLogIRL << "alpha[" << k << "] = " << zalph << " beta[" << k << "] = "<<beta<<std::endl;
     if ( beta < tiny ) 
       std::cout<<GridLogIRL << " beta is tiny "<<beta<<std::endl;
+
+    std::cout<<GridLogIRL << "Lanczos step complete " <<k<<std::endl;
   }
 
   void diagonalize_Eigen(std::vector<RealD>& lmd, std::vector<RealD>& lme, 
diff --git a/Grid/algorithms/iterative/NormalEquations.h b/Grid/algorithms/iterative/NormalEquations.h
index 270b0115..c9c92777 100644
--- a/Grid/algorithms/iterative/NormalEquations.h
+++ b/Grid/algorithms/iterative/NormalEquations.h
@@ -33,26 +33,78 @@ NAMESPACE_BEGIN(Grid);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // Take a matrix and form an NE solver calling a Herm solver
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class NormalEquations : public OperatorFunction<Field>{
+template<class Field> class NormalEquations {
 private:
   SparseMatrixBase<Field> & _Matrix;
   OperatorFunction<Field> & _HermitianSolver;
-
+  LinearFunction<Field>   & _Guess;
 public:
 
   /////////////////////////////////////////////////////
   // Wrap the usual normal equations trick
   /////////////////////////////////////////////////////
-  NormalEquations(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver) 
-    :  _Matrix(Matrix), _HermitianSolver(HermitianSolver) {}; 
+ NormalEquations(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver,
+		 LinearFunction<Field> &Guess) 
+   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
 
   void operator() (const Field &in, Field &out){
  
     Field src(in.Grid());
+    Field tmp(in.Grid());
 
+    MdagMLinearOperator<SparseMatrixBase<Field>,Field> MdagMOp(_Matrix);
     _Matrix.Mdag(in,src);
-    _HermitianSolver(src,out);  // Mdag M out = Mdag in
+    _Guess(src,out);
+    _HermitianSolver(MdagMOp,src,out);  // Mdag M out = Mdag in
+
+  }     
+};
+
+template<class Field> class HPDSolver {
+private:
+  LinearOperatorBase<Field> & _Matrix;
+  OperatorFunction<Field> & _HermitianSolver;
+  LinearFunction<Field>   & _Guess;
+public:
+
+  /////////////////////////////////////////////////////
+  // Wrap the usual normal equations trick
+  /////////////////////////////////////////////////////
+ HPDSolver(LinearOperatorBase<Field> &Matrix,
+	   OperatorFunction<Field> &HermitianSolver,
+	   LinearFunction<Field> &Guess) 
+   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
+
+  void operator() (const Field &in, Field &out){
  
+    _Guess(in,out);
+    _HermitianSolver(_Matrix,in,out);  // Mdag M out = Mdag in
+
+  }     
+};
+
+
+template<class Field> class MdagMSolver {
+private:
+  SparseMatrixBase<Field> & _Matrix;
+  OperatorFunction<Field> & _HermitianSolver;
+  LinearFunction<Field>   & _Guess;
+public:
+
+  /////////////////////////////////////////////////////
+  // Wrap the usual normal equations trick
+  /////////////////////////////////////////////////////
+ MdagMSolver(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver,
+	     LinearFunction<Field> &Guess) 
+   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
+
+  void operator() (const Field &in, Field &out){
+ 
+    MdagMLinearOperator<SparseMatrixBase<Field>,Field> MdagMOp(_Matrix);
+    _Guess(in,out);
+
+    _HermitianSolver(MdagMOp,in,out);  // Mdag M out = Mdag in
+
   }     
 };
 
diff --git a/Grid/algorithms/iterative/PowerMethod.h b/Grid/algorithms/iterative/PowerMethod.h
index 8a238ea6..6aa8e923 100644
--- a/Grid/algorithms/iterative/PowerMethod.h
+++ b/Grid/algorithms/iterative/PowerMethod.h
@@ -30,12 +30,12 @@ template<class Field> class PowerMethod
       RealD vden = norm2(src_n); 
       RealD na = vnum/vden; 
       
-      if ( (fabs(evalMaxApprox/na - 1.0) < 0.01) || (i==_MAX_ITER_EST_-1) ) { 
+      if ( (fabs(evalMaxApprox/na - 1.0) < 0.001) || (i==_MAX_ITER_EST_-1) ) { 
  	evalMaxApprox = na; 
+	std::cout << GridLogMessage << " Approximation of largest eigenvalue: " << evalMaxApprox << std::endl;
  	return evalMaxApprox; 
       } 
       evalMaxApprox = na; 
-      std::cout << GridLogMessage << " Approximation of largest eigenvalue: " << evalMaxApprox << std::endl;
       src_n = tmp;
     }
     assert(0);
diff --git a/Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h b/Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h
index d3188ecb..bf454ade 100644
--- a/Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h
+++ b/Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h
@@ -38,10 +38,11 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 NAMESPACE_BEGIN(Grid);
 
+#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< " Level "<<level<<" " 
+
 template<class Field>
-class PrecGeneralisedConjugateResidual : public OperatorFunction<Field> {
+class PrecGeneralisedConjugateResidual : public LinearFunction<Field> {
 public:                                                
-  using OperatorFunction<Field>::operator();
 
   RealD   Tolerance;
   Integer MaxIterations;
@@ -49,23 +50,29 @@ public:
   int mmax;
   int nstep;
   int steps;
+  int level;
   GridStopWatch PrecTimer;
   GridStopWatch MatTimer;
   GridStopWatch LinalgTimer;
 
-  LinearFunction<Field> &Preconditioner;
+  LinearFunction<Field>     &Preconditioner;
+  LinearOperatorBase<Field> &Linop;
 
-  PrecGeneralisedConjugateResidual(RealD tol,Integer maxit,LinearFunction<Field> &Prec,int _mmax,int _nstep) : 
+  void Level(int lv) { level=lv; };
+
+  PrecGeneralisedConjugateResidual(RealD tol,Integer maxit,LinearOperatorBase<Field> &_Linop,LinearFunction<Field> &Prec,int _mmax,int _nstep) : 
     Tolerance(tol), 
     MaxIterations(maxit),
+    Linop(_Linop),
     Preconditioner(Prec),
     mmax(_mmax),
     nstep(_nstep)
   { 
+    level=1;
     verbose=1;
   };
 
-  void operator() (LinearOperatorBase<Field> &Linop,const Field &src, Field &psi){
+  void operator() (const Field &src, Field &psi){
 
     psi=Zero();
     RealD cp, ssq,rsq;
@@ -84,9 +91,9 @@ public:
     steps=0;
     for(int k=0;k<MaxIterations;k++){
 
-      cp=GCRnStep(Linop,src,psi,rsq);
+      cp=GCRnStep(src,psi,rsq);
 
-      std::cout<<GridLogMessage<<"VPGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<cp<<" target "<<rsq <<std::endl;
+      GCRLogLevel <<"PGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<cp<<" target "<<rsq <<std::endl;
 
       if(cp<rsq) {
 
@@ -95,24 +102,26 @@ public:
 	Linop.HermOp(psi,r);
 	axpy(r,-1.0,src,r);
 	RealD tr = norm2(r);
-	std::cout<<GridLogMessage<<"PrecGeneralisedConjugateResidual: Converged on iteration " <<steps
+	GCRLogLevel<<"PGCR: Converged on iteration " <<steps
 		 << " computed residual "<<sqrt(cp/ssq)
 		 << " true residual "    <<sqrt(tr/ssq)
 		 << " target "           <<Tolerance <<std::endl;
 
-	std::cout<<GridLogMessage<<"VPGCR Time elapsed: Total  "<< SolverTimer.Elapsed() <<std::endl;
-	std::cout<<GridLogMessage<<"VPGCR Time elapsed: Precon "<<   PrecTimer.Elapsed() <<std::endl;
-	std::cout<<GridLogMessage<<"VPGCR Time elapsed: Matrix "<<    MatTimer.Elapsed() <<std::endl;
-	std::cout<<GridLogMessage<<"VPGCR Time elapsed: Linalg "<< LinalgTimer.Elapsed() <<std::endl;
+	GCRLogLevel<<"PGCR Time elapsed: Total  "<< SolverTimer.Elapsed() <<std::endl;
+	/*
+	  GCRLogLevel<<"PGCR Time elapsed: Precon "<<   PrecTimer.Elapsed() <<std::endl;
+	  GCRLogLevel<<"PGCR Time elapsed: Matrix "<<    MatTimer.Elapsed() <<std::endl;
+	  GCRLogLevel<<"PGCR Time elapsed: Linalg "<< LinalgTimer.Elapsed() <<std::endl;
+	*/
 	return;
       }
 
     }
-    std::cout<<GridLogMessage<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    assert(0);
+    GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
+    //    assert(0);
   }
 
-  RealD GCRnStep(LinearOperatorBase<Field> &Linop,const Field &src, Field &psi,RealD rsq){
+  RealD GCRnStep(const Field &src, Field &psi,RealD rsq){
 
     RealD cp;
     RealD a, b;
@@ -134,9 +143,7 @@ public:
     std::vector<Field> p(mmax,grid);
     std::vector<RealD> qq(mmax);
       
-    std::cout<<GridLogIterative<< " ************** "<< std::endl;
-    std::cout<<GridLogIterative<< "   GCRnStep("<<nstep<<")"<<std::endl;
-    std::cout<<GridLogIterative<< " ************** "<< std::endl;
+    GCRLogLevel<< "PGCR nStep("<<nstep<<")"<<std::endl;
 
     //////////////////////////////////
     // initial guess x0 is taken as nonzero.
@@ -150,35 +157,15 @@ public:
     LinalgTimer.Start();
     r=src-Az;
     LinalgTimer.Stop();
-    std::cout<<GridLogIterative<< " GCRnStep true residual r = src - A psi   "<<norm2(r) <<std::endl;
+    GCRLogLevel<< "PGCR true residual r = src - A psi   "<<norm2(r) <<std::endl;
     
     /////////////////////
     // p = Prec(r)
     /////////////////////
 
-    std::cout<<GridLogIterative<< " GCRnStep apply preconditioner z= M^-1 r "<< std::endl;
-    std::cout<<GridLogIterative<< " --------------------------------------- "<< std::endl;
     PrecTimer.Start();
     Preconditioner(r,z);
     PrecTimer.Stop();
-    std::cout<<GridLogIterative<< " --------------------------------------- "<< std::endl;
-    std::cout<<GridLogIterative<< " GCRnStep called Preconditioner z "<< norm2(z) <<std::endl;
-
-    //    MatTimer.Start();
-    //    Linop.HermOp(z,tmp); 
-    //    MatTimer.Stop();
-
-    //    LinalgTimer.Start();
-    //    ttmp=tmp;
-    //    tmp=tmp-r;
-    //    LinalgTimer.Stop();
-
-    /*
-      std::cout<<GridLogMessage<<r<<std::endl;
-      std::cout<<GridLogMessage<<z<<std::endl;
-      std::cout<<GridLogMessage<<ttmp<<std::endl;
-      std::cout<<GridLogMessage<<tmp<<std::endl;
-    */
 
     MatTimer.Start();
     Linop.HermOpAndNorm(z,Az,zAz,zAAz); 
@@ -190,7 +177,6 @@ public:
     p[0]= z;
     q[0]= Az;
     qq[0]= zAAz;
-    std::cout<<GridLogIterative<< " GCRnStep p0=z, q0 = A p0 " <<std::endl;
     
     cp =norm2(r);
     LinalgTimer.Stop();
@@ -212,20 +198,16 @@ public:
       cp = axpy_norm(r,-a,q[peri_k],r);
       LinalgTimer.Stop();
 
-      std::cout<<GridLogMessage<< " VPGCR_step["<<steps<<"]  resid " << cp << " target " <<rsq<<std::endl; 
+      GCRLogLevel<< "PGCR step["<<steps<<"]  resid " << cp << " target " <<rsq<<std::endl; 
 
       if((k==nstep-1)||(cp<rsq)){
 	return cp;
       }
 
 
-      std::cout<<GridLogIterative<< " GCRnStep apply preconditioner z= M^-1 r "<< std::endl;
-      std::cout<<GridLogIterative<< " --------------------------------------- "<< std::endl;
       PrecTimer.Start();
       Preconditioner(r,z);// solve Az = r
       PrecTimer.Stop();
-      std::cout<<GridLogIterative<< " --------------------------------------- "<< std::endl;
-      std::cout<<GridLogIterative<< " GCRnStep called Preconditioner z "<< norm2(z) <<std::endl;
 
       MatTimer.Start();
       Linop.HermOpAndNorm(z,Az,zAz,zAAz);
diff --git a/Grid/algorithms/iterative/SchurRedBlack.h b/Grid/algorithms/iterative/SchurRedBlack.h
index dd8a14b6..d0b133a3 100644
--- a/Grid/algorithms/iterative/SchurRedBlack.h
+++ b/Grid/algorithms/iterative/SchurRedBlack.h
@@ -405,6 +405,70 @@ namespace Grid {
     }
   };
 
+  template<class Field> class NonHermitianSchurRedBlackDiagMooeeSolve : public SchurRedBlackBase<Field> 
+  {
+    public:
+      typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
+
+      NonHermitianSchurRedBlackDiagMooeeSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
+          const bool _solnAsInitGuess = false)  
+      : SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
+
+      //////////////////////////////////////////////////////
+      // Override RedBlack specialisation
+      //////////////////////////////////////////////////////
+      virtual void RedBlackSource(Matrix& _Matrix, const Field& src, Field& src_e, Field& src_o)
+      {
+        GridBase* grid  = _Matrix.RedBlackGrid();
+        GridBase* fgrid = _Matrix.Grid();
+
+        Field  tmp(grid);
+        Field Mtmp(grid);
+
+        pickCheckerboard(Even, src_e, src);
+        pickCheckerboard(Odd , src_o, src);
+
+        /////////////////////////////////////////////////////
+        // src_o = Mdag * (source_o - Moe MeeInv source_e)
+        /////////////////////////////////////////////////////
+        _Matrix.MooeeInv(src_e, tmp);   assert(   tmp.Checkerboard() == Even );
+        _Matrix.Meooe   (tmp, Mtmp);    assert(  Mtmp.Checkerboard() == Odd  );     
+        src_o -= Mtmp;                  assert( src_o.Checkerboard() == Odd  );     
+      }
+      
+      virtual void RedBlackSolution(Matrix& _Matrix, const Field& sol_o, const Field& src_e, Field& sol)
+      {
+        GridBase* grid  = _Matrix.RedBlackGrid();
+        GridBase* fgrid = _Matrix.Grid();
+
+        Field     tmp(grid);
+        Field   sol_e(grid);
+        Field src_e_i(grid);
+        
+        ///////////////////////////////////////////////////
+        // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
+        ///////////////////////////////////////////////////
+        _Matrix.Meooe(sol_o, tmp);         assert(     tmp.Checkerboard() == Even );
+        src_e_i = src_e - tmp;             assert( src_e_i.Checkerboard() == Even );
+        _Matrix.MooeeInv(src_e_i, sol_e);  assert(   sol_e.Checkerboard() == Even );
+       
+        setCheckerboard(sol, sol_e); assert( sol_e.Checkerboard() == Even );
+        setCheckerboard(sol, sol_o); assert( sol_o.Checkerboard() == Odd  );
+      }
+
+      virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
+      {
+        NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
+        this->_HermitianRBSolver(_OpEO, src_o, sol_o);  assert(sol_o.Checkerboard() == Odd);
+      }
+
+      virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o, std::vector<Field>& sol_o)
+      {
+        NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
+        this->_HermitianRBSolver(_OpEO, src_o, sol_o); 
+      }
+  };
+
   ///////////////////////////////////////////////////////////////////////////////////////////////////////
   // Site diagonal is identity, right preconditioned by Mee^inv
   // ( 1 - Meo Moo^inv Moe Mee^inv  ) phi =( 1 - Meo Moo^inv Moe Mee^inv  ) Mee psi =  = eta  = eta
@@ -482,5 +546,76 @@ namespace Grid {
       this->_HermitianRBSolver(_HermOpEO,src_o,sol_o); 
     }
   };
+
+  template<class Field> class NonHermitianSchurRedBlackDiagTwoSolve : public SchurRedBlackBase<Field> 
+  {
+    public:
+      typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
+
+      /////////////////////////////////////////////////////
+      // Wrap the usual normal equations Schur trick
+      /////////////////////////////////////////////////////
+      NonHermitianSchurRedBlackDiagTwoSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
+          const bool _solnAsInitGuess = false)  
+      : SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
+
+      virtual void RedBlackSource(Matrix& _Matrix, const Field& src, Field& src_e, Field& src_o)
+      {
+        GridBase* grid  = _Matrix.RedBlackGrid();
+        GridBase* fgrid = _Matrix.Grid();
+
+        Field  tmp(grid);
+        Field Mtmp(grid);
+
+        pickCheckerboard(Even, src_e, src);
+        pickCheckerboard(Odd , src_o, src);
+      
+        /////////////////////////////////////////////////////
+        // src_o = Mdag * (source_o - Moe MeeInv source_e)
+        /////////////////////////////////////////////////////
+        _Matrix.MooeeInv(src_e, tmp);   assert(   tmp.Checkerboard() == Even );
+        _Matrix.Meooe   (tmp, Mtmp);    assert(  Mtmp.Checkerboard() == Odd  );     
+        src_o -= Mtmp;                  assert( src_o.Checkerboard() == Odd  );     
+      }
+
+      virtual void RedBlackSolution(Matrix& _Matrix, const Field& sol_o, const Field& src_e, Field& sol)
+      {
+        GridBase* grid  = _Matrix.RedBlackGrid();
+        GridBase* fgrid = _Matrix.Grid();
+
+        Field sol_o_i(grid);
+        Field     tmp(grid);
+        Field   sol_e(grid);
+
+        ////////////////////////////////////////////////
+        // MooeeInv due to pecond
+        ////////////////////////////////////////////////
+        _Matrix.MooeeInv(sol_o, tmp);
+        sol_o_i = tmp;
+
+        ///////////////////////////////////////////////////
+        // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
+        ///////////////////////////////////////////////////
+        _Matrix.Meooe(sol_o_i, tmp);    assert(   tmp.Checkerboard() == Even );
+        tmp = src_e - tmp;              assert( src_e.Checkerboard() == Even );
+        _Matrix.MooeeInv(tmp, sol_e);   assert( sol_e.Checkerboard() == Even );
+       
+        setCheckerboard(sol, sol_e);    assert(   sol_e.Checkerboard() == Even );
+        setCheckerboard(sol, sol_o_i);  assert( sol_o_i.Checkerboard() == Odd  );
+      };
+
+      virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
+      {
+        NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
+        this->_HermitianRBSolver(_OpEO, src_o, sol_o);
+      };
+
+      virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o,  std::vector<Field>& sol_o)
+      {
+        NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
+        this->_HermitianRBSolver(_OpEO, src_o, sol_o); 
+      }
+  };
 }
+
 #endif
diff --git a/Grid/allocator/AlignedAllocator.cc b/Grid/allocator/AlignedAllocator.cc
index ed27a8bd..d53c4dc2 100644
--- a/Grid/allocator/AlignedAllocator.cc
+++ b/Grid/allocator/AlignedAllocator.cc
@@ -6,6 +6,12 @@ NAMESPACE_BEGIN(Grid);
 MemoryStats *MemoryProfiler::stats = nullptr;
 bool         MemoryProfiler::debug = false;
 
+#ifdef GRID_NVCC
+#define SMALL_LIMIT (0)
+#else
+#define SMALL_LIMIT (4096)
+#endif
+
 #ifdef POINTER_CACHE
 int PointerCache::victim;
 
@@ -13,7 +19,7 @@ PointerCache::PointerCacheEntry PointerCache::Entries[PointerCache::Ncache];
 
 void *PointerCache::Insert(void *ptr,size_t bytes) {
 
-  if (bytes < 4096 ) return ptr;
+  if (bytes < SMALL_LIMIT ) return ptr;
 
 #ifdef GRID_OMP
   assert(omp_in_parallel()==0);
@@ -50,7 +56,7 @@ void *PointerCache::Insert(void *ptr,size_t bytes) {
 
 void *PointerCache::Lookup(size_t bytes) {
 
-  if (bytes < 4096 ) return NULL;
+  if (bytes < SMALL_LIMIT ) return NULL;
 
 #ifdef GRID_OMP
   assert(omp_in_parallel()==0);
diff --git a/Grid/allocator/AlignedAllocator.h b/Grid/allocator/AlignedAllocator.h
index 2aa7d82b..8c189be8 100644
--- a/Grid/allocator/AlignedAllocator.h
+++ b/Grid/allocator/AlignedAllocator.h
@@ -49,8 +49,13 @@ NAMESPACE_BEGIN(Grid);
 #ifdef POINTER_CACHE
 class PointerCache {
 private:
-
+/*Pinning pages is costly*/
+/*Could maintain separate large and small allocation caches*/
+#ifdef GRID_NVCC 
+  static const int Ncache=128;
+#else
   static const int Ncache=8;
+#endif
   static int victim;
 
   typedef struct { 
@@ -63,7 +68,6 @@ private:
 
 public:
 
-
   static void *Insert(void *ptr,size_t bytes) ;
   static void *Lookup(size_t bytes) ;
 
@@ -170,13 +174,14 @@ public:
     // Unified (managed) memory
     ////////////////////////////////////
     if ( ptr == (_Tp *) NULL ) {
+      //      printf(" alignedAllocater cache miss %ld bytes ",bytes);      BACKTRACEFP(stdout);
       auto err = cudaMallocManaged((void **)&ptr,bytes);
       if( err != cudaSuccess ) {
 	ptr = (_Tp *) NULL;
 	std::cerr << " cudaMallocManaged failed for " << bytes<<" bytes " <<cudaGetErrorString(err)<< std::endl;
 	assert(0);
       }
-    }
+    } 
     assert( ptr != (_Tp *)NULL);
 #else 
     //////////////////////////////////////////////////////////////////////////////////////////
diff --git a/Grid/cartesian/Cartesian_base.h b/Grid/cartesian/Cartesian_base.h
index 76abe0ee..87472cc9 100644
--- a/Grid/cartesian/Cartesian_base.h
+++ b/Grid/cartesian/Cartesian_base.h
@@ -47,20 +47,19 @@ public:
   // Give Lattice access
   template<class object> friend class Lattice;
 
-  GridBase(const Coordinate & processor_grid) : CartesianCommunicator(processor_grid) {}; 
+  GridBase(const Coordinate & processor_grid) : CartesianCommunicator(processor_grid) { LocallyPeriodic=0;}; 
 
   GridBase(const Coordinate & processor_grid,
 	   const CartesianCommunicator &parent,
 	   int &split_rank) 
-    : CartesianCommunicator(processor_grid,parent,split_rank) {};
+    : CartesianCommunicator(processor_grid,parent,split_rank) {LocallyPeriodic=0;};
 
   GridBase(const Coordinate & processor_grid,
 	   const CartesianCommunicator &parent) 
-    : CartesianCommunicator(processor_grid,parent,dummy) {};
+    : CartesianCommunicator(processor_grid,parent,dummy) {LocallyPeriodic=0;};
 
   virtual ~GridBase() = default;
 
-
   // Physics Grid information.
   Coordinate _simd_layout;// Which dimensions get relayed out over simd lanes.
   Coordinate _fdimensions;// (full) Global dimensions of array prior to cb removal
@@ -80,7 +79,8 @@ public:
   Coordinate _lstart;     // local start of array in gcoors _processor_coor[d]*_ldimensions[d]
   Coordinate _lend  ;     // local end of array in gcoors   _processor_coor[d]*_ldimensions[d]+_ldimensions_[d]-1
 
-    bool _isCheckerBoarded; 
+  bool _isCheckerBoarded; 
+  int        LocallyPeriodic;
 
 public:
 
diff --git a/Grid/lattice/Lattice_base.h b/Grid/lattice/Lattice_base.h
index 0b9b9b56..ec7c54ec 100644
--- a/Grid/lattice/Lattice_base.h
+++ b/Grid/lattice/Lattice_base.h
@@ -173,6 +173,7 @@ public:
   ///////////////////////////////////////////////////
   typedef typename vobj::scalar_type scalar_type;
   typedef typename vobj::vector_type vector_type;
+  typedef typename vobj::scalar_object scalar_object;
   typedef vobj vector_object;
 
 private:
diff --git a/Grid/lattice/Lattice_coordinate.h b/Grid/lattice/Lattice_coordinate.h
index 16f3641b..a1abe58d 100644
--- a/Grid/lattice/Lattice_coordinate.h
+++ b/Grid/lattice/Lattice_coordinate.h
@@ -37,19 +37,18 @@ template<class iobj> inline void LatticeCoordinate(Lattice<iobj> &l,int mu)
   GridBase *grid = l.Grid();
   int Nsimd = grid->iSites();
 
-  Coordinate gcoor;
-  ExtractBuffer<scalar_type> mergebuf(Nsimd);
-
-  vector_type vI;
   auto l_v = l.View();
-  for(int o=0;o<grid->oSites();o++){
+  thread_for( o, grid->oSites(), {
+    vector_type vI;
+    Coordinate gcoor;
+    ExtractBuffer<scalar_type> mergebuf(Nsimd);
     for(int i=0;i<grid->iSites();i++){
       grid->RankIndexToGlobalCoor(grid->ThisRank(),o,i,gcoor);
       mergebuf[i]=(Integer)gcoor[mu];
     }
     merge<vector_type,scalar_type>(vI,mergebuf);
     l_v[o]=vI;
-  }
+  });
 };
 
 // LatticeCoordinate();
diff --git a/Grid/lattice/Lattice_peekpoke.h b/Grid/lattice/Lattice_peekpoke.h
index c3e7e931..feca2f44 100644
--- a/Grid/lattice/Lattice_peekpoke.h
+++ b/Grid/lattice/Lattice_peekpoke.h
@@ -156,7 +156,7 @@ void peekSite(sobj &s,const Lattice<vobj> &l,const Coordinate &site){
 // Peek a scalar object from the SIMD array
 //////////////////////////////////////////////////////////
 template<class vobj,class sobj>
-void peekLocalSite(sobj &s,const Lattice<vobj> &l,Coordinate &site){
+accelerator_inline void peekLocalSite(sobj &s,const Lattice<vobj> &l,Coordinate &site){
         
   GridBase *grid = l.Grid();
 
@@ -185,7 +185,7 @@ void peekLocalSite(sobj &s,const Lattice<vobj> &l,Coordinate &site){
 };
 
 template<class vobj,class sobj>
-void pokeLocalSite(const sobj &s,Lattice<vobj> &l,Coordinate &site){
+accelerator_inline void pokeLocalSite(const sobj &s,Lattice<vobj> &l,Coordinate &site){
 
   GridBase *grid=l.Grid();
 
diff --git a/Grid/lattice/Lattice_transfer.h b/Grid/lattice/Lattice_transfer.h
index 865a4b14..c80e7db2 100644
--- a/Grid/lattice/Lattice_transfer.h
+++ b/Grid/lattice/Lattice_transfer.h
@@ -1,5 +1,4 @@
 /*************************************************************************************
-
     Grid physics library, www.github.com/paboyle/Grid 
 
     Source file: ./lib/lattice/Lattice_transfer.h
@@ -83,12 +82,35 @@ template<class vobj> inline void setCheckerboard(Lattice<vobj> &full,const Latti
   });
 }
   
-
 template<class vobj,class CComplex,int nbasis>
 inline void blockProject(Lattice<iVector<CComplex,nbasis > > &coarseData,
+			  const             Lattice<vobj>   &fineData,
+			  const std::vector<Lattice<vobj> > &Basis)
+{
+  GridBase * fine  = fineData.Grid();
+  GridBase * coarse= coarseData.Grid();
+
+  Lattice<CComplex> ip(coarse); 
+
+  //  auto fineData_   = fineData.View();
+  auto coarseData_ = coarseData.View();
+  auto ip_         = ip.View();
+  for(int v=0;v<nbasis;v++) {
+    blockInnerProduct(ip,Basis[v],fineData);
+    accelerator_for( sc, coarse->oSites(), vobj::Nsimd(), {
+	coalescedWrite(coarseData_[sc](v),ip_(sc));
+      });
+  }
+}
+
+template<class vobj,class CComplex,int nbasis>
+inline void blockProject1(Lattice<iVector<CComplex,nbasis > > &coarseData,
 			 const             Lattice<vobj>   &fineData,
 			 const std::vector<Lattice<vobj> > &Basis)
 {
+  typedef iVector<CComplex,nbasis > coarseSiteData;
+  coarseSiteData elide;
+  typedef decltype(coalescedRead(elide)) ScalarComplex;
   GridBase * fine  = fineData.Grid();
   GridBase * coarse= coarseData.Grid();
   int  _ndimension = coarse->_ndimension;
@@ -106,26 +128,40 @@ inline void blockProject(Lattice<iVector<CComplex,nbasis > > &coarseData,
     block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
     assert(block_r[d]*coarse->_rdimensions[d] == fine->_rdimensions[d]);
   }
+  int blockVol = fine->oSites()/coarse->oSites();
 
   coarseData=Zero();
 
   auto fineData_   = fineData.View();
   auto coarseData_ = coarseData.View();
-  // Loop over coars parallel, and then loop over fine associated with coarse.
-  thread_for( sf, fine->oSites(), {
-    int sc;
-    Coordinate coor_c(_ndimension);
-    Coordinate coor_f(_ndimension);
-    Lexicographic::CoorFromIndex(coor_f,sf,fine->_rdimensions);
-    for(int d=0;d<_ndimension;d++) coor_c[d]=coor_f[d]/block_r[d];
-    Lexicographic::IndexFromCoor(coor_c,sc,coarse->_rdimensions);
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////
+  // To make this lock free, loop over coars parallel, and then loop over fine associated with coarse.
+  // Otherwise do fine inner product per site, and make the update atomic
+  ////////////////////////////////////////////////////////////////////////////////////////////////////////
+  accelerator_for( sci, nbasis*coarse->oSites(), vobj::Nsimd(), {
 
-    thread_critical {
-      for(int i=0;i<nbasis;i++) {
-	auto Basis_      = Basis[i].View();
-	coarseData_[sc](i)=coarseData_[sc](i) + innerProduct(Basis_[sf],fineData_[sf]);
-      }
+    auto sc=sci/nbasis;
+    auto i=sci%nbasis;
+    auto Basis_      = Basis[i].View();
+
+    Coordinate coor_c(_ndimension);
+    Lexicographic::CoorFromIndex(coor_c,sc,coarse->_rdimensions);  // Block coordinate
+
+    int sf;
+    decltype(innerProduct(Basis_(sf),fineData_(sf))) reduce=Zero();
+
+    for(int sb=0;sb<blockVol;sb++){
+
+      Coordinate coor_b(_ndimension);
+      Coordinate coor_f(_ndimension);
+
+      Lexicographic::CoorFromIndex(coor_b,sb,block_r);
+      for(int d=0;d<_ndimension;d++) coor_f[d]=coor_c[d]*block_r[d]+coor_b[d];
+      Lexicographic::IndexFromCoor(coor_f,sf,fine->_rdimensions);
+      
+      reduce=reduce+innerProduct(Basis_(sf),fineData_(sf));
     }
+    coalescedWrite(coarseData_[sc](i),reduce);
   });
   return;
 }
@@ -160,7 +196,7 @@ inline void blockZAXPY(Lattice<vobj> &fineZ,
   auto fineY_  = fineY.View();
   auto coarseA_= coarseA.View();
 
-  thread_for(sf, fine->oSites(), {
+  accelerator_for(sf, fine->oSites(), CComplex::Nsimd(), {
     
     int sc;
     Coordinate coor_c(_ndimension);
@@ -171,7 +207,7 @@ inline void blockZAXPY(Lattice<vobj> &fineZ,
     Lexicographic::IndexFromCoor(coor_c,sc,coarse->_rdimensions);
 
     // z = A x + y
-    fineZ_[sf]=coarseA_[sc]*fineX_[sf]+fineY_[sf];
+    coalescedWrite(fineZ_[sf],coarseA_(sc)*fineX_(sf)+fineY_(sf));
 
   });
 
@@ -196,7 +232,7 @@ inline void blockInnerProduct(Lattice<CComplex> &CoarseInner,
 
   fine_inner = localInnerProduct(fineX,fineY);
   blockSum(coarse_inner,fine_inner);
-  thread_for(ss, coarse->oSites(),{
+  accelerator_for(ss, coarse->oSites(), 1, {
     CoarseInner_[ss] = coarse_inner_[ss];
   });
 }
@@ -226,23 +262,29 @@ inline void blockSum(Lattice<vobj> &coarseData,const Lattice<vobj> &fineData)
   for(int d=0 ; d<_ndimension;d++){
     block_r[d] = fine->_rdimensions[d] / coarse->_rdimensions[d];
   }
+  int blockVol = fine->oSites()/coarse->oSites();
 
   // Turn this around to loop threaded over sc and interior loop 
   // over sf would thread better
-  coarseData=Zero();
   auto coarseData_ = coarseData.View();
   auto fineData_   = fineData.View();
 
-  thread_for(sf,fine->oSites(),{
-    int sc;
+  accelerator_for(sc,coarse->oSites(),1,{
+
+    // One thread per sub block
     Coordinate coor_c(_ndimension);
-    Coordinate coor_f(_ndimension);
-    
-    Lexicographic::CoorFromIndex(coor_f,sf,fine->_rdimensions);
-    for(int d=0;d<_ndimension;d++) coor_c[d]=coor_f[d]/block_r[d];
-    Lexicographic::IndexFromCoor(coor_c,sc,coarse->_rdimensions);
-    
-    thread_critical { 
+    Lexicographic::CoorFromIndex(coor_c,sc,coarse->_rdimensions);  // Block coordinate
+    coarseData_[sc]=Zero();
+
+    for(int sb=0;sb<blockVol;sb++){
+      
+      int sf;
+      Coordinate coor_b(_ndimension);
+      Coordinate coor_f(_ndimension);
+      Lexicographic::CoorFromIndex(coor_b,sb,block_r);               // Block sub coordinate
+      for(int d=0;d<_ndimension;d++) coor_f[d]=coor_c[d]*block_r[d] + coor_b[d];
+      Lexicographic::IndexFromCoor(coor_f,sf,fine->_rdimensions);
+
       coarseData_[sc]=coarseData_[sc]+fineData_[sf];
     }
 
@@ -296,6 +338,7 @@ inline void blockOrthogonalise(Lattice<CComplex> &ip,std::vector<Lattice<vobj> >
   }
 }
 
+#if 0
 template<class vobj,class CComplex,int nbasis>
 inline void blockPromote(const Lattice<iVector<CComplex,nbasis > > &coarseData,
 			 Lattice<vobj>   &fineData,
@@ -321,7 +364,7 @@ inline void blockPromote(const Lattice<iVector<CComplex,nbasis > > &coarseData,
   auto coarseData_ = coarseData.View();
 
   // Loop with a cache friendly loop ordering
-  thread_for(sf,fine->oSites(),{
+  accelerator_for(sf,fine->oSites(),1,{
     int sc;
     Coordinate coor_c(_ndimension);
     Coordinate coor_f(_ndimension);
@@ -332,13 +375,35 @@ inline void blockPromote(const Lattice<iVector<CComplex,nbasis > > &coarseData,
 
     for(int i=0;i<nbasis;i++) {
       auto basis_ = Basis[i].View();
-      if(i==0) fineData_[sf]=coarseData_[sc](i) *basis_[sf];
-      else     fineData_[sf]=fineData_[sf]+coarseData_[sc](i)*basis_[sf];
+      if(i==0) fineData_[sf]=coarseData_[sc](i) *basis_[sf]);
+      else     fineData_[sf]=fineData_[sf]+coarseData_[sc](i)*basis_[sf]);
     }
   });
   return;
   
 }
+#else
+template<class vobj,class CComplex,int nbasis>
+inline void blockPromote(const Lattice<iVector<CComplex,nbasis > > &coarseData,
+			 Lattice<vobj>   &fineData,
+			 const std::vector<Lattice<vobj> > &Basis)
+{
+  GridBase * fine  = fineData.Grid();
+  GridBase * coarse= coarseData.Grid();
+
+  fineData=Zero();
+  for(int i=0;i<nbasis;i++) {
+    Lattice<iScalar<CComplex> > ip = PeekIndex<0>(coarseData,i);
+    Lattice<CComplex> cip(coarse);
+    auto cip_ = cip.View();
+    auto  ip_ =  ip.View();
+    accelerator_forNB(sc,coarse->oSites(),CComplex::Nsimd(),{
+	coalescedWrite(cip_[sc], ip_(sc)());
+    });
+    blockZAXPY<vobj,CComplex >(fineData,cip,Basis[i],fineData);
+  }
+}
+#endif
 
 // Useful for precision conversion, or indeed anything where an operator= does a conversion on scalars.
 // Simd layouts need not match since we use peek/poke Local
@@ -374,6 +439,67 @@ void localConvert(const Lattice<vobj> &in,Lattice<vvobj> &out)
   });
 }
 
+template<class vobj>
+void localCopyRegion(const Lattice<vobj> &From,Lattice<vobj> & To,Coordinate FromLowerLeft, Coordinate ToLowerLeft, Coordinate RegionSize)
+{
+  typedef typename vobj::scalar_object sobj;
+  typedef typename vobj::scalar_type scalar_type;
+  typedef typename vobj::vector_type vector_type;
+
+  static const int words=sizeof(vobj)/sizeof(vector_type);
+
+  GridBase *Fg = From.Grid();
+  GridBase *Tg = To.Grid();
+  assert(!Fg->_isCheckerBoarded);
+  assert(!Tg->_isCheckerBoarded);
+  int Nsimd = Fg->Nsimd();
+  int nF = Fg->_ndimension;
+  int nT = Tg->_ndimension;
+  int nd = nF;
+  assert(nF == nT);
+
+  for(int d=0;d<nd;d++){
+    assert(Fg->_processors[d]  == Tg->_processors[d]);
+  }
+
+  // the above should guarantee that the operations are local
+  Coordinate ldf = Fg->_ldimensions;
+  Coordinate rdf = Fg->_rdimensions;
+  Coordinate isf = Fg->_istride;
+  Coordinate osf = Fg->_ostride;
+  Coordinate rdt = Tg->_rdimensions;
+  Coordinate ist = Tg->_istride;
+  Coordinate ost = Tg->_ostride;
+  auto t_v = To.View();
+  auto f_v = From.View();
+  accelerator_for(idx,Fg->lSites(),1,{
+    sobj s;
+    Coordinate Fcoor(nd);
+    Coordinate Tcoor(nd);
+    Lexicographic::CoorFromIndex(Fcoor,idx,ldf);
+    int in_region=1;
+    for(int d=0;d<nd;d++){
+      if ( (Fcoor[d] < FromLowerLeft[d]) || (Fcoor[d]>=FromLowerLeft[d]+RegionSize[d]) ){ 
+	in_region=0;
+      }
+      Tcoor[d] = ToLowerLeft[d]+ Fcoor[d]-FromLowerLeft[d];
+    }
+    if (in_region) {
+      Integer idx_f = 0; for(int d=0;d<nd;d++) idx_f+=isf[d]*(Fcoor[d]/rdf[d]);
+      Integer idx_t = 0; for(int d=0;d<nd;d++) idx_t+=ist[d]*(Tcoor[d]/rdt[d]);
+      Integer odx_f = 0; for(int d=0;d<nd;d++) odx_f+=osf[d]*(Fcoor[d]%rdf[d]);
+      Integer odx_t = 0; for(int d=0;d<nd;d++) odx_t+=ost[d]*(Tcoor[d]%rdt[d]);
+      scalar_type * fp = (scalar_type *)&f_v[odx_f];
+      scalar_type * tp = (scalar_type *)&t_v[odx_t];
+      for(int w=0;w<words;w++){
+	tp[idx_t+w*Nsimd] = fp[idx_f+w*Nsimd];  // FIXME IF RRII layout, type pun no worke
+      }
+      //      peekLocalSite(s,From,Fcoor);
+      //      pokeLocalSite(s,To  ,Tcoor);
+    }
+  });
+}
+
 
 template<class vobj>
 void InsertSlice(const Lattice<vobj> &lowDim,Lattice<vobj> & higherDim,int slice, int orthog)
diff --git a/Grid/qcd/action/fermion/CayleyFermion5D.h b/Grid/qcd/action/fermion/CayleyFermion5D.h
index 333ba49b..c2ccb98b 100644
--- a/Grid/qcd/action/fermion/CayleyFermion5D.h
+++ b/Grid/qcd/action/fermion/CayleyFermion5D.h
@@ -101,7 +101,8 @@ public:
   virtual void MeoDeriv(GaugeField &mat,const FermionField &U,const FermionField &V,int dag);
 
   // Efficient support for multigrid coarsening
-  virtual void  Mdir (const FermionField &in, FermionField &out,int dir,int disp);
+  virtual void  Mdir   (const FermionField &in, FermionField &out,int dir,int disp);
+  virtual void  MdirAll(const FermionField &in, std::vector<FermionField> &out);
 
   void   Meooe5D       (const FermionField &in, FermionField &out);
   void   MeooeDag5D    (const FermionField &in, FermionField &out);
diff --git a/Grid/qcd/action/fermion/ContinuedFractionFermion5D.h b/Grid/qcd/action/fermion/ContinuedFractionFermion5D.h
index 379c5f8f..5aa7bfbd 100644
--- a/Grid/qcd/action/fermion/ContinuedFractionFermion5D.h
+++ b/Grid/qcd/action/fermion/ContinuedFractionFermion5D.h
@@ -62,14 +62,15 @@ public:
 
   // Efficient support for multigrid coarsening
   virtual void  Mdir (const FermionField &in, FermionField &out,int dir,int disp);
+  virtual void  MdirAll(const FermionField &in, std::vector<FermionField> &out);
 
-      ///////////////////////////////////////////////////////////////
-      // Physical surface field utilities
-      ///////////////////////////////////////////////////////////////
-      //      virtual void Dminus(const FermionField &psi, FermionField &chi);     // Inherit trivial case
-      //      virtual void DminusDag(const FermionField &psi, FermionField &chi);  // Inherit trivial case
-      virtual void ExportPhysicalFermionSolution(const FermionField &solution5d,FermionField &exported4d);
-      virtual void ImportPhysicalFermionSource  (const FermionField &input4d,FermionField &imported5d);
+  ///////////////////////////////////////////////////////////////
+  // Physical surface field utilities
+  ///////////////////////////////////////////////////////////////
+  //      virtual void Dminus(const FermionField &psi, FermionField &chi);     // Inherit trivial case
+  //      virtual void DminusDag(const FermionField &psi, FermionField &chi);  // Inherit trivial case
+  virtual void ExportPhysicalFermionSolution(const FermionField &solution5d,FermionField &exported4d);
+  virtual void ImportPhysicalFermionSource  (const FermionField &input4d,FermionField &imported5d);
 
   // Constructors
   ContinuedFractionFermion5D(GaugeField &_Umu,
diff --git a/Grid/qcd/action/fermion/FermionOperator.h b/Grid/qcd/action/fermion/FermionOperator.h
index c60a2e84..cbc6ca63 100644
--- a/Grid/qcd/action/fermion/FermionOperator.h
+++ b/Grid/qcd/action/fermion/FermionOperator.h
@@ -89,6 +89,7 @@ public:
 
   virtual void  Mdiag  (const FermionField &in, FermionField &out) { Mooee(in,out);};   // Same as Mooee applied to both CB's
   virtual void  Mdir   (const FermionField &in, FermionField &out,int dir,int disp)=0;   // case by case Wilson, Clover, Cayley, ContFrac, PartFrac
+  virtual void  MdirAll(const FermionField &in, std::vector<FermionField> &out)=0;   // case by case Wilson, Clover, Cayley, ContFrac, PartFrac
 
 
       virtual void  MomentumSpacePropagator(FermionField &out,const FermionField &in,RealD _m,std::vector<double> twist) { assert(0);};
diff --git a/Grid/qcd/action/fermion/ImprovedStaggeredFermion.h b/Grid/qcd/action/fermion/ImprovedStaggeredFermion.h
index b4d8d60b..5cb95ca6 100644
--- a/Grid/qcd/action/fermion/ImprovedStaggeredFermion.h
+++ b/Grid/qcd/action/fermion/ImprovedStaggeredFermion.h
@@ -103,6 +103,7 @@ public:
   // Multigrid assistance; force term uses too
   ///////////////////////////////////////////////////////////////
   void Mdir(const FermionField &in, FermionField &out, int dir, int disp);
+  void MdirAll(const FermionField &in, std::vector<FermionField> &out);
   void DhopDir(const FermionField &in, FermionField &out, int dir, int disp);
 
   ///////////////////////////////////////////////////////////////
diff --git a/Grid/qcd/action/fermion/ImprovedStaggeredFermion5D.h b/Grid/qcd/action/fermion/ImprovedStaggeredFermion5D.h
index b10c0356..8e3d4be5 100644
--- a/Grid/qcd/action/fermion/ImprovedStaggeredFermion5D.h
+++ b/Grid/qcd/action/fermion/ImprovedStaggeredFermion5D.h
@@ -86,7 +86,8 @@ public:
   void   MooeeDag    (const FermionField &in, FermionField &out);
   void   MooeeInvDag (const FermionField &in, FermionField &out);
 
-  void   Mdir   (const FermionField &in, FermionField &out,int dir,int disp);
+  void Mdir   (const FermionField &in, FermionField &out,int dir,int disp);
+  void MdirAll(const FermionField &in, std::vector<FermionField> &out);
   void DhopDir(const FermionField &in, FermionField &out,int dir,int disp);
 
   // These can be overridden by fancy 5d chiral action
diff --git a/Grid/qcd/action/fermion/MADWF.h b/Grid/qcd/action/fermion/MADWF.h
index f7f0ee1b..6b3c6e71 100644
--- a/Grid/qcd/action/fermion/MADWF.h
+++ b/Grid/qcd/action/fermion/MADWF.h
@@ -40,6 +40,11 @@ inline void convert(const Fieldi &from,Fieldo &to)
   to=from;
 }
 
+struct MADWFinnerIterCallbackBase{
+  virtual void operator()(const RealD current_resid){}
+  virtual ~MADWFinnerIterCallbackBase(){}
+};
+
 template<class Matrixo,class Matrixi,class PVinverter,class SchurSolver, class Guesser> 
 class MADWF 
 {
@@ -56,24 +61,30 @@ class MADWF
 
   RealD target_resid;
   int   maxiter;
- public:
 
+  //operator() is called on "callback" at the end of every inner iteration. This allows for example the adjustment of the inner
+  //tolerance to speed up subsequent iteration
+  MADWFinnerIterCallbackBase* callback;
+  
+ public:
   MADWF(Matrixo &_Mato,
-	Matrixi &_Mati, 
-	PVinverter &_PauliVillarsSolvero, 
+	Matrixi &_Mati,
+	PVinverter &_PauliVillarsSolvero,
 	SchurSolver &_SchurSolveri,
 	Guesser & _Guesseri,
 	RealD resid,
-	int _maxiter) :
+	int _maxiter,
+	MADWFinnerIterCallbackBase* _callback = NULL) :
 
   Mato(_Mato),Mati(_Mati),
     SchurSolveri(_SchurSolveri),
-    PauliVillarsSolvero(_PauliVillarsSolvero),Guesseri(_Guesseri)
-  {   
-    target_resid=resid;
-    maxiter     =_maxiter; 
-  };
-
+    PauliVillarsSolvero(_PauliVillarsSolvero),Guesseri(_Guesseri),
+    callback(_callback)
+    {
+      target_resid=resid;
+      maxiter     =_maxiter;
+    };
+   
   void operator() (const FermionFieldo &src4,FermionFieldo &sol5)
   {
     std::cout << GridLogMessage<< " ************************************************" << std::endl;
@@ -177,6 +188,8 @@ class MADWF
        std::cout << GridLogMessage << "Residual " << i << ": " << resid  << std::endl;
        std::cout << GridLogMessage << "***************************************" <<std::endl;
 
+       if(callback != NULL) (*callback)(resid);       
+       
        if (resid < target_resid) {
 	 return;
        }
diff --git a/Grid/qcd/action/fermion/PartialFractionFermion5D.h b/Grid/qcd/action/fermion/PartialFractionFermion5D.h
index d61515f0..928abd3f 100644
--- a/Grid/qcd/action/fermion/PartialFractionFermion5D.h
+++ b/Grid/qcd/action/fermion/PartialFractionFermion5D.h
@@ -67,12 +67,13 @@ public:
 
   // Efficient support for multigrid coarsening
   virtual void  Mdir (const FermionField &in, FermionField &out,int dir,int disp);
+  virtual void  MdirAll(const FermionField &in, std::vector<FermionField> &out);
 
-      ///////////////////////////////////////////////////////////////
-      // Physical surface field utilities
-      ///////////////////////////////////////////////////////////////
-      virtual void ExportPhysicalFermionSolution(const FermionField &solution5d,FermionField &exported4d);
-      virtual void ImportPhysicalFermionSource  (const FermionField &input4d,FermionField &imported5d);
+  ///////////////////////////////////////////////////////////////
+  // Physical surface field utilities
+  ///////////////////////////////////////////////////////////////
+  virtual void ExportPhysicalFermionSolution(const FermionField &solution5d,FermionField &exported4d);
+  virtual void ImportPhysicalFermionSource  (const FermionField &input4d,FermionField &imported5d);
 
   // Constructors
   PartialFractionFermion5D(GaugeField &_Umu,
diff --git a/Grid/qcd/action/fermion/WilsonFermion.h b/Grid/qcd/action/fermion/WilsonFermion.h
index 3a712435..a3f5d2d7 100644
--- a/Grid/qcd/action/fermion/WilsonFermion.h
+++ b/Grid/qcd/action/fermion/WilsonFermion.h
@@ -115,9 +115,10 @@ public:
   // Multigrid assistance; force term uses too
   ///////////////////////////////////////////////////////////////
   void Mdir(const FermionField &in, FermionField &out, int dir, int disp);
+  void MdirAll(const FermionField &in, std::vector<FermionField> &out);
   void DhopDir(const FermionField &in, FermionField &out, int dir, int disp);
-  void DhopDirDisp(const FermionField &in, FermionField &out, int dirdisp,
-                   int gamma, int dag);
+  void DhopDirAll(const FermionField &in, std::vector<FermionField> &out);
+  void DhopDirCalc(const FermionField &in, FermionField &out, int dirdisp,int gamma, int dag);
 
   ///////////////////////////////////////////////////////////////
   // Extra methods added by derived
diff --git a/Grid/qcd/action/fermion/WilsonFermion5D.h b/Grid/qcd/action/fermion/WilsonFermion5D.h
index 8f1073db..58b54421 100644
--- a/Grid/qcd/action/fermion/WilsonFermion5D.h
+++ b/Grid/qcd/action/fermion/WilsonFermion5D.h
@@ -111,15 +111,16 @@ public:
   virtual void   MooeeDag    (const FermionField &in, FermionField &out){assert(0);};
   virtual void   MooeeInvDag (const FermionField &in, FermionField &out){assert(0);};
   virtual void   Mdir   (const FermionField &in, FermionField &out,int dir,int disp){assert(0);};   // case by case Wilson, Clover, Cayley, ContFrac, PartFrac
+  virtual void   MdirAll(const FermionField &in, std::vector<FermionField> &out){assert(0);};   // case by case Wilson, Clover, Cayley, ContFrac, PartFrac
 
   // These can be overridden by fancy 5d chiral action
   virtual void DhopDeriv  (GaugeField &mat,const FermionField &U,const FermionField &V,int dag);
   virtual void DhopDerivEO(GaugeField &mat,const FermionField &U,const FermionField &V,int dag);
   virtual void DhopDerivOE(GaugeField &mat,const FermionField &U,const FermionField &V,int dag);
 
-      void MomentumSpacePropagatorHt_5d(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
-      void MomentumSpacePropagatorHt(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
-      void MomentumSpacePropagatorHw(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
+  void MomentumSpacePropagatorHt_5d(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
+  void MomentumSpacePropagatorHt(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
+  void MomentumSpacePropagatorHw(FermionField &out,const FermionField &in,RealD mass,std::vector<double> twist) ;
 
   // Implement hopping term non-hermitian hopping term; half cb or both
   // Implement s-diagonal DW
@@ -131,6 +132,9 @@ public:
   // add a DhopComm
   // -- suboptimal interface will presently trigger multiple comms.
   void DhopDir(const FermionField &in, FermionField &out,int dir,int disp);
+  void DhopDirAll(const FermionField &in,std::vector<FermionField> &out);
+  void DhopDirComms(const FermionField &in);
+  void DhopDirCalc(const FermionField &in, FermionField &out,int point);
     
   ///////////////////////////////////////////////////////////////
   // New methods added 
diff --git a/Grid/qcd/action/fermion/WilsonKernels.h b/Grid/qcd/action/fermion/WilsonKernels.h
index 35715097..7348a463 100644
--- a/Grid/qcd/action/fermion/WilsonKernels.h
+++ b/Grid/qcd/action/fermion/WilsonKernels.h
@@ -60,6 +60,9 @@ public:
 			    int Ls, int Nsite, const FermionField &in, FermionField &out,
 			    int interior=1,int exterior=1) ;
 
+  static void DhopDirAll( StencilImpl &st, DoubledGaugeField &U,SiteHalfSpinor *buf, int Ls,
+			  int Nsite, const FermionField &in, std::vector<FermionField> &out) ;
+
   static void DhopDirKernel(StencilImpl &st, DoubledGaugeField &U,SiteHalfSpinor * buf,
 			    int Ls, int Nsite, const FermionField &in, FermionField &out, int dirdisp, int gamma);
 
@@ -100,8 +103,17 @@ public:
 
 private:
 
-  static accelerator void DhopDirK(StencilView &st, DoubledGaugeFieldView &U,SiteHalfSpinor * buf,
+  static accelerator_inline void DhopDirK(StencilView &st, DoubledGaugeFieldView &U,SiteHalfSpinor * buf,
 				   int sF, int sU, const FermionFieldView &in, FermionFieldView &out, int dirdisp, int gamma);
+
+  static accelerator_inline void DhopDirXp(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirYp(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirZp(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirTp(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirXm(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirYm(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirZm(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
+  static accelerator_inline void DhopDirTm(StencilView &st,DoubledGaugeFieldView &U,SiteHalfSpinor *buf,int sF,int sU,const FermionFieldView &in,FermionFieldView &out,int dirdisp);
       
   // Specialised variants
   static accelerator void GenericDhopSite(StencilView &st,  DoubledGaugeFieldView &U, SiteHalfSpinor * buf,
diff --git a/Grid/qcd/action/fermion/g5HermitianLinop.h b/Grid/qcd/action/fermion/g5HermitianLinop.h
index 2e417ceb..90bb6d59 100644
--- a/Grid/qcd/action/fermion/g5HermitianLinop.h
+++ b/Grid/qcd/action/fermion/g5HermitianLinop.h
@@ -54,6 +54,14 @@ public:
     _Mat.Mdir(in,tmp,dir,disp);
     G5R5(out,tmp);
   }
+  void OpDirAll(const Field &in, std::vector<Field> &out) {
+    Field tmp(in.Grid());
+    _Mat.MdirAll(in,out);
+    for(int p=0;p<out.size();p++) {
+      tmp=out[p];
+      G5R5(out[p],tmp);
+    }
+  }
 
   void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
 
@@ -96,6 +104,12 @@ public:
     _Mat.Mdir(in,tmp,dir,disp);
     out=g5*tmp;
   }
+  void OpDirAll(const Field &in, std::vector<Field> &out) {
+    _Mat.MdirAll(in,out);
+    for(int p=0;p<out.size();p++) {
+      out[p]=g5*out[p];
+    }
+  }
 
   void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
 
diff --git a/Grid/qcd/action/fermion/implementation/CayleyFermion5DImplementation.h b/Grid/qcd/action/fermion/implementation/CayleyFermion5DImplementation.h
index 6823eb26..c3c14ae9 100644
--- a/Grid/qcd/action/fermion/implementation/CayleyFermion5DImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/CayleyFermion5DImplementation.h
@@ -389,6 +389,14 @@ void  CayleyFermion5D<Impl>::Mdir (const FermionField &psi, FermionField &chi,in
   Meo5D(psi,tmp);
   this->DhopDir(tmp,chi,dir,disp);
 }
+template<class Impl>
+void  CayleyFermion5D<Impl>::MdirAll(const FermionField &psi, std::vector<FermionField> &out)
+{
+  FermionField tmp(psi.Grid());
+  Meo5D(psi,tmp);
+  this->DhopDirAll(tmp,out);
+}
+
 // force terms; five routines; default to Dhop on diagonal
 template<class Impl>
 void CayleyFermion5D<Impl>::MDeriv  (GaugeField &mat,const FermionField &U,const FermionField &V,int dag)
diff --git a/Grid/qcd/action/fermion/implementation/ContinuedFractionFermion5DImplementation.h b/Grid/qcd/action/fermion/implementation/ContinuedFractionFermion5DImplementation.h
index 7af02263..beeb3e00 100644
--- a/Grid/qcd/action/fermion/implementation/ContinuedFractionFermion5DImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/ContinuedFractionFermion5DImplementation.h
@@ -143,6 +143,25 @@ void  ContinuedFractionFermion5D<Impl>::Mdir (const FermionField &psi, FermionFi
   }
 }
 template<class Impl>
+void  ContinuedFractionFermion5D<Impl>::MdirAll (const FermionField &psi, std::vector<FermionField> &chi)
+{
+  int Ls = this->Ls;
+
+  this->DhopDirAll(psi,chi); // Dslash on diagonal. g5 Dslash is hermitian
+
+  for(int p=0;p<chi.size();p++){
+    int sign=1;
+    for(int s=0;s<Ls;s++){
+      if ( s==(Ls-1) ){
+	ag5xpby_ssp(chi[p],Beta[s]*ZoloHiInv,chi[p],0.0,chi[p],s,s);
+      } else {
+	ag5xpby_ssp(chi[p],cc[s]*Beta[s]*sign*ZoloHiInv,chi[p],0.0,chi[p],s,s);
+      }
+      sign=-sign; 
+    }
+  }
+}
+template<class Impl>
 void   ContinuedFractionFermion5D<Impl>::Meooe       (const FermionField &psi, FermionField &chi)
 {
   int Ls = this->Ls;
diff --git a/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermion5DImplementation.h b/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermion5DImplementation.h
index c42e896f..fdaa2f71 100644
--- a/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermion5DImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermion5DImplementation.h
@@ -538,10 +538,16 @@ void ImprovedStaggeredFermion5D<Impl>::ZeroCounters(void)
 // Implement the general interface. Here we use SAME mass on all slices
 /////////////////////////////////////////////////////////////////////////
 template <class Impl>
-void ImprovedStaggeredFermion5D<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) {
+void ImprovedStaggeredFermion5D<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) 
+{
   DhopDir(in, out, dir, disp);
 }
 template <class Impl>
+void ImprovedStaggeredFermion5D<Impl>::MdirAll(const FermionField &in, std::vector<FermionField> &out) 
+{
+  assert(0);
+}
+template <class Impl>
 RealD ImprovedStaggeredFermion5D<Impl>::M(const FermionField &in, FermionField &out) {
   out.Checkerboard() = in.Checkerboard();
   Dhop(in, out, DaggerNo);
diff --git a/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermionImplementation.h b/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermionImplementation.h
index e2605d81..0b723c47 100644
--- a/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermionImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/ImprovedStaggeredFermionImplementation.h
@@ -362,12 +362,19 @@ void ImprovedStaggeredFermion<Impl>::DhopEO(const FermionField &in, FermionField
 }
 
 template <class Impl>
-void ImprovedStaggeredFermion<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) {
+void ImprovedStaggeredFermion<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) 
+{
   DhopDir(in, out, dir, disp);
 }
+template <class Impl>
+void ImprovedStaggeredFermion<Impl>::MdirAll(const FermionField &in, std::vector<FermionField> &out) 
+{
+  assert(0); // Not implemented yet
+}
 
 template <class Impl>
-void ImprovedStaggeredFermion<Impl>::DhopDir(const FermionField &in, FermionField &out, int dir, int disp) {
+void ImprovedStaggeredFermion<Impl>::DhopDir(const FermionField &in, FermionField &out, int dir, int disp) 
+{
 
   Compressor compressor;
   Stencil.HaloExchange(in, compressor);
@@ -380,6 +387,7 @@ void ImprovedStaggeredFermion<Impl>::DhopDir(const FermionField &in, FermionFiel
   });
 };
 
+
 template <class Impl>
 void ImprovedStaggeredFermion<Impl>::DhopInternal(StencilImpl &st, LebesgueOrder &lo,
 						  DoubledGaugeField &U,
@@ -404,7 +412,6 @@ void ImprovedStaggeredFermion<Impl>::DhopInternalOverlappedComms(StencilImpl &st
 #ifdef GRID_OMP
   Compressor compressor; 
   int len =  U.Grid()->oSites();
-  const int LLs =  1;
 
   DhopTotalTime   -= usecond();
 
diff --git a/Grid/qcd/action/fermion/implementation/PartialFractionFermion5DImplementation.h b/Grid/qcd/action/fermion/implementation/PartialFractionFermion5DImplementation.h
index 9f8f91ad..edc674cc 100644
--- a/Grid/qcd/action/fermion/implementation/PartialFractionFermion5DImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/PartialFractionFermion5DImplementation.h
@@ -31,7 +31,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 
 NAMESPACE_BEGIN(Grid);
 
-template<class Impl>
+ template<class Impl>
 void  PartialFractionFermion5D<Impl>::Mdir (const FermionField &psi, FermionField &chi,int dir,int disp){
   // this does both dag and undag but is trivial; make a common helper routing
   int Ls = this->Ls;
@@ -45,8 +45,25 @@ void  PartialFractionFermion5D<Impl>::Mdir (const FermionField &psi, FermionFiel
     ag5xpby_ssp(chi, scale,chi,0.0,chi,s+1,s+1); 
   }
   ag5xpby_ssp(chi,p[nblock]*scale/amax,chi,0.0,chi,Ls-1,Ls-1);
-
 }
+template<class Impl>
+void  PartialFractionFermion5D<Impl>::MdirAll (const FermionField &psi, std::vector<FermionField> &chi){
+  // this does both dag and undag but is trivial; make a common helper routing
+  int Ls = this->Ls;
+
+  this->DhopDirAll(psi,chi);
+
+  for(int point=0;point<chi.size();point++){
+    int nblock=(Ls-1)/2;
+    for(int b=0;b<nblock;b++){
+      int s = 2*b;
+      ag5xpby_ssp(chi[point],-scale,chi[point],0.0,chi[point],s,s); 
+      ag5xpby_ssp(chi[point], scale,chi[point],0.0,chi[point],s+1,s+1); 
+    }
+    ag5xpby_ssp(chi[point],p[nblock]*scale/amax,chi[point],0.0,chi[point],Ls-1,Ls-1);
+  }
+}
+
 template<class Impl>
 void   PartialFractionFermion5D<Impl>::Meooe_internal(const FermionField &psi, FermionField &chi,int dag)
 {
diff --git a/Grid/qcd/action/fermion/implementation/WilsonFermion5DImplementation.h b/Grid/qcd/action/fermion/implementation/WilsonFermion5DImplementation.h
index 1bdc9a64..613eaa7b 100644
--- a/Grid/qcd/action/fermion/implementation/WilsonFermion5DImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/WilsonFermion5DImplementation.h
@@ -241,6 +241,15 @@ void WilsonFermion5D<Impl>::DhopDir(const FermionField &in, FermionField &out,in
   Kernels::DhopDirKernel(Stencil,Umu,Stencil.CommBuf(),Ls,Nsite,in,out,dirdisp,gamma);
 
 };
+template<class Impl>
+void WilsonFermion5D<Impl>::DhopDirAll(const FermionField &in, std::vector<FermionField> &out)
+{
+  Compressor compressor(DaggerNo);
+  Stencil.HaloExchange(in,compressor);
+  uint64_t Nsite = Umu.Grid()->oSites();
+  Kernels::DhopDirAll(Stencil,Umu,Stencil.CommBuf(),Ls,Nsite,in,out);
+};
+
 
 template<class Impl>
 void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
diff --git a/Grid/qcd/action/fermion/implementation/WilsonFermionImplementation.h b/Grid/qcd/action/fermion/implementation/WilsonFermionImplementation.h
index 756bdbf4..76b904e9 100644
--- a/Grid/qcd/action/fermion/implementation/WilsonFermionImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/WilsonFermionImplementation.h
@@ -319,28 +319,51 @@ void WilsonFermion<Impl>::DhopEO(const FermionField &in, FermionField &out,int d
 }
 
 template <class Impl>
-void WilsonFermion<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) {
+void WilsonFermion<Impl>::Mdir(const FermionField &in, FermionField &out, int dir, int disp) 
+{
   DhopDir(in, out, dir, disp);
 }
+template <class Impl>
+void WilsonFermion<Impl>::MdirAll(const FermionField &in, std::vector<FermionField> &out) 
+{
+  DhopDirAll(in, out);
+}
 
 template <class Impl>
 void WilsonFermion<Impl>::DhopDir(const FermionField &in, FermionField &out, int dir, int disp) 
 {
+  Compressor compressor(DaggerNo);
+  Stencil.HaloExchange(in, compressor);
+
   int skip = (disp == 1) ? 0 : 1;
   int dirdisp = dir + skip * 4;
   int gamma = dir + (1 - skip) * 4;
 
-  DhopDirDisp(in, out, dirdisp, gamma, DaggerNo);
+  DhopDirCalc(in, out, dirdisp, gamma, DaggerNo);
 };
-
 template <class Impl>
-void WilsonFermion<Impl>::DhopDirDisp(const FermionField &in, FermionField &out,int dirdisp, int gamma, int dag) 
+void WilsonFermion<Impl>::DhopDirAll(const FermionField &in, std::vector<FermionField> &out) 
 {
-  Compressor compressor(dag);
-
+  Compressor compressor(DaggerNo);
   Stencil.HaloExchange(in, compressor);
+
+  assert((out.size()==8)||(out.size()==9)); 
+  for(int dir=0;dir<Nd;dir++){
+    for(int disp=-1;disp<=1;disp+=2){
+
+      int skip = (disp == 1) ? 0 : 1;
+      int dirdisp = dir + skip * 4;
+      int gamma = dir + (1 - skip) * 4;
+
+      DhopDirCalc(in, out[dirdisp], dirdisp, gamma, DaggerNo);
+    }
+  }
+}
+template <class Impl>
+void WilsonFermion<Impl>::DhopDirCalc(const FermionField &in, FermionField &out,int dirdisp, int gamma, int dag) 
+{
   int Ls=1;
-  int Nsite=in.oSites();
+  uint64_t Nsite=in.oSites();
   Kernels::DhopDirKernel(Stencil, Umu, Stencil.CommBuf(), Ls, Nsite, in, out, dirdisp, gamma);
 };
 
@@ -348,7 +371,8 @@ template <class Impl>
 void WilsonFermion<Impl>::DhopInternal(StencilImpl &st, LebesgueOrder &lo,
                                        DoubledGaugeField &U,
                                        const FermionField &in,
-                                       FermionField &out, int dag) {
+                                       FermionField &out, int dag) 
+{
 #ifdef GRID_OMP
   if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute )
     DhopInternalOverlappedComms(st,lo,U,in,out,dag);
diff --git a/Grid/qcd/action/fermion/implementation/WilsonKernelsImplementation.h b/Grid/qcd/action/fermion/implementation/WilsonKernelsImplementation.h
index 57306ff5..81216e03 100644
--- a/Grid/qcd/action/fermion/implementation/WilsonKernelsImplementation.h
+++ b/Grid/qcd/action/fermion/implementation/WilsonKernelsImplementation.h
@@ -91,8 +91,7 @@ accelerator_inline void get_stencil(StencilEntry * mem, StencilEntry &chip)
   }								\
   synchronise();						
 
-#define GENERIC_DHOPDIR_LEG(Dir,spProj,Recon)			\
-  if (gamma == Dir) {						\
+#define GENERIC_DHOPDIR_LEG_BODY(Dir,spProj,Recon)		\
     if (SE->_is_local ) {					\
       int perm= SE->_permute;					\
       auto tmp = coalescedReadPermute(in[SE->_offset],ptype,perm,lane);	\
@@ -102,10 +101,14 @@ accelerator_inline void get_stencil(StencilEntry * mem, StencilEntry &chip)
     }								\
     synchronise();						\
     Impl::multLink(Uchi, U[sU], chi, dir, SE, st);		\
-    Recon(result, Uchi);					\
-    synchronise();						\
+    Recon(result, Uchi);					
+
+#define GENERIC_DHOPDIR_LEG(Dir,spProj,Recon)			\
+  if (gamma == Dir) {						\
+    GENERIC_DHOPDIR_LEG_BODY(Dir,spProj,Recon);			\
   }
 
+
   ////////////////////////////////////////////////////////////////////
   // All legs kernels ; comms then compute
   ////////////////////////////////////////////////////////////////////
@@ -284,7 +287,36 @@ void WilsonKernels<Impl>::GenericDhopSiteExt(StencilView &st,  DoubledGaugeField
   }
 };
 
-template <class Impl>
+#define DhopDirMacro(Dir,spProj,spRecon)	\
+  template <class Impl>							\
+  void WilsonKernels<Impl>::DhopDir##Dir(StencilView &st, DoubledGaugeFieldView &U,SiteHalfSpinor *buf, int sF, \
+					 int sU, const FermionFieldView &in, FermionFieldView &out, int dir) \
+  {									\
+  typedef decltype(coalescedRead(buf[0])) calcHalfSpinor;		\
+  typedef decltype(coalescedRead(in[0]))  calcSpinor;			\
+  calcHalfSpinor chi;							\
+  calcSpinor result;							\
+  calcHalfSpinor Uchi;							\
+  StencilEntry *SE;							\
+  int ptype;								\
+  const int Nsimd = SiteHalfSpinor::Nsimd();				\
+  const int lane=SIMTlane(Nsimd);					\
+									\
+  SE = st.GetEntry(ptype, dir, sF);					\
+  GENERIC_DHOPDIR_LEG_BODY(Dir,spProj,spRecon);				\
+  coalescedWrite(out[sF], result,lane);					\
+  }									
+
+DhopDirMacro(Xp,spProjXp,spReconXp);
+DhopDirMacro(Yp,spProjYp,spReconYp);
+DhopDirMacro(Zp,spProjZp,spReconZp);
+DhopDirMacro(Tp,spProjTp,spReconTp);
+DhopDirMacro(Xm,spProjXm,spReconXm);
+DhopDirMacro(Ym,spProjYm,spReconYm);
+DhopDirMacro(Zm,spProjZm,spReconZm);
+DhopDirMacro(Tm,spProjTm,spReconTm);
+
+template <class Impl> 
 void WilsonKernels<Impl>::DhopDirK( StencilView &st, DoubledGaugeFieldView &U,SiteHalfSpinor *buf, int sF,
 				    int sU, const FermionFieldView &in, FermionFieldView &out, int dir, int gamma) 
 {
@@ -299,18 +331,7 @@ void WilsonKernels<Impl>::DhopDirK( StencilView &st, DoubledGaugeFieldView &U,Si
   const int lane=SIMTlane(Nsimd);
 
   SE = st.GetEntry(ptype, dir, sF);
-  if (gamma == Xp) {						
-    if (SE->_is_local ) {					
-      int perm= SE->_permute;					
-      auto tmp = coalescedReadPermute(in[SE->_offset],ptype,perm,lane);	
-      spProjXp(chi,tmp);						
-    } else {							
-      chi = coalescedRead(buf[SE->_offset],lane);			
-    }								
-    Impl::multLink(Uchi, U[sU], chi, dir, SE, st);		
-    spReconXp(result, Uchi);					
-  }
-
+  GENERIC_DHOPDIR_LEG(Xp,spProjXp,spReconXp);
   GENERIC_DHOPDIR_LEG(Yp,spProjYp,spReconYp);
   GENERIC_DHOPDIR_LEG(Zp,spProjZp,spReconZp);
   GENERIC_DHOPDIR_LEG(Tp,spProjTp,spReconTp);
@@ -321,6 +342,38 @@ void WilsonKernels<Impl>::DhopDirK( StencilView &st, DoubledGaugeFieldView &U,Si
   coalescedWrite(out[sF], result,lane);
 }
 
+template <class Impl>
+void WilsonKernels<Impl>::DhopDirAll( StencilImpl &st, DoubledGaugeField &U,SiteHalfSpinor *buf, int Ls,
+				      int Nsite, const FermionField &in, std::vector<FermionField> &out) 
+{
+   auto U_v   = U.View();
+   auto in_v  = in.View();
+   auto st_v  = st.View();
+
+   auto out_Xm = out[0].View();
+   auto out_Ym = out[1].View();
+   auto out_Zm = out[2].View();
+   auto out_Tm = out[3].View();
+   auto out_Xp = out[4].View();
+   auto out_Yp = out[5].View();
+   auto out_Zp = out[6].View();
+   auto out_Tp = out[7].View();
+
+   accelerator_forNB(sss,Nsite*Ls,Simd::Nsimd(),{
+      int sU=sss/Ls;				
+      int sF =sss;				
+      DhopDirXm(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Xm,0);
+      DhopDirYm(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Ym,1);
+      DhopDirZm(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Zm,2);
+      DhopDirTm(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Tm,3);
+      DhopDirXp(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Xp,4);
+      DhopDirYp(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Yp,5);
+      DhopDirZp(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Zp,6);
+      DhopDirTp(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_Tp,7);
+   });
+}
+
+
 template <class Impl>
 void WilsonKernels<Impl>::DhopDirKernel( StencilImpl &st, DoubledGaugeField &U,SiteHalfSpinor *buf, int Ls,
 					 int Nsite, const FermionField &in, FermionField &out, int dirdisp, int gamma) 
@@ -332,13 +385,32 @@ void WilsonKernels<Impl>::DhopDirKernel( StencilImpl &st, DoubledGaugeField &U,S
    auto in_v  = in.View();
    auto out_v = out.View();
    auto st_v  = st.View();
-   accelerator_for(ss,Nsite,Simd::Nsimd(),{
-    for(int s=0;s<Ls;s++){
-      int sU=ss;
-      int sF = s+Ls*sU; 
-      DhopDirK(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_v,dirdisp,gamma);
-    }
-  });
+#define LoopBody(Dir)				\
+   case Dir :			\
+     accelerator_forNB(ss,Nsite,Simd::Nsimd(),{	\
+       for(int s=0;s<Ls;s++){			\
+	 int sU=ss;				\
+	 int sF = s+Ls*sU;						\
+	 DhopDir##Dir(st_v,U_v,st.CommBuf(),sF,sU,in_v,out_v,dirdisp);\
+       }							       \
+       });							       \
+     break;
+
+   switch(gamma){
+   LoopBody(Xp);
+   LoopBody(Yp);
+   LoopBody(Zp);
+   LoopBody(Tp);
+
+   LoopBody(Xm);
+   LoopBody(Ym);
+   LoopBody(Zm);
+   LoopBody(Tm);
+   default:
+     assert(0);
+     break;
+   }
+#undef LoopBody
 } 
 
 #define KERNEL_CALLNB(A) \
diff --git a/Grid/qcd/modules/Registration.h b/Grid/qcd/modules/Registration.h
index ebf8f420..ec28f020 100644
--- a/Grid/qcd/modules/Registration.h
+++ b/Grid/qcd/modules/Registration.h
@@ -80,6 +80,8 @@ static Registrar<OneFlavourRatioEOFModule<FermionImplementationPolicy>,
 
 static Registrar< ConjugateGradientModule<WilsonFermionR::FermionField>,   
                   HMC_SolverModuleFactory<solver_string, WilsonFermionR::FermionField, Serialiser> > __CGWFmodXMLInit("ConjugateGradient"); 
+static Registrar< BiCGSTABModule<WilsonFermionR::FermionField>,   
+                  HMC_SolverModuleFactory<solver_string, WilsonFermionR::FermionField, Serialiser> > __CGWFmodXMLInit("BiCGSTAB"); 
 static Registrar< ConjugateResidualModule<WilsonFermionR::FermionField>,   
                   HMC_SolverModuleFactory<solver_string, WilsonFermionR::FermionField, Serialiser> > __CRWFmodXMLInit("ConjugateResidual"); 
 
diff --git a/Grid/qcd/modules/SolverModules.h b/Grid/qcd/modules/SolverModules.h
index 65cb91f9..2daaaed5 100644
--- a/Grid/qcd/modules/SolverModules.h
+++ b/Grid/qcd/modules/SolverModules.h
@@ -119,6 +119,17 @@ class ConjugateGradientModule: public SolverModule<ConjugateGradient, Field, Sol
   }
 };
 
+template <class Field >
+class BiCGSTABModule: public SolverModule<BiCGSTAB, Field, SolverParameters> {
+  typedef SolverModule<BiCGSTAB, Field, SolverParameters> SolverBase;
+  using SolverBase::SolverBase; // for constructors
+
+  // acquire resource
+  virtual void initialize(){
+    this->SolverPtr.reset(new BiCGSTAB<Field>(this->Par_.tolerance, this->Par_.max_iterations, true));
+  }
+};
+
 template <class Field >
 class ConjugateResidualModule: public SolverModule<ConjugateResidual, Field, SolverParameters> {
   typedef SolverModule<ConjugateResidual, Field, SolverParameters> SolverBase;
diff --git a/Grid/qcd/utils/CovariantLaplacian.h b/Grid/qcd/utils/CovariantLaplacian.h
index 0e0620a7..94322507 100644
--- a/Grid/qcd/utils/CovariantLaplacian.h
+++ b/Grid/qcd/utils/CovariantLaplacian.h
@@ -92,6 +92,7 @@ public:
   };
 
   void Mdir(const GaugeField&, GaugeField&, int, int){ assert(0);}
+  void MdirAll(const GaugeField&, std::vector<GaugeField> &){ assert(0);}
   void Mdiag(const GaugeField&, GaugeField&){ assert(0);}
 
   void ImportGauge(const GaugeField& _U) {
diff --git a/Grid/simd/Grid_gpu_vec.h b/Grid/simd/Grid_gpu_vec.h
index 471fbccc..4584fb36 100644
--- a/Grid/simd/Grid_gpu_vec.h
+++ b/Grid/simd/Grid_gpu_vec.h
@@ -403,6 +403,10 @@ namespace Optimization {
     accelerator_inline GpuVectorRD operator()(GpuVectorRD a, GpuVectorRD b){
       return a/b;
     }
+    accelerator_inline GpuVectorI operator()(GpuVectorI a, GpuVectorI b){
+      return a/b;
+    }
+
     // Danger -- element wise divide fro complex, not complex div. 
     // See Grid_vector_types.h lines around 735, applied after "toReal"
     accelerator_inline GpuVectorCF operator()(GpuVectorCF a, GpuVectorCF b){
diff --git a/Grid/util/Init.cc b/Grid/util/Init.cc
index 472013f4..570f4234 100644
--- a/Grid/util/Init.cc
+++ b/Grid/util/Init.cc
@@ -628,6 +628,7 @@ void Grid_debug_handler_init(void)
   sigaction(SIGSEGV,&sa,NULL);
   sigaction(SIGTRAP,&sa,NULL);
   sigaction(SIGBUS,&sa,NULL);
+  sigaction(SIGUSR2,&sa,NULL);
 
   feenableexcept( FE_INVALID|FE_OVERFLOW|FE_DIVBYZERO);
 
diff --git a/Hadrons/A2AMatrix.hpp b/Hadrons/A2AMatrix.hpp
deleted file mode 100644
index 72ac7951..00000000
--- a/Hadrons/A2AMatrix.hpp
+++ /dev/null
@@ -1,777 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/A2AMatrix.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef A2A_Matrix_hpp_
-#define A2A_Matrix_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/TimerArray.hpp>
-#include <Grid/Eigen/unsupported/CXX11/Tensor>
-#ifdef USE_MKL
-#include "mkl.h"
-#include "mkl_cblas.h"
-#endif
-
-#ifndef HADRONS_A2AM_NAME 
-#define HADRONS_A2AM_NAME "a2aMatrix"
-#endif
-
-#ifndef HADRONS_A2AM_IO_TYPE
-#define HADRONS_A2AM_IO_TYPE ComplexF
-#endif
-
-#define HADRONS_A2AM_PARALLEL_IO
-
-BEGIN_HADRONS_NAMESPACE
-
-// general A2A matrix set based on Eigen tensors and Grid-allocated memory
-// Dimensions:
-//   0 - ext - external field (momentum, EM field, ...)
-//   1 - str - spin-color structure
-//   2 - t   - timeslice
-//   3 - i   - left  A2A mode index
-//   4 - j   - right A2A mode index
-template <typename T>
-using A2AMatrixSet = Eigen::TensorMap<Eigen::Tensor<T, 5, Eigen::RowMajor>>;
-
-template <typename T>
-using A2AMatrix = Eigen::Matrix<T, -1, -1, Eigen::RowMajor>;
-
-template <typename T>
-using A2AMatrixTr = Eigen::Matrix<T, -1, -1, Eigen::ColMajor>;
-
-/******************************************************************************
- *                      Abstract class for A2A kernels                        *
- ******************************************************************************/
-template <typename T, typename Field>
-class A2AKernel
-{
-public:
-    A2AKernel(void) = default;
-    virtual ~A2AKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const Field *left, const Field *right,
-                          const unsigned int orthogDim, double &time) = 0;
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej) = 0;
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej) = 0;
-};
-
-/******************************************************************************
- *                  Class to handle A2A matrix block HDF5 I/O                 *
- ******************************************************************************/
-template <typename T>
-class A2AMatrixIo
-{
-public:
-    // constructors
-    A2AMatrixIo(void) = default;
-    A2AMatrixIo(std::string filename, std::string dataname, 
-                const unsigned int nt, const unsigned int ni = 0,
-                const unsigned int nj = 0);
-    // destructor
-    ~A2AMatrixIo(void) = default;
-    // access
-    unsigned int getNi(void) const;
-    unsigned int getNj(void) const;
-    unsigned int getNt(void) const;
-    size_t       getSize(void) const;
-    // file allocation
-    template <typename MetadataType>
-    void initFile(const MetadataType &d, const unsigned int chunkSize);
-    // block I/O
-    void saveBlock(const T *data, const unsigned int i, const unsigned int j,
-                   const unsigned int blockSizei, const unsigned int blockSizej);
-    void saveBlock(const A2AMatrixSet<T> &m, const unsigned int ext, const unsigned int str,
-                   const unsigned int i, const unsigned int j);
-    template <template <class> class Vec, typename VecT>
-    void load(Vec<VecT> &v, double *tRead = nullptr, GridBase *grid = nullptr);
-private:
-    std::string  filename_{""}, dataname_{""};
-    unsigned int nt_{0}, ni_{0}, nj_{0};
-};
-
-/******************************************************************************
- *                  Wrapper for A2A matrix block computation                  *
- ******************************************************************************/
-template <typename T, typename Field, typename MetadataType, typename TIo = T>
-class A2AMatrixBlockComputation
-{
-private:
-    struct IoHelper
-    {
-        A2AMatrixIo<TIo> io;
-        MetadataType     md;
-        unsigned int     e, s, i, j;
-    };
-    typedef std::function<std::string(const unsigned int, const unsigned int)>  FilenameFn;
-    typedef std::function<MetadataType(const unsigned int, const unsigned int)> MetadataFn;
-public:
-    // constructor
-    A2AMatrixBlockComputation(GridBase *grid,
-                              const unsigned int orthogDim,
-                              const unsigned int next,
-                              const unsigned int nstr,
-                              const unsigned int blockSize,
-                              const unsigned int cacheBlockSize,
-                              TimerArray *tArray = nullptr);
-    // execution
-    void execute(const std::vector<Field> &left, 
-                 const std::vector<Field> &right,
-                 A2AKernel<T, Field> &kernel,
-                 const FilenameFn &ionameFn,
-                 const FilenameFn &filenameFn,
-                 const MetadataFn &metadataFn);
-private:
-    // I/O handler
-    void saveBlock(const A2AMatrixSet<TIo> &m, IoHelper &h);
-private:
-    TimerArray            *tArray_;
-    GridBase              *grid_;
-    unsigned int          orthogDim_, nt_, next_, nstr_, blockSize_, cacheBlockSize_;
-    Vector<T>             mCache_;
-    Vector<TIo>           mBuf_;
-    std::vector<IoHelper> nodeIo_;
-};
-
-/******************************************************************************
- *                       A2A matrix contraction kernels                       *
- ******************************************************************************/
-class A2AContraction
-{
-public:
-    // accTrMul(acc, a, b): acc += tr(a*b)
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void accTrMul(C &acc, const MatLeft &a, const MatRight &b)
-    {
-        const int RowMajor = Eigen::RowMajor;
-        const int ColMajor = Eigen::ColMajor;
-        if ((MatLeft::Options  == RowMajor) and
-            (MatRight::Options == ColMajor))
-        {
-  	  thread_for(r,a.rows(),
-            {
-                C tmp;
-#ifdef USE_MKL
-                dotuRow(tmp, r, a, b);
-#else
-                tmp = a.row(r).conjugate().dot(b.col(r));
-#endif
-                thread_critical
-                {
-                    acc += tmp;
-                }
-            });
-        }
-        else
-	  {
-            thread_for(c,a.cols(),
-            {
-                C tmp;
-#ifdef USE_MKL 
-                dotuCol(tmp, c, a, b);
-#else
-                tmp = a.col(c).conjugate().dot(b.row(c));
-#endif
-                thread_critical
-                {
-                    acc += tmp;
-                }
-            });
-        }
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline double accTrMulFlops(const MatLeft &a, const MatRight &b)
-    {
-        double n = a.rows()*a.cols();
-
-        return 8.*n;
-    }
-
-    // mul(res, a, b): res = a*b
-#ifdef USE_MKL
-    template <template <class, int...> class Mat, int... Opts>
-    static inline void mul(Mat<ComplexD, Opts...> &res, 
-                           const Mat<ComplexD, Opts...> &a, 
-                           const Mat<ComplexD, Opts...> &b)
-    {
-        static const ComplexD one(1., 0.), zero(0., 0.);
-        const int RowMajor = Eigen::RowMajor;
-        const int ColMajor = Eigen::ColMajor;
-
-        if ((res.rows() != a.rows()) or (res.cols() != b.cols()))
-        {
-            res.resize(a.rows(), b.cols());
-        }
-        if (Mat<ComplexD, Opts...>::Options == RowMajor)
-        {
-            cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.cols(), b.data(), b.cols(), &zero,
-                        res.data(), res.cols());
-        }
-        else if (Mat<ComplexD, Opts...>::Options == ColMajor)
-        {
-            cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.rows(), b.data(), b.rows(), &zero,
-                        res.data(), res.rows());
-        }
-    }
-
-    template <template <class, int...> class Mat, int... Opts>
-    static inline void mul(Mat<ComplexF, Opts...> &res, 
-                           const Mat<ComplexF, Opts...> &a, 
-                           const Mat<ComplexF, Opts...> &b)
-    {
-        static const ComplexF one(1., 0.), zero(0., 0.);
-        const int RowMajor = Eigen::RowMajor;
-        const int ColMajor = Eigen::ColMajor;
-
-        if ((res.rows() != a.rows()) or (res.cols() != b.cols()))
-        {
-            res.resize(a.rows(), b.cols());
-        }
-        if (Mat<ComplexF, Opts...>::Options == RowMajor)
-        {
-            cblas_cgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.cols(), b.data(), b.cols(), &zero,
-                        res.data(), res.cols());
-        }
-        else if (Mat<ComplexF, Opts...>::Options == ColMajor)
-        {
-            cblas_cgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.rows(), b.data(), b.rows(), &zero,
-                        res.data(), res.rows());
-        }
-    }
-#else
-    template <typename Mat>
-    static inline void mul(Mat &res, const Mat &a, const Mat &b)
-    {
-        res = a*b;
-    }
-#endif
-    template <typename Mat>
-    static inline double mulFlops(const Mat &a, const Mat &b)
-    {
-        double nr = a.rows(), nc = a.cols();
-
-        return nr*nr*(6.*nc + 2.*(nc - 1.));
-    }
-private:
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void makeDotRowPt(C * &aPt, unsigned int &aInc, C * &bPt, 
-                                    unsigned int &bInc, const unsigned int aRow, 
-                                    const MatLeft &a, const MatRight &b)
-    {
-        const int RowMajor = Eigen::RowMajor;
-        const int ColMajor = Eigen::ColMajor;
-
-        if (MatLeft::Options == RowMajor)
-        {
-            aPt  = a.data() + aRow*a.cols();
-            aInc = 1;
-        }
-        else if (MatLeft::Options == ColMajor)
-        {
-            aPt  = a.data() + aRow;
-            aInc = a.rows();
-        }
-        if (MatRight::Options == RowMajor)
-        {
-            bPt  = b.data() + aRow;
-            bInc = b.cols();
-        }
-        else if (MatRight::Options == ColMajor)
-        {
-            bPt  = b.data() + aRow*b.rows();
-            bInc = 1;
-        }
-    }
-
-#ifdef USE_MKL
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void makeDotColPt(C * &aPt, unsigned int &aInc, C * &bPt, 
-                                    unsigned int &bInc, const unsigned int aCol, 
-                                    const MatLeft &a, const MatRight &b)
-    {
-        const int RowMajor = Eigen::RowMajor;
-        const int ColMajor = Eigen::ColMajor;
-        if (MatLeft::Options == RowMajor)
-        {
-            aPt  = a.data() + aCol;
-            aInc = a.cols();
-        }
-        else if (MatLeft::Options == ColMajor)
-        {
-            aPt  = a.data() + aCol*a.rows();
-            aInc = 1;
-        }
-        if (MatRight::Options == RowMajor)
-        {
-            bPt  = b.data() + aCol*b.cols();
-            bInc = 1;
-        }
-        else if (MatRight::Options == ColMajor)
-        {
-            bPt  = b.data() + aCol;
-            bInc = b.rows();
-        }
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuRow(ComplexF &res, const unsigned int aRow,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexF *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotRowPt(aPt, aInc, bPt, bInc, aRow, a, b);
-        cblas_cdotu_sub(a.cols(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuCol(ComplexF &res, const unsigned int aCol,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexF *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotColPt(aPt, aInc, bPt, bInc, aCol, a, b);
-        cblas_cdotu_sub(a.rows(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuRow(ComplexD &res, const unsigned int aRow,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexD *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotRowPt(aPt, aInc, bPt, bInc, aRow, a, b);
-        cblas_zdotu_sub(a.cols(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuCol(ComplexD &res, const unsigned int aCol,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexD *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotColPt(aPt, aInc, bPt, bInc, aCol, a, b);
-        cblas_zdotu_sub(a.rows(), aPt, aInc, bPt, bInc, &res);
-    }
-#endif
-};
-
-/******************************************************************************
- *                     A2AMatrixIo template implementation                    *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T>
-A2AMatrixIo<T>::A2AMatrixIo(std::string filename, std::string dataname, 
-                            const unsigned int nt, const unsigned int ni,
-                            const unsigned int nj)
-: filename_(filename), dataname_(dataname)
-, nt_(nt), ni_(ni), nj_(nj)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNt(void) const
-{
-    return nt_;
-}
-
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNi(void) const
-{
-    return ni_;
-}
-
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNj(void) const
-{
-    return nj_;
-}
-
-template <typename T>
-size_t A2AMatrixIo<T>::getSize(void) const
-{
-    return nt_*ni_*nj_*sizeof(T);
-}
-
-// file allocation /////////////////////////////////////////////////////////////
-template <typename T>
-template <typename MetadataType>
-void A2AMatrixIo<T>::initFile(const MetadataType &d, const unsigned int chunkSize)
-{
-#ifdef HAVE_HDF5
-    std::vector<hsize_t>    dim = {static_cast<hsize_t>(nt_), 
-                                   static_cast<hsize_t>(ni_), 
-                                   static_cast<hsize_t>(nj_)},
-                            chunk = {static_cast<hsize_t>(nt_), 
-                                     static_cast<hsize_t>(chunkSize), 
-                                     static_cast<hsize_t>(chunkSize)};
-    H5NS::DataSpace         dataspace(dim.size(), dim.data());
-    H5NS::DataSet           dataset;
-    H5NS::DSetCreatPropList plist;
-    
-    // create empty file just with metadata
-    {
-        Hdf5Writer writer(filename_);
-        write(writer, dataname_, d);
-    }
-
-    // create the dataset
-    Hdf5Reader reader(filename_, false);
-
-    push(reader, dataname_);
-    auto &group = reader.getGroup();
-    plist.setChunk(chunk.size(), chunk.data());
-    plist.setFletcher32();
-    dataset = group.createDataSet(HADRONS_A2AM_NAME, Hdf5Type<T>::type(), dataspace, plist);
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-// block I/O ///////////////////////////////////////////////////////////////////
-template <typename T>
-void A2AMatrixIo<T>::saveBlock(const T *data, 
-                               const unsigned int i, 
-                               const unsigned int j,
-                               const unsigned int blockSizei,
-                               const unsigned int blockSizej)
-{
-#ifdef HAVE_HDF5
-    Hdf5Reader           reader(filename_, false);
-    std::vector<hsize_t> count = {nt_, blockSizei, blockSizej},
-                         offset = {0, static_cast<hsize_t>(i),
-                                   static_cast<hsize_t>(j)},
-                         stride = {1, 1, 1},
-                         block  = {1, 1, 1}; 
-    H5NS::DataSpace      memspace(count.size(), count.data()), dataspace;
-    H5NS::DataSet        dataset;
-    //    size_t               shift;
-
-    push(reader, dataname_);
-    auto &group = reader.getGroup();
-    dataset     = group.openDataSet(HADRONS_A2AM_NAME);
-    dataspace   = dataset.getSpace();
-    dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data(),
-                              stride.data(), block.data());
-    dataset.write(data, Hdf5Type<T>::type(), memspace, dataspace);
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-template <typename T>
-void A2AMatrixIo<T>::saveBlock(const A2AMatrixSet<T> &m,
-                               const unsigned int ext, const unsigned int str,
-                               const unsigned int i, const unsigned int j)
-{
-    unsigned int blockSizei = m.dimension(3);
-    unsigned int blockSizej = m.dimension(4);
-    unsigned int nstr       = m.dimension(1);
-    size_t       offset     = (ext*nstr + str)*nt_*blockSizei*blockSizej;
-
-    saveBlock(m.data() + offset, i, j, blockSizei, blockSizej);
-}
-
-template <typename T>
-template <template <class> class Vec, typename VecT>
-void A2AMatrixIo<T>::load(Vec<VecT> &v, double *tRead, GridBase *grid)
-{
-#ifdef HAVE_HDF5
-    std::vector<hsize_t> hdim;
-    H5NS::DataSet        dataset;
-    H5NS::DataSpace      dataspace;
-    H5NS::CompType       datatype;
-
-    if (!(grid) || grid->IsBoss())
-    {
-        Hdf5Reader reader(filename_);
-        push(reader, dataname_);
-        auto &group = reader.getGroup();
-        dataset = group.openDataSet(HADRONS_A2AM_NAME);
-        datatype = dataset.getCompType();
-        dataspace = dataset.getSpace();
-        hdim.resize(dataspace.getSimpleExtentNdims());
-        dataspace.getSimpleExtentDims(hdim.data());
-        if ((nt_ * ni_ * nj_ != 0) and
-            ((hdim[0] != nt_) or (hdim[1] != ni_) or (hdim[2] != nj_)))
-        {
-            HADRONS_ERROR(Size, "all-to-all matrix size mismatch (got "
-                + std::to_string(hdim[0]) + "x" + std::to_string(hdim[1]) + "x"
-                + std::to_string(hdim[2]) + ", expected "
-                + std::to_string(nt_) + "x" + std::to_string(ni_) + "x"
-                + std::to_string(nj_));
-        }
-        else if (ni_*nj_ == 0)
-        {
-            if (hdim[0] != nt_)
-            {
-                HADRONS_ERROR(Size, "all-to-all time size mismatch (got "
-                    + std::to_string(hdim[0]) + ", expected "
-                    + std::to_string(nt_) + ")");
-            }
-            ni_ = hdim[1];
-            nj_ = hdim[2];
-        }
-    }
-    if (grid)
-    {
-        grid->Broadcast(grid->BossRank(), &ni_, sizeof(unsigned int));
-        grid->Broadcast(grid->BossRank(), &nj_, sizeof(unsigned int));
-    }
-
-    A2AMatrix<T>         buf(ni_, nj_);
-    int broadcastSize =  sizeof(T) * buf.size();
-    std::vector<hsize_t> count    = {1, static_cast<hsize_t>(ni_),
-                                     static_cast<hsize_t>(nj_)},
-                         stride   = {1, 1, 1},
-                         block    = {1, 1, 1},
-                         memCount = {static_cast<hsize_t>(ni_),
-                                     static_cast<hsize_t>(nj_)};
-    H5NS::DataSpace      memspace(memCount.size(), memCount.data());
-
-    std::cout << "Loading timeslice";
-    std::cout.flush();
-    *tRead = 0.;
-    for (unsigned int tp1 = nt_; tp1 > 0; --tp1)
-    {
-        unsigned int         t      = tp1 - 1;
-        std::vector<hsize_t> offset = {static_cast<hsize_t>(t), 0, 0};
-        
-        if (t % 10 == 0)
-        {
-            std::cout << " " << t;
-            std::cout.flush();
-        }
-        if (!(grid) || grid->IsBoss())
-        {
-            dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data(),
-                                      stride.data(), block.data());
-        }
-        if (tRead) *tRead -= usecond();
-        if (!(grid) || grid->IsBoss())
-        {
-            dataset.read(buf.data(), datatype, memspace, dataspace);
-        }
-        if (grid)
-        {
-            grid->Broadcast(grid->BossRank(), buf.data(), broadcastSize);
-        }
-        if (tRead) *tRead += usecond();
-        v[t] = buf.template cast<VecT>();
-    }
-    std::cout << std::endl;
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-/******************************************************************************
- *               A2AMatrixBlockComputation template implementation            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::A2AMatrixBlockComputation(GridBase *grid,
-                            const unsigned int orthogDim,
-                            const unsigned int next, 
-                            const unsigned int nstr,
-                            const unsigned int blockSize, 
-                            const unsigned int cacheBlockSize,
-                            TimerArray *tArray)
-: grid_(grid), nt_(grid->GlobalDimensions()[orthogDim]), orthogDim_(orthogDim)
-, next_(next), nstr_(nstr), blockSize_(blockSize), cacheBlockSize_(cacheBlockSize)
-, tArray_(tArray)
-{
-    mCache_.resize(nt_*next_*nstr_*cacheBlockSize_*cacheBlockSize_);
-    mBuf_.resize(nt_*next_*nstr_*blockSize_*blockSize_);
-}
-
-#define START_TIMER(name) if (tArray_) tArray_->startTimer(name)
-#define STOP_TIMER(name)  if (tArray_) tArray_->stopTimer(name)
-#define GET_TIMER(name)   ((tArray_ != nullptr) ? tArray_->getDTimer(name) : 0.)
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-void A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::execute(const std::vector<Field> &left, const std::vector<Field> &right,
-          A2AKernel<T, Field> &kernel, const FilenameFn &ionameFn,
-          const FilenameFn &filenameFn, const MetadataFn &metadataFn)
-{
-    //////////////////////////////////////////////////////////////////////////
-    // i,j   is first  loop over blockSize_ factors
-    // ii,jj is second loop over cacheBlockSize_ factors for high perf contractions
-    // iii,jjj are loops within cacheBlock
-    // Total index is sum of these  i+ii+iii etc...
-    //////////////////////////////////////////////////////////////////////////
-    int    N_i = left.size();
-    int    N_j = right.size();
-    double flops, bytes, t_kernel;
-    double nodes = grid_->NodeCount();
-    
-    int NBlock_i = N_i/blockSize_ + (((N_i % blockSize_) != 0) ? 1 : 0);
-    int NBlock_j = N_j/blockSize_ + (((N_j % blockSize_) != 0) ? 1 : 0);
-
-    for(int i=0;i<N_i;i+=blockSize_)
-    for(int j=0;j<N_j;j+=blockSize_)
-    {
-        // Get the W and V vectors for this block^2 set of terms
-        int N_ii = MIN(N_i-i,blockSize_);
-        int N_jj = MIN(N_j-j,blockSize_);
-        A2AMatrixSet<TIo> mBlock(mBuf_.data(), next_, nstr_, nt_, N_ii, N_jj);
-
-        LOG(Message) << "All-to-all matrix block " 
-                     << j/blockSize_ + NBlock_j*i/blockSize_ + 1 
-                     << "/" << NBlock_i*NBlock_j << " [" << i <<" .. " 
-                     << i+N_ii-1 << ", " << j <<" .. " << j+N_jj-1 << "]" 
-                     << std::endl;
-        // Series of cache blocked chunks of the contractions within this block
-        flops    = 0.0;
-        bytes    = 0.0;
-        t_kernel = 0.0;
-        for(int ii=0;ii<N_ii;ii+=cacheBlockSize_)
-        for(int jj=0;jj<N_jj;jj+=cacheBlockSize_)
-        {
-            double t;
-            int N_iii = MIN(N_ii-ii,cacheBlockSize_);
-            int N_jjj = MIN(N_jj-jj,cacheBlockSize_);
-            A2AMatrixSet<T> mCacheBlock(mCache_.data(), next_, nstr_, nt_, N_iii, N_jjj);
-
-            START_TIMER("kernel");
-            kernel(mCacheBlock, &left[i+ii], &right[j+jj], orthogDim_, t);
-            STOP_TIMER("kernel");
-            t_kernel += t;
-            flops    += kernel.flops(N_iii, N_jjj);
-            bytes    += kernel.bytes(N_iii, N_jjj);
-
-            START_TIMER("cache copy");
-            thread_for_collapse( 5,e,next_,{
-              for(int s =0;s< nstr_;s++)
-              for(int t =0;t< nt_;t++)
-              for(int iii=0;iii< N_iii;iii++)
-              for(int jjj=0;jjj< N_jjj;jjj++)
-              {
-                mBlock(e,s,t,ii+iii,jj+jjj) = mCacheBlock(e,s,t,iii,jjj);
-              }
-            });
-            STOP_TIMER("cache copy");
-        }
-
-        // perf
-        LOG(Message) << "Kernel perf " << flops/t_kernel/1.0e3/nodes 
-                     << " Gflop/s/node " << std::endl;
-        LOG(Message) << "Kernel perf " << bytes/t_kernel*1.0e6/1024/1024/1024/nodes 
-                     << " GB/s/node "  << std::endl;
-
-        // IO
-        double       blockSize, ioTime;
-        unsigned int myRank = grid_->ThisRank(), nRank  = grid_->RankCount();
-    
-        LOG(Message) << "Writing block to disk" << std::endl;
-        ioTime = -GET_TIMER("IO: write block");
-        START_TIMER("IO: total");
-        makeFileDir(filenameFn(0, 0), grid_);
-#ifdef HADRONS_A2AM_PARALLEL_IO
-        grid_->Barrier();
-        // make task list for current node
-        nodeIo_.clear();
-        for(int f = myRank; f < next_*nstr_; f += nRank)
-        {
-            IoHelper h;
-
-            h.i  = i;
-            h.j  = j;
-            h.e  = f/nstr_;
-            h.s  = f % nstr_;
-            h.io = A2AMatrixIo<TIo>(filenameFn(h.e, h.s), 
-                                    ionameFn(h.e, h.s), nt_, N_i, N_j);
-            h.md = metadataFn(h.e, h.s);
-            nodeIo_.push_back(h);
-        }
-        // parallel IO
-        for (auto &h: nodeIo_)
-        {
-            saveBlock(mBlock, h);
-        }
-        grid_->Barrier();
-#else
-        // serial IO, for testing purposes only
-        for(int e = 0; e < next_; e++)
-        for(int s = 0; s < nstr_; s++)
-        {
-            IoHelper h;
-
-            h.i  = i;
-            h.j  = j;
-            h.e  = e;
-            h.s  = s;
-            h.io = A2AMatrixIo<TIo>(filenameFn(h.e, h.s), 
-                                    ionameFn(h.e, h.s), nt_, N_i, N_j);
-            h.md = metadataFn(h.e, h.s);
-            saveBlock(mfBlock, h);
-        }
-#endif
-        STOP_TIMER("IO: total");
-        blockSize  = static_cast<double>(next_*nstr_*nt_*N_ii*N_jj*sizeof(TIo));
-        ioTime    += GET_TIMER("IO: write block");
-        LOG(Message) << "HDF5 IO done " << sizeString(blockSize) << " in "
-                     << ioTime  << " us (" 
-                     << blockSize/ioTime*1.0e6/1024/1024
-                     << " MB/s)" << std::endl;
-    }
-}
-
-// I/O handler /////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-void A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::saveBlock(const A2AMatrixSet<TIo> &m, IoHelper &h)
-{
-    if ((h.i == 0) and (h.j == 0))
-    {
-        START_TIMER("IO: file creation");
-        h.io.initFile(h.md, blockSize_);
-        STOP_TIMER("IO: file creation");
-    }
-    START_TIMER("IO: write block");
-    h.io.saveBlock(m, h.e, h.s, h.i, h.j);
-    STOP_TIMER("IO: write block");
-}
-
-#undef START_TIMER
-#undef STOP_TIMER
-#undef GET_TIMER
-
-END_HADRONS_NAMESPACE
-
-#endif // A2A_Matrix_hpp_
diff --git a/Hadrons/A2AVectors.hpp b/Hadrons/A2AVectors.hpp
deleted file mode 100644
index 7cbd19ef..00000000
--- a/Hadrons/A2AVectors.hpp
+++ /dev/null
@@ -1,342 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/A2AVectors.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: fionnoh <fionnoh@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef A2A_Vectors_hpp_
-#define A2A_Vectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Environment.hpp>
-#include <Hadrons/Solver.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                 Class to generate V & W all-to-all vectors                 *
- ******************************************************************************/
-template <typename FImpl>
-class A2AVectorsSchurDiagTwo
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-public:
-    A2AVectorsSchurDiagTwo(FMat &action, Solver &solver);
-    virtual ~A2AVectorsSchurDiagTwo(void) = default;
-    void makeLowModeV(FermionField &vout, 
-                      const FermionField &evec, const Real &eval);
-    void makeLowModeV5D(FermionField &vout_4d, FermionField &vout_5d, 
-                        const FermionField &evec, const Real &eval);
-    void makeLowModeW(FermionField &wout, 
-                      const FermionField &evec, const Real &eval);
-    void makeLowModeW5D(FermionField &wout_4d, FermionField &wout_5d, 
-                        const FermionField &evec, const Real &eval);
-    void makeHighModeV(FermionField &vout, const FermionField &noise);
-    void makeHighModeV5D(FermionField &vout_4d, FermionField &vout_5d, 
-                         const FermionField &noise_5d);
-    void makeHighModeW(FermionField &wout, const FermionField &noise);
-    void makeHighModeW5D(FermionField &vout_5d, FermionField &wout_5d, 
-                         const FermionField &noise_5d);
-private:
-    FMat                                     &action_;
-    Solver                                   &solver_;
-    GridBase                                 *fGrid_, *frbGrid_, *gGrid_;
-    bool                                     is5d_;
-    FermionField                             src_o_, sol_e_, sol_o_, tmp_, tmp5_;
-    SchurDiagTwoOperator<FMat, FermionField> op_;
-};
-
-/******************************************************************************
- *                  Methods for V & W all-to-all vectors I/O                  *
- ******************************************************************************/
-class A2AVectorsIo
-{
-public:
-    struct Record: Serializable
-    {
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Record,
-                                        unsigned int, index);
-        Record(void): index(0) {}
-    };
-public:
-    template <typename Field>
-    static void write(const std::string fileStem, std::vector<Field> &vec, 
-                      const bool multiFile, const int trajectory = -1);
-    template <typename Field>
-    static void read(std::vector<Field> &vec, const std::string fileStem,
-                     const bool multiFile, const int trajectory = -1);
-private:
-    static inline std::string vecFilename(const std::string stem, const int traj, 
-                                          const bool multiFile)
-    {
-        std::string t = (traj < 0) ? "" : ("." + std::to_string(traj));
-
-        if (multiFile)
-        {
-            return stem + t;
-        }
-        else
-        {
-            return stem + t + ".bin";
-        }
-    }
-};
-
-/******************************************************************************
- *               A2AVectorsSchurDiagTwo template implementation               *
- ******************************************************************************/
-template <typename FImpl>
-A2AVectorsSchurDiagTwo<FImpl>::A2AVectorsSchurDiagTwo(FMat &action, Solver &solver)
-: action_(action)
-, solver_(solver)
-, fGrid_(action_.FermionGrid())
-, frbGrid_(action_.FermionRedBlackGrid())
-, gGrid_(action_.GaugeGrid())
-, src_o_(frbGrid_)
-, sol_e_(frbGrid_)
-, sol_o_(frbGrid_)
-, tmp_(frbGrid_)
-, tmp5_(fGrid_)
-, op_(action_)
-{}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeV(FermionField &vout, const FermionField &evec, const Real &eval)
-{
-    src_o_ = evec;
-    src_o_.Checkerboard() = Odd;
-    pickCheckerboard(Even, sol_e_, vout);
-    pickCheckerboard(Odd, sol_o_, vout);
-
-    /////////////////////////////////////////////////////
-    // v_ie = -(1/eval_i) * MeeInv Meo MooInv evec_i
-    /////////////////////////////////////////////////////
-    action_.MooeeInv(src_o_, tmp_);
-    assert(tmp_.Checkerboard() == Odd);
-    action_.Meooe(tmp_, sol_e_);
-    assert(sol_e_.Checkerboard() == Even);
-    action_.MooeeInv(sol_e_, tmp_);
-    assert(tmp_.Checkerboard() == Even);
-    sol_e_ = (-1.0 / eval) * tmp_;
-    assert(sol_e_.Checkerboard() == Even);
-
-    /////////////////////////////////////////////////////
-    // v_io = (1/eval_i) * MooInv evec_i
-    /////////////////////////////////////////////////////
-    action_.MooeeInv(src_o_, tmp_);
-    assert(tmp_.Checkerboard() == Odd);
-    sol_o_ = (1.0 / eval) * tmp_;
-    assert(sol_o_.Checkerboard() == Odd);
-    setCheckerboard(vout, sol_e_);
-    assert(sol_e_.Checkerboard() == Even);
-    setCheckerboard(vout, sol_o_);
-    assert(sol_o_.Checkerboard() == Odd);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeV5D(FermionField &vout_4d, FermionField &vout_5d, const FermionField &evec, const Real &eval)
-{
-    makeLowModeV(vout_5d, evec, eval);
-    action_.ExportPhysicalFermionSolution(vout_5d, vout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeW(FermionField &wout, const FermionField &evec, const Real &eval)
-{
-    src_o_ = evec;
-    src_o_.Checkerboard() = Odd;
-    pickCheckerboard(Even, sol_e_, wout);
-    pickCheckerboard(Odd, sol_o_, wout);
-
-    /////////////////////////////////////////////////////
-    // w_ie = - MeeInvDag MoeDag Doo evec_i
-    /////////////////////////////////////////////////////
-    op_.Mpc(src_o_, tmp_);
-    assert(tmp_.Checkerboard() == Odd);
-    action_.MeooeDag(tmp_, sol_e_);
-    assert(sol_e_.Checkerboard() == Even);
-    action_.MooeeInvDag(sol_e_, tmp_);
-    assert(tmp_.Checkerboard() == Even);
-    sol_e_ = (-1.0) * tmp_;
-
-    /////////////////////////////////////////////////////
-    // w_io = Doo evec_i
-    /////////////////////////////////////////////////////
-    op_.Mpc(src_o_, sol_o_);
-    assert(sol_o_.Checkerboard() == Odd);
-    setCheckerboard(wout, sol_e_);
-    assert(sol_e_.Checkerboard() == Even);
-    setCheckerboard(wout, sol_o_);
-    assert(sol_o_.Checkerboard() == Odd);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeW5D(FermionField &wout_4d, 
-                                                   FermionField &wout_5d, 
-                                                   const FermionField &evec, 
-                                                   const Real &eval)
-{
-    makeLowModeW(tmp5_, evec, eval);
-    action_.DminusDag(tmp5_, wout_5d);
-    action_.ExportPhysicalFermionSource(wout_5d, wout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeV(FermionField &vout, 
-                                                  const FermionField &noise)
-{
-    solver_(vout, noise);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeV5D(FermionField &vout_4d, 
-                                                    FermionField &vout_5d, 
-                                                    const FermionField &noise)
-{
-    if (noise.Grid()->Dimensions() == fGrid_->Dimensions() - 1)
-    {
-        action_.ImportPhysicalFermionSource(noise, tmp5_);
-    }
-    else
-    {
-        tmp5_ = noise;
-    }
-    makeHighModeV(vout_5d, tmp5_);
-    action_.ExportPhysicalFermionSolution(vout_5d, vout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeW(FermionField &wout, 
-                                                  const FermionField &noise)
-{
-    wout = noise;
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeW5D(FermionField &wout_4d, 
-                                                    FermionField &wout_5d, 
-                                                    const FermionField &noise)
-{
-    if (noise.Grid()->Dimensions() == fGrid_->Dimensions() - 1)
-    {
-        action_.ImportUnphysicalFermion(noise, wout_5d);
-        wout_4d = noise;
-    }
-    else
-    {
-        wout_5d = noise;
-        action_.ExportPhysicalFermionSource(wout_5d, wout_4d);
-    }
-}
-
-/******************************************************************************
- *               all-to-all vectors I/O template implementation               *
- ******************************************************************************/
-template <typename Field>
-void A2AVectorsIo::write(const std::string fileStem, std::vector<Field> &vec, 
-                         const bool multiFile, const int trajectory)
-{
-    Record       record;
-    GridBase     *grid = vec[0].Grid();
-    ScidacWriter binWriter(grid->IsBoss());
-    std::string  filename = vecFilename(fileStem, trajectory, multiFile);
-
-    if (multiFile)
-    {
-        std::string fullFilename;
-
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            fullFilename = filename + "/elem" + std::to_string(i) + ".bin";
-
-            LOG(Message) << "Writing vector " << i << std::endl;
-            makeFileDir(fullFilename, grid);
-            binWriter.open(fullFilename);
-            record.index = i;
-            binWriter.writeScidacFieldRecord(vec[i], record);
-            binWriter.close();
-        }
-    }
-    else
-    {
-        makeFileDir(filename, grid);
-        binWriter.open(filename);
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            LOG(Message) << "Writing vector " << i << std::endl;
-            record.index = i;
-            binWriter.writeScidacFieldRecord(vec[i], record);
-        }
-        binWriter.close();
-    }
-}
-
-template <typename Field>
-void A2AVectorsIo::read(std::vector<Field> &vec, const std::string fileStem, 
-                        const bool multiFile, const int trajectory)
-{
-    Record       record;
-    ScidacReader binReader;
-    std::string  filename = vecFilename(fileStem, trajectory, multiFile);
-
-    if (multiFile)
-    {
-        std::string fullFilename;
-
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            fullFilename = filename + "/elem" + std::to_string(i) + ".bin";
-
-            LOG(Message) << "Reading vector " << i << std::endl;
-            binReader.open(fullFilename);
-            binReader.readScidacFieldRecord(vec[i], record);
-            binReader.close();
-            if (record.index != i)
-            {
-                HADRONS_ERROR(Io, "vector index mismatch");
-            }
-        }
-    }
-    else
-    {
-        binReader.open(filename);
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            LOG(Message) << "Reading vector " << i << std::endl;
-            binReader.readScidacFieldRecord(vec[i], record);
-            if (record.index != i)
-            {
-                HADRONS_ERROR(Io, "vector index mismatch");
-            }
-        }
-        binReader.close();
-    }
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // A2A_Vectors_hpp_
diff --git a/Hadrons/Application.cc b/Hadrons/Application.cc
deleted file mode 100644
index ad21e199..00000000
--- a/Hadrons/Application.cc
+++ /dev/null
@@ -1,287 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Application.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/GeneticScheduler.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-#define BIG_SEP "================"
-#define SEP     "----------------"
-
-/******************************************************************************
- *                       Application implementation                           *
- ******************************************************************************/
-// constructors ////////////////////////////////////////////////////////////////
-#define MACOUT(macro)    macro              << " (" << #macro << ")"
-#define MACOUTS(macro) HADRONS_STR(macro) << " (" << #macro << ")"
-
-Application::Application(void)
-{
-    initLogger();
-    auto dim = GridDefaultLatt(), mpi = GridDefaultMpi(), loc(dim);
-
-    if (dim.size())
-    {
-        locVol_ = 1;
-        for (unsigned int d = 0; d < dim.size(); ++d)
-        {
-            loc[d]  /= mpi[d];
-            locVol_ *= loc[d];
-        }
-        LOG(Message) << "====== HADRONS APPLICATION INITIALISATION ======" << std::endl;
-        LOG(Message) << "** Dimensions" << std::endl;
-        LOG(Message) << "Global lattice: " << dim << std::endl;
-        LOG(Message) << "MPI partition : " << mpi << std::endl;
-        LOG(Message) << "Local lattice : " << loc << std::endl;
-        LOG(Message) << std::endl;
-        LOG(Message) << "** Default parameters (and associated C macros)" << std::endl;
-        LOG(Message) << "ASCII output precision  : " << MACOUT(DEFAULT_ASCII_PREC) << std::endl;
-        LOG(Message) << "Fermion implementation  : " << MACOUTS(FIMPLBASE) << std::endl;
-        LOG(Message) << "z-Fermion implementation: " << MACOUTS(ZFIMPLBASE) << std::endl;
-        LOG(Message) << "Scalar implementation   : " << MACOUTS(SIMPLBASE) << std::endl;
-        LOG(Message) << "Gauge implementation    : " << MACOUTS(GIMPLBASE) << std::endl;
-        LOG(Message) << "Eigenvector base size   : " 
-                    << MACOUT(HADRONS_DEFAULT_LANCZOS_NBASIS) << std::endl;
-        LOG(Message) << "Schur decomposition     : " << MACOUTS(HADRONS_DEFAULT_SCHUR) << std::endl;
-        LOG(Message) << std::endl;
-    }
-}
-
-Application::Application(const Application::GlobalPar &par)
-: Application()
-{
-    setPar(par);
-}
-
-Application::Application(const std::string parameterFileName)
-: Application()
-{
-    parameterFileName_ = parameterFileName;
-}
-
-// access //////////////////////////////////////////////////////////////////////
-void Application::setPar(const Application::GlobalPar &par)
-{
-    par_ = par;
-}
-
-const Application::GlobalPar & Application::getPar(void)
-{
-    return par_;
-}
-
-// execute /////////////////////////////////////////////////////////////////////
-void Application::run(void)
-{
-    LOG(Message) << "====== HADRONS APPLICATION START ======" << std::endl;
-    if (!parameterFileName_.empty() and (vm().getNModule() == 0))
-    {
-        parseParameterFile(parameterFileName_);
-    }
-    if (getPar().runId.empty())
-    {
-        HADRONS_ERROR(Definition, "run id is empty");
-    }
-    LOG(Message) << "RUN ID '" << getPar().runId << "'" << std::endl;
-    BinaryIO::latticeWriteMaxRetry = getPar().parallelWriteMaxRetry;
-    LOG(Message) << "Attempt(s) for resilient parallel I/O: " 
-                 << BinaryIO::latticeWriteMaxRetry << std::endl;
-    vm().setRunId(getPar().runId);
-    vm().printContent();
-    env().printContent();
-    if (getPar().saveSchedule or getPar().scheduleFile.empty())
-    {
-        schedule();
-        if (getPar().saveSchedule)
-        {
-            std::string filename;
-
-            filename = (getPar().scheduleFile.empty()) ? 
-                         "hadrons.sched" : getPar().scheduleFile;
-            saveSchedule(filename);
-        }
-    }
-    else
-    {
-        loadSchedule(getPar().scheduleFile);
-    }
-    printSchedule();
-    if (!getPar().graphFile.empty())
-    {
-        makeFileDir(getPar().graphFile, env().getGrid());
-        vm().dumpModuleGraph(getPar().graphFile);
-    }
-    configLoop();
-}
-
-// parse parameter file ////////////////////////////////////////////////////////
-class ObjectId: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ObjectId,
-                                    std::string, name,
-                                    std::string, type);
-};
-
-void Application::parseParameterFile(const std::string parameterFileName)
-{
-    XmlReader reader(parameterFileName);
-    GlobalPar par;
-    ObjectId  id;
-    
-    LOG(Message) << "Building application from '" << parameterFileName << "'..." << std::endl;
-    read(reader, "parameters", par);
-    setPar(par);
-    if (!push(reader, "modules"))
-    {
-        HADRONS_ERROR(Parsing, "Cannot open node 'modules' in parameter file '" 
-                              + parameterFileName + "'");
-    }
-    if (!push(reader, "module"))
-    {
-        HADRONS_ERROR(Parsing, "Cannot open node 'modules/module' in parameter file '" 
-                              + parameterFileName + "'");
-    }
-    do
-    {
-        read(reader, "id", id);
-        vm().createModule(id.name, id.type, reader);
-    } while (reader.nextElement("module"));
-    pop(reader);
-    pop(reader);
-}
-
-void Application::saveParameterFile(const std::string parameterFileName, unsigned int prec)
-{
-    LOG(Message) << "Saving application to '" << parameterFileName << "'..." << std::endl;
-    if (env().getGrid()->IsBoss())
-    {
-        XmlWriter          writer(parameterFileName);
-        writer.setPrecision(prec);
-        ObjectId           id;
-        const unsigned int nMod = vm().getNModule();
-
-        write(writer, "parameters", getPar());
-        push(writer, "modules");
-        for (unsigned int i = 0; i < nMod; ++i)
-        {
-            push(writer, "module");
-            id.name = vm().getModuleName(i);
-            id.type = vm().getModule(i)->getRegisteredName();
-            write(writer, "id", id);
-            vm().getModule(i)->saveParameters(writer, "options");
-            pop(writer);
-        }
-        pop(writer);
-        pop(writer);
-    }
-}
-
-// schedule computation ////////////////////////////////////////////////////////
-void Application::schedule(void)
-{
-    if (!scheduled_ and !loadedSchedule_)
-    {
-        program_   = vm().schedule(par_.genetic);
-        scheduled_ = true;
-    }
-}
-
-void Application::saveSchedule(const std::string filename)
-{
-    LOG(Message) << "Saving current schedule to '" << filename << "'..."
-                 << std::endl;
-    if (env().getGrid()->IsBoss())
-    {
-        TextWriter               writer(filename);
-        std::vector<std::string> program;
-        
-        if (!scheduled_)
-        {
-            HADRONS_ERROR(Definition, "Computation not scheduled");
-        }
-
-        for (auto address: program_)
-        {
-            program.push_back(vm().getModuleName(address));
-        }
-        write(writer, "schedule", program);
-    }
-}
-
-void Application::loadSchedule(const std::string filename)
-{
-    TextReader               reader(filename);
-    std::vector<std::string> program;
-    
-    LOG(Message) << "Loading schedule from '" << filename << "'..."
-                 << std::endl;
-    read(reader, "schedule", program);
-    program_.clear();
-    for (auto &name: program)
-    {
-        program_.push_back(vm().getModuleAddress(name));
-    }
-    loadedSchedule_ = true;
-    scheduled_      = true;
-}
-
-void Application::printSchedule(void)
-{
-    if (!scheduled_ and !loadedSchedule_)
-    {
-        HADRONS_ERROR(Definition, "Computation not scheduled");
-    }
-    auto peak = vm().memoryNeeded(program_);
-    LOG(Message) << "Schedule (memory needed: " << sizeString(peak) << "):"
-                 << std::endl;
-    for (unsigned int i = 0; i < program_.size(); ++i)
-    {
-        LOG(Message) << std::setw(4) << i + 1 << ": "
-                     << vm().getModuleName(program_[i]) << std::endl;
-    }
-}
-
-// loop on configurations //////////////////////////////////////////////////////
-void Application::configLoop(void)
-{
-    auto range = par_.trajCounter;
-    
-    for (unsigned int t = range.start; t < range.end; t += range.step)
-    {
-        LOG(Message) << BIG_SEP << " Starting measurement for trajectory " << t
-                     << " " << BIG_SEP << std::endl;
-        vm().setTrajectory(t);
-        vm().executeProgram(program_);
-    }
-    LOG(Message) << BIG_SEP << " End of measurement " << BIG_SEP << std::endl;
-    env().freeAll();
-}
diff --git a/Hadrons/Application.hpp b/Hadrons/Application.hpp
deleted file mode 100644
index 36179c5f..00000000
--- a/Hadrons/Application.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Application.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Application_hpp_
-#define Hadrons_Application_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/VirtualMachine.hpp>
-#include <Hadrons/Module.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Main program manager                               *
- ******************************************************************************/
-class Application
-{
-public:
-    class TrajRange: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(TrajRange,
-                                        unsigned int, start,
-                                        unsigned int, end,
-                                        unsigned int, step);
-    };
-    class GlobalPar: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(GlobalPar,
-                                        TrajRange,                  trajCounter,
-                                        VirtualMachine::GeneticPar, genetic,
-                                        std::string,                runId,
-                                        std::string,                graphFile,
-                                        std::string,                scheduleFile,
-                                        bool,                       saveSchedule,
-                                        int,                        parallelWriteMaxRetry);
-        GlobalPar(void): parallelWriteMaxRetry{-1} {}
-    };
-public:
-    // constructors
-    Application(void);
-    Application(const GlobalPar &par);
-    Application(const std::string parameterFileName);
-    // destructor
-    virtual ~Application(void) = default;
-    // access
-    void              setPar(const GlobalPar &par);
-    const GlobalPar & getPar(void);
-    // module creation
-    template <typename M>
-    void createModule(const std::string name);
-    template <typename M>
-    void createModule(const std::string name, const typename M::Par &par);
-    // execute
-    void run(void);
-    // XML parameter file I/O
-    void parseParameterFile(const std::string parameterFileName);
-    void saveParameterFile(const std::string parameterFileName, unsigned int prec=15);
-    // schedule computation
-    void schedule(void);
-    void saveSchedule(const std::string filename);
-    void loadSchedule(const std::string filename);
-    void printSchedule(void);
-    // loop on configurations
-    void configLoop(void);
-private:
-    // environment shortcut
-    DEFINE_ENV_ALIAS;
-    // virtual machine shortcut
-    DEFINE_VM_ALIAS;
-private:
-    long unsigned int       locVol_;
-    std::string             parameterFileName_{""};
-    GlobalPar               par_;
-    VirtualMachine::Program program_;
-    bool                    scheduled_{false}, loadedSchedule_{false};
-};
-
-/******************************************************************************
- *                     Application template implementation                    *
- ******************************************************************************/
-// module creation /////////////////////////////////////////////////////////////
-template <typename M>
-void Application::createModule(const std::string name)
-{
-    vm().createModule<M>(name);
-    scheduled_ = false;
-}
-
-template <typename M>
-void Application::createModule(const std::string name,
-                               const typename M::Par &par)
-{
-    vm().createModule<M>(name, par);
-    scheduled_ = false;
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Application_hpp_
diff --git a/Hadrons/Archive/Modules/ScalarVP.cc b/Hadrons/Archive/Modules/ScalarVP.cc
deleted file mode 100644
index f4f7e59b..00000000
--- a/Hadrons/Archive/Modules/ScalarVP.cc
+++ /dev/null
@@ -1,564 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/ScalarVP.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/ChargedProp.hpp>
-#include <Hadrons/Modules/MScalar/ScalarVP.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/*
- * Scalar QED vacuum polarisation up to O(alpha)
- *
- * Conserved vector 2-point function diagram notation:
- *        _______
- *       /       \
- * U_nu *         * U_mu
- *       \_______/
- *
- *                (   adj(S(a\hat{nu}|x)) U_mu(x) S(0|x+a\hat{mu}) U_nu(0)    )
- *          = 2 Re(                             -                             )
- *                ( adj(S(a\hat{nu}|x+a\hat{mu})) adj(U_mu(x)) S(0|x) U_nu(0) )
- *  
- *
- *            _______
- *           /       \
- * free = 1 *         * 1
- *           \_______/
- *
- *
- *
- *             _______
- *            /       \
- * S = iA_nu *         * iA_mu
- *            \_______/
- *
- *
- *         Delta_1
- *         ___*___
- *        /       \
- * X = 1 *         * 1
- *        \___*___/
- *         Delta_1
- *
- *          Delta_1                     Delta_1
- *          ___*___                     ___*___
- *         /       \                   /       \
- *      1 *         * iA_mu  +  iA_nu *         * 1
- *         \_______/                   \_______/
- * 4C =        _______                     _______
- *            /       \                   /       \
- *      +  1 *         * iA_mu  +  iA_nu *         * 1
- *            \___*___/                   \___*___/
- *             Delta_1                     Delta_1
- *
- *     Delta_1   Delta_1
- *          _*___*_             _______
- *         /       \           /       \
- * 2E = 1 *         * 1  +  1 *         * 1
- *         \_______/           \_*___*_/
- *                         Delta_1   Delta_1
- *
- *          Delta_2
- *          ___*___             _______
- *         /       \           /       \
- * 2T = 1 *         * 1  +  1 *         * 1
- *         \_______/           \___*___/
- *                              Delta_2
- *
- *
- *                    _______
- *                   /       \
- * srcT = -A_nu^2/2 *         * 1
- *                   \_______/
- *
- *
- *
- *            _______
- *           /       \
- * snkT = 1 *         * -A_mu^2/2
- *           \_______/
- *
- * Full VP to O(alpha) = free + q^2*(S+X+4C+2E+2T+srcT+snkT)
- */
-
-/******************************************************************************
-*                  TScalarVP implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TScalarVP::TScalarVP(const std::string name)
-: Module<ScalarVPPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TScalarVP::getInput(void)
-{
-    prop0Name_ = par().scalarProp + "_0";
-    propQName_ = par().scalarProp + "_Q";
-    propSunName_ = par().scalarProp + "_Sun";
-    propTadName_ = par().scalarProp + "_Tad";
-
-	std::vector<std::string> in = {par().emField, prop0Name_, propQName_,
-                                   propSunName_, propTadName_};
-    
-    return in;
-}
-
-std::vector<std::string> TScalarVP::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        // out.push_back(getName() + "_propQ_" + std::to_string(mu));
-
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            out.push_back(getName() + "_" + std::to_string(mu)
-                          + "_" + std::to_string(nu));
-        }
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TScalarVP::setup(void)
-{
-	freeMomPropName_ = FREEMOMPROP(static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().mass);
-	GFSrcName_ = par().scalarProp + "_DinvSrc";
-    fftName_   = par().scalarProp + "_fft";
-	phaseName_.clear();
-	muPropQName_.clear();
-    vpTensorName_.clear();
-    momPhaseName_.clear();
-	for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        phaseName_.push_back("_shiftphase_" + std::to_string(mu));
-        muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu));
-
-        std::vector<std::string> vpTensorName_mu;
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            vpTensorName_mu.push_back(getName() + "_" + std::to_string(mu)
-                                      + "_" + std::to_string(nu));
-        }
-        vpTensorName_.push_back(vpTensorName_mu);
-    }
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p));
-        }
-    }
-
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-	{
-	    envCreateLat(ScalarField, muPropQName_[mu]);
-
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            envCreateLat(ScalarField, vpTensorName_[mu][nu]);
-        }
-	}
-    if (!par().output.empty())
-    {
-        momPhasesDone_ = env().hasCreatedObject(momPhaseName_[0]);
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            envCacheLat(ScalarField, momPhaseName_[i_p]);
-        }
-    }
-    envTmpLat(ScalarField, "buf");
-    envTmpLat(ScalarField, "result");
-    envTmpLat(ScalarField, "Amu");
-    envTmpLat(ScalarField, "Usnk");
-    envTmpLat(ScalarField, "tmpProp");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TScalarVP::execute(void)
-{
-    // CACHING ANALYTIC EXPRESSIONS
-    makeCaches();
-
-    Complex ci(0.0,1.0);
-    Real    q        = static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().charge;
-    auto    &prop0   = envGet(ScalarField, prop0Name_);
-    auto    &propQ   = envGet(ScalarField, propQName_);
-    auto    &propSun = envGet(ScalarField, propSunName_);
-    auto    &propTad = envGet(ScalarField, propTadName_);
-    auto    &GFSrc   = envGet(ScalarField, GFSrcName_);
-    auto    &G       = envGet(ScalarField, freeMomPropName_);
-    auto    &fft     = envGet(FFT, fftName_);
-    phase_.clear();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        auto &phmu = envGet(ScalarField, phaseName_[mu]);
-        phase_.push_back(&phmu);
-    }
-    
-    // PROPAGATORS FROM SHIFTED SOURCES
-    LOG(Message) << "Computing O(q) charged scalar propagators..."
-                 << std::endl;
-    std::vector<ScalarField *> muPropQ;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        auto &propmu = envGet(ScalarField, muPropQName_[mu]);
-
-        // -G*momD1*G*F*tau_mu*Src (momD1 = F*D1*Finv)
-        propmu = adj(*phase_[mu])*GFSrc;
-        momD1(propmu, fft);
-        propmu = -G*propmu;
-        fft.FFT_all_dim(propmu, propmu, FFT::backward);
-
-        muPropQ.push_back(&propmu);
-    }
-
-    // CONTRACTIONS
-    auto        &A = envGet(EmField, par().emField);
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-    envGetTmp(ScalarField, Usnk);
-    envGetTmp(ScalarField, tmpProp);
-    TComplex    Anu0, Usrc;
-    std::vector<int> coor0 = {0, 0, 0, 0};
-    std::vector<std::vector<ScalarField *> > vpTensor;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        std::vector<ScalarField *> vpTensor_mu;
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            auto &vpmunu = envGet(ScalarField, vpTensorName_[mu][nu]);
-            vpTensor_mu.push_back(&vpmunu);
-        }
-        vpTensor.push_back(vpTensor_mu);
-    }
-
-    // Prepare output data structure if necessary
-    Result outputData;
-    if (!par().output.empty())
-    {
-        outputData.projection.resize(par().outputMom.size());
-        outputData.lattice_size = env().getGrid()->FullDimensions().toVector();
-        outputData.mass = static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().mass;
-        outputData.charge = q;
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            outputData.projection[i_p].momentum = strToVec<int>(par().outputMom[i_p]);
-            outputData.projection[i_p].pi.resize(env().getNd());
-            outputData.projection[i_p].pi_free.resize(env().getNd());
-            outputData.projection[i_p].pi_2E.resize(env().getNd());
-            outputData.projection[i_p].pi_2T.resize(env().getNd());
-            outputData.projection[i_p].pi_S.resize(env().getNd());
-            outputData.projection[i_p].pi_4C.resize(env().getNd());
-            outputData.projection[i_p].pi_X.resize(env().getNd());
-            outputData.projection[i_p].pi_srcT.resize(env().getNd());
-            outputData.projection[i_p].pi_snkT.resize(env().getNd());
-            for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-            {
-                outputData.projection[i_p].pi[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_free[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_2E[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_2T[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_S[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_4C[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_X[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_srcT[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_snkT[nu].resize(env().getNd());
-            }
-        }
-    }
-
-    // Do contractions
-    for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-    {
-        peekSite(Anu0, peekLorentz(A, nu), coor0);
-
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..."
-                         << std::endl;
-            Amu = peekLorentz(A, mu);
-
-            // free
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(0|x-a\hat{\nu})
-                                                 // = S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, prop0, tmpProp, Usrc, mu);
-            *vpTensor[mu][nu] = result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_free[mu][nu], result,
-                            i_p);
-                }
-            }
-            tmpProp = result; // Just using tmpProp as a temporary ScalarField
-                              // here (buf is modified by calls to writeVP())
-
-            // srcT
-            result = tmpProp * (-0.5)*Anu0*Anu0;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_srcT[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // snkT
-            result = tmpProp * (-0.5)*Amu*Amu;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_snkT[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // S
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = ci*Anu0;
-            Usnk    = ci*Amu;
-            vpContraction(result, prop0, tmpProp, Usrc, Usnk, mu);
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_S[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 4C
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            Usnk    = ci*Amu;
-            vpContraction(result, propQ, tmpProp, Usrc, Usnk, mu);
-            Usrc    = ci*Anu0;
-            vpContraction(buf, propQ, tmpProp, Usrc, mu);
-            result += buf;
-            vpContraction(buf, prop0, *muPropQ[nu], Usrc, mu);
-            result += buf;
-            Usrc = Complex(1.0,0.0);
-            Usnk = ci*Amu;
-            vpContraction(buf, prop0, *muPropQ[nu], Usrc, Usnk, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_4C[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // X
-            Usrc = Complex(1.0,0.0);
-            vpContraction(result, propQ, *muPropQ[nu], Usrc, mu);
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_X[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 2E
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, propSun, tmpProp, Usrc, mu);
-            tmpProp = Cshift(propSun, nu, -1);     // S_\Sigma(0|x-a\hat{\nu})
-                               //(Note: <S(0|x-a\hat{\nu})> = <S(a\hat{\nu}|x)>)
-            vpContraction(buf, prop0, tmpProp, Usrc, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_2E[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 2T
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, propTad, tmpProp, Usrc, mu);
-            tmpProp = Cshift(propTad, nu, -1);     // S_T(0|x-a\hat{\nu})
-            vpContraction(buf, prop0, tmpProp, Usrc, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_2T[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // Do momentum projections of full VP if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi[mu][nu],
-                            *vpTensor[mu][nu], i_p);
-                }
-            }
-        }
-    }
-
-    // OUTPUT IF NECESSARY
-    if (!par().output.empty())
-    {
-        LOG(Message) << "Saving momentum-projected HVP to '"
-                     << RESULT_FILE_NAME(par().output, vm().getTrajectory()) << "'..."
-                     << std::endl;
-        saveResult(par().output, "HVP", outputData);
-    }
-}
-
-void TScalarVP::makeCaches(void)
-{
-    envGetTmp(ScalarField, buf);
-
-    if ( (!par().output.empty()) && (!momPhasesDone_) )
-    {
-        LOG(Message) << "Caching phases for momentum projections..."
-                     << std::endl;
-        auto l = env().getGrid()->FullDimensions();
-        Complex          ci(0.0,1.0);
-
-        // Calculate phase factors
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            std::vector<int> mom = strToVec<int>(par().outputMom[i_p]);
-            auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]);
-            momph_ip = Zero();
-            for (unsigned int j = 0; j < env().getNd()-1; ++j)
-            {
-                Real twoPiL = M_PI*2./l[j];
-                LatticeCoordinate(buf, j);
-                buf = mom[j]*twoPiL*buf;
-                momph_ip = momph_ip + buf;
-            }
-            momph_ip = exp(-ci*momph_ip);
-            momPhase_.push_back(&momph_ip);
-        }
-    }
-}
-
-void TScalarVP::vpContraction(ScalarField &vp,
-                   ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                   TComplex u_src, ScalarField &u_snk, int mu)
-{
-    // Note: this function assumes a point source is used.
-    vp = adj(prop_nu_x) * u_snk * Cshift(prop_0_x, mu, 1) * u_src;
-    vp -= Cshift(adj(prop_nu_x), mu, 1) * adj(u_snk) * prop_0_x * u_src;
-    vp = 2.0*real(vp);
-}
-
-void TScalarVP::vpContraction(ScalarField &vp,
-                   ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                   TComplex u_src, int mu)
-{
-    // Note: this function assumes a point source is used.
-    vp = adj(prop_nu_x) * Cshift(prop_0_x, mu, 1) * u_src;
-    vp -= Cshift(adj(prop_nu_x), mu, 1) * prop_0_x * u_src;
-    vp = 2.0*real(vp);
-}
-
-void TScalarVP::project(std::vector<Complex> &projection, const ScalarField &vp, int i_p)
-{
-    std::vector<TComplex>   vecBuf;
-    envGetTmp(ScalarField, buf);
-
-    buf = vp*(*momPhase_[i_p]);
-    sliceSum(buf, vecBuf, Tp);
-    projection.resize(vecBuf.size());
-    for (unsigned int t = 0; t < vecBuf.size(); ++t)
-    {
-        projection[t] = TensorRemove(vecBuf[t]);
-    }
-}
-
-void TScalarVP::momD1(ScalarField &s, FFT &fft)
-{
-    auto        &A = envGet(EmField, par().emField);
-    Complex     ci(0.0,1.0);
-
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-
-    result = Zero();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = (*phase_[mu])*s;
-        fft.FFT_all_dim(buf, buf, FFT::backward);
-        buf = Amu*buf;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result - ci*buf;
-    }
-    fft.FFT_all_dim(s, s, FFT::backward);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = Amu*s;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result + ci*adj(*phase_[mu])*buf;
-    }
-
-    s = result;
-}
diff --git a/Hadrons/Archive/Modules/ScalarVP.hpp b/Hadrons/Archive/Modules/ScalarVP.hpp
deleted file mode 100644
index 310299a1..00000000
--- a/Hadrons/Archive/Modules/ScalarVP.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/ScalarVP.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_ScalarVP_hpp_
-#define Hadrons_MScalar_ScalarVP_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Scalar vacuum polarisation                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class ScalarVPPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar,
-                                    std::string, emField,
-                                    std::string, scalarProp,
-                                    std::string, output,
-                                    std::vector<std::string>, outputMom);
-};
-
-class TScalarVP: public Module<ScalarVPPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-    typedef PhotonR::GaugeField     EmField;
-    typedef PhotonR::GaugeLinkField EmComp;
-    class Result: Serializable
-    {
-    public:
-        class Projection: Serializable
-        {
-        public:
-            GRID_SERIALIZABLE_CLASS_MEMBERS(Projection,
-                                            std::vector<int>,     momentum,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_free,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_2E,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_2T,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_S,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_4C,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_X,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_srcT,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_snkT);
-        };
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<int>,        lattice_size,
-                                        double,                  mass,
-                                        double,                  charge,
-                                        std::vector<Projection>, projection);
-    };
-public:
-    // constructor
-    TScalarVP(const std::string name);
-    // destructor
-    virtual ~TScalarVP(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    void makeCaches(void);
-    // conserved vector two-point contraction
-    void vpContraction(ScalarField &vp,
-                       ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                       TComplex u_src, ScalarField &u_snk, int mu);
-    // conserved vector two-point contraction with unit gauge link at sink
-    void vpContraction(ScalarField &vp,
-                       ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                       TComplex u_src, int mu);
-    // write momentum-projected vacuum polarisation to file(s)
-    void project(std::vector<Complex> &projection, const ScalarField &vp,
-                 int i_p);
-    // momentum-space Delta_1 insertion
-    void momD1(ScalarField &s, FFT &fft);
-private:
-    bool                                        momPhasesDone_;
-    std::string                                 freeMomPropName_, GFSrcName_,
-                                                prop0Name_, propQName_,
-                                                propSunName_, propTadName_,
-                                                fftName_;
-    std::vector<std::string>                    phaseName_, muPropQName_,
-                                                momPhaseName_;
-    std::vector<std::vector<std::string> >      vpTensorName_;
-    std::vector<ScalarField *>                  phase_, momPhase_;
-};
-
-MODULE_REGISTER(ScalarVP, TScalarVP, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_ScalarVP_hpp_
diff --git a/Hadrons/Archive/Modules/TestSeqConserved.cc b/Hadrons/Archive/Modules/TestSeqConserved.cc
deleted file mode 100644
index 46227b99..00000000
--- a/Hadrons/Archive/Modules/TestSeqConserved.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/TestSeqConserved.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MUtilities/TestSeqConserved.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MUtilities;
-
-template class Grid::Hadrons::MUtilities::TTestSeqConserved<FIMPL>;
-
diff --git a/Hadrons/Archive/Modules/TestSeqConserved.hpp b/Hadrons/Archive/Modules/TestSeqConserved.hpp
deleted file mode 100644
index fde8cfcd..00000000
--- a/Hadrons/Archive/Modules/TestSeqConserved.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/TestSeqConserved.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MUtilities_TestSeqConserved_hpp_
-#define Hadrons_MUtilities_TestSeqConserved_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
-  Ward Identity contractions using sequential propagators.
- -----------------------------
- 
- * options:
- - q:      point source propagator, 5D if available (string)
- - qSeq:   result of sequential insertion of conserved current using q (string)
- - action: action used for computation of q (string)
- - origin: string giving point source origin of q (string)
- - t_J:    time at which sequential current is inserted (int)
- - mu:     Lorentz index of current inserted (int)
- - curr:   current type, e.g. vector/axial (Current)
-*/
-
-/******************************************************************************
- *                            TestSeqConserved                                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MUtilities)
-
-class TestSeqConservedPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TestSeqConservedPar,
-                                    std::string,  q,
-                                    std::string,  qSeq,
-                                    std::string,  action,
-                                    std::string,  origin,
-                                    unsigned int, t_J,
-                                    unsigned int, mu,
-                                    Current,      curr);
-};
-
-template <typename FImpl>
-class TTestSeqConserved: public Module<TestSeqConservedPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TTestSeqConserved(const std::string name);
-    // destructor
-    virtual ~TTestSeqConserved(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TestSeqConserved, TTestSeqConserved<FIMPL>, MUtilities);
-
-/******************************************************************************
- *                     TTestSeqConserved implementation                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TTestSeqConserved<FImpl>::TTestSeqConserved(const std::string name)
-: Module<TestSeqConservedPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TTestSeqConserved<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q, par().qSeq, par().action};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TTestSeqConserved<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTestSeqConserved<FImpl>::setup(void)
-{
-    auto Ls = env().getObjectLs(par().q);
-    if (Ls != env().getObjectLs(par().action))
-    {
-        HADRONS_ERROR(Size, "Ls mismatch between quark action and propagator");
-    }
-    envTmpLat(PropagatorField, "tmp");
-    envTmpLat(LatticeComplex, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTestSeqConserved<FImpl>::execute(void)
-{
-    // Check sequential insertion of current gives same result as conserved 
-    // current sink upon contraction. Assume q uses a point source.
-
-    auto                  &q    = envGet(PropagatorField, par().q);
-    auto                  &qSeq = envGet(PropagatorField, par().qSeq);
-    auto                  &act  = envGet(FMat, par().action);
-    Gamma                 g5(Gamma::Algebra::Gamma5);
-    Gamma::Algebra        gA = (par().curr == Current::Axial) ?
-                                  Gamma::Algebra::Gamma5 :
-                                  Gamma::Algebra::Identity;
-    Gamma                 g(gA);
-    SitePropagator        qSite;
-    Complex               test_S, test_V, check_S, check_V;
-    std::vector<TComplex> check_buf;
-    std::vector<int>      siteCoord;
-
-    envGetTmp(PropagatorField, tmp);
-    envGetTmp(LatticeComplex, c);
-    siteCoord = strToVec<int>(par().origin);
-    peekSite(qSite, qSeq, siteCoord);
-    test_S = trace(qSite*g);
-    test_V = trace(qSite*g*Gamma::gmu[par().mu]);
-    act.ContractConservedCurrent(q, q, tmp, par().curr, par().mu);
-    c = trace(tmp*g);
-    sliceSum(c, check_buf, Tp);
-    check_S = TensorRemove(check_buf[par().t_J]);
-
-    c = trace(tmp*g*Gamma::gmu[par().mu]);
-    sliceSum(c, check_buf, Tp);
-    check_V = TensorRemove(check_buf[par().t_J]);
-
-    LOG(Message) << "Test S  = " << abs(test_S)   << std::endl;
-    LOG(Message) << "Test V  = " << abs(test_V) << std::endl;
-    LOG(Message) << "Check S = " << abs(check_S) << std::endl;
-    LOG(Message) << "Check V = " << abs(check_V) << std::endl;
-
-    // Check difference = 0
-    check_S -= test_S;
-    check_V -= test_V;
-
-    LOG(Message) << "Consistency check for sequential conserved " 
-                 << par().curr << " current insertion: " << std::endl; 
-    LOG(Message) << "Diff S  = " << abs(check_S) << std::endl;
-    LOG(Message) << "Diff V  = " << abs(check_V) << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_TestSeqConserved_hpp_
diff --git a/Hadrons/Archive/Modules/TestSeqGamma.cc b/Hadrons/Archive/Modules/TestSeqGamma.cc
deleted file mode 100644
index e52d0ade..00000000
--- a/Hadrons/Archive/Modules/TestSeqGamma.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/TestSeqGamma.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MUtilities/TestSeqGamma.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MUtilities;
-
-template class Grid::Hadrons::MUtilities::TTestSeqGamma<FIMPL>;
-
diff --git a/Hadrons/Archive/Modules/TestSeqGamma.hpp b/Hadrons/Archive/Modules/TestSeqGamma.hpp
deleted file mode 100644
index 3e1cdb6c..00000000
--- a/Hadrons/Archive/Modules/TestSeqGamma.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/TestSeqGamma.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MUtilities_TestSeqGamma_hpp_
-#define Hadrons_MUtilities_TestSeqGamma_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              TestSeqGamma                                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MUtilities)
-
-class TestSeqGammaPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TestSeqGammaPar,
-                                    std::string,    q,
-                                    std::string,    qSeq,
-                                    std::string,    origin,
-                                    Gamma::Algebra, gamma,
-                                    unsigned int,   t_g);
-};
-
-template <typename FImpl>
-class TTestSeqGamma: public Module<TestSeqGammaPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TTestSeqGamma(const std::string name);
-    // destructor
-    virtual ~TTestSeqGamma(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TestSeqGamma, TTestSeqGamma<FIMPL>, MUtilities);
-
-/******************************************************************************
- *                      TTestSeqGamma implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TTestSeqGamma<FImpl>::TTestSeqGamma(const std::string name)
-: Module<TestSeqGammaPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TTestSeqGamma<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q, par().qSeq};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TTestSeqGamma<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTestSeqGamma<FImpl>::setup(void)
-{
-    envTmpLat(LatticeComplex, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTestSeqGamma<FImpl>::execute(void)
-{
-    auto                  &q    = envGet(PropagatorField, par().q);
-    auto                  &qSeq = envGet(PropagatorField, par().qSeq);
-    Gamma                 g5(Gamma::Algebra::Gamma5);
-    Gamma                 g(par().gamma);
-    SitePropagator        qSite;
-    Complex               test, check;
-    std::vector<TComplex> check_buf;
-    std::vector<int>      siteCoord;
-
-    // Check sequential insertion of gamma matrix gives same result as 
-    // insertion of gamma at sink upon contraction. Assume q uses a point 
-    // source.
-    
-    envGetTmp(LatticeComplex, c);
-    siteCoord = strToVec<int>(par().origin);
-    peekSite(qSite, qSeq, siteCoord);
-    test = trace(g*qSite);
-
-    c = trace(adj(g)*g5*adj(q)*g5*g*q);
-    sliceSum(c, check_buf, Tp);
-    check = TensorRemove(check_buf[par().t_g]);
-
-    LOG(Message) << "Seq Result = " << abs(test)  << std::endl;
-    LOG(Message) << "Reference  = " << abs(check) << std::endl;
-
-    // Check difference = 0
-    check -= test;
-
-    LOG(Message) << "Consistency check for sequential " << par().gamma  
-                 << " insertion = " << abs(check) << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_TestSeqGamma_hpp_
diff --git a/Hadrons/Archive/Modules/VPCounterTerms.cc b/Hadrons/Archive/Modules/VPCounterTerms.cc
deleted file mode 100644
index c324ed5e..00000000
--- a/Hadrons/Archive/Modules/VPCounterTerms.cc
+++ /dev/null
@@ -1,260 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/VPCounterTerms.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/VPCounterTerms.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/******************************************************************************
-*                  TVPCounterTerms implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TVPCounterTerms::TVPCounterTerms(const std::string name)
-: Module<VPCounterTermsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TVPCounterTerms::getInput(void)
-{
-    std::vector<std::string> in = {par().source};
-    
-    return in;
-}
-
-std::vector<std::string> TVPCounterTerms::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TVPCounterTerms::setup(void)
-{
-	freeMomPropName_ = FREEMOMPROP(par().mass);
-    phaseName_.clear();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        phaseName_.push_back("_shiftphase_" + std::to_string(mu));
-    }
-    GFSrcName_ = getName() + "_DinvSrc";
-    phatsqName_ = getName() + "_pHatSquared";
-    prop0Name_ = getName() + "_freeProp";
-    twoscalarName_ = getName() + "_2scalarProp";
-    psquaredName_ = getName() + "_psquaredProp";
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p));
-        }
-    }
-
-    envCreateLat(ScalarField, freeMomPropName_);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        envCreateLat(ScalarField, phaseName_[mu]);
-    }
-    envCreateLat(ScalarField, phatsqName_);
-    envCreateLat(ScalarField, GFSrcName_);
-    envCreateLat(ScalarField, prop0Name_);
-    envCreateLat(ScalarField, twoscalarName_);
-    envCreateLat(ScalarField, psquaredName_);
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            envCacheLat(ScalarField, momPhaseName_[i_p]);
-        }
-    }
-    envTmpLat(ScalarField, "buf");
-    envTmpLat(ScalarField, "tmp_vp");
-    envTmpLat(ScalarField, "vpPhase");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TVPCounterTerms::execute(void)
-{
-	auto &source = envGet(ScalarField, par().source);
-    Complex     ci(0.0,1.0);
-    FFT         fft(env().getGrid());
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, tmp_vp);
-    
-    // Momentum-space free scalar propagator
-    auto &G = envGet(ScalarField, freeMomPropName_);
-    SIMPL::MomentumSpacePropagator(G, par().mass);
-
-    // Phases and hat{p}^2
-    auto &phatsq = envGet(ScalarField, phatsqName_);
-    Coordinate l = env().getGrid()->FullDimensions();
-    
-    LOG(Message) << "Calculating shift phases..." << std::endl;
-    phatsq = Zero();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Real    twoPiL = M_PI*2./l[mu];
-        auto &phmu  = envGet(ScalarField, phaseName_[mu]);
-
-        LatticeCoordinate(buf, mu);
-        phmu = exp(ci*twoPiL*buf);
-        phase_.push_back(&phmu);
-        buf = 2.*sin(.5*twoPiL*buf);
-		phatsq = phatsq + buf*buf;
-    }
-
-    // G*F*src
-    auto &GFSrc       = envGet(ScalarField, GFSrcName_);
-    fft.FFT_all_dim(GFSrc, source, FFT::forward);
-    GFSrc = G*GFSrc;
-
-    // Position-space free scalar propagator
-    auto &prop0       = envGet(ScalarField, prop0Name_);
-    prop0 = GFSrc;
-    fft.FFT_all_dim(prop0, prop0, FFT::backward);
-
-    // Propagators for counter-terms
-    auto &twoscalarProp        = envGet(ScalarField, twoscalarName_);
-    auto &psquaredProp         = envGet(ScalarField, psquaredName_);
-
-    twoscalarProp = G*GFSrc;
-    fft.FFT_all_dim(twoscalarProp, twoscalarProp, FFT::backward);
-
-    psquaredProp = G*phatsq*GFSrc;
-    fft.FFT_all_dim(psquaredProp, psquaredProp, FFT::backward);
-
-    // Prepare output data structure if necessary
-    Result outputData;
-    if (!par().output.empty())
-    {
-        outputData.projection.resize(par().outputMom.size());
-        outputData.lattice_size = env().getGrid()->FullDimensions().toVector();
-        outputData.mass = par().mass;
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            outputData.projection[i_p].momentum = strToVec<int>(par().outputMom[i_p]);
-            outputData.projection[i_p].twoScalar.resize(env().getNd());
-            outputData.projection[i_p].threeScalar.resize(env().getNd());
-            outputData.projection[i_p].pSquaredInsertion.resize(env().getNd());
-            for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-            {
-                outputData.projection[i_p].twoScalar[nu].resize(env().getNd());
-                outputData.projection[i_p].threeScalar[nu].resize(env().getNd());
-                outputData.projection[i_p].pSquaredInsertion[nu].resize(env().getNd());
-            }
-            // Calculate phase factors
-            auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]);
-            momph_ip = Zero();
-            for (unsigned int j = 0; j < env().getNd()-1; ++j)
-            {
-                Real twoPiL = M_PI*2./l[j];
-                LatticeCoordinate(buf, j);
-                buf = outputData.projection[i_p].momentum[j]*twoPiL*buf;
-                momph_ip = momph_ip + buf;
-            }
-            momph_ip = exp(-ci*momph_ip);
-            momPhase_.push_back(&momph_ip);
-        }
-    }
-
-    // Contractions
-    for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-    {
-    	buf = adj(Cshift(prop0, nu, -1));
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            // Two-scalar loop
-            tmp_vp = buf * Cshift(prop0, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * prop0;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].twoScalar[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-
-        	// Three-scalar loop (no vertex)
-    		tmp_vp = buf * Cshift(twoscalarProp, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * twoscalarProp;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].threeScalar[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-
-            // Three-scalar loop (hat{p}^2 insertion)
-    		tmp_vp = buf * Cshift(psquaredProp, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * psquaredProp;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pSquaredInsertion[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-        }
-    }
-
-    // OUTPUT IF NECESSARY
-    if (!par().output.empty())
-    {
-        LOG(Message) << "Saving momentum-projected correlators to '"
-                     << RESULT_FILE_NAME(par().output, vm().getTrajectory()) << "'..."
-                     << std::endl;
-        saveResult(par().output, "scalar_loops", outputData);
-    }
-}
-
-void TVPCounterTerms::project(std::vector<Complex> &projection, const ScalarField &vp, int i_p)
-{
-    std::vector<TComplex>   vecBuf;
-    envGetTmp(ScalarField, vpPhase);
-
-    vpPhase = vp*(*momPhase_[i_p]);
-    sliceSum(vpPhase, vecBuf, Tp);
-    projection.resize(vecBuf.size());
-    for (unsigned int t = 0; t < vecBuf.size(); ++t)
-    {
-        projection[t] = TensorRemove(vecBuf[t]);
-    }
-}
diff --git a/Hadrons/Archive/Modules/VPCounterTerms.hpp b/Hadrons/Archive/Modules/VPCounterTerms.hpp
deleted file mode 100644
index d8e6cc9a..00000000
--- a/Hadrons/Archive/Modules/VPCounterTerms.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/VPCounterTerms.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_VPCounterTerms_hpp_
-#define Hadrons_MScalar_VPCounterTerms_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         VPCounterTerms                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class VPCounterTermsPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(VPCounterTermsPar,
-                                    std::string, source,
-                                    double,      mass,
-                                    std::string, output,
-                                    std::vector<std::string>, outputMom);
-};
-
-class TVPCounterTerms: public Module<VPCounterTermsPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-    class Result: Serializable
-    {
-    public:
-        class Projection: Serializable
-        {
-        public:
-            GRID_SERIALIZABLE_CLASS_MEMBERS(Projection,
-                                            std::vector<int>,     momentum,
-                                            std::vector<std::vector<std::vector<Complex>>>, twoScalar,
-                                            std::vector<std::vector<std::vector<Complex>>>, threeScalar,
-                                            std::vector<std::vector<std::vector<Complex>>>, pSquaredInsertion);
-        };
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<int>,        lattice_size,
-                                        double,                  mass,
-                                        std::vector<Projection>, projection);
-    };
-public:
-    // constructor
-    TVPCounterTerms(const std::string name);
-    // destructor
-    virtual ~TVPCounterTerms(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    void project(std::vector<Complex> &projection, const ScalarField &vp, int i_p);
-private:
-    std::string                freeMomPropName_, GFSrcName_, phatsqName_, prop0Name_,
-                               twoscalarName_, twoscalarVertexName_,
-                               psquaredName_, psquaredVertexName_;
-    std::vector<std::string>   phaseName_, momPhaseName_;
-    std::vector<ScalarField *> phase_, momPhase_;
-};
-
-MODULE_REGISTER(VPCounterTerms, TVPCounterTerms, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_VPCounterTerms_hpp_
diff --git a/Hadrons/Archive/Modules/WardIdentity.cc b/Hadrons/Archive/Modules/WardIdentity.cc
deleted file mode 100644
index 07e5b222..00000000
--- a/Hadrons/Archive/Modules/WardIdentity.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WardIdentity.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/WardIdentity.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TWardIdentity<FIMPL>;
-
diff --git a/Hadrons/Archive/Modules/WardIdentity.hpp b/Hadrons/Archive/Modules/WardIdentity.hpp
deleted file mode 100644
index e7732fc0..00000000
--- a/Hadrons/Archive/Modules/WardIdentity.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WardIdentity.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WardIdentity_hpp_
-#define Hadrons_MContraction_WardIdentity_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
-  Ward Identity contractions
- -----------------------------
- 
- * options:
- - q:          propagator, 5D if available (string)
- - action:     action module used for propagator solution (string)
- - mass:       mass of quark (double)
- - test_axial: whether or not to test PCAC relation.
-*/
-
-/******************************************************************************
- *                              WardIdentity                                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class WardIdentityPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WardIdentityPar,
-                                    std::string, q,
-                                    std::string, action,
-                                    double,      mass,
-                                    bool,        test_axial);
-};
-
-template <typename FImpl>
-class TWardIdentity: public Module<WardIdentityPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TWardIdentity(const std::string name);
-    // destructor
-    virtual ~TWardIdentity(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(WardIdentity, TWardIdentity<FIMPL>, MContraction);
-
-/******************************************************************************
- *                     TWardIdentity implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWardIdentity<FImpl>::TWardIdentity(const std::string name)
-: Module<WardIdentityPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWardIdentity<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q, par().action};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWardIdentity<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWardIdentity<FImpl>::setup(void)
-{
-    Ls_ = env().getObjectLs(par().q);
-    if (Ls_ != env().getObjectLs(par().action))
-    {
-        HADRONS_ERROR(Size, "Ls mismatch between quark action and propagator");
-    }
-    envTmpLat(PropagatorField, "tmp");
-    envTmpLat(PropagatorField, "vector_WI");
-    if (par().test_axial)
-    {
-        envTmpLat(PropagatorField, "psi");
-        envTmpLat(LatticeComplex,  "PP");
-        envTmpLat(LatticeComplex,  "axial_defect");
-        envTmpLat(LatticeComplex,  "PJ5q");
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWardIdentity<FImpl>::execute(void)
-{
-    LOG(Message) << "Performing Ward Identity checks for quark '" << par().q
-                 << "'." << std::endl;
-
-    auto  &q   = envGet(PropagatorField, par().q);
-    auto  &act = envGet(FMat, par().action);
-    Gamma g5(Gamma::Algebra::Gamma5);
-
-    // Compute D_mu V_mu, D here is backward derivative.
-    envGetTmp(PropagatorField, tmp);
-    envGetTmp(PropagatorField, vector_WI);
-    vector_WI    = Zero();
-    for (unsigned int mu = 0; mu < Nd; ++mu)
-    {
-        act.ContractConservedCurrent(q, q, tmp, Current::Vector, mu);
-        tmp -= Cshift(tmp, mu, -1);
-        vector_WI += tmp;
-    }
-
-    // Test ward identity D_mu V_mu = 0;
-    LOG(Message) << "Vector Ward Identity check Delta_mu V_mu = " 
-                 << norm2(vector_WI) << std::endl;
-
-    if (par().test_axial)
-    {
-        envGetTmp(PropagatorField, psi);
-        envGetTmp(LatticeComplex, PP);
-        envGetTmp(LatticeComplex, axial_defect);
-        envGetTmp(LatticeComplex, PJ5q);
-        std::vector<TComplex> axial_buf;
-
-        // Compute <P|D_mu A_mu>, D is backwards derivative.
-        axial_defect = Zero();
-        for (unsigned int mu = 0; mu < Nd; ++mu)
-        {
-            act.ContractConservedCurrent(q, q, tmp, Current::Axial, mu);
-            tmp -= Cshift(tmp, mu, -1);
-            axial_defect += trace(g5*tmp);
-        }
-
-        // Get <P|J5q> for 5D (Zero(); for 4D) and <P|P>.
-        PJ5q = Zero();
-        if (Ls_ > 1)
-        {
-            // <P|P>
-            ExtractSlice(tmp, q, 0, 0);
-            psi  = 0.5 * (tmp - g5*tmp);
-            ExtractSlice(tmp, q, Ls_ - 1, 0);
-            psi += 0.5 * (tmp + g5*tmp);
-            PP = trace(adj(psi)*psi);
-
-            // <P|5Jq>
-            ExtractSlice(tmp, q, Ls_/2 - 1, 0);
-            psi  = 0.5 * (tmp + g5*tmp);
-            ExtractSlice(tmp, q, Ls_/2, 0);
-            psi += 0.5 * (tmp - g5*tmp);
-            PJ5q = trace(adj(psi)*psi);
-        }
-        else
-        {
-            PP = trace(adj(q)*q);
-        }
-
-        // Test ward identity <P|D_mu A_mu> = 2m<P|P> + 2<P|J5q>
-        LOG(Message) << "|D_mu A_mu|^2 = " << norm2(axial_defect) << std::endl;
-        LOG(Message) << "|PP|^2        = " << norm2(PP) << std::endl;
-        LOG(Message) << "|PJ5q|^2      = " << norm2(PJ5q) << std::endl;
-        LOG(Message) << "Axial Ward Identity defect Delta_mu A_mu = "
-                     << norm2(axial_defect) << std::endl;
-    
-        // Axial defect by timeslice.
-        axial_defect -= 2.*(par().mass*PP + PJ5q);
-        LOG(Message) << "Check Axial defect by timeslice" << std::endl;
-        sliceSum(axial_defect, axial_buf, Tp);
-        for (int t = 0; t < axial_buf.size(); ++t)
-        {
-            LOG(Message) << "t = " << t << ": " 
-                         << TensorRemove(axial_buf[t]) << std::endl;
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_WardIdentity_hpp_
diff --git a/Hadrons/Archive/Modules/WeakHamiltonian.hpp b/Hadrons/Archive/Modules/WeakHamiltonian.hpp
deleted file mode 100644
index d047a5fb..00000000
--- a/Hadrons/Archive/Modules/WeakHamiltonian.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakHamiltonian.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WeakHamiltonian_hpp_
-#define Hadrons_MContraction_WeakHamiltonian_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         WeakHamiltonian                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-/*******************************************************************************
- * Utilities for contractions involving the Weak Hamiltonian.
- ******************************************************************************/
-//// Sum and store correlator.
-#define MAKE_DIAG(exp, buf, res, n)\
-sliceSum(exp, buf, Tp);\
-res.name = (n);\
-res.corr.resize(buf.size());\
-for (unsigned int t = 0; t < buf.size(); ++t)\
-{\
-    res.corr[t] = TensorRemove(buf[t]);\
-}
-
-//// Contraction of mu index: use 'mu' variable in exp.
-#define SUM_MU(buf,exp)\
-   buf = Zero();				\
-for (unsigned int mu = 0; mu < ndim; ++mu)\
-{\
-    buf += exp;\
-}
-
-enum 
-{
-  i_V = 0,
-  i_A = 1,
-  n_i = 2
-};
-
-class WeakHamiltonianPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WeakHamiltonianPar,
-                                    std::string, q1,
-                                    std::string, q2,
-                                    std::string, q3,
-                                    std::string, q4,
-                                    unsigned int, tSnk,
-                                    std::string, output);
-};
-
-#define MAKE_WEAK_MODULE(modname)\
-class T##modname: public Module<WeakHamiltonianPar>\
-{\
-public:\
-    FERM_TYPE_ALIASES(FIMPL,)\
-    class Result: Serializable\
-    {\
-    public:\
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,\
-                                        std::string, name,\
-                                        std::vector<Complex>, corr);\
-    };\
-public:\
-    /* constructor */ \
-    T##modname(const std::string name);\
-    /* destructor */ \
-    virtual ~T##modname(void) {};\
-    /* dependency relation */ \
-    virtual std::vector<std::string> getInput(void);\
-    virtual std::vector<std::string> getOutput(void);\
-public:\
-    std::vector<std::string> VA_label = {"V", "A"};\
-protected:\
-    /* setup */ \
-    virtual void setup(void);\
-    /* execution */ \
-    virtual void execute(void);\
-};\
-MODULE_REGISTER(modname, T##modname, MContraction);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakHamiltonian_hpp_
diff --git a/Hadrons/Archive/Modules/WeakHamiltonianEye.cc b/Hadrons/Archive/Modules/WeakHamiltonianEye.cc
deleted file mode 100644
index df4d494c..00000000
--- a/Hadrons/Archive/Modules/WeakHamiltonianEye.cc
+++ /dev/null
@@ -1,151 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakHamiltonianEye.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-/*
- * Weak Hamiltonian current-current contractions, Eye-type.
- * 
- * These contractions are generated by the Q1 and Q2 operators in the physical
- * basis (see e.g. Fig 3 of arXiv:1507.03094).
- * 
- * Schematics:        q4                 |                  
- *                  /-<-¬                |                             
- *                 /     \               |             q2           q3
- *                 \     /               |        /----<------*------<----¬                        
- *            q2    \   /    q3          |       /          /-*-¬          \
- *       /-----<-----* *-----<----¬      |      /          /     \          \
- *    i *            H_W           * f   |   i *           \     /  q4      * f
- *       \                        /      |      \           \->-/          /   
- *        \                      /       |       \                        /       
- *         \---------->---------/        |        \----------->----------/        
- *                   q1                  |                   q1                  
- *                                       |
- *                Saucer (S)             |                  Eye (E)
- * 
- * S: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1]*q4*gL[mu][p_2])
- * E: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1])*trace(q4*gL[mu][p_2])
- * 
- * Note q1 must be sink smeared.
- */
-
-/******************************************************************************
- *                  TWeakHamiltonianEye implementation                        *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TWeakHamiltonianEye::TWeakHamiltonianEye(const std::string name)
-: Module<WeakHamiltonianPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TWeakHamiltonianEye::getInput(void)
-{
-    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
-    
-    return in;
-}
-
-std::vector<std::string> TWeakHamiltonianEye::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TWeakHamiltonianEye::setup(void)
-{
-    unsigned int ndim = env().getNd();
-
-    envTmpLat(LatticeComplex,  "expbuf");
-    envTmpLat(PropagatorField, "tmp1");
-    envTmpLat(LatticeComplex,  "tmp2");
-    envTmp(std::vector<PropagatorField>, "S_body", 1, ndim, PropagatorField(env().getGrid()));
-    envTmp(std::vector<PropagatorField>, "S_loop", 1, ndim, PropagatorField(env().getGrid()));
-    envTmp(std::vector<LatticeComplex>,  "E_body", 1, ndim, LatticeComplex(env().getGrid()));
-    envTmp(std::vector<LatticeComplex>,  "E_loop", 1, ndim, LatticeComplex(env().getGrid()));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TWeakHamiltonianEye::execute(void)
-{
-    LOG(Message) << "Computing Weak Hamiltonian (Eye type) contractions '" 
-                 << getName() << "' using quarks '" << par().q1 << "', '" 
-                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
-                 << "'." << std::endl;
-
-    auto                   &q1 = envGet(SlicedPropagator, par().q1);
-    auto                   &q2 = envGet(PropagatorField, par().q2);
-    auto                   &q3 = envGet(PropagatorField, par().q3);
-    auto                   &q4 = envGet(PropagatorField, par().q4);
-    Gamma                  g5  = Gamma(Gamma::Algebra::Gamma5);
-    std::vector<TComplex>  corrbuf;
-    std::vector<Result>    result(n_eye_diag);
-    unsigned int ndim    = env().getNd();
-
-    envGetTmp(LatticeComplex,               expbuf); 
-    envGetTmp(PropagatorField,              tmp1);
-    envGetTmp(LatticeComplex,               tmp2);
-    envGetTmp(std::vector<PropagatorField>, S_body);
-    envGetTmp(std::vector<PropagatorField>, S_loop);
-    envGetTmp(std::vector<LatticeComplex>,  E_body);
-    envGetTmp(std::vector<LatticeComplex>,  E_loop);
-
-    // Get sink timeslice of q1.
-    SitePropagator q1Snk = q1[par().tSnk];
-
-    // Setup for S-type contractions.
-    for (int mu = 0; mu < ndim; ++mu)
-    {
-        S_body[mu] = MAKE_SE_BODY(q1Snk, q2, q3, GammaL(Gamma::gmu[mu]));
-        S_loop[mu] = MAKE_SE_LOOP(q4, GammaL(Gamma::gmu[mu]));
-    }
-
-    // Perform S-type contractions.    
-    SUM_MU(expbuf, trace(S_body[mu]*S_loop[mu]))
-    MAKE_DIAG(expbuf, corrbuf, result[S_diag], "HW_S")
-
-    // Recycle sub-expressions for E-type contractions.
-    for (unsigned int mu = 0; mu < ndim; ++mu)
-    {
-        E_body[mu] = trace(S_body[mu]);
-        E_loop[mu] = trace(S_loop[mu]);
-    }
-
-    // Perform E-type contractions.
-    SUM_MU(expbuf, E_body[mu]*E_loop[mu])
-    MAKE_DIAG(expbuf, corrbuf, result[E_diag], "HW_E")
-
-    // IO
-    saveResult(par().output, "HW_Eye", result);
-}
diff --git a/Hadrons/Archive/Modules/WeakHamiltonianEye.hpp b/Hadrons/Archive/Modules/WeakHamiltonianEye.hpp
deleted file mode 100644
index 9d8db9a6..00000000
--- a/Hadrons/Archive/Modules/WeakHamiltonianEye.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakHamiltonianEye.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WeakHamiltonianEye_hpp_
-#define Hadrons_MContraction_WeakHamiltonianEye_hpp_
-
-#include <Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         WeakHamiltonianEye                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-enum
-{
-    S_diag = 0,
-    E_diag = 1,
-    n_eye_diag = 2
-};
-
-// Saucer and Eye subdiagram contractions.
-#define MAKE_SE_BODY(Q_1, Q_2, Q_3, gamma) (Q_3*g5*Q_1*adj(Q_2)*g5*gamma)
-#define MAKE_SE_LOOP(Q_loop, gamma) (Q_loop*gamma)
-
-MAKE_WEAK_MODULE(WeakHamiltonianEye)
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakHamiltonianEye_hpp_
diff --git a/Hadrons/Archive/Modules/WeakHamiltonianNonEye.cc b/Hadrons/Archive/Modules/WeakHamiltonianNonEye.cc
deleted file mode 100644
index 3b5ab2e9..00000000
--- a/Hadrons/Archive/Modules/WeakHamiltonianNonEye.cc
+++ /dev/null
@@ -1,148 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakHamiltonianNonEye.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-/*
- * Weak Hamiltonian current-current contractions, Non-Eye-type.
- * 
- * These contractions are generated by the Q1 and Q2 operators in the physical
- * basis (see e.g. Fig 3 of arXiv:1507.03094).
- * 
- * Schematic:     
- *            q2             q3          |           q2              q3
- *          /--<--¬       /--<--¬        |        /--<--¬         /--<--¬       
- *         /       \     /       \       |       /       \       /       \      
- *        /         \   /         \      |      /         \     /         \     
- *       /           \ /           \     |     /           \   /           \    
- *    i *             * H_W         *  f |  i *             * * H_W         * f 
- *      \             *             |    |     \           /   \           /
- *       \           / \           /     |      \         /     \         /    
- *        \         /   \         /      |       \       /       \       /  
- *         \       /     \       /       |        \-->--/         \-->--/      
- *          \-->--/       \-->--/        |          q1               q4 
- *            q1             q4          |
- *                Connected (C)          |                 Wing (W)
- *
- * C: trace(q1*adj(q2)*g5*gL[mu]*q3*adj(q4)*g5*gL[mu])
- * W: trace(q1*adj(q2)*g5*gL[mu])*trace(q3*adj(q4)*g5*gL[mu])
- * 
- */
-
-/******************************************************************************
- *                  TWeakHamiltonianNonEye implementation                     *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TWeakHamiltonianNonEye::TWeakHamiltonianNonEye(const std::string name)
-: Module<WeakHamiltonianPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TWeakHamiltonianNonEye::getInput(void)
-{
-    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
-    
-    return in;
-}
-
-std::vector<std::string> TWeakHamiltonianNonEye::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TWeakHamiltonianNonEye::setup(void)
-{
-    unsigned int ndim = env().getNd();
-
-    envTmpLat(LatticeComplex,  "expbuf");
-    envTmpLat(PropagatorField, "tmp1");
-    envTmpLat(LatticeComplex,  "tmp2");
-    envTmp(std::vector<PropagatorField>, "C_i_side_loop", 1, ndim, PropagatorField(env().getGrid()));
-    envTmp(std::vector<PropagatorField>, "C_f_side_loop", 1, ndim, PropagatorField(env().getGrid()));
-    envTmp(std::vector<LatticeComplex>,  "W_i_side_loop", 1, ndim, LatticeComplex(env().getGrid()));
-    envTmp(std::vector<LatticeComplex>,  "W_f_side_loop", 1, ndim, LatticeComplex(env().getGrid()));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TWeakHamiltonianNonEye::execute(void)
-{
-    LOG(Message) << "Computing Weak Hamiltonian (Non-Eye type) contractions '" 
-                 << getName() << "' using quarks '" << par().q1 << "', '" 
-                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
-                 << "'." << std::endl;
-    
-    auto                  &q1 = envGet(PropagatorField, par().q1);
-    auto                  &q2 = envGet(PropagatorField, par().q2);
-    auto                  &q3 = envGet(PropagatorField, par().q3);
-    auto                  &q4 = envGet(PropagatorField, par().q4);
-    Gamma                 g5  = Gamma(Gamma::Algebra::Gamma5);
-    std::vector<TComplex> corrbuf;
-    std::vector<Result>   result(n_noneye_diag); 
-    unsigned int          ndim = env().getNd();
-
-    envGetTmp(LatticeComplex,               expbuf); 
-    envGetTmp(PropagatorField,              tmp1);
-    envGetTmp(LatticeComplex,               tmp2);
-    envGetTmp(std::vector<PropagatorField>, C_i_side_loop);
-    envGetTmp(std::vector<PropagatorField>, C_f_side_loop);
-    envGetTmp(std::vector<LatticeComplex>,  W_i_side_loop);
-    envGetTmp(std::vector<LatticeComplex>,  W_f_side_loop);
-
-    // Setup for C-type contractions.
-    for (int mu = 0; mu < ndim; ++mu)
-    {
-        C_i_side_loop[mu] = MAKE_CW_SUBDIAG(q1, q2, GammaL(Gamma::gmu[mu]));
-        C_f_side_loop[mu] = MAKE_CW_SUBDIAG(q3, q4, GammaL(Gamma::gmu[mu]));
-    }
-
-    // Perform C-type contractions.    
-    SUM_MU(expbuf, trace(C_i_side_loop[mu]*C_f_side_loop[mu]))
-    MAKE_DIAG(expbuf, corrbuf, result[C_diag], "HW_C")
-
-    // Recycle sub-expressions for W-type contractions.
-    for (unsigned int mu = 0; mu < ndim; ++mu)
-    {
-        W_i_side_loop[mu] = trace(C_i_side_loop[mu]);
-        W_f_side_loop[mu] = trace(C_f_side_loop[mu]);
-    }
-
-    // Perform W-type contractions.
-    SUM_MU(expbuf, W_i_side_loop[mu]*W_f_side_loop[mu])
-    MAKE_DIAG(expbuf, corrbuf, result[W_diag], "HW_W")
-
-    // IO
-    saveResult(par().output, "HW_NonEye", result);
-}
diff --git a/Hadrons/Archive/Modules/WeakHamiltonianNonEye.hpp b/Hadrons/Archive/Modules/WeakHamiltonianNonEye.hpp
deleted file mode 100644
index ce74642e..00000000
--- a/Hadrons/Archive/Modules/WeakHamiltonianNonEye.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakHamiltonianNonEye.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WeakHamiltonianNonEye_hpp_
-#define Hadrons_MContraction_WeakHamiltonianNonEye_hpp_
-
-#include <Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         WeakHamiltonianNonEye                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-enum
-{
-    W_diag = 0,
-    C_diag = 1,
-    n_noneye_diag = 2
-};
-
-// Wing and Connected subdiagram contractions
-#define MAKE_CW_SUBDIAG(Q_1, Q_2, gamma) (Q_1*adj(Q_2)*g5*gamma)
-
-MAKE_WEAK_MODULE(WeakHamiltonianNonEye)
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakHamiltonianNonEye_hpp_
diff --git a/Hadrons/Archive/Modules/WeakNeutral4ptDisc.cc b/Hadrons/Archive/Modules/WeakNeutral4ptDisc.cc
deleted file mode 100644
index 52fce3f6..00000000
--- a/Hadrons/Archive/Modules/WeakNeutral4ptDisc.cc
+++ /dev/null
@@ -1,142 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakNeutral4ptDisc.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-/*
- * Weak Hamiltonian + current contractions, disconnected topology for neutral 
- * mesons.
- * 
- * These contractions are generated by operators Q_1,...,10 of the dS=1 Weak
- * Hamiltonian in the physical basis and an additional current J (see e.g. 
- * Fig 11 of arXiv:1507.03094).
- * 
- * Schematic:
- *                        
- *           q2          q4             q3
- *       /--<--¬     /---<--¬       /---<--¬
- *     /         \ /         \     /        \
- *  i *           * H_W      |  J *          * f
- *     \         / \         /     \        /
- *      \--->---/   \-------/       \------/
- *          q1 
- * 
- * options
- * - q1: input propagator 1 (string)
- * - q2: input propagator 2 (string)
- * - q3: input propagator 3 (string), assumed to be sequential propagator 
- * - q4: input propagator 4 (string), assumed to be a loop
- * 
- * type 1: trace(q1*adj(q2)*g5*gL[mu])*trace(loop*gL[mu])*trace(q3*g5)
- * type 2: trace(q1*adj(q2)*g5*gL[mu]*loop*gL[mu])*trace(q3*g5)
- */
-
-/*******************************************************************************
- *                  TWeakNeutral4ptDisc implementation                         *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TWeakNeutral4ptDisc::TWeakNeutral4ptDisc(const std::string name)
-: Module<WeakHamiltonianPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TWeakNeutral4ptDisc::getInput(void)
-{
-    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
-    
-    return in;
-}
-
-std::vector<std::string> TWeakNeutral4ptDisc::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TWeakNeutral4ptDisc::setup(void)
-{
-    unsigned int ndim = env().getNd();
-
-    envTmpLat(LatticeComplex,  "expbuf");
-    envTmpLat(PropagatorField, "tmp");
-    envTmpLat(LatticeComplex,  "curr");
-    envTmp(std::vector<PropagatorField>, "meson", 1, ndim, PropagatorField(env().getGrid()));
-    envTmp(std::vector<PropagatorField>, "loop", 1, ndim,  PropagatorField(env().getGrid()));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TWeakNeutral4ptDisc::execute(void)
-{
-    LOG(Message) << "Computing Weak Hamiltonian neutral disconnected contractions '" 
-                 << getName() << "' using quarks '" << par().q1 << "', '" 
-                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
-                 << "'." << std::endl;
-
-    auto                  &q1 = envGet(PropagatorField, par().q1);
-    auto                  &q2 = envGet(PropagatorField, par().q2);
-    auto                  &q3 = envGet(PropagatorField, par().q3);
-    auto                  &q4 = envGet(PropagatorField, par().q4);
-    Gamma                 g5  = Gamma(Gamma::Algebra::Gamma5);
-    std::vector<TComplex> corrbuf;
-    std::vector<Result>   result(n_neut_disc_diag);
-    unsigned int          ndim = env().getNd();
-
-    envGetTmp(LatticeComplex,               expbuf); 
-    envGetTmp(PropagatorField,              tmp);
-    envGetTmp(LatticeComplex,               curr);
-    envGetTmp(std::vector<PropagatorField>, meson);
-    envGetTmp(std::vector<PropagatorField>, loop);
-
-    // Setup for type 1 contractions.
-    for (int mu = 0; mu < ndim; ++mu)
-    {
-        meson[mu] = MAKE_DISC_MESON(q1, q2, GammaL(Gamma::gmu[mu]));
-        loop[mu] = MAKE_DISC_LOOP(q4, GammaL(Gamma::gmu[mu]));
-    }
-    curr = MAKE_DISC_CURR(q3, GammaL(Gamma::Algebra::Gamma5));
-
-    // Perform type 1 contractions.    
-    SUM_MU(expbuf, trace(meson[mu]*loop[mu]))
-    expbuf *= curr;
-    MAKE_DIAG(expbuf, corrbuf, result[neut_disc_1_diag], "HW_disc0_1")
-
-    // Perform type 2 contractions.
-    SUM_MU(expbuf, trace(meson[mu])*trace(loop[mu]))
-    expbuf *= curr;
-    MAKE_DIAG(expbuf, corrbuf, result[neut_disc_2_diag], "HW_disc0_2")
-
-    // IO
-    saveResult(par().output, "HW_disc0", result);
-}
diff --git a/Hadrons/Archive/Modules/WeakNeutral4ptDisc.hpp b/Hadrons/Archive/Modules/WeakNeutral4ptDisc.hpp
deleted file mode 100644
index 7a1d1451..00000000
--- a/Hadrons/Archive/Modules/WeakNeutral4ptDisc.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Archive/Modules/WeakNeutral4ptDisc.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WeakNeutral4ptDisc_hpp_
-#define Hadrons_MContraction_WeakNeutral4ptDisc_hpp_
-
-#include <Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         WeakNeutral4ptDisc                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-enum
-{
-    neut_disc_1_diag = 0,
-    neut_disc_2_diag = 1,
-    n_neut_disc_diag = 2
-};
-
-// Neutral 4pt disconnected subdiagram contractions.
-#define MAKE_DISC_MESON(Q_1, Q_2, gamma) (Q_1*adj(Q_2)*g5*gamma)
-#define MAKE_DISC_LOOP(Q_LOOP, gamma) (Q_LOOP*gamma)
-#define MAKE_DISC_CURR(Q_c, gamma) (trace(Q_c*gamma))
-
-MAKE_WEAK_MODULE(WeakNeutral4ptDisc)
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakNeutral4ptDisc_hpp_
diff --git a/Hadrons/DilutedNoise.hpp b/Hadrons/DilutedNoise.hpp
deleted file mode 100644
index f25edaba..00000000
--- a/Hadrons/DilutedNoise.hpp
+++ /dev/null
@@ -1,356 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/DilutedNoise.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_DilutedNoise_hpp_
-#define Hadrons_DilutedNoise_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                   Abstract container for diluted noise                     *
- ******************************************************************************/
-template <typename FImpl>
-class DilutedNoise
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    DilutedNoise(GridCartesian *g);
-    DilutedNoise(GridCartesian *g, const unsigned int nNoise);
-    virtual ~DilutedNoise(void) = default;
-    // access
-    std::vector<FermionField> &       getNoise(void);
-    const std::vector<FermionField> & getNoise(void) const;
-    const FermionField &              operator[](const unsigned int i) const;
-    FermionField &                    operator[](const unsigned int i);
-    void                              normalise(Real norm);
-    void                              resize(const unsigned int nNoise);
-    unsigned int                      size(void) const;
-    GridCartesian                     *getGrid(void) const;
-    // generate noise (pure virtual)
-    virtual void generateNoise(GridParallelRNG &rng) = 0;
-private:
-    std::vector<FermionField> noise_;
-    GridCartesian             *grid_;
-    unsigned int              nNoise_;
-};
-
-template <typename FImpl>
-class TimeDilutedSpinColorDiagonalNoise: public DilutedNoise<FImpl>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    TimeDilutedSpinColorDiagonalNoise(GridCartesian *g);
-    virtual ~TimeDilutedSpinColorDiagonalNoise(void) = default;
-    // generate noise
-    virtual void generateNoise(GridParallelRNG &rng);
-private:
-    unsigned int nt_;
-};
-
-template <typename FImpl>
-class FullVolumeSpinColorDiagonalNoise: public DilutedNoise<FImpl>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    FullVolumeSpinColorDiagonalNoise(GridCartesian *g, unsigned int n_src);
-    virtual ~FullVolumeSpinColorDiagonalNoise(void) = default;
-    // generate noise
-    virtual void generateNoise(GridParallelRNG &rng);
-private:
-    unsigned int nSrc_;
-};
-
-template <typename FImpl>
-class SparseSpinColorDiagonalNoise: public DilutedNoise<FImpl>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    SparseSpinColorDiagonalNoise(GridCartesian *g, unsigned int n_src, unsigned int n_sparse);
-    virtual ~SparseSpinColorDiagonalNoise(void) = default;
-    // generate noise
-    virtual void generateNoise(GridParallelRNG &rng);
-private:
-    unsigned int nSrc_;
-    unsigned int nSparse_;
-};
-
-/******************************************************************************
- *                    DilutedNoise template implementation                    *
- ******************************************************************************/
-template <typename FImpl>
-DilutedNoise<FImpl>::DilutedNoise(GridCartesian *g)
-: grid_(g)
-{}
-
-template <typename FImpl>
-DilutedNoise<FImpl>::DilutedNoise(GridCartesian *g,
-                                  const unsigned int nNoise)
-: DilutedNoise(g)
-{
-    resize(nNoise);
-}
-
-template <typename FImpl>
-std::vector<typename DilutedNoise<FImpl>::FermionField> & DilutedNoise<FImpl>::
-getNoise(void)
-{
-    return noise_;
-}
-
-template <typename FImpl>
-const std::vector<typename DilutedNoise<FImpl>::FermionField> & DilutedNoise<FImpl>::
-getNoise(void) const
-{
-    return noise_;
-}
-
-template <typename FImpl>
-const typename DilutedNoise<FImpl>::FermionField & 
-DilutedNoise<FImpl>::operator[](const unsigned int i) const
-{
-    return noise_[i];
-}
-
-template <typename FImpl>
-typename DilutedNoise<FImpl>::FermionField & 
-DilutedNoise<FImpl>::operator[](const unsigned int i)
-{
-    return noise_[i];
-}
-
-template <typename FImpl>
-void DilutedNoise<FImpl>::normalise(Real norm)
-{
-    for(int i=0;i<noise_.size();i++)
-    {
-        noise_[i] = norm*noise_[i];
-    }
-}
-
-template <typename FImpl>
-void DilutedNoise<FImpl>::resize(const unsigned int nNoise)
-{
-    nNoise_ = nNoise;
-    noise_.resize(nNoise, grid_);
-}
-
-template <typename FImpl>
-unsigned int DilutedNoise<FImpl>::size(void) const
-{  
-    return noise_.size();
-}
-
-template <typename FImpl>
-GridCartesian * DilutedNoise<FImpl>::getGrid(void) const
-{
-    return grid_;
-}
-
-/******************************************************************************
- *        TimeDilutedSpinColorDiagonalNoise template implementation           *
- ******************************************************************************/
-template <typename FImpl>
-TimeDilutedSpinColorDiagonalNoise<FImpl>::
-TimeDilutedSpinColorDiagonalNoise(GridCartesian *g)
-: DilutedNoise<FImpl>(g)
-{
-    nt_ = this->getGrid()->GlobalDimensions().size();
-    this->resize(nt_*Ns*FImpl::Dimension);
-}
-
-template <typename FImpl>
-void TimeDilutedSpinColorDiagonalNoise<FImpl>::generateNoise(GridParallelRNG &rng)
-{
-    typedef decltype(peekColour((*this)[0], 0)) SpinField;
-
-    auto                       &noise = *this;
-    auto                       g      = this->getGrid();
-    auto                       nd     = g->GlobalDimensions().size();
-    auto                       nc     = FImpl::Dimension;
-    Complex                    shift(1., 1.);
-    Lattice<iScalar<vInteger>> tLat(g);
-    LatticeComplex             eta(g), etaCut(g);
-    SpinField                  etas(g);
-    unsigned int               i = 0;
-
-    LatticeCoordinate(tLat, nd - 1);
-    bernoulli(rng, eta);
-    eta = (2.*eta - shift)*(1./::sqrt(2.));
-    for (unsigned int t = 0; t < nt_; ++t)
-    {
-        etaCut = where((tLat == t), eta, 0.*eta);
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-	    etas = Zero();
-	    pokeSpin(etas, etaCut, s);
-            for (unsigned int c = 0; c < nc; ++c)
-            {
-  	        noise[i] = Zero();
-                pokeColour(noise[i], etas, c);
-                i++;
-            }
-        }
-    }
-}
-
-/******************************************************************************
- *        FullVolumeSpinColorDiagonalNoise template implementation           *
- ******************************************************************************/
-template <typename FImpl>
-FullVolumeSpinColorDiagonalNoise<FImpl>::
-FullVolumeSpinColorDiagonalNoise(GridCartesian *g, unsigned int nSrc)
-: DilutedNoise<FImpl>(g, nSrc*Ns*FImpl::Dimension), nSrc_(nSrc)
-{}
-
-template <typename FImpl>
-void FullVolumeSpinColorDiagonalNoise<FImpl>::generateNoise(GridParallelRNG &rng)
-{
-    typedef decltype(peekColour((*this)[0], 0)) SpinField;
-
-    auto                       &noise = *this;
-    auto                       g      = this->getGrid();
-    auto                       nd     = g->GlobalDimensions().size();
-    auto                       nc     = FImpl::Dimension;
-    Complex                    shift(1., 1.);
-    LatticeComplex             eta(g);
-    SpinField                  etas(g);
-    unsigned int               i = 0;
-
-    bernoulli(rng, eta);
-    eta = (2.*eta - shift)*(1./::sqrt(2.));
-    for (unsigned int n = 0; n < nSrc_; ++n)
-    {
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-  	    etas = Zero();
-            pokeSpin(etas, eta, s);
-            for (unsigned int c = 0; c < nc; ++c)
-            {
-	        noise[i] = Zero();
-                pokeColour(noise[i], etas, c);
-                i++;
-            }
-        }
-    }
-}
-
-/******************************************************************************
- *        SparseSpinColorDiagonalNoise template implementation           *
- ******************************************************************************/
-template <typename FImpl>
-SparseSpinColorDiagonalNoise<FImpl>::
-SparseSpinColorDiagonalNoise(GridCartesian *g, unsigned int nSrc, unsigned int nSparse)
-: DilutedNoise<FImpl>(g, nSrc*Ns*FImpl::Dimension), nSrc_(nSrc), nSparse_(nSparse)
-{}
-
-template <typename FImpl>
-void SparseSpinColorDiagonalNoise<FImpl>::generateNoise(GridParallelRNG &rng)
-{
-    typedef decltype(peekColour((*this)[0], 0)) SpinField;
-
-    auto                       &noise = *this;
-    auto                       g      = this->getGrid();
-    auto                       nd     = g->GlobalDimensions().size();
-    auto                       nc     = FImpl::Dimension;
-    LatticeInteger             coor(g), coorTot(g); coorTot = 0.;
-    Complex                    shift(1., 1.);
-    LatticeComplex             eta(g), etaSparse(g);
-    SpinField                  etas(g);
-    unsigned int               i = 0;
-    unsigned int               j = 0;
-    unsigned int               nSrc_ec;
-    
-    if(nSrc_%nSparse_==0)
-    {
-         nSrc_ec = nSrc_/nSparse_;
-    }
-    else
-    {
-         nSrc_ec = (nSrc_ - nSrc_%nSparse_)/nSparse_;
-    }
-
-    for (unsigned int n = 0; n < nSrc_; ++n)
-    {
-        bernoulli(rng, eta);
-        eta = (2.*eta - shift)*(1./::sqrt(2.));
-
-        if(nSparse_ != 1)
-        { 
-        assert(g->GlobalDimensions()[1]%nSparse_ == 0);
-        // # 0 # 0
-        // 0 # 0 #
-        // # 0 # 0
-        // 0 # 0 #
-
-        coorTot = 0;
-
-            for(unsigned int d = 0; d < nd; ++d) 
-            {
-                LatticeCoordinate(coor, d);
-                coorTot = coorTot + coor;
-            }
-            coorTot = coorTot + j;
-            eta = where(mod(coorTot,nSparse_), 0.*eta, eta);
-            
-        }
-        
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-            etas = Zero();
-            pokeSpin(etas, eta, s);
-            for (unsigned int c = 0; c < nc; ++c)
-            {
-                noise[i] = Zero();
-                pokeColour(noise[i], etas, c);
-                
-                i++;
-                
-                /**/ 
-            
-            }
-        }
-        ((n+1)%nSrc_ec == 0) ? j++: 0;
-    }
-    Real norm = sqrt(1./nSrc_ec);
-    this->normalise(norm);
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_DilutedNoise_hpp_
diff --git a/Hadrons/DiskVector.hpp b/Hadrons/DiskVector.hpp
deleted file mode 100644
index dd5956aa..00000000
--- a/Hadrons/DiskVector.hpp
+++ /dev/null
@@ -1,511 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/DiskVector.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_DiskVector_hpp_
-#define Hadrons_DiskVector_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-#include <deque>
-#include <sys/stat.h>
-#include <ftw.h>
-#include <unistd.h>
-
-#ifdef DV_DEBUG
-#define DV_DEBUG_MSG(dv, stream) LOG(Debug) << "diskvector " << (dv) << ": " << stream << std::endl
-#else
-#define DV_DEBUG_MSG(dv, stream)
-#endif
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                           Abstract base class                              *
- ******************************************************************************/
-template <typename T>
-class DiskVectorBase
-{
-public:
-    typedef T ObjectType;
-
-    // helper for read/write vector access
-    class RwAccessHelper
-    {
-    public:
-        RwAccessHelper(DiskVectorBase<T> &master, const unsigned int i)
-        : master_(master), cmaster_(master), i_(i) {}
-
-        // operator=: somebody is trying to store a vector element
-        // write to cache and tag as modified
-        T &operator=(const T &obj) const
-        {
-            auto &cache    = *master_.cachePtr_;
-            auto &modified = *master_.modifiedPtr_;
-            auto &index    = *master_.indexPtr_;
-
-            DV_DEBUG_MSG(&master_, "writing to " << i_);
-            master_.cacheInsert(i_, obj);
-            modified[index.at(i_)] = true;
-            
-            return cache[index.at(i_)];
-        }
-
-        // implicit cast to const object reference and redirection
-        // to the const operator[] for read-only operations
-        operator const T&() const
-        {
-            return cmaster_[i_];
-        }
-    private:
-        DiskVectorBase<T>       &master_;
-        const DiskVectorBase<T> &cmaster_;
-        const unsigned int      i_;
-    };
-public:
-    DiskVectorBase(const std::string dirname, const unsigned int size = 0,
-                   const unsigned int cacheSize = 1, const bool clean = true,
-                   GridBase *grid = nullptr);
-    DiskVectorBase(DiskVectorBase<T> &&v) = default;
-    virtual ~DiskVectorBase(void);
-    const T & operator[](const unsigned int i) const;
-    RwAccessHelper operator[](const unsigned int i);
-    double hitRatio(void) const;
-    void resetStat(void);
-    void setSize(unsigned int size_);
-    unsigned int getSize() const;
-    unsigned int dvSize;
-    void setGrid(GridBase *grid_);
-    GridBase *getGrid() const;
-    GridBase *dvGrid;
-private:
-    virtual void load(T &obj, const std::string filename) const = 0;
-    virtual void save(const std::string filename, const T &obj) const = 0;
-    virtual std::string filename(const unsigned int i) const;
-    void evict(void) const;
-    void fetch(const unsigned int i) const;
-    void cacheInsert(const unsigned int i, const T &obj) const;
-    void clean(void);
-private:
-    std::string                                           dirname_;
-    unsigned int                                          size_, cacheSize_;
-    double                                                access_{0.}, hit_{0.};
-    bool                                                  clean_;
-    GridBase                                              *grid_;
-    // using pointers to allow modifications when class is const
-    // semantic: const means data unmodified, but cache modification allowed
-    std::unique_ptr<std::vector<T>>                       cachePtr_;
-    std::unique_ptr<std::vector<bool>>                    modifiedPtr_;
-    std::unique_ptr<std::map<unsigned int, unsigned int>> indexPtr_;
-    std::unique_ptr<std::stack<unsigned int>>             freePtr_;
-    std::unique_ptr<std::deque<unsigned int>>             loadsPtr_;                
-};
-
-/******************************************************************************
- *                   Specialisation for serialisable classes                  *
- ******************************************************************************/
-template <typename T, typename Reader, typename Writer>
-class SerializableDiskVector: public DiskVectorBase<T>
-{
-public:
-    using DiskVectorBase<T>::DiskVectorBase;
-private:
-    virtual void load(T &obj, const std::string filename) const
-    {
-        Reader reader(filename);
-
-        read(reader, basename(filename), obj);
-    }
-
-    virtual void save(const std::string filename, const T &obj) const
-    {
-        Writer writer(filename);
-
-        write(writer, basename(filename), obj);
-    }
-};
-
-/******************************************************************************
- *                      Specialisation for Eigen matrices                     *
- ******************************************************************************/
-template <typename T>
-using EigenDiskVectorMat = A2AMatrix<T>;
-
-template <typename T>
-class EigenDiskVector: public DiskVectorBase<EigenDiskVectorMat<T>>
-{
-public:
-    using DiskVectorBase<EigenDiskVectorMat<T>>::DiskVectorBase;
-    typedef EigenDiskVectorMat<T> Matrix;
-public:
-    T operator()(const unsigned int i, const Eigen::Index j,
-                 const Eigen::Index k) const
-    {
-        return (*this)[i](j, k);
-    }
-    std::vector<int> dimensions() const
-    {
-        std::vector<int> dims(3);
-        dims[0] = (*this).getSize();
-        dims[1] = (*this)[0].rows();
-        dims[2] = (*this)[0].cols();
-        return dims;
-    }
-private:
-    virtual void load(EigenDiskVectorMat<T> &obj, const std::string filename) const
-    {
-        GridBase *loadGrid;
-        loadGrid = (*this).getGrid();
-        if (!(loadGrid) || loadGrid->IsBoss())
-        {
-            std::ifstream f(filename, std::ios::binary);
-            uint32_t      crc, check;
-            Eigen::Index  nRow, nCol;
-            size_t        matSize;
-            double        tRead, tHash;
-
-            f.read(reinterpret_cast<char *>(&crc), sizeof(crc));
-            f.read(reinterpret_cast<char *>(&nRow), sizeof(nRow));
-            f.read(reinterpret_cast<char *>(&nCol), sizeof(nCol));
-            obj.resize(nRow, nCol);
-            matSize = nRow*nCol*sizeof(T);
-            tRead  = -usecond();
-            f.read(reinterpret_cast<char *>(obj.data()), matSize);
-            tRead += usecond();
-            tHash  = -usecond();
-    #ifdef USE_IPP
-            check  = GridChecksum::crc32c(obj.data(), matSize);
-    #else
-            check  = GridChecksum::crc32(obj.data(), matSize);
-    #endif
-            tHash += usecond();
-            DV_DEBUG_MSG(this, "Eigen read " << tRead/1.0e6 << " sec " << matSize/tRead*1.0e6/1024/1024 << " MB/s");
-            DV_DEBUG_MSG(this, "Eigen crc32 " << std::hex << check << std::dec 
-                        << " " << tHash/1.0e6 << " sec " << matSize/tHash*1.0e6/1024/1024 << " MB/s");
-            if (crc != check)
-            {
-                HADRONS_ERROR(Io, "checksum failed")
-            }
-        }
-        int broadcastSize;
-        broadcastSize = sizeof(T)*obj.size();
-        if (loadGrid)
-        {
-            loadGrid->Broadcast(loadGrid->BossRank(), obj.data(), broadcastSize);
-            loadGrid->Barrier();
-        }
-    }
-
-    virtual void save(const std::string filename, const EigenDiskVectorMat<T> &obj) const
-    {
-        GridBase *saveGrid;
-        saveGrid = (*this).getGrid();
-        if (!(saveGrid) || saveGrid->IsBoss())
-        {
-            std::ofstream f(filename, std::ios::binary);
-            uint32_t      crc;
-            Eigen::Index  nRow, nCol;
-            size_t        matSize;
-            double        tWrite, tHash;
-            
-            nRow    = obj.rows();
-            nCol    = obj.cols();
-            matSize = nRow*nCol*sizeof(T);
-            tHash   = -usecond();
-    #ifdef USE_IPP
-            crc     = GridChecksum::crc32c(obj.data(), matSize);
-    #else
-            crc     = GridChecksum::crc32(obj.data(), matSize);
-    #endif
-            tHash  += usecond();
-            f.write(reinterpret_cast<char *>(&crc), sizeof(crc));
-            f.write(reinterpret_cast<char *>(&nRow), sizeof(nRow));
-            f.write(reinterpret_cast<char *>(&nCol), sizeof(nCol));
-            tWrite = -usecond();
-            f.write(reinterpret_cast<const char *>(obj.data()), matSize);
-            tWrite += usecond();
-            DV_DEBUG_MSG(this, "Eigen write " << tWrite/1.0e6 << " sec " << matSize/tWrite*1.0e6/1024/1024 << " MB/s");
-            DV_DEBUG_MSG(this, "Eigen crc32 " << std::hex << crc << std::dec
-                        << " " << tHash/1.0e6 << " sec " << matSize/tHash*1.0e6/1024/1024 << " MB/s");
-        }
-        if (saveGrid)   saveGrid->Barrier();
-    }
-};
-
-/******************************************************************************
- *                       DiskVectorBase implementation                         *
- ******************************************************************************/
-template <typename T>
-DiskVectorBase<T>::DiskVectorBase(const std::string dirname, 
-                                  const unsigned int size,
-                                  const unsigned int cacheSize,
-                                  const bool clean,
-                                  GridBase *grid)
-: dirname_(dirname), size_(size), cacheSize_(cacheSize), clean_(clean), grid_(grid)
-, cachePtr_(new std::vector<T>(size))
-, modifiedPtr_(new std::vector<bool>(size, false))
-, indexPtr_(new std::map<unsigned int, unsigned int>())
-, freePtr_(new std::stack<unsigned int>)
-, loadsPtr_(new std::deque<unsigned int>())
-{
-    struct stat s;
-
-    if (!(grid_) || grid_->IsBoss())
-    {
-        if(stat(dirname.c_str(), &s) == 0)
-        {
-            HADRONS_ERROR(Io, "directory '" + dirname + "' already exists")
-        }
-        mkdir(dirname);
-    }
-    if (grid_)  grid_->Barrier();
-    for (unsigned int i = 0; i < cacheSize_; ++i)
-    {
-        freePtr_->push(i);
-    }
-    setSize(size_);
-    setGrid(grid_);
-}
-
-template <typename T>
-DiskVectorBase<T>::~DiskVectorBase(void)
-{
-    if (clean_)
-    {
-        clean();
-    }
-}
-
-template <typename T>
-void DiskVectorBase<T>::setSize(unsigned int size_)
-{
-    dvSize = size_;
-}
-
-template <typename T>
-unsigned int DiskVectorBase<T>::getSize() const
-{
-    return dvSize;
-}
-
-template <typename T>
-void DiskVectorBase<T>::setGrid(GridBase *grid_)
-{
-    dvGrid = grid_;
-}
-
-template <typename T>
-GridBase *DiskVectorBase<T>::getGrid() const
-{
-    return dvGrid;
-}
-
-template <typename T>
-const T & DiskVectorBase<T>::operator[](const unsigned int i) const
-{
-    auto &cache   = *cachePtr_;
-    auto &index   = *indexPtr_;
-    auto &freeInd = *freePtr_;
-    auto &loads   = *loadsPtr_;
-
-    DV_DEBUG_MSG(this, "accessing " << i << " (RO)");
-
-    if (i >= size_)
-    {
-        HADRONS_ERROR(Size, "index out of range");
-    }
-    const_cast<double &>(access_)++;
-    if (index.find(i) == index.end())
-    {
-        // cache miss
-        DV_DEBUG_MSG(this, "cache miss");
-        fetch(i);
-    }
-    else
-    {
-        DV_DEBUG_MSG(this, "cache hit");
-
-        auto pos = std::find(loads.begin(), loads.end(), i);
-
-        const_cast<double &>(hit_)++;
-        loads.erase(pos);
-        loads.push_back(i);
-    }
-
-#ifdef DV_DEBUG
-    std::string msg;
-
-    for (auto &p: loads)
-    {
-        msg += std::to_string(p) + " ";
-    }
-    DV_DEBUG_MSG(this, "in cache: " << msg);
-#endif
-    if (grid_)  grid_->Barrier();
-    return cache[index.at(i)];
-}
-
-template <typename T>
-typename DiskVectorBase<T>::RwAccessHelper DiskVectorBase<T>::operator[](const unsigned int i)
-{
-    DV_DEBUG_MSG(this, "accessing " << i << " (RW)");
-
-    if (i >= size_)
-    {
-        HADRONS_ERROR(Size, "index out of range");
-    }
-
-    return RwAccessHelper(*this, i);
-}
-
-template <typename T>
-double DiskVectorBase<T>::hitRatio(void) const
-{
-    return hit_/access_;
-}
-
-template <typename T>
-void DiskVectorBase<T>::resetStat(void)
-{
-    access_ = 0.;
-    hit_    = 0.;
-}
-
-template <typename T>
-std::string DiskVectorBase<T>::filename(const unsigned int i) const
-{
-    return dirname_ + "/elem_" + std::to_string(i);
-}
-
-template <typename T>
-void DiskVectorBase<T>::evict(void) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    if (index.size() >= cacheSize_)
-    {
-        unsigned int i = loads.front();
-        
-        DV_DEBUG_MSG(this, "evicting " << i);
-        if (modified[index.at(i)])
-        {
-            DV_DEBUG_MSG(this, "element " << i << " modified, saving to disk");
-            save(filename(i), cache[index.at(i)]);
-        }
-        freeInd.push(index.at(i));
-        index.erase(i);
-        loads.pop_front();
-    }
-    if (grid_)  grid_->Barrier();
-}
-
-template <typename T>
-void DiskVectorBase<T>::fetch(const unsigned int i) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    struct stat s;
-
-    DV_DEBUG_MSG(this, "loading " << i << " from disk");
-
-    evict();
-    
-    if(stat(filename(i).c_str(), &s) != 0)
-    {
-        HADRONS_ERROR(Io, "disk vector element " + std::to_string(i) + " uninitialised");
-    }
-    index[i] = freeInd.top();
-    freeInd.pop();
-    load(cache[index.at(i)], filename(i));
-    loads.push_back(i);
-    modified[index.at(i)] = false;
-}
-
-template <typename T>
-void DiskVectorBase<T>::cacheInsert(const unsigned int i, const T &obj) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    evict();
-    index[i] = freeInd.top();
-    freeInd.pop();
-    cache[index.at(i)] = obj;
-    loads.push_back(i);
-    modified[index.at(i)] = false;
-
-    if (grid_)  grid_->Barrier();
-#ifdef DV_DEBUG
-    std::string msg;
-
-    for (auto &p: loads)
-    {
-        msg += std::to_string(p) + " ";
-    }
-    DV_DEBUG_MSG(this, "in cache: " << msg);
-#endif
-}
-
-#ifdef DV_DEBUG
-#undef DV_DEBUG_MSG
-#endif
-
-template <typename T>
-void DiskVectorBase<T>::clean(void)
-{
-    if (!(grid_) || grid_->IsBoss())
-    {
-        auto unlink = [](const char *fpath, const struct stat *sb,
-                         int typeflag, struct FTW *ftwbuf) {
-            int rv = remove(fpath);
-
-            if (rv)
-            {
-                HADRONS_ERROR(Io, "cannot remove '" + std::string(fpath) + "': " + std::string(std::strerror(errno)));
-            }
-
-            return rv;
-        };
-
-        nftw(dirname_.c_str(), unlink, 64, FTW_DEPTH | FTW_PHYS);
-    }
-    if (grid_)  grid_->Barrier();
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_DiskVector_hpp_
diff --git a/Hadrons/EigenPack.hpp b/Hadrons/EigenPack.hpp
deleted file mode 100644
index 2e7c62c9..00000000
--- a/Hadrons/EigenPack.hpp
+++ /dev/null
@@ -1,416 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/EigenPack.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_EigenPack_hpp_
-#define Hadrons_EigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Grid/algorithms/iterative/Deflation.h>
-#include <Grid/algorithms/iterative/LocalCoherenceLanczos.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-// Lanczos type
-#ifndef HADRONS_DEFAULT_LANCZOS_NBASIS
-#define HADRONS_DEFAULT_LANCZOS_NBASIS 60
-#endif
-
-#define HADRONS_DUMP_EP_METADATA(record) \
-LOG(Message) << "Eigenpack metadata:" << std::endl;\
-LOG(Message) << "* operator" << std::endl;\
-LOG(Message) << (record).operatorXml << std::endl;\
-LOG(Message) << "* solver" << std::endl;\
-LOG(Message) << (record).solverXml << std::endl;
-
-struct PackRecord
-{
-    std::string operatorXml, solverXml;
-};
-
-struct VecRecord: Serializable
-{
-    GRID_SERIALIZABLE_CLASS_MEMBERS(VecRecord,
-                                    unsigned int, index,
-                                    double,       eval);
-    VecRecord(void): index(0), eval(0.) {}
-};
-
-namespace EigenPackIo
-{
-    inline void readHeader(PackRecord &record, ScidacReader &binReader)
-    {
-        std::string recordXml;
-
-        binReader.readLimeObject(recordXml, SCIDAC_FILE_XML);
-        XmlReader xmlReader(recordXml, true, "eigenPackPar");
-        xmlReader.push();
-        xmlReader.readCurrentSubtree(record.operatorXml);
-        xmlReader.nextElement();
-        xmlReader.readCurrentSubtree(record.solverXml);
-    }
-
-    template <typename T, typename TIo = T>
-    void readElement(T &evec, RealD &eval, const unsigned int index,
-                     ScidacReader &binReader, TIo *ioBuf = nullptr)
-    {
-        VecRecord vecRecord;
-
-        LOG(Message) << "Reading eigenvector " << index << std::endl;
-        if (ioBuf == nullptr)
-        {
-            binReader.readScidacFieldRecord(evec, vecRecord);
-        }
-        else
-        {
-            binReader.readScidacFieldRecord(*ioBuf, vecRecord);
-            precisionChange(evec, *ioBuf);
-        }
-        if (vecRecord.index != index)
-        {
-            HADRONS_ERROR(Io, "Eigenvector " + std::to_string(index) + " has a"
-                            + " wrong index (expected " + std::to_string(vecRecord.index) 
-                            + ")");
-        }
-        eval = vecRecord.eval;
-    }
-
-    template <typename T, typename TIo = T>
-    static void readPack(std::vector<T> &evec, std::vector<RealD> &eval,
-                         PackRecord &record, const std::string filename, 
-                         const unsigned int size, bool multiFile, 
-                         GridBase *gridIo = nullptr)
-    {
-        std::unique_ptr<TIo> ioBuf{nullptr};
-        ScidacReader         binReader;
-
-        if (typeHash<T>() != typeHash<TIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-            ioBuf.reset(new TIo(gridIo));
-        }
-        if (multiFile)
-        {
-            std::string fullFilename;
-
-            for(int k = 0; k < size; ++k) 
-            {
-                fullFilename = filename + "/v" + std::to_string(k) + ".bin";
-                binReader.open(fullFilename);
-                readHeader(record, binReader);
-                readElement(evec[k], eval[k], k, binReader, ioBuf.get());
-                binReader.close();
-            }
-        }
-        else
-        {
-            binReader.open(filename);
-            readHeader(record, binReader);
-            for(int k = 0; k < size; ++k) 
-            {
-                readElement(evec[k], eval[k], k, binReader, ioBuf.get());
-            }
-            binReader.close();
-        }
-    }
-
-    inline void writeHeader(ScidacWriter &binWriter, PackRecord &record)
-    {
-        XmlWriter xmlWriter("", "eigenPackPar");
-
-        xmlWriter.pushXmlString(record.operatorXml);
-        xmlWriter.pushXmlString(record.solverXml);
-        binWriter.writeLimeObject(1, 1, xmlWriter, "parameters", SCIDAC_FILE_XML);
-    }
-
-    template <typename T, typename TIo = T>
-    void writeElement(ScidacWriter &binWriter, T &evec, RealD &eval, 
-                      const unsigned int index, TIo *ioBuf, 
-                      T *testBuf = nullptr)
-    {
-        VecRecord vecRecord;
-
-        LOG(Message) << "Writing eigenvector " << index << std::endl;
-        vecRecord.eval  = eval;
-        vecRecord.index = index;
-        if ((ioBuf == nullptr) || (testBuf == nullptr))
-        {
-            binWriter.writeScidacFieldRecord(evec, vecRecord, DEFAULT_ASCII_PREC);
-        }
-        else
-        {
-            precisionChange(*ioBuf, evec);
-            precisionChange(*testBuf, *ioBuf);
-            *testBuf -= evec;
-            LOG(Message) << "Precision diff norm^2 " << norm2(*testBuf) << std::endl;
-            binWriter.writeScidacFieldRecord(*ioBuf, vecRecord, DEFAULT_ASCII_PREC);
-        }   
-    }
-    
-    template <typename T, typename TIo = T>
-    static void writePack(const std::string filename, std::vector<T> &evec, 
-                          std::vector<RealD> &eval, PackRecord &record, 
-                          const unsigned int size, bool multiFile, 
-                          GridBase *gridIo = nullptr)
-    {
-        GridBase             *grid = evec[0].Grid();
-        std::unique_ptr<TIo> ioBuf{nullptr}; 
-        std::unique_ptr<T>   testBuf{nullptr};
-        ScidacWriter         binWriter(grid->IsBoss());
-
-        if (typeHash<T>() != typeHash<TIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-            ioBuf.reset(new TIo(gridIo));
-            testBuf.reset(new T(grid));
-        }
-        if (multiFile)
-        {
-            std::string fullFilename;
-
-            for(int k = 0; k < size; ++k) 
-            {
-                fullFilename = filename + "/v" + std::to_string(k) + ".bin";
-
-                makeFileDir(fullFilename, grid);
-                binWriter.open(fullFilename);
-                writeHeader(binWriter, record);
-                writeElement(binWriter, evec[k], eval[k], k, ioBuf.get(), testBuf.get());
-                binWriter.close();
-            }
-        }
-        else
-        {
-            makeFileDir(filename, grid);
-            binWriter.open(filename);
-            writeHeader(binWriter, record);
-            for(int k = 0; k < size; ++k) 
-            {
-                writeElement(binWriter, evec[k], eval[k], k, ioBuf.get(), testBuf.get());
-            }
-            binWriter.close();
-        }
-    }
-}
-
-template <typename F>
-class BaseEigenPack
-{
-public:
-    typedef F Field;
-public:
-    std::vector<RealD> eval;
-    std::vector<F>     evec;
-    PackRecord         record;
-public:
-    BaseEigenPack(void)          = default;
-    BaseEigenPack(const size_t size, GridBase *grid)
-    {
-        resize(size, grid);
-    }
-    virtual ~BaseEigenPack(void) = default;
-    void resize(const size_t size, GridBase *grid)
-    {
-        eval.resize(size);
-        evec.resize(size, grid);
-    }
-};
-
-template <typename F, typename FIo = F>
-class EigenPack: public BaseEigenPack<F>
-{
-public:
-    typedef F   Field;
-    typedef FIo FieldIo;
-public:
-    EigenPack(void)          = default;
-    virtual ~EigenPack(void) = default;
-
-    EigenPack(const size_t size, GridBase *grid, GridBase *gridIo = nullptr)
-    : BaseEigenPack<F>(size, grid)
-    {
-        if (typeHash<F>() != typeHash<FIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-        }
-        gridIo_ = gridIo;
-    }
-
-    virtual void read(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::readPack<F, FIo>(this->evec, this->eval, this->record, 
-                                      evecFilename(fileStem, traj, multiFile), 
-                                      this->evec.size(), multiFile, gridIo_);
-        HADRONS_DUMP_EP_METADATA(this->record);
-    }
-
-    virtual void write(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::writePack<F, FIo>(evecFilename(fileStem, traj, multiFile), 
-                                       this->evec, this->eval, this->record, 
-                                       this->evec.size(), multiFile, gridIo_);
-    }
-protected:
-    std::string evecFilename(const std::string stem, const int traj, const bool multiFile)
-    {
-        std::string t = (traj < 0) ? "" : ("." + std::to_string(traj));
-
-        if (multiFile)
-        {
-            return stem + t;
-        }
-        else
-        {
-            return stem + t + ".bin";
-        }
-    }
-protected:
-    GridBase *gridIo_;
-};
-
-template <typename FineF, typename CoarseF, 
-          typename FineFIo = FineF, typename CoarseFIo = CoarseF>
-class CoarseEigenPack: public EigenPack<FineF, FineFIo>
-{
-public:
-    typedef CoarseF   CoarseField;
-    typedef CoarseFIo CoarseFieldIo;
-public:      
-    std::vector<CoarseF> evecCoarse;
-    std::vector<RealD>   evalCoarse;
-public:
-    CoarseEigenPack(void)          = default;
-    virtual ~CoarseEigenPack(void) = default;
-
-    CoarseEigenPack(const size_t sizeFine, const size_t sizeCoarse, 
-                    GridBase *gridFine, GridBase *gridCoarse,
-                    GridBase *gridFineIo = nullptr, 
-                    GridBase *gridCoarseIo = nullptr)
-    {
-        if (typeHash<FineF>() != typeHash<FineFIo>())
-        {
-            if (gridFineIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "Fine I/O type different from vector type but null fine I/O grid passed");
-            }
-        }
-        if (typeHash<CoarseF>() != typeHash<CoarseFIo>())
-        {
-            if (gridCoarseIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "Coarse I/O type different from vector type but null coarse I/O grid passed");
-            }
-        }
-        this->gridIo_ = gridFineIo;
-        gridCoarseIo_ = gridCoarseIo;
-        resize(sizeFine, sizeCoarse, gridFine, gridCoarse);
-    }
-
-    void resize(const size_t sizeFine, const size_t sizeCoarse, 
-                GridBase *gridFine, GridBase *gridCoarse)
-    {
-        EigenPack<FineF, FineFIo>::resize(sizeFine, gridFine);
-        evalCoarse.resize(sizeCoarse);
-        evecCoarse.resize(sizeCoarse, gridCoarse);
-    }
-
-    void readFine(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPack<FineF, FineFIo>::read(fileStem + "_fine", multiFile, traj);
-    }
-
-    void readCoarse(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        PackRecord dummy;
-
-        EigenPackIo::readPack<CoarseF, CoarseFIo>(evecCoarse, evalCoarse, dummy, 
-                              this->evecFilename(fileStem + "_coarse", traj, multiFile), 
-                              evecCoarse.size(), multiFile, gridCoarseIo_);
-    }
-
-    virtual void read(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        readFine(fileStem, multiFile, traj);
-        readCoarse(fileStem, multiFile, traj);
-    }
-
-    void writeFine(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPack<FineF, FineFIo>::write(fileStem + "_fine", multiFile, traj);
-    }
-
-    void writeCoarse(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::writePack<CoarseF, CoarseFIo>(this->evecFilename(fileStem + "_coarse", traj, multiFile), 
-                                                   evecCoarse, evalCoarse, this->record, 
-                                                   evecCoarse.size(), multiFile, gridCoarseIo_);
-    }
-    
-    virtual void write(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        writeFine(fileStem, multiFile, traj);
-        writeCoarse(fileStem, multiFile, traj);
-    }
-private:
-    GridBase *gridCoarseIo_;
-};
-
-template <typename FImpl>
-using BaseFermionEigenPack = BaseEigenPack<typename FImpl::FermionField>;
-
-template <typename FImpl, typename FImplIo = FImpl>
-using FermionEigenPack = EigenPack<typename FImpl::FermionField, typename FImplIo::FermionField>;
-
-template <typename FImpl, int nBasis, typename FImplIo = FImpl>
-using CoarseFermionEigenPack = CoarseEigenPack<
-    typename FImpl::FermionField,
-    typename LocalCoherenceLanczos<typename FImpl::SiteSpinor, 
-                                   typename FImpl::SiteComplex, 
-                                   nBasis>::CoarseField,
-    typename FImplIo::FermionField,
-    typename LocalCoherenceLanczos<typename FImplIo::SiteSpinor, 
-                                   typename FImplIo::SiteComplex, 
-                                   nBasis>::CoarseField>;
-
-#undef HADRONS_DUMP_EP_METADATA
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_EigenPack_hpp_
diff --git a/Hadrons/Environment.cc b/Hadrons/Environment.cc
deleted file mode 100644
index 449646e4..00000000
--- a/Hadrons/Environment.cc
+++ /dev/null
@@ -1,347 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Environment.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Environment.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-using namespace Grid;
- 
-using namespace Hadrons;
-
-#define ERROR_NO_ADDRESS(address)\
-HADRONS_ERROR_REF(ObjectDefinition, "no object with address " + std::to_string(address), address);
-
-/******************************************************************************
- *                       Environment implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-Environment::Environment(void)
-{
-    dim_ = GridDefaultLatt().toVector();
-    nd_  = dim_.size();
-    vol_ = 1.;
-    for (auto d: dim_)
-    {
-        vol_ *= d;
-    }
-}
-
-// grids ///////////////////////////////////////////////////////////////////////
-unsigned int Environment::getNd(void) const
-{
-    return nd_;
-}
-
-std::vector<int> Environment::getDim(void) const
-{
-    return dim_;
-}
-
-int Environment::getDim(const unsigned int mu) const
-{
-    return dim_[mu];
-}
-
-double Environment::getVolume(void) const
-{
-    return vol_;
-}
-
-// random number generator /////////////////////////////////////////////////////
-GridParallelRNG * Environment::get4dRng(void)
-{
-    if (rng4d_ == nullptr)
-    {
-        rng4d_.reset(new GridParallelRNG(getGrid()));
-    }
-
-    return rng4d_.get();
-}
-
-GridSerialRNG * Environment::getSerialRng(void)
-{
-    if (rngSerial_ == nullptr)
-    {
-        rngSerial_.reset(new GridSerialRNG());
-    }
-
-    return rngSerial_.get();
-}
-
-// general memory management ///////////////////////////////////////////////////
-void Environment::addObject(const std::string name, const int moduleAddress)
-{
-    if (!hasObject(name))
-    {
-        ObjInfo info;
-        
-        info.name   = name;
-        info.module = moduleAddress;
-        info.data   = nullptr;
-        object_.push_back(std::move(info));
-        objectAddress_[name] = static_cast<unsigned int>(object_.size() - 1);
-    }
-    else
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "object '" + name + "' already exists",
-                          getObjectAddress(name));
-    }
-}
-
-void Environment::setObjectModule(const unsigned int objAddress,
-                                  const int modAddress)
-{
-    object_[objAddress].module = modAddress;
-}
-
-unsigned int Environment::getMaxAddress(void) const
-{
-    return object_.size();
-}
-
-unsigned int Environment::getObjectAddress(const std::string name) const
-{
-    if (hasObject(name))
-    {
-        return objectAddress_.at(name);
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "no object with name '" + name + "'");
-    }
-}
-
-std::string Environment::getObjectName(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        return object_[address].name;
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-std::string Environment::getObjectType(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        if (object_[address].type)
-        {
-            return typeName(object_[address].type);
-        }
-        else
-        {
-            return "<no type>";
-        }
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-std::string Environment::getObjectType(const std::string name) const
-{
-    return getObjectType(getObjectAddress(name));
-}
-
-Environment::Size Environment::getObjectSize(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        return object_[address].size;
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-Environment::Size Environment::getObjectSize(const std::string name) const
-{
-    return getObjectSize(getObjectAddress(name));
-}
-
-Environment::Storage Environment::getObjectStorage(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        return object_[address].storage;
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-Environment::Storage Environment::getObjectStorage(const std::string name) const
-{
-    return getObjectStorage(getObjectAddress(name));
-}
-
-int Environment::getObjectModule(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        return object_[address].module;
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-int Environment::getObjectModule(const std::string name) const
-{
-    return getObjectModule(getObjectAddress(name));
-}
-
-unsigned int Environment::getObjectLs(const unsigned int address) const
-{
-    if (hasCreatedObject(address))
-    {
-        return object_[address].Ls;
-    }
-    else
-    {
-        ERROR_NO_ADDRESS(address);
-    }
-}
-
-unsigned int Environment::getObjectLs(const std::string name) const
-{
-    return getObjectLs(getObjectAddress(name));
-}
-
-bool Environment::hasObject(const unsigned int address) const
-{
-    return (address < object_.size());
-}
-
-bool Environment::hasObject(const std::string name) const
-{
-    auto it = objectAddress_.find(name);
-    
-    return ((it != objectAddress_.end()) and hasObject(it->second));
-}
-
-bool Environment::hasCreatedObject(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        return (object_[address].data != nullptr);
-    }
-    else
-    {
-        return false;
-    }
-}
-
-bool Environment::hasCreatedObject(const std::string name) const
-{
-    if (hasObject(name))
-    {
-        return hasCreatedObject(getObjectAddress(name));
-    }
-    else
-    {
-        return false;
-    }
-}
-
-bool Environment::isObject5d(const unsigned int address) const
-{
-    return (getObjectLs(address) > 1);
-}
-
-bool Environment::isObject5d(const std::string name) const
-{
-    return (getObjectLs(name) > 1);
-}
-
-Environment::Size Environment::getTotalSize(void) const
-{
-    Environment::Size size = 0;
-    
-    for (auto &o: object_)
-    {
-        size += o.size;
-    }
-    
-    return size;
-}
-
-void Environment::freeObject(const unsigned int address)
-{
-    if (hasCreatedObject(address))
-    {
-        LOG(Message) << "Destroying object '" << object_[address].name
-                     << "'" << std::endl;
-    }
-    object_[address].size = 0;
-    object_[address].type = nullptr;
-    object_[address].data.reset(nullptr);
-}
-
-void Environment::freeObject(const std::string name)
-{
-    freeObject(getObjectAddress(name));
-}
-
-void Environment::freeAll(void)
-{
-    for (unsigned int i = 0; i < object_.size(); ++i)
-    {
-        freeObject(i);
-    }
-}
-
-void Environment::protectObjects(const bool protect)
-{
-    protect_ = protect;
-}
-
-bool Environment::objectsProtected(void) const
-{
-    return protect_;
-}
-
-// print environment content ///////////////////////////////////////////////////
-void Environment::printContent(void) const
-{
-    LOG(Debug) << "Objects: " << std::endl;
-    for (unsigned int i = 0; i < object_.size(); ++i)
-    {
-        LOG(Debug) << std::setw(4) << i << ": "
-                   << getObjectName(i) << " ("
-                   << sizeString(getObjectSize(i)) << ")" << std::endl;
-    }
-}
diff --git a/Hadrons/Environment.hpp b/Hadrons/Environment.hpp
deleted file mode 100644
index 8066a0e7..00000000
--- a/Hadrons/Environment.hpp
+++ /dev/null
@@ -1,588 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Environment.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Environment_hpp_
-#define Hadrons_Environment_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Global environment                                 *
- ******************************************************************************/
-class Object
-{
-public:
-    Object(void) = default;
-    virtual ~Object(void) = default;
-};
-
-template <typename T>
-class Holder: public Object
-{
-public:
-    Holder(void) = default;
-    Holder(T *pt);
-    virtual ~Holder(void) = default;
-    T &       get(void) const;
-    T *       getPt(void) const;
-    void      reset(T *pt);
-private:
-    std::unique_ptr<T> objPt_{nullptr};
-};
-
-#define DEFINE_ENV_ALIAS \
-inline Environment & env(void) const\
-{\
-    return Environment::getInstance();\
-}
-
-#define DEFINE_ENV_LAMBDA \
-auto env = [](void)->Environment &{return Environment::getInstance();}
-
-class Environment
-{
-    SINGLETON(Environment);
-public:
-    typedef SITE_SIZE_TYPE                         Size;
-    typedef std::unique_ptr<GridCartesian>         GridPt;
-    typedef std::unique_ptr<GridRedBlackCartesian> GridRbPt;
-    typedef std::unique_ptr<GridParallelRNG>       RngPt;
-    typedef std::unique_ptr<GridSerialRNG>         SerialRngPt;
-    enum class Storage {object, cache, temporary};
-private:
-    struct ObjInfo
-    {
-        Size                    size{0};
-        Storage                 storage{Storage::object};
-        unsigned int            Ls{0};
-        const std::type_info    *type{nullptr}, *derivedType{nullptr};
-        std::string             name;
-        int                     module{-1};
-        std::unique_ptr<Object> data{nullptr};
-    };
-    typedef std::pair<size_t, unsigned int>     FineGridKey;
-    typedef std::pair<size_t, std::vector<int>> CoarseGridKey;
-public:
-    // grids
-    template <typename VType = vComplex>
-    void                    createGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    void                    createCoarseGrid(const std::vector<int> &blockSize,
-                                             const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridCartesian *         getGrid(void);
-    template <typename VType = vComplex>
-    GridRedBlackCartesian * getRbGrid(void);
-    template <typename VType = vComplex>
-    GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize);
-    template <typename VType = vComplex>
-    GridCartesian *         getGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridRedBlackCartesian * getRbGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize,
-                                          const unsigned int Ls);
-    std::vector<int>        getDim(void) const;
-    int                     getDim(const unsigned int mu) const;
-    unsigned int            getNd(void) const;
-    double                  getVolume(void) const;
-    // random number generator
-    GridParallelRNG *       get4dRng(void);
-    GridSerialRNG *         getSerialRng(void);
-    // general memory management
-    void                    addObject(const std::string name,
-                                      const int moduleAddress = -1);
-    template <typename B, typename T, typename ... Ts>
-    void                    createDerivedObject(const std::string name,
-                                                const Environment::Storage storage,
-                                                const unsigned int Ls,
-                                                Ts && ... args);
-    template <typename T, typename ... Ts>
-    void                    createObject(const std::string name,
-                                         const Environment::Storage storage,
-                                         const unsigned int Ls,
-                                         Ts && ... args);
-    void                    setObjectModule(const unsigned int objAddress,
-                                            const int modAddress);
-    template <typename B, typename T>
-    T *                     getDerivedObject(const unsigned int address) const;
-    template <typename B, typename T>
-    T *                     getDerivedObject(const std::string name) const;
-    template <typename T>
-    T *                     getObject(const unsigned int address) const;
-    template <typename T>
-    T *                     getObject(const std::string name) const;
-    unsigned int            getMaxAddress(void) const;
-    unsigned int            getObjectAddress(const std::string name) const;
-    std::string             getObjectName(const unsigned int address) const;
-    std::string             getObjectType(const unsigned int address) const;
-    std::string             getObjectType(const std::string name) const;
-    Size                    getObjectSize(const unsigned int address) const;
-    Size                    getObjectSize(const std::string name) const;
-    Storage                 getObjectStorage(const unsigned int address) const;
-    Storage                 getObjectStorage(const std::string name) const;
-    int                     getObjectModule(const unsigned int address) const;
-    int                     getObjectModule(const std::string name) const;
-    unsigned int            getObjectLs(const unsigned int address) const;
-    unsigned int            getObjectLs(const std::string name) const;
-    bool                    hasObject(const unsigned int address) const;
-    bool                    hasObject(const std::string name) const;
-    bool                    hasCreatedObject(const unsigned int address) const;
-    bool                    hasCreatedObject(const std::string name) const;
-    bool                    isObject5d(const unsigned int address) const;
-    bool                    isObject5d(const std::string name) const;
-    template <typename T>
-    bool                    isObjectOfType(const unsigned int address) const;
-    template <typename T>
-    bool                    isObjectOfType(const std::string name) const;
-    Environment::Size       getTotalSize(void) const;
-    void                    freeObject(const unsigned int address);
-    void                    freeObject(const std::string name);
-    void                    freeAll(void);
-    void                    protectObjects(const bool protect);
-    bool                    objectsProtected(void) const;
-    // print environment content
-    void                    printContent(void) const;
-private:
-    // general
-    double                              vol_;
-    bool                                protect_{true};
-    // grids
-    std::vector<int>                    dim_;
-    std::map<FineGridKey, GridPt>       grid4d_;
-    std::map<FineGridKey, GridPt>       grid5d_;
-    std::map<FineGridKey, GridRbPt>     gridRb4d_;
-    std::map<FineGridKey, GridRbPt>     gridRb5d_;
-    std::map<CoarseGridKey, GridPt>     gridCoarse4d_;
-    std::map<CoarseGridKey, GridPt>     gridCoarse5d_;
-    unsigned int                        nd_;
-    // random number generator
-    RngPt                               rng4d_{nullptr};
-    SerialRngPt                         rngSerial_{nullptr};
-    // object store
-    std::vector<ObjInfo>                object_;
-    std::map<std::string, unsigned int> objectAddress_;
-};
-
-/******************************************************************************
- *                       Holder template implementation                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T>
-Holder<T>::Holder(T *pt)
-: objPt_(pt)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-template <typename T>
-T & Holder<T>::get(void) const
-{
-    return *objPt_.get();
-}
-
-template <typename T>
-T * Holder<T>::getPt(void) const
-{
-    return objPt_.get();
-}
-
-template <typename T>
-void Holder<T>::reset(T *pt)
-{
-    objPt_.reset(pt);
-}
-
-/******************************************************************************
- *                     Environment template implementation                    *
- ******************************************************************************/
-// grids ///////////////////////////////////////////////////////////////////////
-#define HADRONS_DUMP_GRID(...)\
-LOG(Debug) << "New grid " << (__VA_ARGS__) << std::endl;\
-LOG(Debug) << " - cb  : " << (__VA_ARGS__)->_isCheckerBoarded << std::endl;\
-LOG(Debug) << " - fdim: " << (__VA_ARGS__)->_fdimensions << std::endl;\
-LOG(Debug) << " - gdim: " << (__VA_ARGS__)->_gdimensions << std::endl;\
-LOG(Debug) << " - ldim: " << (__VA_ARGS__)->_ldimensions << std::endl;\
-LOG(Debug) << " - rdim: " << (__VA_ARGS__)->_rdimensions << std::endl;
-
-template <typename VType>
-void Environment::createGrid(const unsigned int Ls)
-{
-    size_t hash = typeHash<VType>();
-
-    if (grid4d_.find({hash, 1}) == grid4d_.end())
-    {
-        grid4d_[{hash, 1}].reset(
-            SpaceTimeGrid::makeFourDimGrid(getDim(), 
-                                        GridDefaultSimd(getNd(), VType::Nsimd()),
-                                        GridDefaultMpi()));
-        HADRONS_DUMP_GRID(grid4d_[{hash, 1}].get());
-        gridRb4d_[{hash, 1}].reset(
-            SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_[{hash, 1}].get()));
-        HADRONS_DUMP_GRID(gridRb4d_[{hash, 1}].get());
-    }
-    if (grid5d_.find({hash, Ls}) == grid5d_.end())
-    {
-        auto g = grid4d_[{hash, 1}].get();
-        
-        grid5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimGrid(Ls, g));
-        HADRONS_DUMP_GRID(grid5d_[{hash, Ls}].get());
-        gridRb5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, g));
-        HADRONS_DUMP_GRID(gridRb5d_[{hash, Ls}].get());
-    }
-}
-
-template <typename VType>
-void Environment::createCoarseGrid(const std::vector<int> &blockSize,
-                                   const unsigned int Ls)
-{
-    int              nd      = getNd();
-    std::vector<int> fineDim = getDim(), coarseDim(nd);
-    unsigned int     cLs;
-    auto             key4d = blockSize, key5d = blockSize;
-    size_t           hash  = typeHash<VType>();
-
-    createGrid(Ls);
-    for (int d = 0; d < coarseDim.size(); d++)
-    {
-        coarseDim[d] = fineDim[d]/blockSize[d];
-        if (coarseDim[d]*blockSize[d] != fineDim[d])
-        {
-            HADRONS_ERROR(Size, "Fine dimension " + std::to_string(d) 
-                         + " (" + std::to_string(fineDim[d]) 
-                         + ") not divisible by coarse dimension ("
-                         + std::to_string(coarseDim[d]) + ")"); 
-        }
-    }
-    if (blockSize.size() > nd)
-    {
-        cLs = Ls/blockSize[nd];
-        if (cLs*blockSize[nd] != Ls)
-        {
-            HADRONS_ERROR(Size, "Fine Ls (" + std::to_string(Ls) 
-                         + ") not divisible by coarse Ls ("
-                         + std::to_string(cLs) + ")");
-        }
-    }
-    else
-    {
-        cLs = Ls;
-    }
-    key4d.resize(nd);
-    key5d.push_back(Ls);
-
-    CoarseGridKey hkey4d = {hash, key4d}, hkey5d = {hash, key5d};
-
-    if (gridCoarse4d_.find(hkey4d) == gridCoarse4d_.end())
-    {
-        gridCoarse4d_[hkey4d].reset(
-            SpaceTimeGrid::makeFourDimGrid(coarseDim, 
-                GridDefaultSimd(nd, VType::Nsimd()), GridDefaultMpi()));
-        HADRONS_DUMP_GRID(gridCoarse4d_[hkey4d].get());
-    }
-    if (gridCoarse5d_.find(hkey5d) == gridCoarse5d_.end())
-    {
-        gridCoarse5d_[hkey5d].reset(
-            SpaceTimeGrid::makeFiveDimGrid(cLs, gridCoarse4d_[hkey4d].get()));
-        HADRONS_DUMP_GRID(gridCoarse5d_[hkey5d].get());
-    }
-}
-
-#undef HADRONS_DUMP_GRID
-
-template <typename VType>
-GridCartesian * Environment::getGrid(void)
-{
-    FineGridKey key = {typeHash<VType>(), 1};
-
-    auto it = grid4d_.find(key);
-
-    if (it != grid4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(1);
-
-        return grid4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridRedBlackCartesian * Environment::getRbGrid(void)
-{
-    FineGridKey key = {typeHash<VType>(), 1};
-    auto        it  = gridRb4d_.find(key);
-
-    if (it != gridRb4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(1);
-
-        return gridRb4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize)
-{
-    std::vector<int> s = blockSize;
-
-    s.resize(getNd());
-
-    CoarseGridKey key = {typeHash<VType>(), s};
-    auto          it  = gridCoarse4d_.find(key);
-
-    if (it != gridCoarse4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createCoarseGrid<VType>(blockSize, 1);
-        
-        return gridCoarse4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getGrid(const unsigned int Ls)
-{
-    FineGridKey key = {typeHash<VType>(), Ls};
-    auto        it  = grid5d_.find(key);
-
-    if (it != grid5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(Ls);
-
-        return grid5d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls)
-{
-    FineGridKey key = {typeHash<VType>(), Ls};
-    auto        it  = gridRb5d_.find(key);
-
-    if (it != gridRb5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(Ls);
-
-        return gridRb5d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize,
-                                           const unsigned int Ls)
-{
-    std::vector<int> s = blockSize;
-
-    s.push_back(Ls);
-
-    CoarseGridKey key = {typeHash<VType>(), s};
-
-    auto it = gridCoarse5d_.find(key);
-    if (it != gridCoarse5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createCoarseGrid<VType>(blockSize, Ls);
-
-        return gridCoarse5d_.at(key).get();
-    }
-}
-
-
-// general memory management ///////////////////////////////////////////////////
-template <typename B, typename T, typename ... Ts>
-void Environment::createDerivedObject(const std::string name,
-                                      const Environment::Storage storage,
-                                      const unsigned int Ls,
-                                      Ts && ... args)
-{
-    if (!hasObject(name))
-    {
-        addObject(name);
-    }
-    
-    unsigned int address = getObjectAddress(name);
-    
-    if (!object_[address].data or !objectsProtected())
-    {
-        MemoryStats memStats;
-    
-        if (!MemoryProfiler::stats)
-        {
-            MemoryProfiler::stats = &memStats;
-        }
-        size_t initMem               = MemoryProfiler::stats->currentlyAllocated;
-        object_[address].storage     = storage;
-        object_[address].Ls          = Ls;
-        object_[address].data.reset(new Holder<B>(new T(std::forward<Ts>(args)...)));
-        object_[address].size        = MemoryProfiler::stats->maxAllocated - initMem;
-        object_[address].type        = typeIdPt<B>();
-        object_[address].derivedType = typeIdPt<T>();
-        if (MemoryProfiler::stats == &memStats)
-        {
-            MemoryProfiler::stats = nullptr;
-        }
-    }
-    // object already exists, no error if it is a cache, error otherwise
-    else if ((object_[address].storage               != Storage::cache) or 
-             (object_[address].storage               != storage)        or
-             (object_[address].name                  != name)           or
-             (typeHash(object_[address].type)        != typeHash<B>())  or
-             (typeHash(object_[address].derivedType) != typeHash<T>()))
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "object '" + name + "' already allocated", address);
-    }
-}
-
-template <typename T, typename ... Ts>
-void Environment::createObject(const std::string name, 
-                               const Environment::Storage storage,
-                               const unsigned int Ls,
-                               Ts && ... args)
-{
-    createDerivedObject<T, T>(name, storage, Ls, std::forward<Ts>(args)...);
-}
-
-template <typename B, typename T>
-T * Environment::getDerivedObject(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        if (hasCreatedObject(address))
-        {
-            if (auto h = dynamic_cast<Holder<B> *>(object_[address].data.get()))
-            {
-                if (&typeid(T) == &typeid(B))
-                {
-                    return dynamic_cast<T *>(h->getPt());
-                }
-                else
-                {
-                    if (auto hder = dynamic_cast<T *>(h->getPt()))
-                    {
-                        return hder;
-                    }
-                    else
-                    {
-                        HADRONS_ERROR_REF(ObjectType, "object with address " +
-                            std::to_string(address) +
-                            " cannot be casted to '" + typeName(&typeid(T)) +
-                            "' (has type '" + typeName(&typeid(h->get())) + "')", address);
-                    }
-                }
-            }
-            else
-            {
-                HADRONS_ERROR_REF(ObjectType, "object with address " + 
-                            std::to_string(address) +
-                            " does not have type '" + typeName(&typeid(B)) +
-                            "' (has type '" + getObjectType(address) + "')", address);
-            }
-        }
-        else
-        {
-            HADRONS_ERROR_REF(ObjectDefinition, "object with address " + 
-                              std::to_string(address) + " is empty", address);
-        }
-    }
-    else
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "no object with address " + 
-                          std::to_string(address), address);
-    }
-}
-
-template <typename B, typename T>
-T * Environment::getDerivedObject(const std::string name) const
-{
-    return getDerivedObject<B, T>(getObjectAddress(name));
-}
-
-template <typename T>
-T * Environment::getObject(const unsigned int address) const
-{
-    return getDerivedObject<T, T>(address);
-}
-
-template <typename T>
-T * Environment::getObject(const std::string name) const
-{
-    return getObject<T>(getObjectAddress(name));
-}
-
-template <typename T>
-bool Environment::isObjectOfType(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        if (auto h = dynamic_cast<Holder<T> *>(object_[address].data.get()))
-        {
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-    else
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "no object with address " 
-                          + std::to_string(address), address);
-    }
-}
-
-template <typename T>
-bool Environment::isObjectOfType(const std::string name) const
-{
-    return isObjectOfType<T>(getObjectAddress(name));
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Environment_hpp_
diff --git a/Hadrons/Exceptions.cc b/Hadrons/Exceptions.cc
deleted file mode 100644
index bb489cdf..00000000
--- a/Hadrons/Exceptions.cc
+++ /dev/null
@@ -1,102 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Exceptions.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Exceptions.hpp>
-#include <Hadrons/VirtualMachine.hpp>
-#include <Hadrons/Module.hpp>
-
-#ifndef ERR_SUFF
-#define ERR_SUFF " (" + loc + ")"
-#endif
-
-#define CTOR_EXC(name, init) \
-name::name(std::string msg, std::string loc)\
-:init\
-{}
-
-#define CTOR_EXC_REF(name, init) \
-name::name(std::string msg, std::string loc, const unsigned int address)\
-:init\
-{}
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace Exceptions;
-
-// backtrace cache
-std::vector<std::string> Grid::Hadrons::Exceptions::backtraceStr;
-
-// logic errors
-CTOR_EXC(Logic, logic_error(msg + ERR_SUFF))
-CTOR_EXC(Definition, Logic("definition error: " + msg, loc))
-CTOR_EXC(Implementation, Logic("implementation error: " + msg, loc))
-CTOR_EXC(Range, Logic("range error: " + msg, loc))
-CTOR_EXC(Size, Logic("size error: " + msg, loc))
-
-// runtime errors
-CTOR_EXC(Runtime, runtime_error(msg + ERR_SUFF))
-CTOR_EXC(Argument, Runtime("argument error: " + msg, loc))
-CTOR_EXC(Io, Runtime("IO error: " + msg, loc))
-CTOR_EXC(Memory, Runtime("memory error: " + msg, loc))
-CTOR_EXC(Parsing, Runtime("parsing error: " + msg, loc))
-CTOR_EXC(Program, Runtime("program error: " + msg, loc))
-CTOR_EXC(System, Runtime("system error: " + msg, loc))
-
-// virtual machine errors
-CTOR_EXC_REF(ObjectDefinition, RuntimeRef("object definition error: " + msg, loc, address));
-CTOR_EXC_REF(ObjectType, RuntimeRef("object type error: " + msg, loc, address));
-
-// abort functions
-void Grid::Hadrons::Exceptions::abort(const std::exception& e)
-{
-    auto &vm = VirtualMachine::getInstance();
-    int  mod = vm.getCurrentModule();
-
-    LOG(Error) << "FATAL ERROR -- Exception " << typeName(&typeid(e)) 
-               << std::endl;
-    if (mod >= 0)
-    {
-        LOG(Error) << "During execution of module '"
-                    << vm.getModuleName(mod) << "' (address " << mod << ")"
-                    << std::endl;
-    }
-    LOG(Error) << e.what() << std::endl;
-    if (!backtraceStr.empty())
-    {
-        LOG(Error) << "-- BACKTRACE --------------" << std::endl;
-        for (auto &s: backtraceStr)
-        {
-            LOG(Error) << s << std::endl;
-        }
-        LOG(Error) << "---------------------------" << std::endl;
-    }
-    LOG(Error) << "Aborting program" << std::endl;
-    Grid_finalize();
-
-    exit(EXIT_FAILURE);
-}
diff --git a/Hadrons/Exceptions.hpp b/Hadrons/Exceptions.hpp
deleted file mode 100644
index 9974e33d..00000000
--- a/Hadrons/Exceptions.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Exceptions.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Exceptions_hpp_
-#define Hadrons_Exceptions_hpp_
-
-#include <stdexcept>
-#include <execinfo.h>
-#ifndef Hadrons_Global_hpp_
-#include <Hadrons/Global.hpp>
-#endif
-
-#define HADRONS_SRC_LOC std::string(__FUNCTION__) + " at " \
-                        + std::string(__FILE__) + ":" + std::to_string(__LINE__)
-#define HADRONS_BACKTRACE_MAX 128
-#ifdef HAVE_EXECINFO_H
-#define HADRONS_CACHE_BACKTRACE \
-{\
-    void* _callstack[HADRONS_BACKTRACE_MAX];\
-    int _i, _frames = backtrace(_callstack, HADRONS_BACKTRACE_MAX);\
-    char** _strs = backtrace_symbols(_callstack, _frames);\
-    Grid::Hadrons::Exceptions::backtraceStr.clear();\
-    for (_i = 0; _i < _frames; ++_i)\
-    {\
-        Hadrons::Exceptions::backtraceStr.push_back(std::string(_strs[_i]));\
-    }\
-    free(_strs);\
-}
-#else
-#define HADRONS_CACHE_BACKTRACE \
-Grid::Hadrons::Exceptions::backtraceStr.clear();\
-Grid::Hadrons::Exceptions::backtraceStr.push_back("<backtrace not supported>");
-#endif
-
-#define HADRONS_ERROR(exc, msg)\
-HADRONS_CACHE_BACKTRACE \
-throw(Exceptions::exc(msg, HADRONS_SRC_LOC));
-
-#define HADRONS_ERROR_REF(exc, msg, address)\
-HADRONS_CACHE_BACKTRACE \
-throw(Exceptions::exc(msg, HADRONS_SRC_LOC, address));
-
-#define DECL_EXC(name, base) \
-class name: public base\
-{\
-public:\
-    name(std::string msg, std::string loc);\
-}
-
-#define DECL_EXC_REF(name, base) \
-class name: public base\
-{\
-public:\
-    name(std::string msg, std::string loc, const unsigned int address);\
-}
-
-BEGIN_HADRONS_NAMESPACE
-
-namespace Exceptions
-{
-    // backtrace cache
-    extern std::vector<std::string> backtraceStr;
-
-    // logic errors
-    DECL_EXC(Logic, std::logic_error);
-    DECL_EXC(Definition, Logic);
-    DECL_EXC(Implementation, Logic);
-    DECL_EXC(Range, Logic);
-    DECL_EXC(Size, Logic);
-
-    // runtime errors
-    DECL_EXC(Runtime, std::runtime_error);
-    DECL_EXC(Argument, Runtime);
-    DECL_EXC(Io, Runtime);
-    DECL_EXC(Memory, Runtime);
-    DECL_EXC(Parsing, Runtime);
-    DECL_EXC(Program, Runtime);
-    DECL_EXC(System, Runtime);
-
-    // virtual machine errors
-    class RuntimeRef: public Runtime
-    {
-    public:
-        RuntimeRef(std::string msg, std::string loc, const unsigned int address)
-        : Runtime(msg, loc), address_(address)
-        {}
-        unsigned int getAddress(void) const
-        {
-            return address_;
-        }
-    private:
-        unsigned int address_;
-    };
-
-    DECL_EXC_REF(ObjectDefinition, RuntimeRef);
-    DECL_EXC_REF(ObjectType, RuntimeRef);
-
-    // abort functions
-    void abort(const std::exception& e);
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Exceptions_hpp_
diff --git a/Hadrons/Factory.hpp b/Hadrons/Factory.hpp
deleted file mode 100644
index cfb609e9..00000000
--- a/Hadrons/Factory.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Factory.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Factory_hpp_
-#define Hadrons_Factory_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                        abstract factory class                              *
- ******************************************************************************/
-template <typename T>
-class Factory
-{
-public:
-    typedef std::function<std::unique_ptr<T>(const std::string)> Func;
-public:
-    // constructor
-    Factory(void) = default;
-    // destructor
-    virtual ~Factory(void) = default;
-    // registration
-    void registerBuilder(const std::string type, const Func &f);
-    // get builder list
-    std::vector<std::string> getBuilderList(void) const;
-    // factory
-    std::unique_ptr<T> create(const std::string type,
-                              const std::string name) const;
-private:
-    std::map<std::string, Func> builder_;
-};
-
-/******************************************************************************
- *                         template implementation                            *
- ******************************************************************************/
-// registration ////////////////////////////////////////////////////////////////
-template <typename T>
-void Factory<T>::registerBuilder(const std::string type, const Func &f)
-{
-    builder_[type] = f;
-}
-
-// get module list /////////////////////////////////////////////////////////////
-template <typename T>
-std::vector<std::string> Factory<T>::getBuilderList(void) const
-{
-    std::vector<std::string> list;
-    
-    for (auto &b: builder_)
-    {
-        list.push_back(b.first);
-    }
-    
-    return list;
-}
-
-// factory /////////////////////////////////////////////////////////////////////
-template <typename T>
-std::unique_ptr<T> Factory<T>::create(const std::string type,
-                                      const std::string name) const
-{
-    Func func;
-    
-    try
-    {
-        func = builder_.at(type);
-    }
-    catch (std::out_of_range &)
-    {
-        HADRONS_ERROR(Argument, "object of type '" + type + "' unknown");
-    }
-    
-    return func(name);
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Factory_hpp_
diff --git a/Hadrons/GeneticScheduler.hpp b/Hadrons/GeneticScheduler.hpp
deleted file mode 100644
index 178b8301..00000000
--- a/Hadrons/GeneticScheduler.hpp
+++ /dev/null
@@ -1,321 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/GeneticScheduler.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_GeneticScheduler_hpp_
-#define Hadrons_GeneticScheduler_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Graph.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                   Scheduler based on a genetic algorithm                   *
- ******************************************************************************/
-template <typename V, typename T>
-class GeneticScheduler
-{
-public:
-    typedef std::vector<T>                 Gene;
-    typedef std::pair<Gene *, Gene *>      GenePair;
-    typedef std::function<V(const Gene &)> ObjFunc;
-    struct Parameters
-    {
-        double       mutationRate;
-        unsigned int popSize, seed;
-    };
-public:
-    // constructor
-    GeneticScheduler(Graph<T> &graph, const ObjFunc &func,
-                     const Parameters &par);
-    // destructor
-    virtual ~GeneticScheduler(void) = default;
-    // access
-    const Gene & getMinSchedule(void);
-    V            getMinValue(void);
-    // reset population
-    void initPopulation(void);
-    // breed a new generation
-    void nextGeneration(void);
-    // heuristic benchmarks
-    void benchmarkCrossover(const unsigned int nIt);
-    // print population
-    friend std::ostream & operator<<(std::ostream &out,
-                                     const GeneticScheduler<V, T> &s)
-    {
-        out << "[";
-        for (auto &p: s.population_)
-        {
-            out << p.first << ", ";
-        }
-        out << "\b\b]";
-        
-        return out;
-    }
-private:
-    void doCrossover(void);
-    void doMutation(void);
-    // genetic operators
-    GenePair selectPair(void);
-    void     crossover(Gene &c1, Gene &c2, const Gene &p1, const Gene &p2);
-    void     mutation(Gene &m, const Gene &c);
-    
-private:
-    Graph<T>               &graph_;
-    const ObjFunc          &func_;
-    const Parameters       par_;
-    std::multimap<V, Gene> population_;
-    std::mt19937           gen_;
-};
-
-/******************************************************************************
- *                       template implementation                              *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename V, typename T>
-GeneticScheduler<V, T>::GeneticScheduler(Graph<T> &graph, const ObjFunc &func,
-                                      const Parameters &par)
-: graph_(graph)
-, func_(func)
-, par_(par)
-{
-    gen_.seed(par_.seed);
-}
-
-// access //////////////////////////////////////////////////////////////////////
-template <typename V, typename T>
-const typename GeneticScheduler<V, T>::Gene &
-GeneticScheduler<V, T>::getMinSchedule(void)
-{
-    return population_.begin()->second;
-}
-
-template <typename V, typename T>
-V GeneticScheduler<V, T>::getMinValue(void)
-{
-    return population_.begin()->first;
-}
-
-// breed a new generation //////////////////////////////////////////////////////
-template <typename V, typename T>
-void GeneticScheduler<V, T>::nextGeneration(void)
-{
-    // random initialization of the population if necessary
-    if (population_.size() != par_.popSize)
-    {
-        initPopulation();
-    }
-    //LOG(Debug) << "Starting population:\n" << *this << std::endl;
-    
-    // random mutations
-    for (unsigned int i = 0; i < par_.popSize; ++i)
-    {
-        doMutation();
-    }
-    //LOG(Debug) << "After mutations:\n" << *this << std::endl;
-    
-    // mating
-    for (unsigned int i = 0; i < par_.popSize/2; ++i)
-    {
-        doCrossover();
-    }
-    //LOG(Debug) << "After mating:\n" << *this << std::endl;
-    
-    // grim reaper
-    auto it = population_.begin();
-    
-    std::advance(it, par_.popSize);
-    population_.erase(it, population_.end());
-    //LOG(Debug) << "After grim reaper:\n" << *this << std::endl;
-}
-
-// evolution steps /////////////////////////////////////////////////////////////
-template <typename V, typename T>
-void GeneticScheduler<V, T>::initPopulation(void)
-{
-    population_.clear();
-    for (unsigned int i = 0; i < par_.popSize; ++i)
-    {
-        auto p = graph_.topoSort(gen_);
-        
-        population_.insert(std::make_pair(func_(p), p));
-    }
-}
-
-template <typename V, typename T>
-void GeneticScheduler<V, T>::doCrossover(void)
-{
-    auto p = selectPair();
-    Gene &p1 = *(p.first), &p2 = *(p.second);
-    Gene c1, c2;
-    
-    crossover(c1, c2, p1, p2);
-    thread_critical
-    {
-        population_.insert(std::make_pair(func_(c1), c1));
-        population_.insert(std::make_pair(func_(c2), c2));
-    }
-}
-
-template <typename V, typename T>
-void GeneticScheduler<V, T>::doMutation(void)
-{
-    std::uniform_real_distribution<double>      mdis(0., 1.);
-    std::uniform_int_distribution<unsigned int> pdis(0, population_.size() - 1);
-    
-    if (mdis(gen_) < par_.mutationRate)
-    {
-        Gene m;
-        auto it = population_.begin();
-        
-        std::advance(it, pdis(gen_));
-        mutation(m, it->second);
-	thread_critical
-        {
-            population_.insert(std::make_pair(func_(m), m));
-        }
-    }
-}
-
-// genetic operators ///////////////////////////////////////////////////////////
-template <typename V, typename T>
-typename GeneticScheduler<V, T>::GenePair GeneticScheduler<V, T>::selectPair(void)
-{
-    std::vector<double> prob;
-    unsigned int        ind;
-    Gene                *p1, *p2;
-    const double        max = population_.rbegin()->first;
-    
-
-    for (auto &c: population_)
-    {
-        prob.push_back(std::exp((c.first-1.)/max));
-    }        
-    std::discrete_distribution<unsigned int> dis1(prob.begin(), prob.end());
-    auto rIt = population_.begin();
-    ind = dis1(gen_);
-    std::advance(rIt, ind);
-    p1 = &(rIt->second);
-    prob[ind] = 0.;
-    std::discrete_distribution<unsigned int> dis2(prob.begin(), prob.end());
-    rIt = population_.begin();
-    std::advance(rIt, dis2(gen_));
-    p2 = &(rIt->second);
-    
-    return std::make_pair(p1, p2);
-}
-
-template <typename V, typename T>
-void GeneticScheduler<V, T>::crossover(Gene &c1, Gene &c2, const Gene &p1,
-                                    const Gene &p2)
-{
-    Gene                                        buf;
-    std::uniform_int_distribution<unsigned int> dis(0, p1.size() - 1);
-    unsigned int                                cut = dis(gen_);
-    
-    c1.clear();
-    buf = p2;
-    for (unsigned int i = 0; i < cut; ++i)
-    {
-        c1.push_back(p1[i]);
-        buf.erase(std::find(buf.begin(), buf.end(), p1[i]));
-    }
-    for (unsigned int i = 0; i < buf.size(); ++i)
-    {
-        c1.push_back(buf[i]);
-    }
-    c2.clear();
-    buf = p2;
-    for (unsigned int i = cut; i < p1.size(); ++i)
-    {
-        buf.erase(std::find(buf.begin(), buf.end(), p1[i]));
-    }
-    for (unsigned int i = 0; i < buf.size(); ++i)
-    {
-        c2.push_back(buf[i]);
-    }
-    for (unsigned int i = cut; i < p1.size(); ++i)
-    {
-        c2.push_back(p1[i]);
-    }
-}
-
-template <typename V, typename T>
-void GeneticScheduler<V, T>::mutation(Gene &m, const Gene &c)
-{
-    Gene                                        buf;
-    std::uniform_int_distribution<unsigned int> dis(0, c.size() - 1);
-    unsigned int                                cut = dis(gen_);
-    Graph<T>                                    g1 = graph_, g2 = graph_;
-    
-    for (unsigned int i = 0; i < cut; ++i)
-    {
-        g1.removeVertex(c[i]);
-    }
-    for (unsigned int i = cut; i < c.size(); ++i)
-    {
-        g2.removeVertex(c[i]);
-    }
-    if (g1.size() > 0)
-    {
-        buf = g1.topoSort(gen_);
-    }
-    if (g2.size() > 0)
-    {
-        m = g2.topoSort(gen_);
-    }
-    for (unsigned int i = cut; i < c.size(); ++i)
-    {
-        m.push_back(buf[i - cut]);
-    }
-}
-
-template <typename V, typename T>
-void GeneticScheduler<V, T>::benchmarkCrossover(const unsigned int nIt)
-{
-    Gene   p1, p2, c1, c2;
-    double neg = 0., eq = 0., pos = 0., total;
-    int    improvement;
-    
-    LOG(Message) << "Benchmarking crossover..." << std::endl;
-    for (unsigned int i = 0; i < nIt; ++i)
-    {
-        p1 = graph_.topoSort(gen_);
-        p2 = graph_.topoSort(gen_);
-        crossover(c1, c2, p1, p2);
-        improvement = (func_(c1) + func_(c2) - func_(p1) - func_(p2))/2;
-        if (improvement < 0) neg++; else if (improvement == 0) eq++; else pos++;
-    }
-    total = neg + eq + pos;
-    LOG(Message) << "  -: " << neg/total << "  =: " << eq/total
-                 << "  +: " << pos/total << std::endl;
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_GeneticScheduler_hpp_
diff --git a/Hadrons/Global.cc b/Hadrons/Global.cc
deleted file mode 100644
index d74d10d2..00000000
--- a/Hadrons/Global.cc
+++ /dev/null
@@ -1,213 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Global.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Global.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-HadronsLogger Hadrons::HadronsLogError(1,"Error");
-HadronsLogger Hadrons::HadronsLogWarning(1,"Warning");
-HadronsLogger Hadrons::HadronsLogMessage(1,"Message");
-HadronsLogger Hadrons::HadronsLogIterative(1,"Iterative");
-HadronsLogger Hadrons::HadronsLogDebug(1,"Debug");
-HadronsLogger Hadrons::HadronsLogIRL(1,"IRL");
-
-void Hadrons::initLogger(void)
-{
-    auto w  = std::string("Hadrons").length();
-    int  cw = 8;
-
-
-    GridLogError.setTopWidth(w);
-    GridLogWarning.setTopWidth(w);
-    GridLogMessage.setTopWidth(w);
-    GridLogIterative.setTopWidth(w);
-    GridLogDebug.setTopWidth(w);
-    GridLogIRL.setTopWidth(w);
-    GridLogError.setChanWidth(cw);
-    GridLogWarning.setChanWidth(cw);
-    GridLogMessage.setChanWidth(cw);
-    GridLogIterative.setChanWidth(cw);
-    GridLogDebug.setChanWidth(cw);
-    GridLogIRL.setChanWidth(cw);
-    HadronsLogError.Active(true);
-    HadronsLogWarning.Active(true);
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    HadronsLogIRL.Active(GridLogIRL.isActive());
-    HadronsLogError.setChanWidth(cw);
-    HadronsLogWarning.setChanWidth(cw);
-    HadronsLogMessage.setChanWidth(cw);
-    HadronsLogIterative.setChanWidth(cw);
-    HadronsLogDebug.setChanWidth(cw);
-    HadronsLogIRL.setChanWidth(cw);
-}
-
-// type utilities //////////////////////////////////////////////////////////////
-size_t Hadrons::typeHash(const std::type_info *info)
-{
-    return info->hash_code();
-}
-
-//constexpr unsigned int maxNameSize = 1024u;
-
-std::string Hadrons::typeName(const std::type_info *info)
-{
-    char        *buf;
-    std::string name;
-    
-    buf  = abi::__cxa_demangle(info->name(), nullptr, nullptr, nullptr);
-    name = buf;
-    free(buf);
-    
-    return name;
-}
-
-// default writers/readers /////////////////////////////////////////////////////
-#ifdef HAVE_HDF5
-const std::string Hadrons::resultFileExt = "h5";
-#else
-const std::string Hadrons::resultFileExt = "xml";
-#endif
-
-// recursive mkdir /////////////////////////////////////////////////////////////
-int Hadrons::mkdir(const std::string dirName)
-{
-    if (!dirName.empty() and access(dirName.c_str(), R_OK|W_OK|X_OK))
-    {
-        mode_t mode755;
-        char   tmp[MAX_PATH_LENGTH];
-        char   *p = NULL;
-        size_t len;
-
-        mode755 = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
-
-        snprintf(tmp, sizeof(tmp), "%s", dirName.c_str());
-        len = strlen(tmp);
-        if(tmp[len - 1] == '/')
-        {
-            tmp[len - 1] = 0;
-        }
-        for(p = tmp + 1; *p; p++)
-        {
-            if(*p == '/')
-            {
-                *p = 0;
-                ::mkdir(tmp, mode755);
-                *p = '/';
-            }
-        }
-
-        return ::mkdir(tmp, mode755);
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-std::string Hadrons::basename(const std::string &s)
-{
-    constexpr char sep = '/';
-    size_t         i   = s.rfind(sep, s.length());
-    
-    if (i != std::string::npos)
-    {
-        return s.substr(i+1, s.length() - i);
-    }
-    else
-    {
-        return s;
-    }
-}
-
-std::string Hadrons::dirname(const std::string &s)
-{
-    constexpr char sep = '/';
-    size_t         i   = s.rfind(sep, s.length());
-    
-    if (i != std::string::npos)
-    {
-        return s.substr(0, i);
-    }
-    else
-    {
-        return "";
-    }
-}
-
-void Hadrons::makeFileDir(const std::string filename, GridBase *g)
-{
-    bool doIt = true;
-
-    if (g)
-    {
-        doIt = g->IsBoss();
-    }
-    if (doIt)
-    {
-        std::string dir    = dirname(filename);
-        int         status = mkdir(dir);
-
-        if (status)
-        {
-            HADRONS_ERROR(Io, "cannot create directory '" + dir
-                          + "' ( " + std::strerror(errno) + ")");
-        }
-    }
-}
-
-void Hadrons::printTimeProfile(const std::map<std::string, GridTime> &timing, 
-                               GridTime total)
-{
-    typedef decltype(total.count()) Count;
-
-    std::map<Count, std::string, std::greater<Count>> rtiming;
-    const double dtotal = static_cast<double>(total.count());
-    auto cf = std::cout.flags();
-    auto p  = std::cout.precision();
-    unsigned int width = 0;
-
-    for (auto &t: timing)
-    {
-        width = std::max(width, static_cast<unsigned int>(t.first.length()));
-        rtiming[t.second.count()] = t.first;
-    }
-    for (auto &rt: rtiming)
-    {
-        LOG(Message) << std::setw(width) << rt.second << ": " 
-                     << rt.first << " us (" << std::fixed 
-                     << std::setprecision(1) 
-                     << static_cast<double>(rt.first)/dtotal*100 << "%)"
-                     << std::endl;
-    }
-    std::cout.flags(cf);
-    std::cout.precision(p);
-}
diff --git a/Hadrons/Global.hpp b/Hadrons/Global.hpp
deleted file mode 100644
index b82c6288..00000000
--- a/Hadrons/Global.hpp
+++ /dev/null
@@ -1,282 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Global.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Global_hpp_
-#define Hadrons_Global_hpp_
-
-#include <set>
-#include <stack>
-#include <regex>
-#include <Grid/Grid.h>
-#include <cxxabi.h>
-
-#ifndef SITE_SIZE_TYPE
-#define SITE_SIZE_TYPE size_t
-#endif
-
-#ifndef DEFAULT_ASCII_PREC
-#define DEFAULT_ASCII_PREC 16
-#endif
-
-#define ARG(...) __VA_ARGS__
-
-/* the 'using Grid::operator<<;' statement prevents a very nasty compilation
- * error with GCC 5 (clang & GCC 6 compile fine without it).
- */
-
-#define BEGIN_HADRONS_NAMESPACE \
-namespace Grid {\
-namespace Hadrons {\
-using Grid::operator<<;\
-using Grid::operator>>;
-#define END_HADRONS_NAMESPACE }}
-
-#define BEGIN_MODULE_NAMESPACE(name)\
-namespace name {\
-using Grid::operator<<;\
-using Grid::operator>>;
-
-#define END_MODULE_NAMESPACE }
-
-#define _HADRONS_IMPL(impl, sub) impl##sub
-#define HADRONS_IMPL(impl, sub)   _HADRONS_IMPL(impl, sub)
-
-#ifndef FIMPLBASE
-#define FIMPLBASE WilsonImpl
-#endif
-#define FIMPL  HADRONS_IMPL(FIMPLBASE, R)
-#define FIMPLF HADRONS_IMPL(FIMPLBASE, F)
-#define FIMPLD HADRONS_IMPL(FIMPLBASE, D)
-
-#ifndef ZFIMPLBASE
-#define ZFIMPLBASE ZWilsonImpl
-#endif
-#define ZFIMPL  HADRONS_IMPL(ZFIMPLBASE, R)
-#define ZFIMPLF HADRONS_IMPL(ZFIMPLBASE, F)
-#define ZFIMPLD HADRONS_IMPL(ZFIMPLBASE, D)
-
-#ifndef SIMPLBASE
-#define SIMPLBASE ScalarImplC
-#endif
-#define SIMPL  HADRONS_IMPL(SIMPLBASE, R)
-#define SIMPLF HADRONS_IMPL(SIMPLBASE, F)
-#define SIMPLD HADRONS_IMPL(SIMPLBASE, D)
-
-#ifndef GIMPLBASE
-#define GIMPLBASE PeriodicGimpl
-#endif
-#define GIMPL  HADRONS_IMPL(GIMPLBASE, R)
-#define GIMPLF HADRONS_IMPL(GIMPLBASE, F)
-#define GIMPLD HADRONS_IMPL(GIMPLBASE, D)
-
-BEGIN_HADRONS_NAMESPACE
-
-// type aliases
-#define BASIC_TYPE_ALIASES(Impl, suffix)\
-typedef typename Impl::Field                         ScalarField##suffix;\
-typedef typename Impl::PropagatorField               PropagatorField##suffix;\
-typedef typename Impl::SitePropagator::scalar_object SitePropagator##suffix;\
-typedef typename Impl::ComplexField                  ComplexField##suffix;\
-typedef std::vector<SitePropagator##suffix>          SlicedPropagator##suffix;\
-typedef std::vector<typename ComplexField##suffix::vector_object::scalar_object> SlicedComplex##suffix;
-
-#define FERM_TYPE_ALIASES(FImpl, suffix)\
-BASIC_TYPE_ALIASES(FImpl, suffix);\
-typedef FermionOperator<FImpl>                     FMat##suffix;\
-typedef typename FImpl::FermionField               FermionField##suffix;\
-typedef typename FImpl::GaugeField                 GaugeField##suffix;\
-typedef typename FImpl::DoubledGaugeField          DoubledGaugeField##suffix;\
-typedef Lattice<iSpinMatrix<typename FImpl::Simd>> SpinMatrixField##suffix;
-
-#define GAUGE_TYPE_ALIASES(GImpl, suffix)\
-typedef typename GImpl::GaugeField GaugeField##suffix;
-
-#define SOLVER_TYPE_ALIASES(FImpl, suffix)\
-typedef Solver<FImpl> Solver##suffix;
-
-#define SINK_TYPE_ALIASES(suffix)\
-typedef std::function<SlicedPropagator##suffix\
-                      (const PropagatorField##suffix &)> SinkFn##suffix;
-
-// logger
-class HadronsLogger: public Logger
-{
-public:
-    HadronsLogger(int on, std::string nm): Logger("Hadrons", on, nm,
-                                                  GridLogColours, "BLACK"){};
-};
-
-#define LOG(channel) std::cout << HadronsLog##channel
-#define HADRONS_DEBUG_VAR(var) LOG(Debug) << #var << "= " << (var) << std::endl;
-
-extern HadronsLogger HadronsLogError;
-extern HadronsLogger HadronsLogWarning;
-extern HadronsLogger HadronsLogMessage;
-extern HadronsLogger HadronsLogIterative;
-extern HadronsLogger HadronsLogDebug;
-extern HadronsLogger HadronsLogIRL;
-
-void initLogger(void);
-
-// singleton pattern
-#define SINGLETON(name)\
-public:\
-    name(const name &e) = delete;\
-    void operator=(const name &e) = delete;\
-    static name & getInstance(void)\
-    {\
-        static name e;\
-        return e;\
-    }\
-private:\
-    name(void);
-
-#define SINGLETON_DEFCTOR(name)\
-public:\
-    name(const name &e) = delete;\
-    void operator=(const name &e) = delete;\
-    static name & getInstance(void)\
-    {\
-        static name e;\
-        return e;\
-    }\
-private:\
-    name(void) = default;
-
-// type utilities
-template <typename T>
-const std::type_info * typeIdPt(const T &x)
-{
-    return &typeid(x);
-}
-
-template <typename T>
-const std::type_info * typeIdPt(void)
-{
-    return &typeid(T);
-}
-
-size_t typeHash(const std::type_info *info);
-
-template <typename T>
-size_t typeHash(const T &x)
-{
-    return typeHash(typeIdPt(x));
-}
-
-template <typename T>
-size_t typeHash(void)
-{
-    return typeHash(typeIdPt<T>());
-}
-
-std::string typeName(const std::type_info *info);
-
-template <typename T>
-std::string typeName(const T &x)
-{
-    return typeName(typeIdPt(x));
-}
-
-template <typename T>
-std::string typeName(void)
-{
-    return typeName(typeIdPt<T>());
-}
-
-// default writers/readers
-extern const std::string resultFileExt;
-
-#ifdef HAVE_HDF5
-typedef Hdf5Reader ResultReader;
-typedef Hdf5Writer ResultWriter;
-#else
-typedef XmlReader ResultReader;
-typedef XmlWriter ResultWriter;
-#endif
-
-#define RESULT_FILE_NAME(name, traj) \
-name + "." + std::to_string(traj) + "." + resultFileExt
-
-// recursive mkdir
-#define MAX_PATH_LENGTH 512u
-int         mkdir(const std::string dirName);
-std::string basename(const std::string &s);
-std::string dirname(const std::string &s);
-void        makeFileDir(const std::string filename, GridBase *g = nullptr);
-
-// default Schur convention
-#ifndef HADRONS_DEFAULT_SCHUR 
-#define HADRONS_DEFAULT_SCHUR DiagTwo
-#endif
-#define _HADRONS_SCHUR_OP_(conv) Schur##conv##Operator
-#define HADRONS_SCHUR_OP(conv) _HADRONS_SCHUR_OP_(conv)
-#define HADRONS_DEFAULT_SCHUR_OP HADRONS_SCHUR_OP(HADRONS_DEFAULT_SCHUR)
-#define _HADRONS_SCHUR_SOLVE_(conv) SchurRedBlack##conv##Solve
-#define HADRONS_SCHUR_SOLVE(conv) _HADRONS_SCHUR_SOLVE_(conv)
-#define HADRONS_DEFAULT_SCHUR_SOLVE HADRONS_SCHUR_SOLVE(HADRONS_DEFAULT_SCHUR)
-#define _HADRONS_SCHUR_A2A_(conv) A2AVectorsSchur##conv
-#define HADRONS_SCHUR_A2A(conv) _HADRONS_SCHUR_A2A_(conv)
-#define HADRONS_DEFAULT_SCHUR_A2A HADRONS_SCHUR_A2A(HADRONS_DEFAULT_SCHUR)
-
-// stringify macro
-#define _HADRONS_STR(x) #x
-#define HADRONS_STR(x) _HADRONS_STR(x)
-
-// pretty print time profile
-void printTimeProfile(const std::map<std::string, GridTime> &timing, GridTime total);
-
-// token replacement utility
-template <typename T>
-void tokenReplace(std::string &str, const std::string token,
-                  const T &x, const std::string mark = "@")
-{
-    std::string fullToken = mark + token + mark;
-    
-    auto pos = str.find(fullToken);
-    if (pos != std::string::npos)
-    {
-        str.replace(pos, fullToken.size(), std::to_string(x));
-    }
-}
-
-// generic correlator class
-template <typename Metadata, typename Scalar = Complex>
-struct Correlator: Serializable
-{
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ARG(Correlator<Metadata, Scalar>),
-                                    Metadata,             info,
-                                    std::vector<Scalar>, corr);
-};
-
-END_HADRONS_NAMESPACE
-
-#include <Hadrons/Exceptions.hpp>
-
-#endif // Hadrons_Global_hpp_
diff --git a/Hadrons/Graph.hpp b/Hadrons/Graph.hpp
deleted file mode 100644
index 65c74106..00000000
--- a/Hadrons/Graph.hpp
+++ /dev/null
@@ -1,759 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Graph.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Graph_hpp_
-#define Hadrons_Graph_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                          Oriented graph class                              *
- ******************************************************************************/
-// I/O for edges
-template <typename T>
-std::ostream & operator<<(std::ostream &out, const std::pair<T, T> &e)
-{
-    out << "\""  << e.first << "\" -> \"" << e.second << "\"";
-    
-    return out;
-}
-
-// main class
-template <typename T>
-class Graph
-{
-public:
-    typedef std::pair<T, T> Edge;
-public:
-    // constructor
-    Graph(void);
-    // destructor
-    virtual ~Graph(void) = default;
-    // access
-    void           addVertex(const T &value);
-    void           addEdge(const Edge &e);
-    void           addEdge(const T &start, const T &end);
-    std::vector<T> getVertices(void) const;
-    void           removeVertex(const T &value);
-    void           removeEdge(const Edge &e);
-    void           removeEdge(const T &start, const T &end);
-    unsigned int   size(void) const;
-    // tests
-    bool gotValue(const T &value) const;
-    // graph topological manipulations
-    std::vector<T>              getAdjacentVertices(const T &value) const;
-    std::vector<T>              getChildren(const T &value) const;
-    std::vector<T>              getParents(const T &value) const;
-    std::vector<T>              getRoots(void) const;
-    std::vector<Graph<T>>       getConnectedComponents(void) const;
-    std::vector<T>              topoSort(void);
-    template <typename Gen>
-    std::vector<T>              topoSort(Gen &gen);
-    std::vector<std::vector<T>> allTopoSort(void);
-    // I/O
-    friend std::ostream & operator<<(std::ostream &out, const Graph<T> &g)
-    {
-        out << "{";
-        for (auto &e: g.edgeSet_)
-        {
-            out << e << ", ";
-        }
-        if (g.edgeSet_.size() != 0)
-        {
-            out << "\b\b";
-        }
-        out << "}";
-        
-        return out;
-    }
-private:
-    // vertex marking
-    void      mark(const T &value, const bool doMark = true);
-    void      markAll(const bool doMark = true);
-    void      unmark(const T &value);
-    void      unmarkAll(void);
-    bool      isMarked(const T &value) const;
-    const T * getFirstMarked(const bool isMarked = true) const;
-    template <typename Gen>
-    const T * getRandomMarked(const bool isMarked, Gen &gen);
-    const T * getFirstUnmarked(void) const;
-    template <typename Gen>
-    const T * getRandomUnmarked(Gen &gen);
-    // prune marked/unmarked vertices
-    void removeMarked(const bool isMarked = true);
-    void removeUnmarked(void);
-    // depth-first search marking
-    void depthFirstSearch(void);
-    void depthFirstSearch(const T &root);
-private:
-    std::map<T, bool>  isMarked_;
-    std::set<Edge>     edgeSet_;
-};
-
-// build depedency matrix from topological sorts
-template <typename T>
-std::map<T, std::map<T, bool>>
-makeDependencyMatrix(const std::vector<std::vector<T>> &topSort);
-
-/******************************************************************************
- *                       template implementation                              *
- ******************************************************************************
- * in all the following V is the number of vertex and E is the number of edge
- * in the worst case E = V^2
- */
-
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T>
-Graph<T>::Graph(void)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-// complexity: log(V)
-template <typename T>
-void Graph<T>::addVertex(const T &value)
-{
-    isMarked_[value] = false;
-}
-
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::addEdge(const Edge &e)
-{
-    addVertex(e.first);
-    addVertex(e.second);
-    edgeSet_.insert(e);
-}
-
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::addEdge(const T &start, const T &end)
-{
-    addEdge(Edge(start, end));
-}
-
-template <typename T>
-std::vector<T> Graph<T>::getVertices(void) const
-{
-    std::vector<T> vertex;
-    
-    for (auto &v: isMarked_)
-    {
-        vertex.push_back(v.first);
-    }
-    
-    return vertex;
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-void Graph<T>::removeVertex(const T &value)
-{
-    // remove vertex from the mark table
-    auto vIt = isMarked_.find(value);
-    
-    if (vIt != isMarked_.end())
-    {
-        isMarked_.erase(vIt);
-    }
-    else
-    {
-        HADRONS_ERROR(Range, "vertex does not exists");
-    }
-
-    // remove all edges containing the vertex
-    auto pred = [&value](const Edge &e)
-    {
-        return ((e.first == value) or (e.second == value));
-    };
-    auto eIt = find_if(edgeSet_.begin(), edgeSet_.end(), pred);
-    
-    while (eIt != edgeSet_.end())
-    {
-        edgeSet_.erase(eIt);
-        eIt = find_if(edgeSet_.begin(), edgeSet_.end(), pred);
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::removeEdge(const Edge &e)
-{
-    auto eIt = edgeSet_.find(e);
-    
-    if (eIt != edgeSet_.end())
-    {
-        edgeSet_.erase(eIt);
-    }
-    else
-    {
-        HADRONS_ERROR(Range, "edge does not exists");
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::removeEdge(const T &start, const T &end)
-{
-    removeEdge(Edge(start, end));
-}
-
-// complexity: O(1)
-template <typename T>
-unsigned int Graph<T>::size(void) const
-{
-    return isMarked_.size();
-}
-
-// tests ///////////////////////////////////////////////////////////////////////
-// complexity: O(log(V))
-template <typename T>
-bool Graph<T>::gotValue(const T &value) const
-{
-    auto it = isMarked_.find(value);
-    
-    if (it == isMarked_.end())
-    {
-        return false;
-    }
-    else
-    {
-        return true;
-    }
-}
-
-// vertex marking //////////////////////////////////////////////////////////////
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::mark(const T &value, const bool doMark)
-{
-    if (gotValue(value))
-    {
-        isMarked_[value] = doMark;
-    }
-    else
-    {
-        HADRONS_ERROR(Range, "vertex does not exists");
-    }
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-void Graph<T>::markAll(const bool doMark)
-{
-    for (auto &v: isMarked_)
-    {
-        mark(v.first, doMark);
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-void Graph<T>::unmark(const T &value)
-{
-    mark(value, false);
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-void Graph<T>::unmarkAll(void)
-{
-    markAll(false);
-}
-
-// complexity: O(log(V))
-template <typename T>
-bool Graph<T>::isMarked(const T &value) const
-{
-    if (gotValue(value))
-    {
-        return isMarked_.at(value);
-    }
-    else
-    {
-        HADRONS_ERROR(Range, "vertex does not exists");
-        
-        return false;
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-const T * Graph<T>::getFirstMarked(const bool isMarked) const
-{
-    auto pred = [&isMarked](const std::pair<T, bool> &v)
-    {
-        return (v.second == isMarked);
-    };
-    auto vIt = std::find_if(isMarked_.begin(), isMarked_.end(), pred);
-    
-    if (vIt != isMarked_.end())
-    {
-        return &(vIt->first);
-    }
-    else
-    {
-        return nullptr;
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-template <typename Gen>
-const T * Graph<T>::getRandomMarked(const bool isMarked, Gen &gen)
-{
-    auto pred = [&isMarked](const std::pair<T, bool> &v)
-    {
-        return (v.second == isMarked);
-    };
-    std::uniform_int_distribution<unsigned int> dis(0, size() - 1);
-    auto                                        rIt = isMarked_.begin();
-    
-    std::advance(rIt, dis(gen));
-    auto vIt = std::find_if(rIt, isMarked_.end(), pred);
-    if (vIt != isMarked_.end())
-    {
-        return &(vIt->first);
-    }
-    else
-    {
-        vIt = std::find_if(isMarked_.begin(), rIt, pred);
-        if (vIt != rIt)
-        {
-            return &(vIt->first);
-        }
-        else
-        {
-            return nullptr;
-        }
-    }
-}
-
-// complexity: O(log(V))
-template <typename T>
-const T * Graph<T>::getFirstUnmarked(void) const
-{
-    return getFirstMarked(false);
-}
-
-// complexity: O(log(V))
-template <typename T>
-template <typename Gen>
-const T * Graph<T>::getRandomUnmarked(Gen &gen)
-{
-    return getRandomMarked(false, gen);
-}
-
-// prune marked/unmarked vertices //////////////////////////////////////////////
-// complexity: O(V^2*log(V))
-template <typename T>
-void Graph<T>::removeMarked(const bool isMarked)
-{
-    auto isMarkedCopy = isMarked_;
-    
-    for (auto &v: isMarkedCopy)
-    {
-        if (v.second == isMarked)
-        {
-            removeVertex(v.first);
-        }
-    }
-}
-
-// complexity: O(V^2*log(V))
-template <typename T>
-void Graph<T>::removeUnmarked(void)
-{
-    removeMarked(false);
-}
-
-// depth-first search marking //////////////////////////////////////////////////
-// complexity: O(V*log(V))
-template <typename T>
-void Graph<T>::depthFirstSearch(void)
-{
-    depthFirstSearch(isMarked_.begin()->first);
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-void Graph<T>::depthFirstSearch(const T &root)
-{
-    std::vector<T> adjacentVertex;
-    
-    mark(root);
-    adjacentVertex = getAdjacentVertices(root);
-    for (auto &v: adjacentVertex)
-    {
-        if (!isMarked(v))
-        {
-            depthFirstSearch(v);
-        }
-    }
-}
-
-// graph topological manipulations /////////////////////////////////////////////
-// complexity: O(V*log(V))
-template <typename T>
-std::vector<T> Graph<T>::getAdjacentVertices(const T &value) const
-{
-    std::vector<T> adjacentVertex;
-    
-    auto pred = [&value](const Edge &e)
-    {
-        return ((e.first == value) or (e.second == value));
-    };
-    auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred);
-    
-    while (eIt != edgeSet_.end())
-    {
-        if (eIt->first == value)
-        {
-            adjacentVertex.push_back((*eIt).second);
-        }
-        else if (eIt->second == value)
-        {
-            adjacentVertex.push_back((*eIt).first);
-        }
-        eIt = std::find_if(++eIt, edgeSet_.end(), pred);
-    }
-    
-    return adjacentVertex;
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-std::vector<T> Graph<T>::getChildren(const T &value) const
-{
-    std::vector<T> child;
-    
-    auto pred = [&value](const Edge &e)
-    {
-        return (e.first == value);
-    };
-    auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred);
-    
-    while (eIt != edgeSet_.end())
-    {
-        child.push_back((*eIt).second);
-        eIt = std::find_if(++eIt, edgeSet_.end(), pred);
-    }
-    
-    return child;
-}
-
-// complexity: O(V*log(V))
-template <typename T>
-std::vector<T> Graph<T>::getParents(const T &value) const
-{
-    std::vector<T> parent;
-    
-    auto pred = [&value](const Edge &e)
-    {
-        return (e.second == value);
-    };
-    auto eIt = std::find_if(edgeSet_.begin(), edgeSet_.end(), pred);
-    
-    while (eIt != edgeSet_.end())
-    {
-        parent.push_back((*eIt).first);
-        eIt = std::find_if(++eIt, edgeSet_.end(), pred);
-    }
-    
-    return parent;
-}
-
-// complexity: O(V^2*log(V))
-template <typename T>
-std::vector<T> Graph<T>::getRoots(void) const
-{
-    std::vector<T> root;
-    
-    for (auto &v: isMarked_)
-    {
-        auto parent = getParents(v.first);
-        
-        if (parent.size() == 0)
-        {
-            root.push_back(v.first);
-        }
-    }
-    
-    return root;
-}
-
-// complexity: O(V^2*log(V))
-template <typename T>
-std::vector<Graph<T>> Graph<T>::getConnectedComponents(void) const
-{
-    std::vector<Graph<T>> res;
-    Graph<T>              copy(*this);
-    
-    while (copy.size() > 0)
-    {
-        copy.depthFirstSearch();
-        res.push_back(copy);
-        res.back().removeUnmarked();
-        res.back().unmarkAll();
-        copy.removeMarked();
-        copy.unmarkAll();
-    }
-    
-    return res;
-}
-
-// topological sort using a directed DFS algorithm
-// complexity: O(V*log(V))
-template <typename T>
-std::vector<T> Graph<T>::topoSort(void)
-{
-    std::stack<T>     buf;
-    std::vector<T>    res;
-    const T           *vPt;
-    std::map<T, bool> tmpMarked(isMarked_);
-
-    // visit function
-    std::function<void(const T &)> visit = [&](const T &v)
-    {
-        if (tmpMarked.at(v))
-        {
-            HADRONS_ERROR(Range, "cannot topologically sort a cyclic graph");
-        }
-        if (!isMarked(v))
-        {
-            std::vector<T> child = getChildren(v);
-
-            tmpMarked[v] = true;
-            for (auto &c: child)
-            {
-                visit(c);
-            }
-            mark(v);
-            tmpMarked[v] = false;
-            buf.push(v);
-        }
-    };
-    
-    // reset temporary marks
-    for (auto &v: tmpMarked)
-    {
-        tmpMarked.at(v.first) = false;
-    }
-    
-    // loop on unmarked vertices
-    unmarkAll();
-    vPt = getFirstUnmarked();
-    while (vPt)
-    {
-        visit(*vPt);
-        vPt = getFirstUnmarked();
-    }
-    unmarkAll();
-    
-    // create result vector
-    while (!buf.empty())
-    {
-        res.push_back(buf.top());
-        buf.pop();
-    }
-    
-    return res;
-}
-
-// random version of the topological sort
-// complexity: O(V*log(V))
-template <typename T>
-template <typename Gen>
-std::vector<T> Graph<T>::topoSort(Gen &gen)
-{
-    std::stack<T>     buf;
-    std::vector<T>    res;
-    const T           *vPt;
-    std::map<T, bool> tmpMarked(isMarked_);
-    
-    // visit function
-    std::function<void(const T &)> visit = [&](const T &v)
-    {
-        if (tmpMarked.at(v))
-        {
-            HADRONS_ERROR(Range, "cannot topologically sort a cyclic graph");
-        }
-        if (!isMarked(v))
-        {
-            std::vector<T> child = getChildren(v);
-            
-            tmpMarked[v] = true;
-            std::shuffle(child.begin(), child.end(), gen);
-            for (auto &c: child)
-            {
-                visit(c);
-            }
-            mark(v);
-            tmpMarked[v] = false;
-            buf.push(v);
-        }
-    };
-    
-    // reset temporary marks
-    for (auto &v: tmpMarked)
-    {
-        tmpMarked.at(v.first) = false;
-    }
-    
-    // loop on unmarked vertices
-    unmarkAll();
-    vPt = getRandomUnmarked(gen);
-    while (vPt)
-    {
-        visit(*vPt);
-        vPt = getRandomUnmarked(gen);
-    }
-    unmarkAll();
-    
-    // create result vector
-    while (!buf.empty())
-    {
-        res.push_back(buf.top());
-        buf.pop();
-    }
-    
-    return res;
-}
-
-// generate all possible topological sorts
-// Y. L. Varol & D. Rotem, Comput. J. 24(1), pp. 83–84, 1981
-// http://comjnl.oupjournals.org/cgi/doi/10.1093/comjnl/24.1.83
-// complexity: O(V*log(V)) (from the paper, but really ?)
-template <typename T>
-std::vector<std::vector<T>> Graph<T>::allTopoSort(void)
-{
-    std::vector<std::vector<T>>    res;
-    std::map<T, std::map<T, bool>> iMat;
-    
-    // create incidence matrix
-    for (auto &v1: isMarked_)
-    for (auto &v2: isMarked_)
-    {
-        iMat[v1.first][v2.first] = false;
-    }
-    for (auto &v: isMarked_)
-    {
-        auto cVec = getChildren(v.first);
-        
-        for (auto &c: cVec)
-        {
-            iMat[v.first][c] = true;
-        }
-    }
-    
-    // generate initial topological sort
-    res.push_back(topoSort());
-    
-    // generate all other topological sorts by permutation
-    std::vector<T>            p = res[0];
-    const unsigned int        n = size();
-    std::vector<unsigned int> loc(n);
-    unsigned int              i, k, k1;
-    T                         obj_k, obj_k1;
-    bool                      isFinal;
-    
-    for (unsigned int j = 0; j < n; ++j)
-    {
-        loc[j] = j;
-    }
-    i = 0;
-    while (i < n-1)
-    {
-        k      = loc[i];
-        k1     = k + 1;
-        obj_k  = p[k];
-        if (k1 >= n)
-        {
-            isFinal = true;
-            obj_k1  = obj_k;
-        }
-        else
-        {
-            isFinal = false;
-            obj_k1  = p[k1];
-        }
-        if (iMat[res[0][i]][obj_k1] or isFinal)
-        {
-            for (unsigned int l = k; l >= i + 1; --l)
-            {
-                p[l]   = p[l-1];
-            }
-            p[i]   = obj_k;
-            loc[i] = i;
-            i++;
-        }
-        else
-        {
-            p[k]   = obj_k1;
-            p[k1]  = obj_k;
-            loc[i] = k1;
-            i      = 0;
-            res.push_back(p);
-        }
-    }
-    
-    return res;
-}
-
-// build depedency matrix from topological sorts ///////////////////////////////
-// complexity: something like O(V^2*log(V!))
-template <typename T>
-std::map<T, std::map<T, bool>>
-makeDependencyMatrix(const std::vector<std::vector<T>> &topSort)
-{
-    std::map<T, std::map<T, bool>> m;
-    const std::vector<T>           &vList = topSort[0];
-    
-    for (auto &v1: vList)
-    for (auto &v2: vList)
-    {
-        bool dep = true;
-        
-        for (auto &t: topSort)
-        {
-            auto i1 = std::find(t.begin(), t.end(), v1);
-            auto i2 = std::find(t.begin(), t.end(), v2);
-            
-            dep = dep and (i1 - i2 > 0);
-            if (!dep) break;
-        }
-        m[v1][v2] = dep;
-    }
-    
-    return m;
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Graph_hpp_
diff --git a/Hadrons/Makefile.am b/Hadrons/Makefile.am
deleted file mode 100644
index d0036251..00000000
--- a/Hadrons/Makefile.am
+++ /dev/null
@@ -1,38 +0,0 @@
-SUBDIRS = . Utilities
-
-lib_LIBRARIES = libHadrons.a
-
-include modules.inc
-
-libHadrons_a_SOURCES = \
-    Application.cc     \
-    Environment.cc     \
-	Exceptions.cc      \
-    Global.cc          \
-    Module.cc		   \
-	TimerArray.cc      \
-	VirtualMachine.cc  \
-	$(modules_cc)
-	
-libHadrons_adir = $(includedir)/Hadrons
-nobase_libHadrons_a_HEADERS = \
-	A2AVectors.hpp            \
-	A2AMatrix.hpp             \
-	Application.hpp           \
-	DilutedNoise.hpp          \
-	DiskVector.hpp            \
-	EigenPack.hpp             \
-	Environment.hpp           \
-	Exceptions.hpp            \
-	Factory.hpp               \
-	GeneticScheduler.hpp      \
-	Global.hpp                \
-	Graph.hpp                 \
-	Module.hpp                \
-	Modules.hpp               \
-	ModuleFactory.hpp         \
-        NamedTensor.hpp           \
-	Solver.hpp                \
-	TimerArray.hpp            \
-	VirtualMachine.hpp        \
-	$(modules_hpp)
diff --git a/Hadrons/Module.cc b/Hadrons/Module.cc
deleted file mode 100644
index 17017513..00000000
--- a/Hadrons/Module.cc
+++ /dev/null
@@ -1,110 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Module.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Module.hpp>
-
-using namespace Grid;
- 
-using namespace Hadrons;
-
-/******************************************************************************
- *                       ModuleBase implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-ModuleBase::ModuleBase(const std::string name)
-: name_(name)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-std::string ModuleBase::getName(void) const
-{
-    return name_;
-}
-
-// get factory registration name if available
-std::string ModuleBase::getRegisteredName(void)
-{
-    HADRONS_ERROR(Definition, "module '" + getName() + "' has no registered type"
-                 + " in the factory");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void ModuleBase::operator()(void)
-{
-    resetTimers();
-    startTimer("_total");
-    startTimer("_setup");
-    setup();
-    stopTimer("_setup");
-    startTimer("_execute");
-    execute();
-    stopAllTimers();
-}
-
-std::string ModuleBase::makeSeedString(void)
-{
-    std::string seed;
-
-    if (!vm().getRunId().empty())
-    {
-        seed += vm().getRunId() + "-";
-    }
-    seed += getName() + "-" + std::to_string(vm().getTrajectory());
-
-    return seed;
-}
-
-GridParallelRNG & ModuleBase::rng4d(void)
-{
-    auto &r = *env().get4dRng();
-
-    if (makeSeedString() != seed_)
-    {
-        seed_ = makeSeedString();
-        LOG(Message) << "Seeding 4D RNG " << &r << " with string '" 
-                     << seed_ << "'" << std::endl;
-        r.SeedUniqueString(seed_);
-    }
-
-    return r;
-}
-
-GridSerialRNG & ModuleBase::rngSerial(void)
-{
-    auto &r = *env().getSerialRng();
-
-    if (makeSeedString() != seed_)
-    {
-        seed_ = makeSeedString();
-        LOG(Message) << "Seeding Serial RNG " << &r << " with string '" 
-                     << seed_ << "'" << std::endl;
-        r.SeedUniqueString(seed_);
-    }
-
-    return r;
-}
diff --git a/Hadrons/Module.hpp b/Hadrons/Module.hpp
deleted file mode 100644
index 3bea7ff2..00000000
--- a/Hadrons/Module.hpp
+++ /dev/null
@@ -1,295 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-Source file: Hadrons/Module.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Module_hpp_
-#define Hadrons_Module_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/TimerArray.hpp>
-#include <Hadrons/VirtualMachine.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-// module registration macros
-#define MODULE_REGISTER(mod, base, ns)\
-class mod: public base\
-{\
-public:\
-    typedef base Base;\
-    using Base::Base;\
-    virtual std::string getRegisteredName(void)\
-    {\
-        return std::string(#ns "::" #mod);\
-    }\
-};\
-class ns##mod##ModuleRegistrar\
-{\
-public:\
-    ns##mod##ModuleRegistrar(void)\
-    {\
-        ModuleFactory &modFac = ModuleFactory::getInstance();\
-        modFac.registerBuilder(#ns "::" #mod, [&](const std::string name)\
-                              {\
-                                  return std::unique_ptr<ns::mod>(new ns::mod(name));\
-                              });\
-    }\
-};\
-static ns##mod##ModuleRegistrar ns##mod##ModuleRegistrarInstance;
-
-#define MODULE_REGISTER_TMP(mod, base, ns)\
-extern template class base;\
-MODULE_REGISTER(mod, ARG(base), ns);
-
-#define HADRONS_MACRO_REDIRECT_12(arg1, arg2, macro, ...) macro
-#define HADRONS_MACRO_REDIRECT_23(arg1, arg2, arg3, macro, ...) macro
-
-#define envGetGrid4(latticeType)\
-env().template getGrid<typename latticeType::vector_type>()
-
-#define envGetGrid5(latticeType, Ls)\
-env().template getGrid<typename latticeType::vector_type>(Ls)
-
-#define envGetGrid(...)\
-HADRONS_MACRO_REDIRECT_12(__VA_ARGS__, envGetGrid5, envGetGrid4)(__VA_ARGS__)
-
-#define envGetCoarseGrid4(latticeType, blockSize)\
-env().template getCoarseGrid<typename latticeType::vector_type>(blockSize)
-
-#define envGetCoarseGrid5(latticeType, blockSize, Ls)\
-env().template getCoarseGrid<typename latticeType::vector_type>(blockSize, Ls)
-
-#define envGetCoarseGrid(...)\
-HADRONS_MACRO_REDIRECT_23(__VA_ARGS__, envGetCoarseGrid5, envGetCoarseGrid4)(__VA_ARGS__)
-
-#define envGetRbGrid4(latticeType)\
-env().template getRbGrid<typename latticeType::vector_type>()
-
-#define envGetRbGrid5(latticeType, Ls)\
-env().template getRbGrid<typename latticeType::vector_type>(Ls)
-
-#define envGetRbGrid(...)\
-HADRONS_MACRO_REDIRECT_12(__VA_ARGS__, envGetRbGrid5, envGetRbGrid4)(__VA_ARGS__)
-
-#define envGet(type, name)\
-*env().template getObject<type>(name)
-
-#define envGetDerived(base, type, name)\
-*env().template getDerivedObject<base, type>(name)
-
-#define envGetTmp(type, var)\
-type &var = *env().template getObject<type>(getName() + "_tmp_" + #var)
-
-#define envHasType(type, name)\
-env().template isObjectOfType<type>(name)
-
-#define envCreate(type, name, Ls, ...)\
-env().template createObject<type>(name, Environment::Storage::object, Ls, __VA_ARGS__)
-
-#define envCreateDerived(base, type, name, Ls, ...)\
-env().template createDerivedObject<base, type>(name, Environment::Storage::object, Ls, __VA_ARGS__)
-
-#define envCreateLat4(type, name)\
-envCreate(type, name, 1, envGetGrid(type))
-
-#define envCreateLat5(type, name, Ls)\
-envCreate(type, name, Ls, envGetGrid(type, Ls))
-
-#define envCreateLat(...)\
-HADRONS_MACRO_REDIRECT_23(__VA_ARGS__, envCreateLat5, envCreateLat4)(__VA_ARGS__)
-
-#define envCache(type, name, Ls, ...)\
-env().template createObject<type>(name, Environment::Storage::cache, Ls, __VA_ARGS__)
-
-#define envCacheLat4(type, name)\
-envCache(type, name, 1, envGetGrid(type))
-
-#define envCacheLat5(type, name, Ls)\
-envCache(type, name, Ls, envGetGrid(type, Ls))
-
-#define envCacheLat(...)\
-HADRONS_MACRO_REDIRECT_23(__VA_ARGS__, envCacheLat5, envCacheLat4)(__VA_ARGS__)
-
-#define envTmp(type, name, Ls, ...)\
-env().template createObject<type>(getName() + "_tmp_" + name,         \
-                                  Environment::Storage::temporary, Ls, __VA_ARGS__)
-
-#define envTmpLat4(type, name)\
-envTmp(type, name, 1, envGetGrid(type))
-
-#define envTmpLat5(type, name, Ls)\
-envTmp(type, name, Ls, envGetGrid(type, Ls))
-
-#define envTmpLat(...)\
-HADRONS_MACRO_REDIRECT_23(__VA_ARGS__, envTmpLat5, envTmpLat4)(__VA_ARGS__)
-
-#define saveResult(ioStem, name, result)\
-if (env().getGrid()->IsBoss() and !ioStem.empty())\
-{\
-    makeFileDir(ioStem, env().getGrid());\
-    {\
-        ResultWriter _writer(RESULT_FILE_NAME(ioStem, vm().getTrajectory()));\
-        write(_writer, name, result);\
-    }\
-}
-
-/******************************************************************************
- *                            Module class                                    *
- ******************************************************************************/
-// base class
-class ModuleBase: public TimerArray
-{
-public:
-    // constructor
-    ModuleBase(const std::string name);
-    // destructor
-    virtual ~ModuleBase(void) = default;
-    // access
-    std::string getName(void) const;
-    // get factory registration name if available
-    virtual std::string getRegisteredName(void);
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void) = 0;
-    virtual std::vector<std::string> getReference(void)
-    {
-        return std::vector<std::string>(0);
-    };
-    virtual std::vector<std::string> getOutput(void) = 0;
-    // parse parameters
-    virtual void parseParameters(XmlReader &reader, const std::string name) = 0;
-    virtual void saveParameters(XmlWriter &writer, const std::string name) = 0;
-    // parameter string
-    virtual std::string parString(void) const = 0;
-    // setup
-    virtual void setup(void) {};
-    virtual void execute(void) = 0;
-    // execution
-    void operator()(void);
-protected:
-    // environment shortcut
-    DEFINE_ENV_ALIAS;
-    // virtual machine shortcut
-    DEFINE_VM_ALIAS;
-    // RNG seeded from module string
-    GridParallelRNG &rng4d(void);
-    GridSerialRNG &rngSerial(void);
-private:
-    std::string makeSeedString(void);
-private:
-    std::string                          name_, currentTimer_, seed_;
-    std::map<std::string, GridStopWatch> timer_; 
-};
-
-// derived class, templating the parameter class
-template <typename P>
-class Module: public ModuleBase
-{
-public:
-    typedef P Par;
-public:
-    // constructor
-    Module(const std::string name);
-    // destructor
-    virtual ~Module(void) = default;
-    // parse parameters
-    virtual void parseParameters(XmlReader &reader, const std::string name);
-    virtual void saveParameters(XmlWriter &writer, const std::string name);
-    // parameter string
-    virtual std::string parString(void) const;
-    // parameter access
-    const P &   par(void) const;
-    void        setPar(const P &par);
-private:
-    P par_;
-};
-
-// no parameter type
-class NoPar {};
-
-template <>
-class Module<NoPar>: public ModuleBase
-{
-public:
-    // constructor
-    Module(const std::string name): ModuleBase(name) {};
-    // destructor
-    virtual ~Module(void) = default;
-    // parse parameters (do nothing)
-    virtual void parseParameters(XmlReader &reader, const std::string name) {};
-    virtual void saveParameters(XmlWriter &writer, const std::string name)
-    {
-        push(writer, "options");
-        pop(writer);
-    };
-    // parameter string (empty)
-    virtual std::string parString(void) const {return "";};
-};
-
-/******************************************************************************
- *                           Template implementation                          *
- ******************************************************************************/
-template <typename P>
-Module<P>::Module(const std::string name)
-: ModuleBase(name)
-{}
-
-template <typename P>
-void Module<P>::parseParameters(XmlReader &reader, const std::string name)
-{
-    read(reader, name, par_);
-}
-
-template <typename P>
-void Module<P>::saveParameters(XmlWriter &writer, const std::string name)
-{
-    write(writer, name, par_);
-}
-
-template <typename P>
-std::string Module<P>::parString(void) const
-{
-    XmlWriter writer("", "");
-
-    write(writer, par_.SerialisableClassName(), par_);
-
-    return writer.string();
-}
-
-template <typename P>
-const P & Module<P>::par(void) const
-{
-    return par_;
-}
-
-template <typename P>
-void Module<P>::setPar(const P &par)
-{
-    par_ = par;
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Module_hpp_
diff --git a/Hadrons/ModuleFactory.hpp b/Hadrons/ModuleFactory.hpp
deleted file mode 100644
index 4cb39983..00000000
--- a/Hadrons/ModuleFactory.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/ModuleFactory.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_ModuleFactory_hpp_
-#define Hadrons_ModuleFactory_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Factory.hpp>
-#include <Hadrons/Module.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                            ModuleFactory                                   *
- ******************************************************************************/
-class ModuleFactory: public Factory<ModuleBase>
-{
-    SINGLETON_DEFCTOR(ModuleFactory)
-};
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_ModuleFactory_hpp_
diff --git a/Hadrons/Modules.hpp b/Hadrons/Modules.hpp
deleted file mode 100644
index c828e120..00000000
--- a/Hadrons/Modules.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include <Hadrons/Modules/MAction/DWF.hpp>
-#include <Hadrons/Modules/MAction/MobiusDWF.hpp>
-#include <Hadrons/Modules/MAction/ScaledDWF.hpp>
-#include <Hadrons/Modules/MAction/WilsonClover.hpp>
-#include <Hadrons/Modules/MAction/Wilson.hpp>
-#include <Hadrons/Modules/MAction/ZMobiusDWF.hpp>
-#include <Hadrons/Modules/MContraction/A2AAslashField.hpp>
-#include <Hadrons/Modules/MContraction/A2AFourQuarkContraction.hpp>
-#include <Hadrons/Modules/MContraction/A2ALoop.hpp>
-#include <Hadrons/Modules/MContraction/A2AMesonField.hpp>
-#include <Hadrons/Modules/MContraction/Baryon.hpp>
-#include <Hadrons/Modules/MContraction/DiscLoop.hpp>
-#include <Hadrons/Modules/MContraction/Gamma3pt.hpp>
-#include <Hadrons/Modules/MContraction/Meson.hpp>
-#include <Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp>
-#include <Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp>
-#include <Hadrons/Modules/MContraction/WeakEye3pt.hpp>
-#include <Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp>
-#include <Hadrons/Modules/MContraction/WeakNonEye3pt.hpp>
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-#include <Hadrons/Modules/MDistil/DistilPar.hpp>
-#include <Hadrons/Modules/MDistil/DistilVectors.hpp>
-#include <Hadrons/Modules/MDistil/LapEvec.hpp>
-#include <Hadrons/Modules/MDistil/Noises.hpp>
-#include <Hadrons/Modules/MDistil/PerambFromSolve.hpp>
-#include <Hadrons/Modules/MDistil/Perambulator.hpp>
-#include <Hadrons/Modules/MFermion/EMLepton.hpp>
-#include <Hadrons/Modules/MFermion/FreeProp.hpp>
-#include <Hadrons/Modules/MFermion/GaugeProp.hpp>
-#include <Hadrons/Modules/MGauge/Electrify.hpp>
-#include <Hadrons/Modules/MGauge/FundtoHirep.hpp>
-#include <Hadrons/Modules/MGauge/GaugeFix.hpp>
-#include <Hadrons/Modules/MGauge/Random.hpp>
-#include <Hadrons/Modules/MGauge/StochEm.hpp>
-#include <Hadrons/Modules/MGauge/StoutSmearing.hpp>
-#include <Hadrons/Modules/MGauge/UnitEm.hpp>
-#include <Hadrons/Modules/MGauge/Unit.hpp>
-#include <Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.hpp>
-#include <Hadrons/Modules/MIO/LoadA2AVectors.hpp>
-#include <Hadrons/Modules/MIO/LoadBinary.hpp>
-#include <Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp>
-#include <Hadrons/Modules/MIO/LoadCosmHol.hpp>
-#include <Hadrons/Modules/MIO/LoadDistilNoise.hpp>
-#include <Hadrons/Modules/MIO/LoadEigenPack.hpp>
-#include <Hadrons/Modules/MIO/LoadNersc.hpp>
-#include <Hadrons/Modules/MIO/LoadPerambulator.hpp>
-#include <Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp>
-#include <Hadrons/Modules/MNoise/SparseSpinColorDiagonal.hpp>
-#include <Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp>
-#include <Hadrons/Modules/MNPR/Amputate.hpp>
-#include <Hadrons/Modules/MNPR/Bilinear.hpp>
-#include <Hadrons/Modules/MNPR/FourQuark.hpp>
-#include <Hadrons/Modules/MScalar/ChargedProp.hpp>
-#include <Hadrons/Modules/MScalar/FreeProp.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-#include <Hadrons/Modules/MScalarSUN/Div.hpp>
-#include <Hadrons/Modules/MScalarSUN/EMT.hpp>
-#include <Hadrons/Modules/MScalarSUN/Grad.hpp>
-#include <Hadrons/Modules/MScalarSUN/StochFreeField.hpp>
-#include <Hadrons/Modules/MScalarSUN/TransProj.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrKinetic.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrMag.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrPhi.hpp>
-#include <Hadrons/Modules/MScalarSUN/TwoPoint.hpp>
-#include <Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-#include <Hadrons/Modules/MSink/Point.hpp>
-#include <Hadrons/Modules/MSink/Smear.hpp>
-#include <Hadrons/Modules/MSolver/A2AAslashVectors.hpp>
-#include <Hadrons/Modules/MSolver/A2AVectors.hpp>
-#include <Hadrons/Modules/MSolver/Guesser.hpp>
-#include <Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp>
-#include <Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp>
-#include <Hadrons/Modules/MSolver/RBPrecCG.hpp>
-#include <Hadrons/Modules/MSource/Convolution.hpp>
-#include <Hadrons/Modules/MSource/Gauss.hpp>
-#include <Hadrons/Modules/MSource/JacobiSmear.hpp>
-#include <Hadrons/Modules/MSource/Momentum.hpp>
-#include <Hadrons/Modules/MSource/MomentumPhase.hpp>
-#include <Hadrons/Modules/MSource/Point.hpp>
-#include <Hadrons/Modules/MSource/SeqAslash.hpp>
-#include <Hadrons/Modules/MSource/SeqConserved.hpp>
-#include <Hadrons/Modules/MSource/SeqGamma.hpp>
-#include <Hadrons/Modules/MSource/Wall.hpp>
-#include <Hadrons/Modules/MSource/Z2.hpp>
-#include <Hadrons/Modules/MUtilities/PrecisionCast.hpp>
-#include <Hadrons/Modules/MUtilities/RandomVectors.hpp>
diff --git a/Hadrons/Modules/MAction/DWF.cc b/Hadrons/Modules/MAction/DWF.cc
deleted file mode 100644
index 1cb89602..00000000
--- a/Hadrons/Modules/MAction/DWF.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/DWF.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/DWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TDWF<FIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/DWF.hpp b/Hadrons/Modules/MAction/DWF.hpp
deleted file mode 100644
index 21024a4f..00000000
--- a/Hadrons/Modules/MAction/DWF.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/DWF.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MAction_DWF_hpp_
-#define Hadrons_MAction_DWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                     Domain wall quark action                               *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class DWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DWFPar,
-                                    std::string, gauge,
-                                    unsigned int, Ls,
-                                    double      , mass,
-                                    double      , M5,
-                                    std::string , boundary,
-                                    std::string , twist);
-};
-
-template <typename FImpl>
-class TDWF: public Module<DWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TDWF(const std::string name);
-    // destructor
-    virtual ~TDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(DWF, TDWF<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(DWFF, TDWF<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                        DWF template implementation                         *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TDWF<FImpl>::TDWF(const std::string name)
-: Module<DWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << " and Ls= "
-                 << par().Ls << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-                 
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    typename DomainWallFermion<FImpl>::ImplParams implParams;
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases
-                 << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L
-                 << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-    envCreateDerived(FMat, DomainWallFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_DWF_hpp_
diff --git a/Hadrons/Modules/MAction/MobiusDWF.cc b/Hadrons/Modules/MAction/MobiusDWF.cc
deleted file mode 100644
index 00819632..00000000
--- a/Hadrons/Modules/MAction/MobiusDWF.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/MobiusDWF.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/MobiusDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TMobiusDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TMobiusDWF<FIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/MobiusDWF.hpp b/Hadrons/Modules/MAction/MobiusDWF.hpp
deleted file mode 100644
index 3ce02b91..00000000
--- a/Hadrons/Modules/MAction/MobiusDWF.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/MobiusDWF.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_MobiusDWF_hpp_
-#define Hadrons_MAction_MobiusDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      Mobius domain-wall fermion action                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class MobiusDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(MobiusDWFPar,
-                                    std::string , gauge,
-                                    unsigned int, Ls,
-                                    double      , mass,
-                                    double      , M5,
-                                    double      , b,
-                                    double      , c,
-                                    std::string , boundary,
-                                    std::string , twist);
-};
-
-template <typename FImpl>
-class TMobiusDWF: public Module<MobiusDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TMobiusDWF(const std::string name);
-    // destructor
-    virtual ~TMobiusDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(MobiusDWF, TMobiusDWF<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(MobiusDWFF, TMobiusDWF<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                      TMobiusDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TMobiusDWF<FImpl>::TMobiusDWF(const std::string name)
-: Module<MobiusDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TMobiusDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TMobiusDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMobiusDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up Mobius domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", b= " << par().b << ", c= " << par().c
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-                 
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    typename MobiusFermion<FImpl>::ImplParams implParams;
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases
-                 << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L
-                 << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-    envCreateDerived(FMat, MobiusFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, par().b, par().c,
-                     implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMobiusDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_MobiusDWF_hpp_
diff --git a/Hadrons/Modules/MAction/ScaledDWF.cc b/Hadrons/Modules/MAction/ScaledDWF.cc
deleted file mode 100644
index 81b254b1..00000000
--- a/Hadrons/Modules/MAction/ScaledDWF.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ScaledDWF.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/ScaledDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TScaledDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TScaledDWF<FIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/ScaledDWF.hpp b/Hadrons/Modules/MAction/ScaledDWF.hpp
deleted file mode 100644
index 3e052225..00000000
--- a/Hadrons/Modules/MAction/ScaledDWF.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ScaledDWF.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_ScaledDWF_hpp_
-#define Hadrons_MAction_ScaledDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      Scaled domain wall fermion                            *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class ScaledDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScaledDWFPar,
-                                    std::string , gauge,
-                                    unsigned int, Ls,
-                                    double      , mass,
-                                    double      , M5,
-                                    double      , scale,
-                                    std::string , boundary,
-                                    std::string , twist);
-};
-
-template <typename FImpl>
-class TScaledDWF: public Module<ScaledDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TScaledDWF(const std::string name);
-    // destructor
-    virtual ~TScaledDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(ScaledDWF, TScaledDWF<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(ScaledDWFF, TScaledDWF<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                      TScaledDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TScaledDWF<FImpl>::TScaledDWF(const std::string name)
-: Module<ScaledDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TScaledDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TScaledDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TScaledDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up scaled domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", scale= " << par().scale
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    typename ScaledShamirFermion<FImpl>::ImplParams implParams;
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases
-                 << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L
-                 << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-    envCreateDerived(FMat, ScaledShamirFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, par().scale,
-                     implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TScaledDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_ScaledDWF_hpp_
diff --git a/Hadrons/Modules/MAction/Wilson.cc b/Hadrons/Modules/MAction/Wilson.cc
deleted file mode 100644
index 8d0f8b2f..00000000
--- a/Hadrons/Modules/MAction/Wilson.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/Wilson.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/Wilson.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TWilson<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TWilson<FIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/Wilson.hpp b/Hadrons/Modules/MAction/Wilson.hpp
deleted file mode 100644
index 9aec5f79..00000000
--- a/Hadrons/Modules/MAction/Wilson.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/Wilson.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MAction_Wilson_hpp_
-#define Hadrons_MAction_Wilson_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                            TWilson quark action                            *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class WilsonPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WilsonPar,
-                                    std::string, gauge,
-                                    double     , mass,
-                                    std::string, boundary,
-                                    std::string, string,
-                                    std::string, twist);
-};
-
-template <typename FImpl>
-class TWilson: public Module<WilsonPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TWilson(const std::string name);
-    // destructor
-    virtual ~TWilson(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Wilson, TWilson<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(WilsonF, TWilson<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                     TWilson template implementation                        *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWilson<FImpl>::TWilson(const std::string name)
-: Module<WilsonPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWilson<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWilson<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWilson<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up Wilson fermion matrix with m= " << par().mass
-                 << " using gauge field '" << par().gauge << "'" << std::endl;
-                 
-    auto &U      = envGet(GaugeField, par().gauge);
-    auto &grid   = *envGetGrid(FermionField);
-    auto &gridRb = *envGetRbGrid(FermionField);
-    typename WilsonFermion<FImpl>::ImplParams implParams;
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-    envCreateDerived(FMat, WilsonFermion<FImpl>, getName(), 1, U, grid, gridRb,
-                     par().mass, implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWilson<FImpl>::execute()
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Wilson_hpp_
diff --git a/Hadrons/Modules/MAction/WilsonClover.cc b/Hadrons/Modules/MAction/WilsonClover.cc
deleted file mode 100644
index 95f5abe6..00000000
--- a/Hadrons/Modules/MAction/WilsonClover.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/WilsonClover.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/WilsonClover.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TWilsonClover<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TWilsonClover<FIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/WilsonClover.hpp b/Hadrons/Modules/MAction/WilsonClover.hpp
deleted file mode 100644
index d80bccdf..00000000
--- a/Hadrons/Modules/MAction/WilsonClover.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/WilsonClover.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Guido Cossu <guido.cossu@ed.ac.uk>
-Author: pretidav <david.preti@csic.es>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MAction_WilsonClover_hpp_
-#define Hadrons_MAction_WilsonClover_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Wilson clover quark action                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class WilsonCloverPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WilsonCloverPar,
-                                    std::string, gauge,
-                                    double     , mass,
-				                    double     , csw_r,
-				                    double     , csw_t,
-				                    WilsonAnisotropyCoefficients ,clover_anisotropy,
-                                    std::string, boundary,
-                                    std::string, twist
-				    );
-};
-
-template <typename FImpl>
-class TWilsonClover: public Module<WilsonCloverPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TWilsonClover(const std::string name);
-    // destructor
-    virtual ~TWilsonClover(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(WilsonClover, TWilsonClover<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(WilsonCloverF, TWilsonClover<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                    TWilsonClover template implementation                   *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWilsonClover<FImpl>::TWilsonClover(const std::string name)
-: Module<WilsonCloverPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWilsonClover<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWilsonClover<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWilsonClover<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up Wilson clover fermion matrix with m= " << par().mass
-                 << " using gauge field '" << par().gauge << "'" << std::endl;
-    LOG(Message) << "Clover term csw_r: " << par().csw_r
-                 << " csw_t: " << par().csw_t
-                 << std::endl;
-                 
-    auto &U      = envGet(GaugeField, par().gauge);
-    auto &grid   = *envGetGrid(FermionField);
-    auto &gridRb = *envGetRbGrid(FermionField);
-    typename WilsonCloverFermion<FImpl>::ImplParams implParams;
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases
-                 << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L
-                 << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-    envCreateDerived(FMat, WilsonCloverFermion<FImpl>, getName(), 1, U, grid,
-                     gridRb, par().mass, par().csw_r, par().csw_t, 
-                     par().clover_anisotropy, implParams); 
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWilsonClover<FImpl>::execute()
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_WilsonClover_hpp_
diff --git a/Hadrons/Modules/MAction/ZMobiusDWF.cc b/Hadrons/Modules/MAction/ZMobiusDWF.cc
deleted file mode 100644
index 778db139..00000000
--- a/Hadrons/Modules/MAction/ZMobiusDWF.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ZMobiusDWF.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/ZMobiusDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TZMobiusDWF<ZFIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TZMobiusDWF<ZFIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MAction/ZMobiusDWF.hpp b/Hadrons/Modules/MAction/ZMobiusDWF.hpp
deleted file mode 100644
index 62bd1651..00000000
--- a/Hadrons/Modules/MAction/ZMobiusDWF.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ZMobiusDWF.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_ZMobiusDWF_hpp_
-#define Hadrons_MAction_ZMobiusDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      z-Mobius domain-wall fermion action                   *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class ZMobiusDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ZMobiusDWFPar,
-                                    std::string                      , gauge,
-                                    unsigned int                     , Ls,
-                                    double                           , mass,
-                                    double                           , M5,
-                                    double                           , b,
-                                    double                           , c,
-                                    std::vector<std::complex<double> >, omega,
-                                    std::string                      , boundary,
-                                    std::string                      , twist);
-};
-
-template <typename FImpl>
-class TZMobiusDWF: public Module<ZMobiusDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TZMobiusDWF(const std::string name);
-    // destructor
-    virtual ~TZMobiusDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(ZMobiusDWF, TZMobiusDWF<ZFIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(ZMobiusDWFF, TZMobiusDWF<ZFIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                     TZMobiusDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TZMobiusDWF<FImpl>::TZMobiusDWF(const std::string name)
-: Module<ZMobiusDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TZMobiusDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TZMobiusDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZMobiusDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up z-Mobius domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", b= " << par().b << ", c= " << par().c
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-    LOG(Message) << "Omegas: " << std::endl;
-    for (unsigned int i = 0; i < par().omega.size(); ++i)
-    {
-        LOG(Message) << "  omega[" << i << "]= " << par().omega[i] << std::endl;
-    }
-
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    auto omega = par().omega;
-    typename ZMobiusFermion<FImpl>::ImplParams implParams;
-    
-
-    if (!par().boundary.empty())
-    {
-        implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    }
-    if (!par().twist.empty())
-    {
-        implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    }
-    LOG(Message) << "Fermion boundary conditions: " << implParams.boundary_phases << std::endl;
-    LOG(Message) << "Twists: " << implParams.twist_n_2pi_L << std::endl;
-    if (implParams.boundary_phases.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of boundary phase");
-    }
-    if (implParams.twist_n_2pi_L.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "Wrong number of twist");
-    }
-
-    assert(par().Ls==omega.size());
-    int Ls=par().Ls;
-    std::vector<ComplexD> _omega(Ls);
-    for(int i=0;i<Ls;i++){
-      _omega[i] = omega[i];
-    }
-    envCreateDerived(FMat, ZMobiusFermion<FImpl>, getName(), par().Ls,
-		     U, g5, grb5, g4, grb4, 
-		     par().mass, par().M5, 
-		     _omega, par().b, par().c, implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZMobiusDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_ZMobiusDWF_hpp_
diff --git a/Hadrons/Modules/MContraction/A2AAslashField.cc b/Hadrons/Modules/MContraction/A2AAslashField.cc
deleted file mode 100644
index 47c39cca..00000000
--- a/Hadrons/Modules/MContraction/A2AAslashField.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AAslashField.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/A2AAslashField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2AAslashField<FIMPL, PhotonR>;
diff --git a/Hadrons/Modules/MContraction/A2AAslashField.hpp b/Hadrons/Modules/MContraction/A2AAslashField.hpp
deleted file mode 100644
index e62fa54e..00000000
--- a/Hadrons/Modules/MContraction/A2AAslashField.hpp
+++ /dev/null
@@ -1,248 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AAslashField.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_A2AAslashField_hpp_
-#define Hadrons_MContraction_A2AAslashField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         A2AAslashField                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2AAslashFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AAslashFieldPar,
-                                    int, cacheBlock,
-                                    int, block,
-                                    std::string, left,
-                                    std::string, right,
-                                    std::string, output,
-                                    std::vector<std::string>, emField);
-};
-
-class A2AAslashFieldMetadata: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AAslashFieldMetadata,
-                                    std::string, emFieldName);
-};
-
-template <typename T, typename FImpl>
-class AslashFieldKernel: public A2AKernel<T, typename FImpl::FermionField>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    AslashFieldKernel(const std::vector<LatticeComplex> &emB0,
-                      const std::vector<LatticeComplex> &emB1,
-                      GridBase *grid)
-    : emB0_(emB0), emB1_(emB1), grid_(grid)
-    {
-        vol_ = 1.;
-        for (auto &d: grid_->GlobalDimensions())
-        {
-            vol_ *= d;
-        }
-    }
-
-    virtual ~AslashFieldKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const FermionField *left, 
-                            const FermionField *right,
-                            const unsigned int orthogDim, double &t)
-    {
-        A2Autils<FImpl>::AslashField(m, left, right, emB0_, emB1_, orthogDim, &t);
-    }
-
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return 0.;
-    }
-
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return 0.;
-    }
-private:
-    const std::vector<LatticeComplex> &emB0_, &emB1_;
-    GridBase                          *grid_;
-    double                            vol_;
-};
-
-template <typename FImpl, typename PhotonImpl>
-class TA2AAslashField: public Module<A2AAslashFieldPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef typename PhotonImpl::GaugeField EmField;
-    typedef A2AMatrixBlockComputation<Complex, 
-                                      FermionField, 
-                                      A2AAslashFieldMetadata, 
-                                      HADRONS_A2AM_IO_TYPE> Computation;
-    typedef AslashFieldKernel<Complex, FImpl> Kernel;
-public:
-    // constructor
-    TA2AAslashField(const std::string name);
-    // destructor
-    virtual ~TA2AAslashField(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(A2AAslashField, ARG(TA2AAslashField<FIMPL, PhotonR>), MContraction);
-
-/******************************************************************************
- *                 TA2AAslashField implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-TA2AAslashField<FImpl, PhotonImpl>::TA2AAslashField(const std::string name)
-: Module<A2AAslashFieldPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-std::vector<std::string> TA2AAslashField<FImpl, PhotonImpl>::getInput(void)
-{
-    std::vector<std::string> in = par().emField;
-    
-    in.push_back(par().left);
-    in.push_back(par().right);
-
-    return in;
-}
-
-template <typename FImpl, typename PhotonImpl>
-std::vector<std::string> TA2AAslashField<FImpl, PhotonImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-void TA2AAslashField<FImpl, PhotonImpl>::setup(void)
-{
-    envTmp(Computation, "computation", 1, envGetGrid(FermionField), 
-           env().getNd() - 1, par().emField.size(), 1, par().block, 
-           par().cacheBlock, this);
-    envTmp(std::vector<ComplexField>, "B0", 1, 
-           par().emField.size(), envGetGrid(ComplexField));
-    envTmp(std::vector<ComplexField>, "B1", 1, 
-           par().emField.size(), envGetGrid(ComplexField));
-    envTmpLat(ComplexField, "Amu");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-void TA2AAslashField<FImpl, PhotonImpl>::execute(void)
-{
-#ifndef GRID_NVCC
-    auto &left  = envGet(std::vector<FermionField>, par().left);
-    auto &right = envGet(std::vector<FermionField>, par().right);
-
-    int nt         = env().getDim().back();
-    int N_i        = left.size();
-    int N_j        = right.size();
-    int nem        = par().emField.size();
-    int block      = par().block;
-    int cacheBlock = par().cacheBlock;
-
-    LOG(Message) << "Computing all-to-all A-slash fields" << std::endl;
-    LOG(Message) << "Left: '" << par().left << "' Right: '" << par().right << "'" << std::endl;
-    LOG(Message) << "EM fields:" << std::endl;
-    for (auto &name: par().emField)
-    {
-        LOG(Message) << "  " << name << std::endl;
-    }
-    LOG(Message) << "A-slash field size: " << nt << "*" << N_i << "*" << N_j 
-                 << " (filesize " << sizeString(nt*N_i*N_j*sizeof(HADRONS_A2AM_IO_TYPE)) 
-                 << "/EM field)" << std::endl;
-    
-    // preparing "B" complexified fields
-    startTimer("Complexify EM fields");
-    envGetTmp(std::vector<ComplexField>, B0);
-    envGetTmp(std::vector<ComplexField>, B1);
-    for (unsigned int i = 0; i < par().emField.size(); ++i)
-    {
-        auto &A = envGet(EmField, par().emField[i]);
-        envGetTmp(ComplexField, Amu);
-
-        B0[i]  = peekLorentz(A, 0);
-        B0[i] += timesI(peekLorentz(A, 1));
-        B1[i]  = peekLorentz(A, 2);
-        B1[i] += timesI(peekLorentz(A, 3));
-    }
-    stopTimer("Complexify EM fields");
-
-    // I/O name & metadata lambdas
-    auto ionameFn = [this](const unsigned int em, const unsigned int dummy)
-    {
-        return par().emField[em];
-    };
-
-    auto filenameFn = [this, &ionameFn](const unsigned int em, const unsigned int dummy)
-    {
-        return par().output + "." + std::to_string(vm().getTrajectory()) 
-               + "/" + ionameFn(em, dummy) + ".h5";
-    };
-
-    auto metadataFn = [this](const unsigned int em, const unsigned int dummy)
-    {
-        A2AAslashFieldMetadata md;
-
-        md.emFieldName = par().emField[em];
-        
-        return md;
-    };
-
-    // executing computation
-    Kernel kernel(B0, B1, envGetGrid(FermionField));
-
-    envGetTmp(Computation, computation);
-    computation.execute(left, right, kernel, ionameFn, filenameFn, metadataFn);
-#endif
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2AAslashField_hpp_
diff --git a/Hadrons/Modules/MContraction/A2AFourQuarkContraction.cc b/Hadrons/Modules/MContraction/A2AFourQuarkContraction.cc
deleted file mode 100644
index 9afe12ba..00000000
--- a/Hadrons/Modules/MContraction/A2AFourQuarkContraction.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MContraction/A2AFourQuarkContraction.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2AFourQuarkContraction<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/A2AFourQuarkContraction.hpp b/Hadrons/Modules/MContraction/A2AFourQuarkContraction.hpp
deleted file mode 100644
index 7a8112e1..00000000
--- a/Hadrons/Modules/MContraction/A2AFourQuarkContraction.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#ifndef Hadrons_MContraction_A2AFourQuarkContraction_hpp_
-#define Hadrons_MContraction_A2AFourQuarkContraction_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DiskVector.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         A2AFourQuarkContraction                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2AFourQuarkContractionPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AFourQuarkContractionPar,
-                                    std::string,  v1,
-                                    std::string,  v2,
-                                    std::string,  mf12,
-                                    bool,         allContr,
-                                    unsigned int, dt);
-};
-
-template <typename FImpl>
-class TA2AFourQuarkContraction: public Module<A2AFourQuarkContractionPar>
-{
-  public:
-    FERM_TYPE_ALIASES(FImpl, );
-    // constructor
-    TA2AFourQuarkContraction(const std::string name);
-    // destructor
-    virtual ~TA2AFourQuarkContraction(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-  private:
-    unsigned int nt_;
-};
-
-MODULE_REGISTER_TMP(A2AFourQuarkContraction, TA2AFourQuarkContraction<FIMPL>, MContraction);
-
-/******************************************************************************
- *                 TA2AFourQuarkContraction implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TA2AFourQuarkContraction<FImpl>::TA2AFourQuarkContraction(const std::string name)
-: Module<A2AFourQuarkContractionPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TA2AFourQuarkContraction<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().v1, par().v2, par().mf12};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TA2AFourQuarkContraction<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AFourQuarkContraction<FImpl>::setup(void)
-{
-    if (par().allContr)
-    {
-        nt_ = env().getDim(Tp);
-        envTmp(std::vector<PropagatorField>, "tmpWWVV", 1, nt_, envGetGrid(PropagatorField));
-        envCreate(std::vector<PropagatorField>, getName(), 1, nt_, envGetGrid(PropagatorField));
-    }
-    else
-    {
-        envTmp(std::vector<PropagatorField>, "tmpWWVV", 1, 1, envGetGrid(PropagatorField));
-        envCreate(PropagatorField, getName(), 1, envGetGrid(PropagatorField));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AFourQuarkContraction<FImpl>::execute(void)
-{
-    auto &v1   = envGet(std::vector<FermionField>, par().v1);
-    auto &v2   = envGet(std::vector<FermionField>, par().v2);
-    auto &mf12 = envGet(EigenDiskVector<Complex>, par().mf12);
-
-    envGetTmp(std::vector<PropagatorField>, tmpWWVV);
-
-    unsigned int dt = par().dt;
-    unsigned int nt = env().getDim(Tp);
-
-    if (par().allContr)
-    {
-        LOG(Message) << "Computing 4 quark contraction for " << getName()
-                     << " for all t0 time translations "
-                     << "with nt = " << nt_ << " and dt = " << dt << std::endl;
-
-        auto &WWVV = envGet(std::vector<PropagatorField>, getName());
-        A2Autils<FImpl>::ContractWWVV(tmpWWVV, mf12, &v1[0], &v2[0]);
-        for(unsigned int t = 0; t < nt_; t++){
-            unsigned int t0 = (t + dt) % nt_;
-            WWVV[t] = tmpWWVV[t0];
-        }
-    }
-    else
-    {
-        LOG(Message) << "Computing 4 quark contraction for: " << getName()
-                     << " for time dt = " << dt << std::endl;
-
-        auto &WWVV = envGet(PropagatorField, getName());
-        int ni = v1.size();
-        int nj = v2.size();
-        Eigen::Matrix<Complex, -1, -1, Eigen::RowMajor> mf;
-        mf = mf12[dt];
-        Eigen::TensorMap<Eigen::Tensor<Complex, 3, Eigen::RowMajor>> mfT(mf.data(), 1, ni, nj);
-        A2Autils<FImpl>::ContractWWVV(tmpWWVV, mfT, &v1[0], &v2[0]);
-        WWVV = tmpWWVV[0];
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2AFourQuarkContraction_hpp_
diff --git a/Hadrons/Modules/MContraction/A2ALoop.cc b/Hadrons/Modules/MContraction/A2ALoop.cc
deleted file mode 100644
index 3dfcd66d..00000000
--- a/Hadrons/Modules/MContraction/A2ALoop.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2ALoop.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/A2ALoop.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2ALoop<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/A2ALoop.hpp b/Hadrons/Modules/MContraction/A2ALoop.hpp
deleted file mode 100644
index 316b228d..00000000
--- a/Hadrons/Modules/MContraction/A2ALoop.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2ALoop.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_A2ALoop_hpp_
-#define Hadrons_MContraction_A2ALoop_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                  From closed loop from all-to-all vectors                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2ALoopPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2ALoopPar,
-                                    std::string, left,
-                                    std::string, right);
-};
-
-template <typename FImpl>
-class TA2ALoop: public Module<A2ALoopPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TA2ALoop(const std::string name);
-    // destructor
-    virtual ~TA2ALoop(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(A2ALoop, TA2ALoop<FIMPL>, MContraction);
-
-/******************************************************************************
- *                        TA2ALoop implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TA2ALoop<FImpl>::TA2ALoop(const std::string name)
-: Module<A2ALoopPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TA2ALoop<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().left, par().right};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TA2ALoop<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2ALoop<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2ALoop<FImpl>::execute(void)
-{
-    auto &loop  = envGet(PropagatorField, getName());
-    auto &left  = envGet(std::vector<FermionField>, par().left);
-    auto &right = envGet(std::vector<FermionField>, par().right);
-
-    loop = Zero();
-    for (unsigned int i = 0; i < left.size(); ++i)
-    {
-        loop += outerProduct(left[i], right[i]);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2ALoop_hpp_
diff --git a/Hadrons/Modules/MContraction/A2AMesonField.cc b/Hadrons/Modules/MContraction/A2AMesonField.cc
deleted file mode 100644
index 0b4f79a9..00000000
--- a/Hadrons/Modules/MContraction/A2AMesonField.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AMesonField.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/A2AMesonField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2AMesonField<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/A2AMesonField.hpp b/Hadrons/Modules/MContraction/A2AMesonField.hpp
deleted file mode 100644
index cf1b9415..00000000
--- a/Hadrons/Modules/MContraction/A2AMesonField.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AMesonField.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_A2AMesonField_hpp_
-#define Hadrons_MContraction_A2AMesonField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                     All-to-all meson field creation                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2AMesonFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AMesonFieldPar,
-                                    int, cacheBlock,
-                                    int, block,
-                                    std::string, left,
-                                    std::string, right,
-                                    std::string, output,
-                                    std::string, gammas,
-                                    std::vector<std::string>, mom);
-};
-
-class A2AMesonFieldMetadata: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AMesonFieldMetadata,
-                                    std::vector<RealF>, momentum,
-                                    Gamma::Algebra, gamma);
-};
-
-template <typename T, typename FImpl>
-class MesonFieldKernel: public A2AKernel<T, typename FImpl::FermionField>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    MesonFieldKernel(const std::vector<Gamma::Algebra> &gamma,
-                     const std::vector<LatticeComplex> &mom,
-                     GridBase *grid)
-    : gamma_(gamma), mom_(mom), grid_(grid)
-    {
-        vol_ = 1.;
-        for (auto &d: grid_->GlobalDimensions())
-        {
-            vol_ *= d;
-        }
-    }
-
-    virtual ~MesonFieldKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const FermionField *left, 
-                            const FermionField *right,
-                            const unsigned int orthogDim, double &t)
-    {
-        A2Autils<FImpl>::MesonField(m, left, right, gamma_, mom_, orthogDim, &t);
-    }
-
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return vol_*(2*8.0+6.0+8.0*mom_.size())*blockSizei*blockSizej*gamma_.size();
-    }
-
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return vol_*(12.0*sizeof(T))*blockSizei*blockSizej
-               +  vol_*(2.0*sizeof(T)*mom_.size())*blockSizei*blockSizej*gamma_.size();
-    }
-private:
-    const std::vector<Gamma::Algebra> &gamma_;
-    const std::vector<LatticeComplex> &mom_;
-    GridBase                          *grid_;
-    double                            vol_;
-};
-
-template <typename FImpl>
-class TA2AMesonField : public Module<A2AMesonFieldPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef A2AMatrixBlockComputation<Complex, 
-                                      FermionField, 
-                                      A2AMesonFieldMetadata, 
-                                      HADRONS_A2AM_IO_TYPE> Computation;
-    typedef MesonFieldKernel<Complex, FImpl> Kernel;
-public:
-    // constructor
-    TA2AMesonField(const std::string name);
-    // destructor
-    virtual ~TA2AMesonField(void){};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool                               hasPhase_{false};
-    std::string                        momphName_;
-    std::vector<Gamma::Algebra>        gamma_;
-    std::vector<std::vector<Real>>     mom_;
-};
-
-MODULE_REGISTER(A2AMesonField, ARG(TA2AMesonField<FIMPL>), MContraction);
-
-/******************************************************************************
-*                  TA2AMesonField implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TA2AMesonField<FImpl>::TA2AMesonField(const std::string name)
-: Module<A2AMesonFieldPar>(name)
-, momphName_(name + "_momph")
-{
-}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TA2AMesonField<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().left, par().right};
-
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TA2AMesonField<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AMesonField<FImpl>::setup(void)
-{
-    gamma_.clear();
-    mom_.clear();
-    if (par().gammas == "all")
-    {
-        gamma_ = {
-            Gamma::Algebra::Gamma5,
-            Gamma::Algebra::Identity,    
-            Gamma::Algebra::GammaX,
-            Gamma::Algebra::GammaY,
-            Gamma::Algebra::GammaZ,
-            Gamma::Algebra::GammaT,
-            Gamma::Algebra::GammaXGamma5,
-            Gamma::Algebra::GammaYGamma5,
-            Gamma::Algebra::GammaZGamma5,
-            Gamma::Algebra::GammaTGamma5,
-            Gamma::Algebra::SigmaXY,
-            Gamma::Algebra::SigmaXZ,
-            Gamma::Algebra::SigmaXT,
-            Gamma::Algebra::SigmaYZ,
-            Gamma::Algebra::SigmaYT,
-            Gamma::Algebra::SigmaZT
-        };
-    }
-    else
-    {
-        gamma_ = strToVec<Gamma::Algebra>(par().gammas);
-    }
-    for (auto &pstr: par().mom)
-    {
-        auto p = strToVec<Real>(pstr);
-
-        if (p.size() != env().getNd() - 1)
-        {
-            HADRONS_ERROR(Size, "Momentum has " + std::to_string(p.size())
-                                + " components instead of " 
-                                + std::to_string(env().getNd() - 1));
-        }
-        mom_.push_back(p);
-    }
-    envCache(std::vector<ComplexField>, momphName_, 1, 
-             par().mom.size(), envGetGrid(ComplexField));
-    envTmpLat(ComplexField, "coor");
-    envTmp(Computation, "computation", 1, envGetGrid(FermionField), 
-           env().getNd() - 1, mom_.size(), gamma_.size(), par().block, 
-           par().cacheBlock, this);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AMesonField<FImpl>::execute(void)
-{
-    auto &left  = envGet(std::vector<FermionField>, par().left);
-    auto &right = envGet(std::vector<FermionField>, par().right);
-
-    int nt         = env().getDim().back();
-    int N_i        = left.size();
-    int N_j        = right.size();
-    int ngamma     = gamma_.size();
-    int nmom       = mom_.size();
-    int block      = par().block;
-    int cacheBlock = par().cacheBlock;
-
-    if (N_i < block || N_j < block)
-    {
-        HADRONS_ERROR(Range, "blockSize must not exceed size of input vector.");
-    }
-
-    LOG(Message) << "Computing all-to-all meson fields" << std::endl;
-    LOG(Message) << "Left: '" << par().left << "' Right: '" << par().right << "'" << std::endl;
-    LOG(Message) << "Momenta:" << std::endl;
-    for (auto &p: mom_)
-    {
-        LOG(Message) << "  " << p << std::endl;
-    }
-    LOG(Message) << "Spin bilinears:" << std::endl;
-    for (auto &g: gamma_)
-    {
-        LOG(Message) << "  " << g << std::endl;
-    }
-    LOG(Message) << "Meson field size: " << nt << "*" << N_i << "*" << N_j 
-                 << " (filesize " << sizeString(nt*N_i*N_j*sizeof(HADRONS_A2AM_IO_TYPE)) 
-                 << "/momentum/bilinear)" << std::endl;
-
-    auto &ph = envGet(std::vector<ComplexField>, momphName_);
-
-    if (!hasPhase_)
-    {
-        startTimer("Momentum phases");
-        for (unsigned int j = 0; j < nmom; ++j)
-        {
-            Complex           i(0.0,1.0);
-            std::vector<Real> p;
-
-            envGetTmp(ComplexField, coor);
-            ph[j] = Zero();
-            for(unsigned int mu = 0; mu < mom_[j].size(); mu++)
-            {
-                LatticeCoordinate(coor, mu);
-                ph[j] = ph[j] + (mom_[j][mu]/env().getDim(mu))*coor;
-            }
-            ph[j] = exp((Real)(2*M_PI)*i*ph[j]);
-        }
-        hasPhase_ = true;
-        stopTimer("Momentum phases");
-    }
-
-    auto ionameFn = [this](const unsigned int m, const unsigned int g)
-    {
-        std::stringstream ss;
-
-        ss << gamma_[g] << "_";
-        for (unsigned int mu = 0; mu < mom_[m].size(); ++mu)
-        {
-            ss << mom_[m][mu] << ((mu == mom_[m].size() - 1) ? "" : "_");
-        }
-
-        return ss.str();
-    };
-
-    auto filenameFn = [this, &ionameFn](const unsigned int m, const unsigned int g)
-    {
-        return par().output + "." + std::to_string(vm().getTrajectory()) 
-               + "/" + ionameFn(m, g) + ".h5";
-    };
-
-    auto metadataFn = [this](const unsigned int m, const unsigned int g)
-    {
-        A2AMesonFieldMetadata md;
-
-        for (auto pmu: mom_[m])
-        {
-            md.momentum.push_back(pmu);
-        }
-        md.gamma = gamma_[g];
-        
-        return md;
-    };
-
-    Kernel      kernel(gamma_, ph, envGetGrid(FermionField));
-
-    envGetTmp(Computation, computation);
-    computation.execute(left, right, kernel, ionameFn, filenameFn, metadataFn);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2AMesonField_hpp_
diff --git a/Hadrons/Modules/MContraction/Baryon.cc b/Hadrons/Modules/MContraction/Baryon.cc
deleted file mode 100644
index 84e0f984..00000000
--- a/Hadrons/Modules/MContraction/Baryon.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Baryon.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/Baryon.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TBaryon<FIMPL,FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MContraction/Baryon.hpp b/Hadrons/Modules/MContraction/Baryon.hpp
deleted file mode 100644
index 9b48ae0a..00000000
--- a/Hadrons/Modules/MContraction/Baryon.hpp
+++ /dev/null
@@ -1,330 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Baryon.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Felix Erben <felix.erben@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_Baryon_hpp_
-#define Hadrons_MContraction_Baryon_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/qcd/utils/BaryonUtils.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                               Baryon                                       *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-typedef std::pair<Gamma::Algebra, Gamma::Algebra> GammaAB;
-typedef std::pair<GammaAB, GammaAB> GammaABPair;
-
-class BaryonPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(BaryonPar,
-                                    std::string, q1,
-                                    std::string, q2,
-                                    std::string, q3,
-                                    std::string, gammas,
-                                    std::string, quarks,
-                                    std::string, prefactors,
-                                    std::string, parity,
-                                    std::string, sink,
-                                    std::string, output);
-};
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-class TBaryon: public Module<BaryonPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    FERM_TYPE_ALIASES(FImpl3, 3);
-    BASIC_TYPE_ALIASES(ScalarImplCR, Scalar);
-    SINK_TYPE_ALIASES(Scalar);
-    class Metadata: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata,
-                                        Gamma::Algebra, gammaA_left,
-                                        Gamma::Algebra, gammaB_left,
-                                        Gamma::Algebra, gammaA_right,
-                                        Gamma::Algebra, gammaB_right,
-                                        std::string, quarks,
-                                        std::string, prefactors,
-                                        int, parity);
-    };
-    typedef Correlator<Metadata> Result;
-public:
-    // constructor
-    TBaryon(const std::string name);
-    // destructor
-    virtual ~TBaryon(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    virtual void parseGammaString(std::vector<GammaABPair> &gammaList);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-    // Which gamma algebra was specified
-    Gamma::Algebra  al;
-};
-
-MODULE_REGISTER_TMP(Baryon, ARG(TBaryon<FIMPL, FIMPL, FIMPL>), MContraction);
-
-/******************************************************************************
- *                         TBaryon implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-TBaryon<FImpl1, FImpl2, FImpl3>::TBaryon(const std::string name)
-: Module<BaryonPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-std::vector<std::string> TBaryon<FImpl1, FImpl2, FImpl3>::getInput(void)
-{
-    std::vector<std::string> input = {par().q1, par().q2, par().q3, par().sink};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-std::vector<std::string> TBaryon<FImpl1, FImpl2, FImpl3>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TBaryon<FImpl1, FImpl2,FImpl3>::parseGammaString(std::vector<GammaABPair> &gammaList)
-{
-    gammaList.clear();
-    
-    std::string gammaString = par().gammas;
-    //Shorthands for standard baryon operators
-    gammaString = regex_replace(gammaString, std::regex("j12"),"(Identity SigmaXZ)");
-    gammaString = regex_replace(gammaString, std::regex("j32X"),"(Identity MinusGammaZGamma5)");
-    gammaString = regex_replace(gammaString, std::regex("j32Y"),"(Identity GammaT)");
-    gammaString = regex_replace(gammaString, std::regex("j32Z"),"(Identity GammaXGamma5)");
-    //Shorthands for less common baryon operators
-    gammaString = regex_replace(gammaString, std::regex("j12_alt1"),"(Gamma5 MinusSigmaYT)");
-    gammaString = regex_replace(gammaString, std::regex("j12_alt2"),"(Identity GammaYGamma5)");
-    
-    //A single gamma matrix 
-    std::regex rex_g("([0-9a-zA-Z]+)");
-    //The full string we expect
-    std::regex rex("( *\\(( *\\(([0-9a-zA-Z]+) +([0-9a-zA-Z]+) *\\)){2} *\\) *)+");
-    std::smatch sm;
-    std::regex_match(gammaString, sm, rex);
-    assert(sm[0].matched && "invalid gamma structure.");
-
-    auto gamma_begin = std::sregex_iterator(gammaString.begin(), gammaString.end(), rex_g);
-    auto gamma_end = std::sregex_iterator();
-
-    int nGamma = std::distance(gamma_begin, gamma_end); 
-    //couldn't find out how to count the size in the iterator, other than looping through it...
-  /*  int nGamma=0;
-    for (std::sregex_iterator i = gamma_begin; i != gamma_end; ++i) {
-	nGamma++;
-    }
-*/   
-    gammaList.resize(nGamma/4);
-    std::vector<std::string> gS;
-    gS.resize(nGamma);
-    //even more ugly workarounds here...
-    int iG=0;
-    for (std::sregex_iterator i = gamma_begin; i != gamma_end; ++i) {
-        std::smatch match = *i;                                                 
-        gS[iG] = match.str(); 
-	iG++;
-    }
-    for (int i = 0; i < gammaList.size(); i++){
-	std::vector<Gamma::Algebra> gS1 = strToVec<Gamma::Algebra>(gS[4*i]);
-	std::vector<Gamma::Algebra> gS2 = strToVec<Gamma::Algebra>(gS[4*i+1]);
-	std::vector<Gamma::Algebra> gS3 = strToVec<Gamma::Algebra>(gS[4*i+2]);
-	std::vector<Gamma::Algebra> gS4 = strToVec<Gamma::Algebra>(gS[4*i+3]);
-        gammaList[i].first.first=gS1[0];
-        gammaList[i].first.second=gS2[0];
-        gammaList[i].second.first=gS3[0];
-        gammaList[i].second.second=gS4[0];
-    }
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TBaryon<FImpl1, FImpl2, FImpl3>::setup(void)
-{
-    envTmpLat(LatticeComplex, "c");
-    envTmpLat(LatticeComplex, "c2");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TBaryon<FImpl1, FImpl2, FImpl3>::execute(void)
-{
-
-    std::vector<std::string> quarks = strToVec<std::string>(par().quarks);    
-    std::vector<double> prefactors = strToVec<double>(par().prefactors);    
-    int nQ=quarks.size();
-    const int  parity {par().parity.size()>0 ? std::stoi(par().parity) : 1};
-
-    std::vector<GammaABPair> gammaList;
-    parseGammaString(gammaList);
-
-    assert(prefactors.size()==nQ && "number of prefactors needs to match number of quark-structures.");
-    for (int iQ = 0; iQ < nQ; iQ++)
-        assert(quarks[iQ].size()==3 && "quark-structures must consist of 3 quarks each.");
-
-    LOG(Message) << "Computing baryon contractions '" << getName() << "'" << std::endl;
-    for (int iQ1 = 0; iQ1 < nQ; iQ1++)
-        for (int iQ2 = 0; iQ2 < nQ; iQ2++)
-            LOG(Message) << prefactors[iQ1]*prefactors[iQ2] << "*<" << quarks[iQ1] << "|" << quarks[iQ2] << ">" << std::endl;
-    LOG(Message) << " using quarks " << par().q1 << "', " << par().q2 << "', and '" << par().q3 << std::endl;
-     for (int iG = 0; iG < gammaList.size(); iG++)
-         LOG(Message) << "' with (Gamma^A,Gamma^B)_left = ( " << gammaList[iG].first.first << " , " << gammaList[iG].first.second << "') and (Gamma^A,Gamma^B)_right = ( " << gammaList[iG].second.first << " , " << gammaList[iG].second.second << ")" << std::endl; 
-      LOG(Message) << "and parity " << parity << " using sink " << par().sink << "." << std::endl;
-        
-    envGetTmp(LatticeComplex, c);
-    envGetTmp(LatticeComplex, c2);
-    int nt = env().getDim(Tp);
-    std::vector<TComplex> buf;
-    TComplex cs;
-    TComplex ch;
-
-    std::vector<Result> result;
-    Result              r;
-    r.info.parity = parity;
-    r.info.quarks = par().quarks;
-    r.info.prefactors = par().prefactors;
-
-    if (envHasType(SlicedPropagator1, par().q1) and
-        envHasType(SlicedPropagator2, par().q2) and
-        envHasType(SlicedPropagator3, par().q3))
-    {
-        auto &q1 = envGet(SlicedPropagator1, par().q1);
-        auto &q2 = envGet(SlicedPropagator2, par().q2);
-        auto &q3 = envGet(SlicedPropagator3, par().q3);
-        for (unsigned int i = 0; i < gammaList.size(); ++i)
-        {
-            r.info.gammaA_left = gammaList[i].first.first;
-            r.info.gammaB_left = gammaList[i].first.second;
-            r.info.gammaA_right = gammaList[i].second.first;
-            r.info.gammaB_right = gammaList[i].second.second;
-
-            Gamma gAl(gammaList[i].first.first);
-            Gamma gBl(gammaList[i].first.second);
-            Gamma gAr(gammaList[i].second.first);
-            Gamma gBr(gammaList[i].second.second);
-        
-            LOG(Message) << "(propagator already sinked)" << std::endl;
-            r.corr.clear();
-            for (unsigned int t = 0; t < buf.size(); ++t)
-            {
-                cs = Zero();
-                for (int iQ1 = 0; iQ1 < nQ; iQ1++){
-                    for (int iQ2 = 0; iQ2 < nQ; iQ2++){
-                        BaryonUtils<FIMPL>::ContractBaryons_Sliced(q1[t],q2[t],q3[t],gAl,gBl,gAr,gBr,quarks[iQ1].c_str(),quarks[iQ2].c_str(),parity,ch);
-                        cs += prefactors[iQ1]*prefactors[iQ2]*ch;
-                    }
-                }
-                r.corr.push_back(TensorRemove(cs));
-            }
-            result.push_back(r);
-        }
-    }
-    else
-    {
-        auto       &q1 = envGet(PropagatorField1, par().q1);
-        auto       &q2 = envGet(PropagatorField2, par().q2);
-        auto       &q3 = envGet(PropagatorField3, par().q3);
-        for (unsigned int i = 0; i < gammaList.size(); ++i)
-        {
-            r.info.gammaA_left = gammaList[i].first.first;
-            r.info.gammaB_left = gammaList[i].first.second;
-            r.info.gammaA_right = gammaList[i].second.first;
-            r.info.gammaB_right = gammaList[i].second.second;
-
-            Gamma gAl(gammaList[i].first.first);
-            Gamma gBl(gammaList[i].first.second);
-            Gamma gAr(gammaList[i].second.first);
-            Gamma gBr(gammaList[i].second.second);
-        
-            std::string ns;
-                
-            ns = vm().getModuleNamespace(env().getObjectModule(par().sink));
-            if (ns == "MSource")
-            {
-                c=Zero();
-                for (int iQ1 = 0; iQ1 < nQ; iQ1++){
-                    for (int iQ2 = 0; iQ2 < nQ; iQ2++){
-                        BaryonUtils<FIMPL>::ContractBaryons(q1,q2,q3,gAl,gBl,gAr,gBr,quarks[iQ1].c_str(),quarks[iQ2].c_str(),parity,c2);
-                        c+=prefactors[iQ1]*prefactors[iQ2]*c2;
-                    }
-                }
-                PropagatorField1 &sink = envGet(PropagatorField1, par().sink);
-                auto test = closure(trace(sink*c));     
-                sliceSum(test, buf, Tp); 
-            }
-            else if (ns == "MSink")
-            {
-                c=Zero();
-                for (int iQ1 = 0; iQ1 < nQ; iQ1++){
-                    for (int iQ2 = 0; iQ2 < nQ; iQ2++){
-                        BaryonUtils<FIMPL>::ContractBaryons(q1,q2,q3,gAl,gBl,gAr,gBr,quarks[iQ1].c_str(),quarks[iQ2].c_str(),parity,c2);
-                        c+=prefactors[iQ1]*prefactors[iQ2]*c2;
-                    }
-                }
-                SinkFnScalar &sink = envGet(SinkFnScalar, par().sink);
-                buf = sink(c);
-            } 
-            r.corr.clear();
-            for (unsigned int t = 0; t < buf.size(); ++t)
-            {
-                r.corr.push_back(TensorRemove(buf[t]));
-            }
-            result.push_back(r);
-        }
-    }
-
-    saveResult(par().output, "baryon", result);
-
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_Baryon_hpp_
diff --git a/Hadrons/Modules/MContraction/DiscLoop.cc b/Hadrons/Modules/MContraction/DiscLoop.cc
deleted file mode 100644
index 659593c6..00000000
--- a/Hadrons/Modules/MContraction/DiscLoop.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/DiscLoop.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/DiscLoop.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TDiscLoop<FIMPL>;
-
diff --git a/Hadrons/Modules/MContraction/DiscLoop.hpp b/Hadrons/Modules/MContraction/DiscLoop.hpp
deleted file mode 100644
index b28cc742..00000000
--- a/Hadrons/Modules/MContraction/DiscLoop.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/DiscLoop.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_DiscLoop_hpp_
-#define Hadrons_MContraction_DiscLoop_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                DiscLoop                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class DiscLoopPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DiscLoopPar,
-                                    std::string,    q_loop,
-                                    Gamma::Algebra, gamma,
-                                    std::string,    output);
-};
-
-template <typename FImpl>
-class TDiscLoop: public Module<DiscLoopPar>
-{
-    FERM_TYPE_ALIASES(FImpl,);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        Gamma::Algebra, gamma,
-                                        std::vector<Complex>, corr);
-    };
-public:
-    // constructor
-    TDiscLoop(const std::string name);
-    // destructor
-    virtual ~TDiscLoop(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(DiscLoop, TDiscLoop<FIMPL>, MContraction);
-
-/******************************************************************************
- *                       TDiscLoop implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TDiscLoop<FImpl>::TDiscLoop(const std::string name)
-: Module<DiscLoopPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TDiscLoop<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q_loop};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TDiscLoop<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDiscLoop<FImpl>::setup(void)
-{
-    envTmpLat(LatticeComplex, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDiscLoop<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing disconnected loop contraction '" << getName() 
-                 << "' using '" << par().q_loop << "' with " << par().gamma 
-                 << " insertion." << std::endl;
-
-    auto                  &q_loop = envGet(PropagatorField, par().q_loop);
-    Gamma                 gamma(par().gamma);
-    std::vector<TComplex> buf;
-    Result                result;
-
-    envGetTmp(LatticeComplex, c);
-    c = trace(gamma*q_loop);
-    sliceSum(c, buf, Tp);
-    result.gamma = par().gamma;
-    result.corr.resize(buf.size());
-    for (unsigned int t = 0; t < buf.size(); ++t)
-    {
-        result.corr[t] = TensorRemove(buf[t]);
-    }
-    saveResult(par().output, "disc", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_DiscLoop_hpp_
diff --git a/Hadrons/Modules/MContraction/Gamma3pt.cc b/Hadrons/Modules/MContraction/Gamma3pt.cc
deleted file mode 100644
index 044d7c65..00000000
--- a/Hadrons/Modules/MContraction/Gamma3pt.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Gamma3pt.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/Gamma3pt.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TGamma3pt<FIMPL,FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MContraction/Gamma3pt.hpp b/Hadrons/Modules/MContraction/Gamma3pt.hpp
deleted file mode 100644
index cd5c89e6..00000000
--- a/Hadrons/Modules/MContraction/Gamma3pt.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Gamma3pt.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_Gamma3pt_hpp_
-#define Hadrons_MContraction_Gamma3pt_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- * 3pt contraction with gamma matrix insertion.
- *
- * Schematic:
- *
- *             q2           q3
- *        /----<------*------<----¬
- *       /          gamma          \
- *      /                           \
- *   i *                            * f
- *      \                          /
- *       \                        /
- *        \----------->----------/
- *                   q1
- *
- *      trace(g5*q1*adj(q2)*g5*gamma*q3)
- * 
- *  options:
- *   - q1: sink smeared propagator, source at i
- *   - q2: propagator, source at i
- *   - q3: propagator, source at f
- *   - gammas: gamma matrices to insert
- *             (space-separated strings e.g. "GammaT GammaX GammaY") 
- *   - tSnk: sink position for propagator q1.
- *
- */
-
-/******************************************************************************
- *                               Gamma3pt                                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class Gamma3ptPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(Gamma3ptPar,
-                                    std::string,  q1,
-                                    std::string,  q2,
-                                    std::string,  q3,
-                                    std::string,  gamma,
-                                    unsigned int, tSnk,
-                                    std::string,  output);
-};
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-class TGamma3pt: public Module<Gamma3ptPar>
-{
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    FERM_TYPE_ALIASES(FImpl3, 3);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        Gamma::Algebra, gamma,
-                                        std::vector<Complex>, corr);
-    };
-public:
-    // constructor
-    TGamma3pt(const std::string name);
-    // destructor
-    virtual ~TGamma3pt(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    virtual void parseGammaString(std::vector<Gamma::Algebra> &gammaList);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Gamma3pt, ARG(TGamma3pt<FIMPL, FIMPL, FIMPL>), MContraction);
-
-/******************************************************************************
- *                       TGamma3pt implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-TGamma3pt<FImpl1, FImpl2, FImpl3>::TGamma3pt(const std::string name)
-: Module<Gamma3ptPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-std::vector<std::string> TGamma3pt<FImpl1, FImpl2, FImpl3>::getInput(void)
-{
-    std::vector<std::string> in = {par().q1, par().q2, par().q3};
-    
-    return in;
-}
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-std::vector<std::string> TGamma3pt<FImpl1, FImpl2, FImpl3>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TGamma3pt<FImpl1, FImpl2, FImpl3>::setup(void)
-{
-    envTmpLat(LatticeComplex, "c");
-}
-
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TGamma3pt<FImpl1, FImpl2, FImpl3>::parseGammaString(std::vector<Gamma::Algebra> &gammaList)
-{
-    gammaList.clear();
-    // Determine gamma matrices to insert at source/sink.
-    if (par().gamma.compare("all") == 0)
-    {
-        // Do all contractions.
-        for (unsigned int i = 1; i < Gamma::nGamma; i += 2)
-        {
-            gammaList.push_back((Gamma::Algebra)i);
-        }
-    }
-    else
-    {
-        // Parse individual contractions from input string.
-        gammaList = strToVec<Gamma::Algebra>(par().gamma);
-    } 
-}
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2, typename FImpl3>
-void TGamma3pt<FImpl1, FImpl2, FImpl3>::execute(void)
-{
-    LOG(Message) << "Computing 3pt contractions '" << getName() << "' using"
-                 << " quarks '" << par().q1 << "', '" << par().q2 << "' and '"
-                 << par().q3 << "', with " << par().gamma << " insertions." 
-                 << std::endl;
-
-    // Initialise variables. q2 and q3 are normal propagators, q1 may be 
-    // sink smeared.
-    auto                        &q1 = envGet(SlicedPropagator1, par().q1);
-    auto                        &q2 = envGet(PropagatorField2, par().q2);
-    auto                        &q3 = envGet(PropagatorField2, par().q3);
-    Gamma                       g5(Gamma::Algebra::Gamma5);
-    std::vector<Gamma::Algebra> gammaList;
-    std::vector<TComplex>       buf;
-    std::vector<Result>         result;
-    int                         nt = env().getDim(Tp);
-
-
-    parseGammaString(gammaList);
-    result.resize(gammaList.size());
-    for (unsigned int i = 0; i < result.size(); ++i)
-    {
-        result[i].gamma = gammaList[i];
-        result[i].corr.resize(nt);
-    }
-    
-    // Extract relevant timeslice of sinked propagator q1, then contract &
-    // sum over all spacial positions of gamma insertion.
-    SitePropagator1 q1Snk = q1[par().tSnk];
-    envGetTmp(LatticeComplex, c);
-    for (unsigned int i = 0; i < result.size(); ++i)
-    {
-        Gamma gamma(gammaList[i]);
-        c = trace(g5*q1Snk*adj(q2)*(g5*gamma)*q3);
-        sliceSum(c, buf, Tp);
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            result[i].corr[t] = TensorRemove(buf[t]);
-        }
-    }
-    saveResult(par().output, "gamma3pt", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_Gamma3pt_hpp_
diff --git a/Hadrons/Modules/MContraction/Meson.cc b/Hadrons/Modules/MContraction/Meson.cc
deleted file mode 100644
index ddb7c3ae..00000000
--- a/Hadrons/Modules/MContraction/Meson.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Meson.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/Meson.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TMeson<FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MContraction/Meson.hpp b/Hadrons/Modules/MContraction/Meson.hpp
deleted file mode 100644
index 34b46b73..00000000
--- a/Hadrons/Modules/MContraction/Meson.hpp
+++ /dev/null
@@ -1,249 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Meson.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_Meson_hpp_
-#define Hadrons_MContraction_Meson_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Meson contractions
- -----------------------------
- 
- * options:
- - q1: input propagator 1 (string)
- - q2: input propagator 2 (string)
- - gammas: gamma products to insert at sink & source, pairs of gamma matrices 
-           (space-separated strings) in round brackets (i.e. (g_sink g_src)),
-           in a sequence (e.g. "(Gamma5 Gamma5)(Gamma5 GammaT)").
-
-           Special values: "all" - perform all possible contractions.
- - sink: module to compute the sink to use in contraction (string).
-*/
-
-/******************************************************************************
- *                                TMeson                                       *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-typedef std::pair<Gamma::Algebra, Gamma::Algebra> GammaPair;
-
-class MesonPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(MesonPar,
-                                    std::string, q1,
-                                    std::string, q2,
-                                    std::string, gammas,
-                                    std::string, sink,
-                                    std::string, output);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TMeson: public Module<MesonPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    BASIC_TYPE_ALIASES(ScalarImplCR, Scalar);
-    SINK_TYPE_ALIASES(Scalar);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        Gamma::Algebra, gamma_snk,
-                                        Gamma::Algebra, gamma_src,
-                                        std::vector<Complex>, corr);
-    };
-public:
-    // constructor
-    TMeson(const std::string name);
-    // destructor
-    virtual ~TMeson(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    virtual void parseGammaString(std::vector<GammaPair> &gammaList);
-protected:
-    // execution
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Meson, ARG(TMeson<FIMPL, FIMPL>), MContraction);
-
-/******************************************************************************
- *                           TMeson implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TMeson<FImpl1, FImpl2>::TMeson(const std::string name)
-: Module<MesonPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TMeson<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().q1, par().q2, par().sink};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TMeson<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> output = {};
-    
-    return output;
-}
-
-template <typename FImpl1, typename FImpl2>
-void TMeson<FImpl1, FImpl2>::parseGammaString(std::vector<GammaPair> &gammaList)
-{
-    gammaList.clear();
-    // Determine gamma matrices to insert at source/sink.
-    if (par().gammas.compare("all") == 0)
-    {
-        // Do all contractions.
-        for (unsigned int i = 1; i < Gamma::nGamma; i += 2)
-        {
-            for (unsigned int j = 1; j < Gamma::nGamma; j += 2)
-            {
-                gammaList.push_back(std::make_pair((Gamma::Algebra)i, 
-                                                   (Gamma::Algebra)j));
-            }
-        }
-    }
-    else
-    {
-        // Parse individual contractions from input string.
-        gammaList = strToVec<GammaPair>(par().gammas);
-    } 
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TMeson<FImpl1, FImpl2>::setup(void)
-{
-    envTmpLat(LatticeComplex, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-#define mesonConnected(q1, q2, gSnk, gSrc) \
-(g5*(gSnk))*(q1)*(adj(gSrc)*g5)*adj(q2)
-
-template <typename FImpl1, typename FImpl2>
-void TMeson<FImpl1, FImpl2>::execute(void)
-{
-    LOG(Message) << "Computing meson contractions '" << getName() << "' using"
-                 << " quarks '" << par().q1 << "' and '" << par().q2 << "'"
-                 << std::endl;
-    
-    std::vector<TComplex>  buf;
-    std::vector<Result>    result;
-    Gamma                  g5(Gamma::Algebra::Gamma5);
-    std::vector<GammaPair> gammaList;
-    int                    nt = env().getDim(Tp);
-    
-    parseGammaString(gammaList);
-    result.resize(gammaList.size());
-    for (unsigned int i = 0; i < result.size(); ++i)
-    {
-        result[i].gamma_snk = gammaList[i].first;
-        result[i].gamma_src = gammaList[i].second;
-        result[i].corr.resize(nt);
-    }
-    if (envHasType(SlicedPropagator1, par().q1) and
-        envHasType(SlicedPropagator2, par().q2))
-    {
-        auto &q1 = envGet(SlicedPropagator1, par().q1);
-        auto &q2 = envGet(SlicedPropagator2, par().q2);
-        
-        LOG(Message) << "(propagator already sinked)" << std::endl;
-        for (unsigned int i = 0; i < result.size(); ++i)
-        {
-            Gamma gSnk(gammaList[i].first);
-            Gamma gSrc(gammaList[i].second);
-            
-            for (unsigned int t = 0; t < nt; ++t)
-            {
-                result[i].corr[t] = TensorRemove(trace(mesonConnected(q1[t], q2[t], gSnk, gSrc)));
-            }
-        }
-    }
-    else
-    {
-        auto &q1 = envGet(PropagatorField1, par().q1);
-        auto &q2 = envGet(PropagatorField2, par().q2);
-        
-        envGetTmp(LatticeComplex, c);
-        LOG(Message) << "(using sink '" << par().sink << "')" << std::endl;
-        for (unsigned int i = 0; i < result.size(); ++i)
-        {
-            Gamma       gSnk(gammaList[i].first);
-            Gamma       gSrc(gammaList[i].second);
-            std::string ns;
-                
-            ns = vm().getModuleNamespace(env().getObjectModule(par().sink));
-            if (ns == "MSource")
-            {
-                PropagatorField1 &sink = envGet(PropagatorField1, par().sink);
-                
-                c = trace(mesonConnected(q1, q2, gSnk, gSrc)*sink);
-                sliceSum(c, buf, Tp);
-            }
-            else if (ns == "MSink")
-            {
-                SinkFnScalar &sink = envGet(SinkFnScalar, par().sink);
-                
-                c   = trace(mesonConnected(q1, q2, gSnk, gSrc));
-                buf = sink(c);
-            }
-            for (unsigned int t = 0; t < buf.size(); ++t)
-            {
-                result[i].corr[t] = TensorRemove(buf[t]);
-            }
-        }
-    }
-    saveResult(par().output, "meson", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_Meson_hpp_
diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc b/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc
deleted file mode 100644
index ca4bb341..00000000
--- a/Hadrons/Modules/MContraction/SigmaToNucleonEye.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TSigmaToNucleonEye<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp b/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp
deleted file mode 100644
index b65d0689..00000000
--- a/Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/SigmaToNucleonEye.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Felix Erben <felix.erben@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_SigmaToNucleonEye_hpp_
-#define Hadrons_MContraction_SigmaToNucleonEye_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/qcd/utils/BaryonUtils.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                               SigmaToNucleonEye                                       *
- ******************************************************************************/
-/*
- * Sigma-to-nucleon 3-pt diagrams, eye topologies.
- * 
- * Schematics:      qqLoop                |                  
- *                  /->-¬                 |                             
- *                 /     \                |          qsTi      G     qdTf
- *                 \     /                |        /---->------*------>----¬         
- *          qsTi   \   /    qdTf          |       /          /-*-¬          \
- *       /----->-----* *----->----¬       |      /          /  G  \          \
- *      *            G G           *      |     *           \     /  qqLoop  * 
- *      |\                        /|      |     |\           \-<-/          /|   
- *      | \                      / |      |     | \                        / |      
- *      |  \---------->---------/  |      |     |  \----------->----------/  |      
- *       \          quSpec        /       |      \          quSpec          /        
- *        \                      /        |       \                        /
- *         \---------->---------/         |        \----------->----------/
- *                  quSpec                |                 quSpec
- * 
- * analogously to the rare-kaon naming, the left diagram is named 'one-trace' and
- * the diagram on the right 'two-trace'
- *
- * Propagators:
- *  * qqLoop
- *  * quSpec, source at ti
- *  * qdTf,   source at tf 
- *  * qsTi,   source at ti
- */
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class SigmaToNucleonEyePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SigmaToNucleonEyePar,
-                                    std::string, qqLoop,
-                                    std::string, quSpec,
-                                    std::string, qdTf,
-                                    std::string, qsTi,
-                                    unsigned int,   tf,
-                                    std::string, sink,
-                                    std::string, output);
-};
-
-template <typename FImpl>
-class TSigmaToNucleonEye: public Module<SigmaToNucleonEyePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    BASIC_TYPE_ALIASES(ScalarImplCR, Scalar);
-    SINK_TYPE_ALIASES(Scalar);
-    typedef typename SpinMatrixField::vector_object::scalar_object SpinMatrix;
-    class Metadata: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata,
-                                        Gamma::Algebra, gammaH,
-                                        Gamma::Algebra, gammaASigma,
-                                        Gamma::Algebra, gammaBSigma,
-                                        Gamma::Algebra, gammaANucl,
-                                        Gamma::Algebra, gammaBNucl,
-                                        int, trace);
-    };
-    typedef Correlator<Metadata, SpinMatrix> Result;
-public:
-    // constructor
-    TSigmaToNucleonEye(const std::string name);
-    // destructor
-    virtual ~TSigmaToNucleonEye(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-    // Which gamma algebra was specified
-    Gamma::Algebra  al;
-};
-
-MODULE_REGISTER_TMP(SigmaToNucleonEye, ARG(TSigmaToNucleonEye<FIMPL>), MContraction);
-
-/******************************************************************************
- *                         TSigmaToNucleonEye implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSigmaToNucleonEye<FImpl>::TSigmaToNucleonEye(const std::string name)
-: Module<SigmaToNucleonEyePar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSigmaToNucleonEye<FImpl>::getInput(void)
-{
-    std::vector<std::string> input = {par().qqLoop, par().quSpec, par().qdTf, par().qsTi, par().sink};
-    
-    return input;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSigmaToNucleonEye<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSigmaToNucleonEye<FImpl>::setup(void)
-{
-    envTmpLat(SpinMatrixField, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSigmaToNucleonEye<FImpl>::execute(void)
-{
-    const Gamma GammaB(Gamma::Algebra::SigmaXZ); // C*gamma_5
-    const Gamma Id(Gamma::Algebra::Identity); // C*gamma_5
-
-    LOG(Message) << "Computing sigma-to-nucleon contractions '" << getName() << "'" << std::endl;
-    LOG(Message) << "' with (Gamma^A,Gamma^B)_sigma = ( Identity, C*gamma_5 ) and (Gamma^A,Gamma^B)_nucl = ( Identity, C*gamma_5 )" << std::endl; 
-    LOG(Message) << " using sink " << par().sink << "." << std::endl;
-        
-    envGetTmp(SpinMatrixField, c);
-    std::vector<SpinMatrix> buf;
-
-    std::vector<Result> result;
-    Result              r;
-    r.info.gammaASigma = Id.g;
-    r.info.gammaBSigma = GammaB.g;
-    r.info.gammaANucl  = Id.g;
-    r.info.gammaBNucl  = GammaB.g;
-
-    auto &qqLoop    = envGet(PropagatorField, par().qqLoop);
-    auto &quSpec    = envGet(SlicedPropagator, par().quSpec);
-    auto &qdTf      = envGet(PropagatorField, par().qdTf);
-    auto &qsTi      = envGet(PropagatorField, par().qsTi);
-    auto qut         = quSpec[par().tf];
-    for (auto &G: Gamma::gall)
-    {
-      r.info.gammaH = G.g;
-      //Operator Q1, equivalent to the two-trace case in the rare-kaons module
-      c=Zero();
-      BaryonUtils<FIMPL>::Sigma_to_Nucleon_Eye(qqLoop,qut,qdTf,qsTi,G,GammaB,GammaB,"Q1",c);
-      sliceSum(c,buf,Tp);
-      r.corr.clear();
-      for (unsigned int t = 0; t < buf.size(); ++t)
-      {
-          r.corr.push_back(buf[t]);
-      }
-      r.info.trace = 2;
-      result.push_back(r);
-      //Operator Q2, equivalent to the one-trace case in the rare-kaons module
-      c=Zero();
-      BaryonUtils<FIMPL>::Sigma_to_Nucleon_Eye(qqLoop,qut,qdTf,qsTi,G,GammaB,GammaB,"Q2",c);
-      sliceSum(c,buf,Tp);
-      r.corr.clear();
-      for (unsigned int t = 0; t < buf.size(); ++t)
-      {
-          r.corr.push_back(buf[t]);
-      }
-      r.info.trace = 1;
-      result.push_back(r);
-    }
-
-    saveResult(par().output, "stnEye", result);
-
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_SigmaToNucleonEye_hpp_
diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc
deleted file mode 100644
index 117541a3..00000000
--- a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TSigmaToNucleonNonEye<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp b/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp
deleted file mode 100644
index b0c86e2e..00000000
--- a/Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/SigmaToNucleonNonEye.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Felix Erben <felix.erben@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_SigmaToNucleonNonEye_hpp_
-#define Hadrons_MContraction_SigmaToNucleonNonEye_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/qcd/utils/BaryonUtils.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                               SigmaToNucleonNonEye                                       *
- ******************************************************************************/
-/*
- * Sigma-to-Nucleon 3-pt diagrams, non-eye topologies.
- * 
- * Schematic:     
- *            qsTi          quTf           |            qsTi            qdTf
- *          /-->--¬       /-->--¬          |          /-->--¬         /-->--¬       
- *         /       \     /       \         |         /       \       /       \      
- *        /         \   /         \        |        /         \     /         \     
- *       /           \ /           \       |       /           \   /           \    
- *      *             * G           *      |       *           G * * G          * 
- *     |\             * G           |      |      |\           /   \           /|
- *     | \           / \           /|      |      | \         /     \         / |   
- *     |  \         /   \         / |      |      |  \       /       \       /  |
- *     |   \       /     \       /  |      |      |   \-->--/         \-->--/   |   
- *      \   \-->--/       \-->--/  /       |       \   quTi            quTf    /
- *       \    quTi          qdTf  /        |        \                         /
- *        \                      /         |         \                       /
- *         \--------->----------/          |          \--------->-----------/
- *                 quSpec                  |                  quSpec
- *
- *
- * analogously to the rare-kaon naming, the left diagram is named 'one-trace' and
- * the diagram on the right 'two-trace'
- * 
- * Propagators:
- *  * quTi,   source at ti 
- *  * quTf,   source at tf
- *  * quSpec, source at ti
- *  * qdTf,   source at tf 
- *  * qsTi,   source at ti
- */
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class SigmaToNucleonNonEyePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SigmaToNucleonNonEyePar,
-                                    std::string, quTi,
-                                    std::string, quTf,
-                                    std::string, quSpec,
-                                    std::string, qdTf,
-                                    std::string, qsTi,
-                                    unsigned int,   tf,
-                                    std::string, sink,
-                                    std::string, output);
-};
-
-template <typename FImpl>
-class TSigmaToNucleonNonEye: public Module<SigmaToNucleonNonEyePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    BASIC_TYPE_ALIASES(ScalarImplCR, Scalar);
-    SINK_TYPE_ALIASES(Scalar);
-    typedef typename SpinMatrixField::vector_object::scalar_object SpinMatrix;
-    class Metadata: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata,
-                                        Gamma::Algebra, gammaH,
-                                        Gamma::Algebra, gammaASigma,
-                                        Gamma::Algebra, gammaBSigma,
-                                        Gamma::Algebra, gammaANucl,
-                                        Gamma::Algebra, gammaBNucl,
-                                        int, trace);
-    };
-    typedef Correlator<Metadata, SpinMatrix> Result;
-public:
-    // constructor
-    TSigmaToNucleonNonEye(const std::string name);
-    // destructor
-    virtual ~TSigmaToNucleonNonEye(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-    // Which gamma algebra was specified
-    Gamma::Algebra  al;
-};
-
-MODULE_REGISTER_TMP(SigmaToNucleonNonEye, ARG(TSigmaToNucleonNonEye<FIMPL>), MContraction);
-
-/******************************************************************************
- *                         TSigmaToNucleonNonEye implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSigmaToNucleonNonEye<FImpl>::TSigmaToNucleonNonEye(const std::string name)
-: Module<SigmaToNucleonNonEyePar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSigmaToNucleonNonEye<FImpl>::getInput(void)
-{
-    std::vector<std::string> input = {par().quTi, par().quTf, par().quSpec, par().qdTf, par().qsTi, par().sink};
-    
-    return input;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSigmaToNucleonNonEye<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSigmaToNucleonNonEye<FImpl>::setup(void)
-{
-    envTmpLat(SpinMatrixField, "c");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSigmaToNucleonNonEye<FImpl>::execute(void)
-{
-    const Gamma GammaB(Gamma::Algebra::SigmaXZ); // C*gamma_5
-    const Gamma Id(Gamma::Algebra::Identity); // C*gamma_5
-
-    LOG(Message) << "Computing sigma-to-nucleon contractions '" << getName() << "'" << std::endl;
-    LOG(Message) << "' with (Gamma^A,Gamma^B)_sigma = ( Identity, C*gamma_5 ) and (Gamma^A,Gamma^B)_nucl = ( Identity, C*gamma_5 )" << std::endl; 
-    LOG(Message) << " using sink " << par().sink << "." << std::endl;
-        
-    envGetTmp(SpinMatrixField, c);
-    std::vector<SpinMatrix> buf;
-
-    std::vector<Result> result;
-    Result              r;
-    r.info.gammaASigma = Id.g;
-    r.info.gammaBSigma = GammaB.g;
-    r.info.gammaANucl  = Id.g;
-    r.info.gammaBNucl  = GammaB.g;
-
-    auto &quTi      = envGet(PropagatorField, par().quTi);
-    auto &quTf      = envGet(PropagatorField, par().quTf);
-    auto &quSpec    = envGet(SlicedPropagator, par().quSpec);
-    auto &qdTf      = envGet(PropagatorField, par().qdTf);
-    auto &qsTi      = envGet(PropagatorField, par().qsTi);
-    auto qut         = quSpec[par().tf];
-    for (auto &G: Gamma::gall)
-    {
-      r.info.gammaH = G.g;
-      //Operator Q1, equivalent to the two-trace case in the rare-kaons module
-      c=Zero();
-      BaryonUtils<FIMPL>::Sigma_to_Nucleon_NonEye(quTi,quTf,qut,qdTf,qsTi,G,GammaB,GammaB,"Q1",c);
-      sliceSum(c,buf,Tp);
-      r.corr.clear();
-      for (unsigned int t = 0; t < buf.size(); ++t)
-      {
-          r.corr.push_back(buf[t]);
-      }
-      r.info.trace = 2;
-      result.push_back(r);
-      //Operator Q2, equivalent to the one-trace case in the rare-kaons module
-      c=Zero();
-      BaryonUtils<FIMPL>::Sigma_to_Nucleon_NonEye(quTi,quTf,qut,qdTf,qsTi,G,GammaB,GammaB,"Q2",c);
-      sliceSum(c,buf,Tp);
-      r.corr.clear();
-      for (unsigned int t = 0; t < buf.size(); ++t)
-      {
-          r.corr.push_back(buf[t]);
-      }
-      r.info.trace = 1;
-      result.push_back(r);
-    }
-
-    saveResult(par().output, "stnNonEye", result);
-
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_SigmaToNucleonNonEye_hpp_
diff --git a/Hadrons/Modules/MContraction/WeakEye3pt.cc b/Hadrons/Modules/MContraction/WeakEye3pt.cc
deleted file mode 100644
index 4942bbe4..00000000
--- a/Hadrons/Modules/MContraction/WeakEye3pt.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakEye3pt.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/WeakEye3pt.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TWeakEye3pt<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/WeakEye3pt.hpp b/Hadrons/Modules/MContraction/WeakEye3pt.hpp
deleted file mode 100644
index b4165098..00000000
--- a/Hadrons/Modules/MContraction/WeakEye3pt.hpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakEye3pt.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_WeakEye3pt_hpp_
-#define Hadrons_MContraction_WeakEye3pt_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- * Weak Hamiltonian meson 3-pt diagrams, eye topologies.
- * 
- * Schematics:       loop                 |                  
- *                  /-<-¬                 |                             
- *                 /     \                |            qbl     G     qbr
- *                 \     /                |        /----<------*------<----¬         
- *            qbl   \   /    qbr          |       /          /-*-¬          \
- *       /-----<-----* *-----<----¬       |      /          /  G  \          \
- *  gIn *            G G           * gOut | gIn *           \     /  loop    * gOut
- *       \                        /       |      \           \->-/          /   
- *        \                      /        |       \                        /       
- *         \---------->---------/         |        \----------->----------/        
- *                   qs                   |                   qs                  
- *                                        |
- *                one trace               |                two traces
- * 
- * one trace : tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G*loop*G)
- * two traces: tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G)*tr(loop*G)
- * 
- */
-
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class WeakEye3ptPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WeakEye3ptPar,
-                                    std::string,    qBarLeft,
-                                    std::string,    qBarRight,
-                                    std::string,    qSpectator,
-                                    std::string,    loop,
-                                    unsigned int,   tOut,
-                                    Gamma::Algebra, gammaIn,
-                                    Gamma::Algebra, gammaOut,
-                                    std::string,    output);
-};
-
-template <typename FImpl>
-class TWeakEye3pt: public Module<WeakEye3ptPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    class Metadata: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata,
-                                        Gamma::Algebra, in,
-                                        Gamma::Algebra, out,
-                                        Gamma::Algebra, op,
-                                        unsigned int,   trace);
-    };
-    typedef Correlator<Metadata> Result;
-public:
-    // constructor
-    TWeakEye3pt(const std::string name);
-    // destructor
-    virtual ~TWeakEye3pt(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(WeakEye3pt, TWeakEye3pt<FIMPL>, MContraction);
-
-/******************************************************************************
- *                        TWeakEye3pt implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWeakEye3pt<FImpl>::TWeakEye3pt(const std::string name)
-: Module<WeakEye3ptPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWeakEye3pt<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().qBarLeft, par().qBarRight, 
-                                   par().qSpectator, par().loop};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWeakEye3pt<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakEye3pt<FImpl>::setup(void)
-{
-    envTmpLat(ComplexField, "corr");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakEye3pt<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing mesonic weak 3pt contractions, eye topologies" << std::endl;
-    LOG(Message) << "gIn : " << par().gammaIn << std::endl;
-    LOG(Message) << "gOut: " << par().gammaOut << std::endl;
-    LOG(Message) << "tOut: " << par().tOut << std::endl;
-    LOG(Message) << "qbl : " << par().qBarLeft << std::endl;
-    LOG(Message) << "qbr : " << par().qBarRight << std::endl;
-    LOG(Message) << "qs  : " << par().qSpectator << std::endl;
-    LOG(Message) << "loop: " << par().loop << std::endl;
-
-    std::vector<Result> result;
-    Result              r;
-    auto                &qbl  = envGet(PropagatorField, par().qBarLeft);
-    auto                &qbr  = envGet(PropagatorField, par().qBarRight);
-    auto                &loop = envGet(PropagatorField, par().loop);
-    auto                &qs   = envGet(SlicedPropagator, par().qSpectator);
-    auto                qst   = qs[par().tOut];
-    Gamma               gIn(par().gammaIn), gOut(par().gammaOut);
-    Gamma               g5(Gamma::Algebra::Gamma5);
-
-    envGetTmp(ComplexField, corr);
-    r.info.in  = par().gammaIn;
-    r.info.out = par().gammaOut;
-    for (auto &G: Gamma::gall)
-    {
-        SlicedComplex buf;
-
-        r.info.op = G.g;
-        // one trace
-        corr = trace(qbr*gOut*qst*adj(gIn)*g5*adj(qbl)*g5*G*loop*G);
-        sliceSum(corr, buf, Tp);
-        r.corr.clear();
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            r.corr.push_back(TensorRemove(buf[t]));
-        }
-        r.info.trace = 1;
-        result.push_back(r);
-        // two traces
-        corr = trace(qbr*gOut*qst*adj(gIn)*g5*adj(qbl)*g5*G)*trace(loop*G);
-        sliceSum(corr, buf, Tp);
-        r.corr.clear();
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            r.corr.push_back(TensorRemove(buf[t]));
-        }
-        r.info.trace = 2;
-        result.push_back(r);
-    }
-    saveResult(par().output, "weakEye3pt", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakEye3pt_hpp_
diff --git a/Hadrons/Modules/MContraction/WeakMesonDecayKl2.cc b/Hadrons/Modules/MContraction/WeakMesonDecayKl2.cc
deleted file mode 100644
index 78f1a6ae..00000000
--- a/Hadrons/Modules/MContraction/WeakMesonDecayKl2.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakMesonDecayKl2.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TWeakMesonDecayKl2<FIMPL>;
-
diff --git a/Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp b/Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp
deleted file mode 100644
index 7b00ffaa..00000000
--- a/Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakMesonDecayKl2.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MContraction_WeakMesonDecayKl2_hpp_
-#define Hadrons_MContraction_WeakMesonDecayKl2_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
-* Kl2 contraction
-* -----------------------------
-*
-* contraction for Kl2 decay, including the lepton
-*
-* 	trace(q1*adj(q2)*g5*gL[mu]) * (gL[mu] * lepton)_{a,b}
-*
-* with open spinor indices (a,b) for the lepton part
-*
-*             q1                  lepton
-*        /------------\       /------------
-*       /              \     /
-*      /                \H_W/
-* g_5 *                  * * 
-*      \                /
-*       \              / 
-*        \____________/
-*             q2
-*
-* * options:
-* - q1: input propagator 1 (string)
-* - q2: input propagator 2 (string)
-* - lepton: input lepton (string)
-*/
-
-/******************************************************************************
- *                               TWeakMesonDecayKl2                           *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class WeakMesonDecayKl2Par: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WeakMesonDecayKl2Par,
-                                    std::string, q1,
-                                    std::string, q2,
-                                    std::string, lepton,
-				                    std::string, output);
-};
-
-template <typename FImpl>
-class TWeakMesonDecayKl2: public Module<WeakMesonDecayKl2Par>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef typename SpinMatrixField::vector_object::scalar_object SpinMatrix;
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<SpinMatrix>, corr);
-    };
-public:
-    // constructor
-    TWeakMesonDecayKl2(const std::string name);
-    // destructor
-    virtual ~TWeakMesonDecayKl2(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // execution
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(WeakMesonDecayKl2, TWeakMesonDecayKl2<FIMPL>, MContraction);
-
-/******************************************************************************
- *                           TWeakMesonDecayKl2 implementation                   *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWeakMesonDecayKl2<FImpl>::TWeakMesonDecayKl2(const std::string name)
-: Module<WeakMesonDecayKl2Par>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWeakMesonDecayKl2<FImpl>::getInput(void)
-{
-    std::vector<std::string> input = {par().q1, par().q2, par().lepton};
-    
-    return input;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWeakMesonDecayKl2<FImpl>::getOutput(void)
-{
-    std::vector<std::string> output = {};
-    
-    return output;
-}
-
-// setup ////////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakMesonDecayKl2<FImpl>::setup(void)
-{
-    envTmpLat(ComplexField, "c");
-    envTmpLat(PropagatorField, "prop_buf");
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(SpinMatrixField, "buf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakMesonDecayKl2<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing QED Kl2 contractions '" << getName() << "' using"
-                 << " quarks '" << par().q1 << "' and '" << par().q2 << "' and"
-		         << "lepton '"  << par().lepton << "'" << std::endl;
-
-    Gamma                   g5(Gamma::Algebra::Gamma5);
-    int                     nt = env().getDim(Tp);
-    std::vector<SpinMatrix> res_summed;
-    Result                  r;
-
-    auto &res    = envGet(PropagatorField, getName()); res = Zero();
-    auto &q1     = envGet(PropagatorField, par().q1);
-    auto &q2     = envGet(PropagatorField, par().q2);
-    auto &lepton = envGet(PropagatorField, par().lepton);
-    envGetTmp(SpinMatrixField, buf);
-    envGetTmp(ComplexField, c);
-    envGetTmp(PropagatorField, prop_buf);  
-
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        c = Zero();
-        //hadronic part: trace(q1*adj(q2)*g5*gL[mu]) 
-        c = trace(q1*adj(q2)*g5*GammaL(Gamma::gmu[mu]));
-        prop_buf = 1.;
-        //multiply lepton part
-        res += c * prop_buf * GammaL(Gamma::gmu[mu]) * lepton;
-    }
-    buf = peekColour(res, 0, 0);
-    sliceSum(buf, r.corr, Tp);
-    saveResult(par().output, "weakdecay", r);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakMesonDecayKl2_hpp_
diff --git a/Hadrons/Modules/MContraction/WeakNonEye3pt.cc b/Hadrons/Modules/MContraction/WeakNonEye3pt.cc
deleted file mode 100644
index 59ada976..00000000
--- a/Hadrons/Modules/MContraction/WeakNonEye3pt.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakNonEye3pt.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/WeakNonEye3pt.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TWeakNonEye3pt<FIMPL>;
diff --git a/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp b/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp
deleted file mode 100644
index 4068cd8c..00000000
--- a/Hadrons/Modules/MContraction/WeakNonEye3pt.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WeakNonEye3pt.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_WeakNonEye3pt_hpp_
-#define Hadrons_MContraction_WeakNonEye3pt_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- * Weak Hamiltonian meson 3-pt diagrams, non-eye topologies.
- * 
- * Schematic:     
- *            qbl           qbr            |            qbl             qbr
- *          /--<--¬       /--<--¬          |          /--<--¬         /--<--¬       
- *         /       \     /       \         |         /       \       /       \      
- *        /         \   /         \        |        /         \     /         \     
- *       /           \ /           \       |       /           \   /           \    
- *  gIn *             * G           * gOut |  gIn *           G * * G           * gOut
- *      \             * G           |      |       \           /   \           /
- *       \           / \           /       |        \         /     \         /    
- *        \         /   \         /        |         \       /       \       /  
- *         \       /     \       /         |          \-->--/         \-->--/      
- *          \-->--/       \-->--/          |            ql              qr 
- *            ql            qr             |
- *               one trace                 |              two traces
- *
- * one trace : tr(ql*adj(gIn)*g5*adj(qbl)*g5*G*qbr*gOut*g5*adj(qr)*g5*G)
- * two traces: tr(ql*adj(gIn)*g5*adj(qbl)*g5*G)*tr(qbr*gOut*g5*adj(qr)*g5*G)
- * 
- */
-
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class WeakNonEye3ptPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WeakNonEye3ptPar,
-                                    std::string,    qLeft,
-                                    std::string,    qBarLeft,
-                                    std::string,    qRight,
-                                    std::string,    qBarRight,
-                                    Gamma::Algebra, gammaIn,
-                                    Gamma::Algebra, gammaOut,
-                                    std::string,    output);
-};
-
-template <typename FImpl>
-class TWeakNonEye3pt: public Module<WeakNonEye3ptPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    class Metadata: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Metadata,
-                                        Gamma::Algebra, in,
-                                        Gamma::Algebra, out,
-                                        Gamma::Algebra, op,
-                                        unsigned int,   trace);
-    };
-    typedef Correlator<Metadata> Result;
-public:
-    // constructor
-    TWeakNonEye3pt(const std::string name);
-    // destructor
-    virtual ~TWeakNonEye3pt(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(WeakNonEye3pt, TWeakNonEye3pt<FIMPL>, MContraction);
-
-/******************************************************************************
- *                 TWeakNonEye3pt implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWeakNonEye3pt<FImpl>::TWeakNonEye3pt(const std::string name)
-: Module<WeakNonEye3ptPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWeakNonEye3pt<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().qLeft, par().qBarLeft, 
-                                   par().qRight, par().qBarRight};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWeakNonEye3pt<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakNonEye3pt<FImpl>::setup(void)
-{
-    envTmpLat(ComplexField, "corr");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWeakNonEye3pt<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing mesonic weak 3pt contractions, non-eye topologies" << std::endl;
-    LOG(Message) << "gIn : " << par().gammaIn << std::endl;
-    LOG(Message) << "gOut: " << par().gammaOut << std::endl;
-    LOG(Message) << "ql  : " << par().qLeft << std::endl;
-    LOG(Message) << "qbl : " << par().qBarLeft << std::endl;
-    LOG(Message) << "qr  : " << par().qRight << std::endl;
-    LOG(Message) << "qbr : " << par().qBarRight << std::endl;
-
-    std::vector<Result> result;
-    Result              r;
-    auto                &ql  = envGet(PropagatorField, par().qLeft);
-    auto                &qbl = envGet(PropagatorField, par().qBarLeft);
-    auto                &qr  = envGet(PropagatorField, par().qRight);
-    auto                &qbr = envGet(PropagatorField, par().qBarRight);
-    Gamma               gIn(par().gammaIn), gOut(par().gammaOut);
-    Gamma               g5(Gamma::Algebra::Gamma5);
-
-    envGetTmp(ComplexField, corr);
-    r.info.in  = par().gammaIn;
-    r.info.out = par().gammaOut;
-    for (auto &G: Gamma::gall)
-    {
-        SlicedComplex buf;
-
-        r.info.op = G.g;
-        // one trace
-        corr = trace(ql*adj(gIn)*g5*adj(qbl)*g5*G*qbr*gOut*g5*adj(qr)*g5*G);
-        sliceSum(corr, buf, Tp);
-        r.corr.clear();
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            r.corr.push_back(TensorRemove(buf[t]));
-        }
-        r.info.trace = 1;
-        result.push_back(r);
-        // two traces
-        corr = trace(ql*adj(gIn)*g5*adj(qbl)*g5*G)*trace(qbr*gOut*g5*adj(qr)*g5*G);
-        sliceSum(corr, buf, Tp);
-        r.corr.clear();
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            r.corr.push_back(TensorRemove(buf[t]));
-        }
-        r.info.trace = 2;
-        result.push_back(r);
-    }
-    saveResult(par().output, "weakNonEye3pt", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_WeakNonEye3pt_hpp_
diff --git a/Hadrons/Modules/MDistil/Distil.hpp b/Hadrons/Modules/MDistil/Distil.hpp
deleted file mode 100644
index 01a6b9da..00000000
--- a/Hadrons/Modules/MDistil/Distil.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/Distil.hpp
- 
- Copyright (C) 2015-2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_Distil_hpp_
-#define Hadrons_MDistil_Distil_hpp_
-
-#include <Hadrons/NamedTensor.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-#include <Hadrons/A2AVectors.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- Distillation code that is common across modules
-
- Documentation on how to use this code available at
-
- *  https://aportelli.github.io/Hadrons-doc/#/mdistil  *
- 
- Notation for (stochastic) DistilParameters taken from 1104.3870:
-
- TI is interlaced dilution in time (corresponding to Nt = time-dimension of the lattice)
- LI is interlaced dilution in laplacian-eigenvector space (corresponding to nvec)
- SI is interlaced dilution in spin (corresponding to Ns, taken from Grid, usually Ns=4)
-
- This code automatically computes perambulators using exact distillation if
- *   (TI,LI,SI) = (Nt,nvec,Ns)   *
- In this case, nnoise=1 and Noises is set to an array of values =1 as well.
- tsrc then specifies the only timeslice on which the sources are supported.
- (( for stochastic distillation, the vaue of tsrc has no meaning in this code ))
-
- ******************************************************************************/
-
-struct DistilParameters: Serializable {
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DistilParameters,
-                                    int, nvec,
-                                    int, nnoise,
-                                    int, tsrc,
-                                    int, TI,
-                                    int, LI,
-                                    int, SI )
-};
-
-/******************************************************************************
- Make a lower dimensional grid in preparation for local slice operations
- ******************************************************************************/
-
-inline void MakeLowerDimGrid( std::unique_ptr<GridCartesian> &up, GridCartesian * gridHD )
-{
-    int nd{static_cast<int>(gridHD->_ndimension)};
-    Coordinate latt_size   = gridHD->_gdimensions;
-    latt_size[nd-1] = 1;
-    Coordinate simd_layout = GridDefaultSimd(nd-1, vComplex::Nsimd());
-    simd_layout.push_back( 1 );
-    Coordinate mpi_layout  = gridHD->_processors;
-    mpi_layout[nd-1] = 1;
-    up.reset( new GridCartesian(latt_size,simd_layout,mpi_layout,*gridHD) );
-}
-
-/*************************************************************************************
- Rotate eigenvectors into our phase convention
- First component of first eigenvector is real and positive
- *************************************************************************************/
-
-inline void RotateEigen(std::vector<LatticeColourVector> & evec)
-{
-    ColourVector cv0;
-    auto grid = evec[0].Grid();
-    Coordinate siteFirst(grid->Nd(),0);
-    peekSite(cv0, evec[0], siteFirst);
-    const std::complex<Real> cplx0{cv0()()(0).real(), cv0()()(0).imag()};
-    if( cplx0.imag() == 0 )
-        LOG(Message) << "RotateEigen() : Site 0 : " << cplx0 << " => already meets phase convention" << std::endl;
-    else
-    {
-        const Real cplx0_mag{ std::abs(cplx0) };
-        const std::complex<Real> std_phase{std::conj(cplx0/cplx0_mag)};
-        LOG(Message) << "RotateEigen() : Site 0 : |" << cplx0 << "|=" << cplx0_mag
-                     << " => phase=" << (std::arg(std_phase) / M_PI) << " pi" << std::endl;
-        {
-            const Grid::Complex phase{std_phase.real(),std_phase.imag()};
-            for( int k = 0 ; k < evec.size() ; k++ )
-                evec[k] *= phase;
-            // Get rid of the rounding error in imaginary phase on the very first site
-            peekSite(cv0, evec[0], siteFirst);
-            cv0()()(0).imag(0); // this should be zero after the phase multiply - force it to be so
-            pokeSite(cv0, evec[0], siteFirst);
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif
diff --git a/Hadrons/Modules/MDistil/DistilPar.cc b/Hadrons/Modules/MDistil/DistilPar.cc
deleted file mode 100644
index f0c03ec9..00000000
--- a/Hadrons/Modules/MDistil/DistilPar.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MDistil/DistilPar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TDistilPar<FIMPL>;
diff --git a/Hadrons/Modules/MDistil/DistilPar.hpp b/Hadrons/Modules/MDistil/DistilPar.hpp
deleted file mode 100644
index f38e78d1..00000000
--- a/Hadrons/Modules/MDistil/DistilPar.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/DistilPar.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_DistilPar_hpp_
-#define Hadrons_MDistil_DistilPar_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- *                         DistilPar                                 *
- ******************************************************************************/
-
-template <typename FImpl>
-class TDistilPar: public Module<DistilParameters>
-{
-public:
-    // constructor
-    TDistilPar(const std::string name);
-    // destructor
-    virtual ~TDistilPar(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(DistilPar, TDistilPar<FIMPL>, MDistil);
-
-/******************************************************************************
- *                 TDistilPar implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TDistilPar<FImpl>::TDistilPar(const std::string name) : Module<DistilParameters>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TDistilPar<FImpl>::getInput(void)
-{
-    return {};
-}
-
-template <typename FImpl>
-std::vector<std::string> TDistilPar<FImpl>::getOutput(void)
-{
-    return {getName()};
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDistilPar<FImpl>::setup(void)
-{
-    envCreate(DistilParameters, getName(), 1, par() );
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDistilPar<FImpl>::execute(void)
-{
-    // Nothing to do. setup() created and initialised the output object
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif
diff --git a/Hadrons/Modules/MDistil/DistilVectors.cc b/Hadrons/Modules/MDistil/DistilVectors.cc
deleted file mode 100644
index 69b20853..00000000
--- a/Hadrons/Modules/MDistil/DistilVectors.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/DistilVectors.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MDistil/DistilVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TDistilVectors<FIMPL>;
diff --git a/Hadrons/Modules/MDistil/DistilVectors.hpp b/Hadrons/Modules/MDistil/DistilVectors.hpp
deleted file mode 100644
index de871a64..00000000
--- a/Hadrons/Modules/MDistil/DistilVectors.hpp
+++ /dev/null
@@ -1,243 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/DistilVectors.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_DistilVectors_hpp_
-#define Hadrons_MDistil_DistilVectors_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- *                         DistilVectors                                      *
- *                (Create rho and/or phi vectors)                             *
- ******************************************************************************/
-
-class DistilVectorsPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DistilVectorsPar,
-                                    std::string, noise,
-                                    std::string, perambulator,
-                                    std::string, lapevec,
-                                    std::string, rho,
-                                    std::string, phi,
-                                    std::string, DistilParams);
-};
-
-template <typename FImpl>
-class TDistilVectors: public Module<DistilVectorsPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    // constructor
-    TDistilVectors(const std::string name);
-    // destructor
-    virtual ~TDistilVectors(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-protected:
-    std::unique_ptr<GridCartesian> grid3d; // Owned by me, so I must delete it
-public:
-    // These variables contain parameters
-    std::string RhoName;
-    std::string PhiName;
-};
-
-MODULE_REGISTER_TMP(DistilVectors, TDistilVectors<FIMPL>, MDistil);
-
-/******************************************************************************
- *                 TDistilVectors implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TDistilVectors<FImpl>::TDistilVectors(const std::string name) : Module<DistilVectorsPar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TDistilVectors<FImpl>::getInput(void)
-{
-    return {par().noise,par().perambulator,par().lapevec,par().DistilParams};
-}
-
-template <typename FImpl>
-std::vector<std::string> TDistilVectors<FImpl>::getOutput(void)
-{
-    RhoName = par().rho;
-    PhiName = par().phi;
-    if (RhoName.empty() && PhiName.empty())
-    {
-        HADRONS_ERROR(Argument,"No output specified");
-    }
-    std::vector<std::string> out;
-    if (!RhoName.empty())
-        out.push_back(RhoName);
-    if (!PhiName.empty())
-        out.push_back(PhiName);
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDistilVectors<FImpl>::setup(void)
-{
-    // We expect the perambulator to have been created with these indices
-    auto &perambulator = envGet(PerambTensor, par().perambulator);
-    if (!perambulator.ValidateIndexNames())
-    {
-        HADRONS_ERROR(Range,"Perambulator index names bad");
-    }
-
-    const DistilParameters &dp{envGet(DistilParameters, par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt };
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-    
-    if (!RhoName.empty())
-        envCreate(std::vector<FermionField>, RhoName, 1, dp.nnoise*dp.LI*dp.SI*Nt_inv, envGetGrid(FermionField));
-    if (!PhiName.empty())
-        envCreate(std::vector<FermionField>, PhiName, 1, dp.nnoise*dp.LI*dp.SI*Nt_inv, envGetGrid(FermionField));
-    
-    Coordinate latt_size   = GridDefaultLatt();
-    Coordinate mpi_layout  = GridDefaultMpi();
-    Coordinate simd_layout_3 = GridDefaultSimd(Nd-1, vComplex::Nsimd());
-    latt_size[Nd-1] = 1;
-    simd_layout_3.push_back( 1 );
-    mpi_layout[Nd-1] = 1;
-    GridCartesian * const grid4d{env().getGrid()};
-    MakeLowerDimGrid(grid3d, grid4d);
-    
-    envTmp(LatticeSpinColourVector, "source4d",1,LatticeSpinColourVector(grid4d));
-    envTmp(LatticeSpinColourVector, "source3d",1,LatticeSpinColourVector(grid3d.get()));
-    envTmp(LatticeColourVector, "source3d_nospin",1,LatticeColourVector(grid3d.get()));
-    envTmp(LatticeSpinColourVector, "sink3d",1,LatticeSpinColourVector(grid3d.get()));
-    envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d.get()));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TDistilVectors<FImpl>::execute(void)
-{
-    auto &noise        = envGet(NoiseTensor,  par().noise);
-    auto &perambulator = envGet(PerambTensor, par().perambulator);
-    auto &epack        = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, par().lapevec);
-    const DistilParameters &dp{envGet(DistilParameters, par().DistilParams)};
-    
-    envGetTmp(LatticeSpinColourVector, source4d);
-    envGetTmp(LatticeSpinColourVector, source3d);
-    envGetTmp(LatticeColourVector,     source3d_nospin);
-    envGetTmp(LatticeSpinColourVector, sink3d);
-    envGetTmp(LatticeColourVector,     evec3d);
-    
-    GridCartesian * const grid4d{env().getGrid()};
-    const int Ntlocal{ grid4d->LocalDimensions()[3] };
-    const int Ntfirst{ grid4d->LocalStarts()[3] };
-    
-    const int Nt{env().getDim(Tdir)}; 
-    const bool full_tdil{ dp.TI == Nt }; 
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-    
-    int vecindex;
-    if (!RhoName.empty())
-    {
-        auto &rho = envGet(std::vector<FermionField>, RhoName);
-        for (int inoise = 0; inoise < dp.nnoise; inoise++) 
-	{
-            for (int dk = 0; dk < dp.LI; dk++) 
-	    {
-                for (int dt = 0; dt < Nt_inv; dt++) 
-		{
-                    for (int ds = 0; ds < dp.SI; ds++) 
-		    {
-                        vecindex = inoise + dp.nnoise * (dk + dp.LI * (ds + dp.SI * dt));
-                        rho[vecindex] = 0;
-                        for (int it = dt; it < Nt; it += dp.TI)
-			{
-                            const int t_inv{full_tdil ? dp.tsrc : it};
-                            if (t_inv >= Ntfirst && t_inv < Ntfirst + Ntlocal) 
-			    {
-                                for (int ik = dk; ik < dp.nvec; ik += dp.LI)
-				{
-                                    for (int is = ds; is < Ns; is += dp.SI)
-				    {
-                                        ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir);
-                                        source3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is);
-                                        source3d=0;
-                                        pokeSpin(source3d,source3d_nospin,is);
-                                        source4d=0;
-                                        InsertSliceLocal(source3d,source4d,0,t_inv-Ntfirst,Tdir);
-                                        rho[vecindex] += source4d;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    if (!PhiName.empty()) 
-    {
-        auto &phi = envGet(std::vector<FermionField>, PhiName);
-        for (int inoise = 0; inoise < dp.nnoise; inoise++) 
-	{
-            for (int dk = 0; dk < dp.LI; dk++) 
-	    {
-                for (int dt = 0; dt < Nt_inv; dt++) 
-		{
-                    for (int ds = 0; ds < dp.SI; ds++) 
-		    {
-                        vecindex = inoise + dp.nnoise * (dk + dp.LI * (ds + dp.SI * dt));
-                        phi[vecindex] = 0;
-                        for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++) 
-			{
-                            sink3d=0;
-                            for (int ivec = 0; ivec < dp.nvec; ivec++) 
-			    {
-                                ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
-                                sink3d += evec3d * perambulator.tensor(t, ivec, dk, inoise,dt,ds);
-                            }
-                            InsertSliceLocal(sink3d,phi[vecindex],0,t-Ntfirst,Tdir);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif // Hadrons_MDistil_DistilVectors_hpp_
diff --git a/Hadrons/Modules/MDistil/LapEvec.cc b/Hadrons/Modules/MDistil/LapEvec.cc
deleted file mode 100644
index be6838fa..00000000
--- a/Hadrons/Modules/MDistil/LapEvec.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/LapEvec.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MDistil/LapEvec.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TLapEvec<GIMPL>;
diff --git a/Hadrons/Modules/MDistil/LapEvec.hpp b/Hadrons/Modules/MDistil/LapEvec.hpp
deleted file mode 100644
index 3c1122ca..00000000
--- a/Hadrons/Modules/MDistil/LapEvec.hpp
+++ /dev/null
@@ -1,354 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/LapEvec.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_LapEvec_hpp_
-#define Hadrons_MDistil_LapEvec_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- 
- Laplacian eigenvectors - parameters
-
- Computes the eigenvectors of the 3D-Laplacian, built from stout-smeared 
- gauge links with the specified number of steps and smearing parameter rho. 
- The smearing is only applied to the spatial components of the gauge field,
- i.e. rho_{4i} = rho_{i4} = rho_{44} = 0. 
-
- Chebyshev-preconditioning is needed for convergence of the nvec lowest 
- eigenvectors.
- 
- ******************************************************************************/
-
-struct StoutParameters: Serializable {
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StoutParameters,
-                                    int, steps,
-                                    double, rho)
-    StoutParameters() = default;
-    template <class ReaderClass> StoutParameters(Reader<ReaderClass>& Reader){read(Reader,"StoutSmearing",*this);}
-};
-
-struct ChebyshevParameters: Serializable {
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ChebyshevParameters,
-                                    int, PolyOrder,
-                                    double, alpha,
-                                    double, beta)
-    ChebyshevParameters() = default;
-    template <class ReaderClass> ChebyshevParameters(Reader<ReaderClass>& Reader){read(Reader,"Chebyshev",*this);}
-};
-
-struct LanczosParameters: Serializable {
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LanczosParameters,
-                                    int, Nvec,
-                                    int, Nk,
-                                    int, Np,
-                                    int, MaxIt,
-                                    double, resid,
-                                    int, IRLLog)
-    LanczosParameters() = default;
-    template <class ReaderClass> LanczosParameters(Reader<ReaderClass>& Reader){read(Reader,"Lanczos",*this);}
-};
-
-// These are the actual parameters passed to the module during construction
-
-struct LapEvecPar: Serializable {
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LapEvecPar
-                                    ,std::string,         gauge
-                                    ,StoutParameters,     Stout
-                                    ,ChebyshevParameters, Cheby
-                                    ,LanczosParameters,   Lanczos
-                                    ,std::string,         FileName)
-};
-
-/******************************************************************************
- 
- Laplacian eigenvectors - Module (class) definition
- 
- ******************************************************************************/
-
-template <typename GImpl>
-class TLapEvec: public Module<LapEvecPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-    // constructor
-    TLapEvec(const std::string name);
-    // destructor
-    virtual ~TLapEvec(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-protected:
-    std::unique_ptr<GridCartesian> gridLD; // Owned by me, so I must delete it
-};
-
-MODULE_REGISTER_TMP(LapEvec, TLapEvec<GIMPL>, MDistil);
-
-/******************************************************************************
- TLapEvec implementation
- ******************************************************************************/
-
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TLapEvec<GImpl>::TLapEvec(const std::string name) : Module<LapEvecPar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TLapEvec<GImpl>::getInput(void)
-{
-    return std::vector<std::string>{par().gauge};
-}
-
-template <typename GImpl>
-std::vector<std::string> TLapEvec<GImpl>::getOutput(void)
-{
-    return {getName()}; // This is the higher dimensional eigenpack
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TLapEvec<GImpl>::setup(void)
-{
-    GridCartesian * gridHD = env().getGrid();
-    MakeLowerDimGrid(gridLD,gridHD);
-    const int Ntlocal{gridHD->LocalDimensions()[Tdir]};
-    // Temporaries
-    envTmpLat(GaugeField, "Umu_stout");
-    envTmpLat(GaugeField, "Umu_smear");
-    envTmp(LatticeGaugeField, "UmuNoTime",1,LatticeGaugeField(gridLD.get()));
-    envTmp(LatticeColourVector, "src",1,LatticeColourVector(gridLD.get()));
-    envTmp(std::vector<LapEvecs>, "eig",1,std::vector<LapEvecs>(Ntlocal));
-    // Output objects
-    envCreate(LapEvecs, getName(), 1, par().Lanczos.Nvec, gridHD);
-}
-
-/*************************************************************************************
- 
- -Grad^2 (Peardon, 2009, pg 2, equation 3, https://arxiv.org/abs/0905.2160)
- Field      Type of field the operator will be applied to
- GaugeField Gauge field the operator will smear using
- 
- *************************************************************************************/
-
-template<typename Field, typename GaugeField=LatticeGaugeField>
-class Laplacian3D : public LinearOperatorBase<Field>, public LinearFunction<Field> {
-    typedef typename GaugeField::vector_type vCoeff_t;
-public:
-    int          nd; // number of spatial dimensions
-    std::vector<Lattice<iColourMatrix<vCoeff_t> > > U;
-    // Construct this operator given a gauge field and the number of dimensions it should act on
-    Laplacian3D( GaugeField& gf, int dimSpatial = Tdir ) : nd{dimSpatial}
-    {
-        if (dimSpatial<1)
-        {
-            HADRONS_ERROR(Range,"Must be at least one spatial dimension");
-        }
-        for (int mu = 0 ; mu < nd ; mu++)
-            U.push_back(PeekIndex<LorentzIndex>(gf,mu));
-    }
-    
-    // Apply this operator to "in", return result in "out"
-    void operator()(const Field& in, Field& out) {
-        if (nd > in.Grid()->Nd())
-        {
-            HADRONS_ERROR(Range,"nd too large");
-        }
-        conformable( in, out );
-        out = ( ( Real ) ( 2 * nd ) ) * in;
-        Field tmp_(in.Grid());
-        typedef typename GaugeField::vector_type vCoeff_t;
-        for (int mu = 0 ; mu < nd ; mu++)
-        {
-            out -= U[mu] * Cshift( in, mu, 1);
-            tmp_ = adj( U[mu] ) * in;
-            out -= Cshift(tmp_,mu,-1);
-        }
-    }
-    
-    void OpDiag (const Field &in, Field &out) { HADRONS_ERROR(Definition, "OpDiag() undefined"); };
-    void OpDir  (const Field &in, Field &out,int dir,int disp) { HADRONS_ERROR(Definition, "OpDir() undefined"); };
-    void Op     (const Field &in, Field &out) { HADRONS_ERROR(Definition, "Op() undefined"); };
-    void AdjOp  (const Field &in, Field &out) { HADRONS_ERROR(Definition, "AdjOp() undefined"); };
-    void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2) { HADRONS_ERROR(Definition, "HermOpAndNorm() undefined"); };
-    void HermOp(const Field &in, Field &out) { operator()(in,out); };
-};
-
-template<typename Field>
-class Laplacian3DHerm : public LinearFunction<Field> {
-public:
-    OperatorFunction<Field>   & poly_;
-    LinearOperatorBase<Field> &Linop_;
-    Laplacian3DHerm(OperatorFunction<Field> & poly,LinearOperatorBase<Field>& linop)
-    : poly_{poly}, Linop_{linop} {}
-    void operator()(const Field& in, Field& out)
-    {
-        poly_(Linop_,in,out);
-    }
-};
-
-/******************************************************************************
- Calculate low-mode eigenvalues of the Laplacian
- ******************************************************************************/
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TLapEvec<GImpl>::execute(void)
-{
-    const ChebyshevParameters &ChebPar{par().Cheby};
-    const LanczosParameters   &LPar{par().Lanczos};
-    
-    // Disable IRL logging if requested
-    LOG(Message) << "IRLLog=" << LPar.IRLLog << std::endl;
-    const int PreviousIRLLogState{GridLogIRL.isActive()};
-    GridLogIRL.Active( LPar.IRLLog == 0 ? 0 : 1 );
-    
-    // Stout smearing
-    envGetTmp(GaugeField, Umu_smear);
-    Umu_smear = envGet(GaugeField, par().gauge); // The smeared field starts off as the Gauge field
-    LOG(Message) << "Initial plaquette: " << WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu_smear) << std::endl;
-    const StoutParameters &Stout{par().Stout};
-    if( Stout.steps )
-    {
-        envGetTmp(GaugeField, Umu_stout);
-        Smear_Stout<PeriodicGimplR> LS(Stout.rho, Tdir); // spatial smearing only
-        for (int i = 0; i < Stout.steps; i++) {
-            LS.smear(Umu_stout, Umu_smear);
-            Umu_smear = Umu_stout;
-        }
-        LOG(Message) << "Smeared plaquette: " << WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu_smear) << std::endl;
-    }
-    
-    ////////////////////////////////////////////////////////////////////////
-    // Invert nabla operator separately on each time-slice
-    ////////////////////////////////////////////////////////////////////////
-    
-    auto & eig4d = envGet(LapEvecs, getName() );
-    envGetTmp(std::vector<LapEvecs>, eig);   // Eigenpack for each timeslice
-    envGetTmp(LatticeGaugeField, UmuNoTime); // Gauge field without time dimension
-    envGetTmp(LatticeColourVector, src);
-    GridCartesian * gridHD = env().getGrid();
-    const int Ntlocal{gridHD->LocalDimensions()[Tdir]};
-    const int Ntfirst{gridHD->LocalStarts()[Tdir]};
-    uint32_t ConvergenceErrors{0};
-    const int NtFull{env().getDim(Tdir)};
-    TimesliceEvals Evals{ NtFull, LPar.Nvec };
-    for (int t = 0; t < NtFull; t++)
-        for (int v = 0; v < LPar.Nvec; v++)
-            Evals.tensor( t, v ) = 0;
-    for (int t = 0; t < Ntlocal; t++ )
-    {
-        LOG(Message) << "------------------------------------------------------------" << std::endl;
-        LOG(Message) << " Compute eigenpack, local timeslice = " << t << " / " << Ntlocal << std::endl;
-        LOG(Message) << "------------------------------------------------------------" << std::endl;
-        eig[t].resize(LPar.Nk+LPar.Np,gridLD.get());
-        
-        // Construct smearing operator
-        ExtractSliceLocal(UmuNoTime,Umu_smear,0,t,Tdir); // switch to 3d/4d objects
-        Laplacian3D<LatticeColourVector> Nabla(UmuNoTime);
-        LOG(Message) << "Chebyshev preconditioning to order " << ChebPar.PolyOrder
-                     << " with parameters (alpha,beta) = (" << ChebPar.alpha << "," << ChebPar.beta << ")" << std::endl;
-        Chebyshev<LatticeColourVector> Cheb(ChebPar.alpha,ChebPar.beta,ChebPar.PolyOrder);
-        
-        // Construct source vector according to Test_dwf_compressed_lanczos.cc
-        src = 11.0; // NB: This is a dummy parameter and just needs to be non-zero
-        RealD nn = norm2(src);
-        nn = Grid::sqrt(nn);
-        src = src * (1.0/nn);
-        
-        Laplacian3DHerm<LatticeColourVector> NablaCheby(Cheb,Nabla);
-        ImplicitlyRestartedLanczos<LatticeColourVector>
-        IRL(NablaCheby,Nabla,LPar.Nvec,LPar.Nk,LPar.Nk+LPar.Np,LPar.resid,LPar.MaxIt);
-        int Nconv = 0;
-        IRL.calc(eig[t].eval,eig[t].evec,src,Nconv);
-        if (Nconv < LPar.Nvec)
-        {
-            // NB: Can't assert here since we are processing local slices - i.e. not all nodes would assert
-            ConvergenceErrors = 1;
-            LOG(Error) << "MDistil::LapEvec : Not enough eigenvectors converged. If this occurs in practice, we should modify the eigensolver to iterate once more to ensure the second convergence test does not take us below the requested number of eigenvectors" << std::endl;
-        }
-        if( Nconv != LPar.Nvec )
-            eig[t].resize(LPar.Nvec, gridLD.get());
-        RotateEigen( eig[t].evec ); // Rotate the eigenvectors into our phase convention
-        
-        for (int i=0;i<LPar.Nvec;i++){
-            InsertSliceLocal(eig[t].evec[i],eig4d.evec[i],0,t,Tdir);
-            if(t==0 && Ntfirst==0)
-                eig4d.eval[i] = eig[t].eval[i]; // TODO: Discuss: is this needed? Is there a better way?
-            if(gridLD->IsBoss()) // Only do this on one node per timeslice, so a global sum will work
-                Evals.tensor(t + Ntfirst,i) = eig[t].eval[i];
-        }
-    }
-    GridLogIRL.Active( PreviousIRLLogState );
-    gridHD->GlobalSum(ConvergenceErrors);
-    if(ConvergenceErrors!=0)
-    {
-        HADRONS_ERROR(Program,"The eingensolver failed to find enough eigenvectors on at least one node");
-    }
-    // Now write out the 4d eigenvectors
-    std::string sEigenPackName(par().FileName);
-    if( !sEigenPackName.empty() )
-    {
-        eig4d.record.solverXml = parString();
-        ModuleBase * b{vm().getModule(par().gauge)};
-        std::string sOperatorXml{ "<module><id><type>" };
-        sOperatorXml.append( b->getRegisteredName() );
-        sOperatorXml.append( "</type></id><options>" );
-        sOperatorXml.append( b->parString() );
-        sOperatorXml.append( "</options></module>" );
-        eig4d.record.operatorXml = sOperatorXml;
-        sEigenPackName.append(1, '.');
-        std::size_t NameLen{ sEigenPackName.length() };
-        const std::string sTrajNum{std::to_string(vm().getTrajectory())};
-        sEigenPackName.append(sTrajNum);
-        eig4d.write(sEigenPackName,false);
-        // Communicate eig[t].evec to boss-node, save into new object evecs
-        gridHD->GlobalSumVector(EigenIO::getFirstScalar(Evals.tensor),
-                                static_cast<int>(EigenIO::getScalarCount(Evals.tensor)));
-        if(gridHD->IsBoss())
-        {
-            sEigenPackName.resize(NameLen);
-            sEigenPackName.append("evals.");
-            sEigenPackName.append(sTrajNum);
-            Evals.write( sEigenPackName );
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MDistil_LapEvec_hpp_
diff --git a/Hadrons/Modules/MDistil/Noises.cc b/Hadrons/Modules/MDistil/Noises.cc
deleted file mode 100644
index 16576b0d..00000000
--- a/Hadrons/Modules/MDistil/Noises.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/Noises.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MDistil/Noises.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TNoises<FIMPL>;
diff --git a/Hadrons/Modules/MDistil/Noises.hpp b/Hadrons/Modules/MDistil/Noises.hpp
deleted file mode 100644
index bd1a43ff..00000000
--- a/Hadrons/Modules/MDistil/Noises.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/Noises.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_Noises_hpp_
-#define Hadrons_MDistil_Noises_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- *                         Noises                                 *
- ******************************************************************************/
-
-class NoisesPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(NoisesPar,
-                                    std::string, DistilParams,
-                                    std::string, NoiseFileName)
-};
-
-template <typename FImpl>
-class TNoises: public Module<NoisesPar>
-{
-public:
-    // constructor
-    TNoises(const std::string name);
-    // destructor
-    virtual ~TNoises(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Noises, TNoises<FIMPL>, MDistil);
-
-/******************************************************************************
- *                 TNoises implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TNoises<FImpl>::TNoises(const std::string name) : Module<NoisesPar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TNoises<FImpl>::getInput(void)
-{
-    return {par().DistilParams};
-}
-
-template <typename FImpl>
-std::vector<std::string> TNoises<FImpl>::getOutput(void)
-{
-    return {getName()};
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-
-template <typename FImpl>
-void TNoises<FImpl>::setup(void)
-{
-    const DistilParameters &dp{envGet(DistilParameters, par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    std::cout << dp.nnoise << dp.nvec << Nt << Ns << std::endl; 
-    envCreate(NoiseTensor, getName(), 1, dp.nnoise, Nt, dp.nvec, Ns);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TNoises<FImpl>::execute(void)
-{
-    const DistilParameters &dp{envGet(DistilParameters, par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt };
-    const bool exact_distillation{ full_tdil && dp.LI == dp.nvec };
-    
-    // We use our own seeds so we can specify different noises per quark
-    Real rn;
-    auto &noise = envGet(NoiseTensor, getName());
-    for (int inoise = 0; inoise < dp.nnoise; inoise++) 
-    {
-        for (int t = 0; t < Nt; t++) 
-	{
-            for (int ivec = 0; ivec < dp.nvec; ivec++) 
-	    {
-                for (int is = 0; is < Ns; is++) 
-		{
-                    if (exact_distillation)
-		    {
-                        noise.tensor(inoise, t, ivec, is) = 1.;
-		    }
-    		    else
-		    {
-                        random(rngSerial(),rn);
-                        // We could use a greater number of complex roots of unity
-                        // ... but this seems to work well
-                        noise.tensor(inoise, t, ivec, is) = (rn > 0.5) ? -1 : 1;
-                    }
-                }
-            }
-        }
-    }
-    if (env().getGrid()->IsBoss())
-    {
-        std::string sName {par().NoiseFileName};
-        sName.append(".");
-        sName.append(std::to_string(vm().getTrajectory()));
-        noise.write(sName.c_str());
-    }
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif
diff --git a/Hadrons/Modules/MDistil/PerambFromSolve.cc b/Hadrons/Modules/MDistil/PerambFromSolve.cc
deleted file mode 100644
index 69cd0d35..00000000
--- a/Hadrons/Modules/MDistil/PerambFromSolve.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/PerambFromSolve.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MDistil/PerambFromSolve.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TPerambFromSolve<FIMPL>;
diff --git a/Hadrons/Modules/MDistil/PerambFromSolve.hpp b/Hadrons/Modules/MDistil/PerambFromSolve.hpp
deleted file mode 100644
index a0a9b61c..00000000
--- a/Hadrons/Modules/MDistil/PerambFromSolve.hpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/PerambFromSolve.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_PerambFromSolve_hpp_
-#define Hadrons_MDistil_PerambFromSolve_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- *                         PerambFromSolve 
-
-  This module computes a perambulator from an already completed solve. 
-  Optionally, the number of eigenvectors used in the perambulator and the 
-  parameter LI can be chosen to be lower than the ones in the solve, allowing 
-  for a study of the signal with different values of nvec. 
-
-  LI_reduced  : value of LI actually used in the computation
-  nvec_reduced: value of nvec actually used in the computation
-  LI          : value of LI used to compute the 'solve'
-  nvec        : value of nvec used to compute the 'solve'
-
- ******************************************************************************/
-
-class PerambFromSolvePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(PerambFromSolvePar,
-                                    std::string, lapevec,
-                                    std::string, PerambFileName,
-                                    std::string, solve,
-                                    int, nvec_reduced,
-                                    int, LI_reduced,
-                                    std::string, DistilParams);
-};
-
-template <typename FImpl>
-class TPerambFromSolve: public Module<PerambFromSolvePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    // constructor
-    TPerambFromSolve(const std::string name);
-    // destructor
-    virtual ~TPerambFromSolve(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-protected:
-    std::unique_ptr<GridCartesian> grid3d; // Owned by me, so I must delete it
-};
-
-MODULE_REGISTER_TMP(PerambFromSolve, TPerambFromSolve<FIMPL>, MDistil);
-
-/******************************************************************************
- *                 TPerambFromSolve implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TPerambFromSolve<FImpl>::TPerambFromSolve(const std::string name) : Module<PerambFromSolvePar>(name){}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TPerambFromSolve<FImpl>::getInput(void)
-{
-    return {par().solve, par().lapevec, par().DistilParams};
-}
-
-template <typename FImpl>
-std::vector<std::string> TPerambFromSolve<FImpl>::getOutput(void)
-{
-    return std::vector<std::string>{getName()};
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPerambFromSolve<FImpl>::setup(void)
-{
-    const DistilParameters & dp{envGet(MDistil::DistilParameters, par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt };
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-    MakeLowerDimGrid( grid3d, env().getGrid() );
-    const int nvec_reduced{par().nvec_reduced};
-    const int LI_reduced{  par().LI_reduced};
-    envCreate(PerambTensor, getName(), 1, Nt,nvec_reduced,LI_reduced,dp.nnoise,Nt_inv,dp.SI);
-    envCreate(NoiseTensor, getName() + "_noise", 1, dp.nnoise, Nt, dp.nvec, Ns );
-    envTmp(LatticeColourVector, "result3d_nospin",1,LatticeColourVector(grid3d.get()));
-    envTmp(LatticeColourVector, "evec3d",1,LatticeColourVector(grid3d.get()));
-    envTmpLat(LatticeColourVector, "result4d_nospin");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPerambFromSolve<FImpl>::execute(void)
-{
-    GridCartesian * grid4d = env().getGrid();
-    const int Ntlocal{grid4d->LocalDimensions()[3]};
-    const int Ntfirst{grid4d->LocalStarts()[3]};
-    const DistilParameters &dp{envGet(DistilParameters, par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt };
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-    const int nvec_reduced{par().nvec_reduced};
-    const int LI_reduced{  par().LI_reduced};
-    auto &perambulator  = envGet(PerambTensor, getName());
-    auto &solve         = envGet(std::vector<FermionField>, par().solve);
-    auto &epack         = envGet(Grid::Hadrons::EigenPack<LatticeColourVector>, par().lapevec);
-    
-    envGetTmp(LatticeColourVector, result4d_nospin);
-    envGetTmp(LatticeColourVector, result3d_nospin);
-    envGetTmp(LatticeColourVector, evec3d);
-    
-    for (int inoise = 0; inoise < dp.nnoise; inoise++)
-    {
-        for (int dk = 0; dk < LI_reduced; dk++)
-       	{
-            for (int dt = 0; dt < Nt_inv; dt++)
-	    {
-                for (int ds = 0; ds < dp.SI; ds++)
-	       	{
-                    for (int is = 0; is < Ns; is++)
-		    {
-                        result4d_nospin = peekSpin(solve[inoise+dp.nnoise*(dk+dp.LI*(dt+Nt_inv*ds))],is);
-                        for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++)
-		       	{
-                            ExtractSliceLocal(result3d_nospin,result4d_nospin,0,t-Ntfirst,Tdir);
-                            for (int ivec = 0; ivec < nvec_reduced; ivec++)
-			    {
-                                ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
-                                pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result3d_nospin)),is);
-                                LOG(Message) <<  "perambulator(t, ivec, dk, inoise,dt,ds)(is) = (" << t << "," << ivec << "," << dk << "," << inoise << "," << dt << "," << ds << ")(" << is << ") = " <<  perambulator.tensor(t, ivec, dk, inoise,dt,ds)()(is)() << std::endl;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    if(grid4d->IsBoss())
-    {
-        std::string sPerambName{par().PerambFileName};
-        sPerambName.append( "." );
-        sPerambName.append( std::to_string(vm().getTrajectory()));
-        perambulator.write(sPerambName.c_str());
-    }
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif // Hadrons_MDistil_PerambFromSolve_hpp_
diff --git a/Hadrons/Modules/MDistil/Perambulator.cc b/Hadrons/Modules/MDistil/Perambulator.cc
deleted file mode 100644
index 0cd8e5e0..00000000
--- a/Hadrons/Modules/MDistil/Perambulator.cc
+++ /dev/null
@@ -1,61 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/Perambulator.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MDistil/Perambulator.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MDistil;
-
-template class Grid::Hadrons::MDistil::TPerambulator<FIMPL>;
-template class Grid::Hadrons::MDistil::TPerambulator<ZFIMPL>;
-
-BEGIN_HADRONS_NAMESPACE
-
-// Global constants for distillation
-
-#ifdef HAVE_HDF5
-extern const std::string NamedTensorFileExtension{".h5"};
-#else
-extern const std::string NamedTensorFileExtension{".dat"};
-#endif
-
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-const std::string                NoiseTensor::Name__{"Noises"};
-const std::array<std::string, 4> NoiseTensor::DefaultIndexNames__{"nNoise", "nT", "nVec", "nS"};
-
-const std::string                PerambTensor::Name__{"Perambulator"};
-const std::array<std::string, 6> PerambTensor::DefaultIndexNames__{"nT", "nVec", "LI", "nNoise", "nT_inv", "SI"};
-
-const std::string                TimesliceEvals::Name__{"TimesliceEigenValues"};
-const std::array<std::string, 2> TimesliceEvals::DefaultIndexNames__{"nT", "nVec"};
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
diff --git a/Hadrons/Modules/MDistil/Perambulator.hpp b/Hadrons/Modules/MDistil/Perambulator.hpp
deleted file mode 100644
index b59d6c51..00000000
--- a/Hadrons/Modules/MDistil/Perambulator.hpp
+++ /dev/null
@@ -1,288 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/Perambulator.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MDistil_Perambulator_hpp_
-#define Hadrons_MDistil_Perambulator_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-/******************************************************************************
- *                             Perambulator                                    *
- ******************************************************************************/
-
-class PerambulatorPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(PerambulatorPar,
-                                    std::string, lapevec,
-                                    std::string, solver,
-                                    std::string, noise,
-                                    std::string, PerambFileName,
-                                    std::string, UnsmearedSinkFileName,
-                                    std::string, DistilParams);
-};
-
-template <typename FImpl>
-class TPerambulator: public Module<PerambulatorPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-    // constructor
-    TPerambulator(const std::string name);
-    // destructor
-    virtual ~TPerambulator(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-protected:
-    std::unique_ptr<GridCartesian> grid3d; // Owned by me, so I must delete it
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(Perambulator, TPerambulator<FIMPL>, MDistil);
-MODULE_REGISTER_TMP(ZPerambulator, TPerambulator<ZFIMPL>, MDistil);
-
-/******************************************************************************
- *                 TPerambulator implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TPerambulator<FImpl>::TPerambulator(const std::string name) : Module<PerambulatorPar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TPerambulator<FImpl>::getInput(void)
-{
-    return {par().lapevec, par().solver, par().noise, par().DistilParams};
-}
-
-static const std::string UnsmearedSink{ "_unsmeared_sink" };
-
-template <typename FImpl>
-std::vector<std::string> TPerambulator<FImpl>::getOutput(void)
-{
-    // Always return perambulator with name of module
-    std::string objName{ getName() };
-    std::vector<std::string> output{ objName };
-    // If unsmeared sink is specified, then output that as well
-    const std::string UnsmearedSinkFileName{ par().UnsmearedSinkFileName };
-    if( !UnsmearedSinkFileName.empty() )
-    {
-        objName.append( UnsmearedSink );
-        output.push_back( objName );
-    }
-    return output;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPerambulator<FImpl>::setup(void)
-{
-    MakeLowerDimGrid(grid3d, env().getGrid());
-    const DistilParameters &dp = envGet(DistilParameters, par().DistilParams);
-    const int  Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt };
-    const int  Nt_inv{ full_tdil ? 1 : dp.TI };
-
-    std::string objName{ getName() };
-    envCreate(PerambTensor, objName, 1, Nt, dp.nvec, dp.LI, dp.nnoise, Nt_inv, dp.SI);
-    const std::string UnsmearedSinkFileName{ par().UnsmearedSinkFileName };
-    if( !UnsmearedSinkFileName.empty() )
-    {
-        objName.append( UnsmearedSink );
-        envCreate(std::vector<FermionField>, objName, 1, dp.nnoise*dp.LI*Ns*Nt_inv,
-                  envGetGrid(FermionField));
-    }
-    
-    envTmpLat(LatticeSpinColourVector,   "dist_source");
-    envTmpLat(LatticeSpinColourVector,   "source4d");
-    envTmp(LatticeSpinColourVector,      "source3d",1,LatticeSpinColourVector(grid3d.get()));
-    envTmp(LatticeColourVector,          "source3d_nospin",1,LatticeColourVector(grid3d.get()));
-    envTmpLat(LatticeSpinColourVector,   "result4d");
-    envTmpLat(LatticeColourVector,       "result4d_nospin");
-    envTmp(LatticeColourVector,          "result3d_nospin",1,LatticeColourVector(grid3d.get()));
-    envTmp(LatticeColourVector,          "evec3d",1,LatticeColourVector(grid3d.get()));
-    
-    Ls_ = env().getObjectLs(par().solver);
-    envTmpLat(FermionField, "v4dtmp");
-    envTmpLat(FermionField, "v5dtmp", Ls_);
-    envTmpLat(FermionField, "v5dtmp_sol", Ls_);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPerambulator<FImpl>::execute(void)
-{
-    const DistilParameters &dp{ envGet(DistilParameters, par().DistilParams) };
-    const int Nt{env().getDim(Tdir)};
-    const bool full_tdil{ dp.TI == Nt }; 
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-
-    auto &solver=envGet(Solver, par().solver);
-    auto &mat = solver.getFMat();
-    envGetTmp(FermionField, v4dtmp);
-    envGetTmp(FermionField, v5dtmp);
-    envGetTmp(FermionField, v5dtmp_sol);
-    auto &noise = envGet(NoiseTensor, par().noise);
-    std::string objName{ getName() };
-    auto &perambulator = envGet(PerambTensor, objName);
-    auto &epack = envGet(LapEvecs, par().lapevec);
-    objName.append( UnsmearedSink );
-    const std::string UnsmearedSinkFileName{ par().UnsmearedSinkFileName };
-    const bool bSaveUnsmearedSink( !UnsmearedSinkFileName.empty() );
-    envGetTmp(LatticeSpinColourVector, dist_source);
-    envGetTmp(LatticeSpinColourVector, source4d);
-    envGetTmp(LatticeSpinColourVector, source3d);
-    envGetTmp(LatticeColourVector, source3d_nospin);
-    envGetTmp(LatticeSpinColourVector, result4d);
-    envGetTmp(LatticeColourVector, result4d_nospin);
-    envGetTmp(LatticeColourVector, result3d_nospin);
-    envGetTmp(LatticeColourVector, evec3d);
-    GridCartesian * const grid4d{ env().getGrid() }; // Owned by environment (so I won't delete it)
-    const int Ntlocal{grid4d->LocalDimensions()[3]};
-    const int Ntfirst{grid4d->LocalStarts()[3]};
-
-    for (int inoise = 0; inoise < dp.nnoise; inoise++)
-    {
-        for (int dk = 0; dk < dp.LI; dk++)
-        {
-            for (int dt = 0; dt < Nt_inv; dt++)
-            {
-                for (int ds = 0; ds < dp.SI; ds++)
-                {
-                    LOG(Message) <<  "LapH source vector from noise " << inoise << " and dilution component (d_k,d_t,d_alpha) : (" << dk << ","<< dt << "," << ds << ")" << std::endl;
-                    dist_source = 0;
-                    evec3d = 0;
-                    for (int it = dt; it < Nt; it += dp.TI)
-                    {
-                        const int t_inv{full_tdil ? dp.tsrc : it};
-                        if( t_inv >= Ntfirst && t_inv < Ntfirst + Ntlocal )
-                        {
-                            for (int ik = dk; ik < dp.nvec; ik += dp.LI)
-                            {
-                                for (int is = ds; is < Ns; is += dp.SI)
-                                {
-                                    ExtractSliceLocal(evec3d,epack.evec[ik],0,t_inv-Ntfirst,Tdir);
-                                    source3d_nospin = evec3d * noise.tensor(inoise, t_inv, ik, is);
-                                    source3d=0;
-                                    pokeSpin(source3d,source3d_nospin,is);
-                                    source4d=0;
-                                    InsertSliceLocal(source3d,source4d,0,t_inv-Ntfirst,Tdir);
-                                    dist_source += source4d;
-                                }
-                            }
-                        }
-                    }
-                    result4d=0;
-                    v4dtmp = dist_source;
-                    if (Ls_ == 1)
-                        solver(result4d, v4dtmp);
-                    else
-                    {
-                        mat.ImportPhysicalFermionSource(v4dtmp, v5dtmp);
-                        solver(v5dtmp_sol, v5dtmp);
-                        mat.ExportPhysicalFermionSolution(v5dtmp_sol, v4dtmp);
-                        result4d = v4dtmp;
-                    }
-                    if( bSaveUnsmearedSink )
-                    {
-                        auto &unsmeared_sink = envGet(std::vector<FermionField>, objName);
-                        unsmeared_sink[inoise+dp.nnoise*(dk+dp.LI*(dt+Nt_inv*ds))] = result4d;
-                    }
-                    for (int is = 0; is < Ns; is++)
-                    {
-                        result4d_nospin = peekSpin(result4d,is);
-                        for (int t = Ntfirst; t < Ntfirst + Ntlocal; t++)
-                        {
-                            ExtractSliceLocal(result3d_nospin,result4d_nospin,0,t-Ntfirst,Tdir); 
-			    for (int ivec = 0; ivec < dp.nvec; ivec++)
-                            {
-                                ExtractSliceLocal(evec3d,epack.evec[ivec],0,t-Ntfirst,Tdir);
-                                pokeSpin(perambulator.tensor(t, ivec, dk, inoise,dt,ds),static_cast<Complex>(innerProduct(evec3d, result3d_nospin)),is);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-    // Now share my timeslice data with other members of the grid
-    const int NumSlices{grid4d->_processors[Tdir] / grid3d->_processors[Tdir]};
-    if (NumSlices > 1)
-    {
-        LOG(Debug) <<  "Sharing perambulator data with other nodes" << std::endl;
-        const int MySlice {grid4d->_processor_coor[Tdir]};
-        const int SliceCount {static_cast<int>(perambulator.tensor.size()/NumSlices)};
-        PerambTensor::Scalar * const MyData {perambulator.tensor.data()+MySlice*SliceCount};
-        Coordinate coor(Nd);
-        for (int i = 0 ; i < Tdir ; i++) coor[i] = grid4d->_processor_coor[i];
-        std::vector<CommsRequest_t> reqs(0);
-        for (int i = 1; i < NumSlices ; i++)
-        {
-            coor[Tdir] = (MySlice+i)%NumSlices;
-            const int SendRank { grid4d->RankFromProcessorCoor(coor) };
-            const int RecvSlice { ( MySlice - i + NumSlices ) % NumSlices };
-            coor[Tdir] = RecvSlice;
-            const auto RecvRank = grid4d->RankFromProcessorCoor(coor);
-            grid4d->SendToRecvFromBegin(reqs,MyData,SendRank, perambulator.tensor.data()
-                                        + RecvSlice*SliceCount,RecvRank,SliceCount*sizeof(PerambTensor::Scalar));
-        }
-        grid4d->SendToRecvFromComplete(reqs);
-    }
-    
-    // Save the perambulator to disk from the boss node
-    if (grid4d->IsBoss())
-    {
-        std::string sPerambName {par().PerambFileName};
-        sPerambName.append(".");
-        sPerambName.append(std::to_string(vm().getTrajectory()));
-        perambulator.write(sPerambName.c_str());
-    }
-    
-    //Save the unsmeared sinks if filename specified
-    if (bSaveUnsmearedSink)
-    {
-        LOG(Message) << "Writing unsmeared sink to " << UnsmearedSinkFileName << std::endl;
-        auto &unsmeared_sink = envGet(std::vector<FermionField>, objName);
-        A2AVectorsIo::write(UnsmearedSinkFileName, unsmeared_sink, false, vm().getTrajectory());
-    }
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MDistil_Perambulator_hpp_
diff --git a/Hadrons/Modules/MFermion/EMLepton.cc b/Hadrons/Modules/MFermion/EMLepton.cc
deleted file mode 100644
index 891a6286..00000000
--- a/Hadrons/Modules/MFermion/EMLepton.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/EMLepton.cc
-
-Copyright (C) 2015-2019
-
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MFermion/EMLepton.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MFermion;
-
-template class Grid::Hadrons::MFermion::TEMLepton<FIMPL>;
-
diff --git a/Hadrons/Modules/MFermion/EMLepton.hpp b/Hadrons/Modules/MFermion/EMLepton.hpp
deleted file mode 100644
index baae7a7e..00000000
--- a/Hadrons/Modules/MFermion/EMLepton.hpp
+++ /dev/null
@@ -1,315 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/EMLepton.hpp
-
-Copyright (C) 2015-2019
-
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-
-#ifndef Hadrons_MFermion_EMLepton_hpp_
-#define Hadrons_MFermion_EMLepton_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*******************************************************************************
-*
-* Calculates a free lepton propagator with a sequential insertion of 
-* i*\gamma_mu A_mu with a photon field A_mu 
-*
-*	L(x) = \sum_y S(x,y) i*\gamma_mu*A_mu S(y,xl) \delta_{(tl-x0),dt} 
-*
-* with a wall source for the lepton at tl
-*
-* In addition outputs the propagator without photon vertex
-* 
-*	L^{free}(x) =  S(x,xl) \delta_{(tl-x0),dt}
-*
-*
-* options:
-*  - action: fermion action used for propagator (string)
-*  - emField: photon field A_mu (string)
-*  - mass: input mass for the lepton propagator
-*  - boundary: boundary conditions for the lepton propagator, e.g. "1 1 1 -1"
-*  - twist: twisted boundary for lepton propagator, e.g. "0.0 0.0 0.0 0.5"
-*  - deltat: list of source-sink separations
-*
-*******************************************************************************/
-
-
-/******************************************************************************
- *                         EMLepton                                           *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MFermion)
-
-class EMLeptonPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(EMLeptonPar,
-				    std::string,  action,
-				    std::string, emField,
-				    double, mass,
-                                    std::string , boundary,
-				    std::string,  twist,
-				    std::vector<unsigned int>, deltat);
-};
-
-template <typename FImpl>
-class TEMLepton: public Module<EMLeptonPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    typedef PhotonR::GaugeField     EmField;
-public:
-    // constructor
-    TEMLepton(const std::string name);
-    // destructor
-    virtual ~TEMLepton(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(EMLepton, TEMLepton<FIMPL>, MFermion);
-
-/******************************************************************************
- *                 TEMLepton implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TEMLepton<FImpl>::TEMLepton(const std::string name)
-: Module<EMLeptonPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TEMLepton<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().action, par().emField};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TEMLepton<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    for(int i=0; i<par().deltat.size(); i++)
-    {
-	out.push_back(std::to_string(par().deltat[i]) + "_" + getName() + "_free");
-	out.push_back(std::to_string(par().deltat[i]) + "_" + getName());
-    }
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TEMLepton<FImpl>::setup(void)
-{
-    Ls_ = env().getObjectLs(par().action);
-    for(int i=0; i<par().deltat.size(); i++)
-    {
-	envCreateLat(PropagatorField, std::to_string(par().deltat[i]) + "_" + getName() + "_free");
-	envCreateLat(PropagatorField, std::to_string(par().deltat[i]) + "_" + getName());
-    }
-    envTmpLat(FermionField, "source", Ls_);
-    envTmpLat(FermionField, "sol", Ls_);
-    envTmpLat(FermionField, "tmp");
-    envTmpLat(PropagatorField, "sourcetmp");
-    envTmpLat(PropagatorField, "proptmp");
-    envTmpLat(PropagatorField, "freetmp");
-    envTmp(Lattice<iScalar<vInteger>>, "tlat",1, envGetGrid(LatticeComplex));
-
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TEMLepton<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing free fermion propagator '" << getName() << "'"
-                 << std::endl;
-    
-    auto        &mat = envGet(FMat, par().action);
-    RealD mass = par().mass;
-    Complex ci(0.0,1.0);
-    
-    envGetTmp(FermionField, source);
-    envGetTmp(FermionField, sol);
-    envGetTmp(FermionField, tmp);
-    LOG(Message) << "Calculating a lepton Propagator with sequential Aslash insertion with lepton mass " 
-                 << mass << " using the action '" << par().action
-                 << "' for fixed source-sink separation of " << par().deltat << std::endl;
-
-    envGetTmp(Lattice<iScalar<vInteger>>, tlat);
-    LatticeCoordinate(tlat, Tp);
-
-
-    std::vector<double> twist = strToVec<double>(par().twist);
-    if(twist.size() != Nd)
-    {
-	HADRONS_ERROR(Size, "number of twist angles does not match number of dimensions");
-    }
-    std::vector<Complex> boundary = strToVec<Complex>(par().boundary);
-    if(boundary.size() != Nd)
-    {
-	HADRONS_ERROR(Size, "number of boundary conditions does not match number of dimensions");
-    }
-
-    auto &stoch_photon = envGet(EmField,  par().emField);
-    unsigned int nt = env().getDim(Tp);
-
-    envGetTmp(PropagatorField, proptmp);
-    envGetTmp(PropagatorField, freetmp);
-    envGetTmp(PropagatorField, sourcetmp);
-
-    std::vector<int> position;
-    SitePropagator   id;
-    id  = 1.;
-
-    unsigned int tl=0; 
-
-    //wallsource at tl
-    sourcetmp = 1.;
-    sourcetmp = where((tlat == tl), sourcetmp, 0.*sourcetmp);
-
-    //free propagator from pt source 
-    for (unsigned int s = 0; s < Ns; ++s)
-    {
-        LOG(Message) << "Calculation for spin= " << s << std::endl;
-	if (Ls_ == 1)
-	{
-	    PropToFerm<FImpl>(source, sourcetmp, s, 0);
-	}
-	else
-	{
-	    PropToFerm<FImpl>(tmp, sourcetmp, s, 0);
-	    // 5D source if action is 5d
-	    mat.ImportPhysicalFermionSource(tmp, source);
-	}
-        sol = Zero();
-	mat.FreePropagator(source,sol,mass,boundary,twist);
-	if (Ls_ == 1)
-	{
-            FermToProp<FImpl>(freetmp, sol, s, 0);
-	}
-        // create 4D propagators from 5D one if necessary
-        if (Ls_ > 1)
-        {
-            mat.ExportPhysicalFermionSolution(sol, tmp);
-            FermToProp<FImpl>(freetmp, tmp, s, 0);
-        }
-    }
-
-    for(unsigned int dt=0;dt<par().deltat.size();dt++){
-	PropagatorField &lep = envGet(PropagatorField, std::to_string(par().deltat[dt]) + "_" + getName() + "_free");
-	for(tl=0;tl<nt;tl++){
-
-	    //shift free propagator to different source positions
-	    //account for possible anti-periodic boundary in time
-	    proptmp = Cshift(freetmp,Tp, -tl);
-	    proptmp = where( tlat < tl, boundary[Tp]*proptmp, proptmp);
-
-            // free propagator for fixed source-sink separation
-	    lep = where(tlat == (tl-par().deltat[dt]+nt)%nt, proptmp, lep);
-	}
-	//account for possible anti-periodic boundary in time
-	lep = where( tlat >= nt-par().deltat[dt], boundary[Tp]*lep, lep);
-    }
-
-    for(tl=0;tl<nt;tl++){
-
-	//shift free propagator to different source positions
-	//account for possible anti-periodic boundary in time
-	proptmp = Cshift(freetmp,Tp, -tl);
-	proptmp = where( tlat < tl, boundary[Tp]*proptmp, proptmp);
-
-        // i*A_mu*gamma_mu
-        sourcetmp = Zero();
-        for(unsigned int mu=0;mu<=3;mu++)
-        {
-	    Gamma gmu(Gamma::gmu[mu]);
-	    sourcetmp +=  ci * PeekIndex<LorentzIndex>(stoch_photon, mu) *  (gmu * proptmp );
-        }
-
-        proptmp = Zero();
-
-        //sequential propagator from i*Aslash*S
-        LOG(Message) << "Sequential propagator for t= " << tl << std::endl;
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-            LOG(Message) << "Calculation for spin= " << s << std::endl;
-	    if (Ls_ == 1)
-	    {
-		PropToFerm<FImpl>(source, sourcetmp, s, 0);
-	    }
-	    else
-	    {
-		PropToFerm<FImpl>(tmp, sourcetmp, s, 0);
-		// 5D source if action is 5d
-		mat.ImportPhysicalFermionSource(tmp, source);
-	    }
-            sol = Zero();
-	    mat.FreePropagator(source,sol,mass,boundary,twist);
-	    if (Ls_ == 1)
-	    {
-        	FermToProp<FImpl>(proptmp, sol, s, 0);
-	    }
-            // create 4D propagators from 5D one if necessary
-            if (Ls_ > 1)
-            {
-                mat.ExportPhysicalFermionSolution(sol, tmp);
-                FermToProp<FImpl>(proptmp, tmp, s, 0);
-            }
-	}
-	// keep the result for the desired delta t
-	for(unsigned int dt=0;dt<par().deltat.size();dt++){
-	    PropagatorField &Aslashlep = envGet(PropagatorField, std::to_string(par().deltat[dt]) + "_" + getName());
-	    Aslashlep = where(tlat == (tl-par().deltat[dt]+nt)%nt, proptmp, Aslashlep);
-	}
-    }
-
-    //account for possible anti-periodic boundary in time
-    for(unsigned int dt=0;dt<par().deltat.size();dt++){
-	PropagatorField &Aslashlep = envGet(PropagatorField, std::to_string(par().deltat[dt]) + "_" + getName());
-	Aslashlep = where( tlat >= nt-par().deltat[dt], boundary[Tp]*Aslashlep, Aslashlep);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MFermion_EMLepton_hpp_
diff --git a/Hadrons/Modules/MFermion/FreeProp.cc b/Hadrons/Modules/MFermion/FreeProp.cc
deleted file mode 100644
index e35afd2d..00000000
--- a/Hadrons/Modules/MFermion/FreeProp.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/FreeProp.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MFermion/FreeProp.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MFermion;
-
-template class Grid::Hadrons::MFermion::TFreeProp<FIMPL>;
-
diff --git a/Hadrons/Modules/MFermion/FreeProp.hpp b/Hadrons/Modules/MFermion/FreeProp.hpp
deleted file mode 100644
index dcf77802..00000000
--- a/Hadrons/Modules/MFermion/FreeProp.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/FreeProp.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-
-#ifndef Hadrons_MFermion_FreeProp_hpp_
-#define Hadrons_MFermion_FreeProp_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         FreeProp                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MFermion)
-
-class FreePropPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FreePropPar,
-                                    std::string, source,
-				    std::string,  action,
-				    double, mass,
-                                    std::string , boundary,
-				    std::string,  twist);
-};
-
-template <typename FImpl>
-class TFreeProp: public Module<FreePropPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TFreeProp(const std::string name);
-    // destructor
-    virtual ~TFreeProp(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(FreeProp, TFreeProp<FIMPL>, MFermion);
-
-/******************************************************************************
- *                 TFreeProp implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TFreeProp<FImpl>::TFreeProp(const std::string name)
-: Module<FreePropPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TFreeProp<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().source, par().action};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TFreeProp<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName() + "_5d"};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFreeProp<FImpl>::setup(void)
-{
-    Ls_ = env().getObjectLs(par().action);
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(FermionField, "source", Ls_);
-    envTmpLat(FermionField, "sol", Ls_);
-    envTmpLat(FermionField, "tmp");
-    if (Ls_ > 1)
-    {
-        envCreateLat(PropagatorField, getName() + "_5d", Ls_);
-    }    
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFreeProp<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing free fermion propagator '" << getName() << "'"
-                 << std::endl;
-    
-    std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d");
-    auto        &prop    = envGet(PropagatorField, propName);
-    auto        &fullSrc = envGet(PropagatorField, par().source);
-    auto        &mat = envGet(FMat, par().action);
-    RealD mass = par().mass;
-    
-    envGetTmp(FermionField, source);
-    envGetTmp(FermionField, sol);
-    envGetTmp(FermionField, tmp);
-    LOG(Message) << "Calculating a free Propagator with mass " << mass 
-		 << " using the action '" << par().action
-                 << "' on source '" << par().source << "'" << std::endl;
-    for (unsigned int s = 0; s < Ns; ++s)
-      for (unsigned int c = 0; c < FImpl::Dimension; ++c)
-    {
-        LOG(Message) << "Calculation for spin= " << s << ", color= " << c
-                     << std::endl;
-        // source conversion for 4D sources
-        if (!env().isObject5d(par().source))
-        {
-            if (Ls_ == 1)
-            {
-               PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-            else
-            {
-                PropToFerm<FImpl>(tmp, fullSrc, s, c);
-                mat.ImportPhysicalFermionSource(tmp, source);
-            }
-        }
-        // source conversion for 5D sources
-        else
-        {
-            if (Ls_ != env().getObjectLs(par().source))
-            {
-                HADRONS_ERROR(Size, "Ls mismatch between quark action and source");
-            }
-            else
-            {
-                PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-        }
-        sol = Zero();
-	std::vector<double> twist = strToVec<double>(par().twist);
-	if(twist.size() != Nd)
-	{
-	    HADRONS_ERROR(Size, "number of twist angles does not match number of dimensions");
-	}
-	std::vector<Complex> boundary = strToVec<Complex>(par().boundary);
-	if(boundary.size() != Nd)
-	{
-	    HADRONS_ERROR(Size, "number of boundary conditions does not match number of dimensions");
-	}
-	mat.FreePropagator(source,sol,mass,boundary,twist);
-        FermToProp<FImpl>(prop, sol, s, c);
-        // create 4D propagators from 5D one if necessary
-        if (Ls_ > 1)
-        {
-            PropagatorField &p4d = envGet(PropagatorField, getName());
-            mat.ExportPhysicalFermionSolution(sol, tmp);
-            FermToProp<FImpl>(p4d, tmp, s, c);
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MFermion_FreeProp_hpp_
diff --git a/Hadrons/Modules/MFermion/GaugeProp.cc b/Hadrons/Modules/MFermion/GaugeProp.cc
deleted file mode 100644
index 23291714..00000000
--- a/Hadrons/Modules/MFermion/GaugeProp.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/GaugeProp.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MFermion/GaugeProp.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MFermion;
-
-template class Grid::Hadrons::MFermion::TGaugeProp<FIMPL>;
-template class Grid::Hadrons::MFermion::TGaugeProp<ZFIMPL>;
diff --git a/Hadrons/Modules/MFermion/GaugeProp.hpp b/Hadrons/Modules/MFermion/GaugeProp.hpp
deleted file mode 100644
index a11274e6..00000000
--- a/Hadrons/Modules/MFermion/GaugeProp.hpp
+++ /dev/null
@@ -1,196 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/GaugeProp.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Guido Cossu <guido.cossu@ed.ac.uk>
-Author: Lanny91 <andrew.lawson@gmail.com>
-Author: pretidav <david.preti@csic.es>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MFermion_GaugeProp_hpp_
-#define Hadrons_MFermion_GaugeProp_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                GaugeProp                                   *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MFermion)
-
-class GaugePropPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GaugePropPar,
-                                    std::string, source,
-                                    std::string, solver);
-};
-
-template <typename FImpl>
-class TGaugeProp: public Module<GaugePropPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TGaugeProp(const std::string name);
-    // destructor
-    virtual ~TGaugeProp(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-    Solver       *solver_{nullptr};
-};
-
-MODULE_REGISTER_TMP(GaugeProp, TGaugeProp<FIMPL>, MFermion);
-MODULE_REGISTER_TMP(ZGaugeProp, TGaugeProp<ZFIMPL>, MFermion);
-
-/******************************************************************************
- *                      TGaugeProp implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TGaugeProp<FImpl>::TGaugeProp(const std::string name)
-: Module<GaugePropPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TGaugeProp<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().source, par().solver};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TGaugeProp<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName() + "_5d"};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TGaugeProp<FImpl>::setup(void)
-{
-    Ls_ = env().getObjectLs(par().solver);
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(FermionField, "tmp");
-    if (Ls_ > 1)
-    {
-        envTmpLat(FermionField, "source", Ls_);
-        envTmpLat(FermionField, "sol", Ls_);
-        envCreateLat(PropagatorField, getName() + "_5d", Ls_);
-    }
-    else
-    {
-       envTmpLat(FermionField, "source");
-       envTmpLat(FermionField, "sol");
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TGaugeProp<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing quark propagator '" << getName() << "'"
-                 << std::endl;
-    
-    std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d");
-    auto        &prop    = envGet(PropagatorField, propName);
-    auto        &fullSrc = envGet(PropagatorField, par().source);
-    auto        &solver  = envGet(Solver, par().solver);
-    auto        &mat     = solver.getFMat();
-    
-    envGetTmp(FermionField, source);
-    envGetTmp(FermionField, sol);
-    envGetTmp(FermionField, tmp);
-    LOG(Message) << "Inverting using solver '" << par().solver
-                 << "' on source '" << par().source << "'" << std::endl;
-    for (unsigned int s = 0; s < Ns; ++s)
-    for (unsigned int c = 0; c < FImpl::Dimension; ++c)
-    {
-        LOG(Message) << "Inversion for spin= " << s << ", color= " << c
-                     << std::endl;
-        // source conversion for 4D sources
-        LOG(Message) << "Import source" << std::endl;
-        if (!env().isObject5d(par().source))
-        {
-            if (Ls_ == 1)
-            {
-               PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-            else
-            {
-                PropToFerm<FImpl>(tmp, fullSrc, s, c);
-                mat.ImportPhysicalFermionSource(tmp, source);
-            }
-        }
-        // source conversion for 5D sources
-        else
-        {
-            if (Ls_ != env().getObjectLs(par().source))
-            {
-                HADRONS_ERROR(Size, "Ls mismatch between quark action and source");
-            }
-            else
-            {
-                PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-        }
-        sol = Zero();
-        LOG(Message) << "Solve" << std::endl;
-        solver(sol, source);
-        LOG(Message) << "Export solution" << std::endl;
-        FermToProp<FImpl>(prop, sol, s, c);
-        // create 4D propagators from 5D one if necessary
-        if (Ls_ > 1)
-        {
-            PropagatorField &p4d = envGet(PropagatorField, getName());
-            mat.ExportPhysicalFermionSolution(sol, tmp);
-            FermToProp<FImpl>(p4d, tmp, s, c);
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MFermion_GaugeProp_hpp_
diff --git a/Hadrons/Modules/MGauge/Electrify.cc b/Hadrons/Modules/MGauge/Electrify.cc
deleted file mode 100644
index 1ad98ab2..00000000
--- a/Hadrons/Modules/MGauge/Electrify.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Electrify.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Electrify.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TElectrify<GIMPL>;
diff --git a/Hadrons/Modules/MGauge/Electrify.hpp b/Hadrons/Modules/MGauge/Electrify.hpp
deleted file mode 100644
index 4f34eef3..00000000
--- a/Hadrons/Modules/MGauge/Electrify.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Electrify.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGauge_Electrify_hpp_
-#define Hadrons_MGauge_Electrify_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              Electrify gauge                               *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-/****************************************************************************
-*  Electrify a gauge field:
-*
-*  Ue_mu(x) = U_mu(x)*exp(ieqA_mu(x))
-*
-*  with
-*
-*  - gauge: U_mu(x): gauge field
-*  - emField: A_mu(x): electromagnetic photon field
-*  - e: value for the elementary charge
-*  - q: charge in units of e
-*
-*****************************************************************************/
-
-
-class ElectrifyPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ElectrifyPar,
-                                    std::string, gauge,
-				    std::string, emField,
-				    double, e,
-				    double, charge);
-};
-
-template <typename GImpl>
-class TElectrify: public Module<ElectrifyPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    typedef PhotonR::GaugeField     EmField;
-public:
-    // constructor
-    TElectrify(const std::string name);
-    // destructor
-    virtual ~TElectrify(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Electrify, TElectrify<GIMPL>, MGauge);
-
-/******************************************************************************
-*                            TElectrify implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TElectrify<GImpl>::TElectrify(const std::string name)
-: Module<ElectrifyPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TElectrify<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge, par().emField};
-
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TElectrify<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TElectrify<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-    envTmpLat(LatticeComplex, "eiAmu");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TElectrify<GImpl>::execute(void)
-{
-    LOG(Message) << "Electrify the gauge field " << par().gauge << " using the photon field " 
-                  << par().emField << " with charge e*q= " << par().e << "*" << par().charge << std::endl;
-    
-    auto &Ue = envGet(GaugeField, getName());
-    auto &U = envGet(GaugeField, par().gauge);
-    auto &A = envGet(EmField,  par().emField);
-    envGetTmp(LatticeComplex, eiAmu);
-
-    Complex i(0.0,1.0);
-
-    for(unsigned int mu = 0; mu < env().getNd(); mu++)
-    {
-	eiAmu = exp(i * (Real)(par().e * par().charge) * PeekIndex<LorentzIndex>(A, mu));
-	PokeIndex<LorentzIndex>(Ue, PeekIndex<LorentzIndex>(U, mu) * eiAmu, mu);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_Electrify_hpp_
diff --git a/Hadrons/Modules/MGauge/FundtoHirep.cc b/Hadrons/Modules/MGauge/FundtoHirep.cc
deleted file mode 100644
index f5b1385f..00000000
--- a/Hadrons/Modules/MGauge/FundtoHirep.cc
+++ /dev/null
@@ -1,79 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/FundtoHirep.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Guido Cossu <guido.cossu@ed.ac.uk>
-Author: pretidav <david.preti@csic.es>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MGauge/FundtoHirep.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-// constructor /////////////////////////////////////////////////////////////////
-template <class Rep>
-TFundtoHirep<Rep>::TFundtoHirep(const std::string name)
-: Module<FundtoHirepPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <class Rep>
-std::vector<std::string> TFundtoHirep<Rep>::getInput(void)
-{
-    std::vector<std::string> in = {par().gaugeconf};
-
-    return in;
-}
-
-template <class Rep>
-std::vector<std::string> TFundtoHirep<Rep>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Rep>
-void TFundtoHirep<Rep>::setup(void)
-{
-    envCreateLat(Rep::LatticeField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <class Rep>
-void TFundtoHirep<Rep>::execute(void)
-{
-    LOG(Message) << "Transforming Representation" << std::endl;
-
-    auto &U    = envGet(LatticeGaugeField, par().gaugeconf);
-    auto &URep = envGet(Rep::LatticeField, getName());
-
-    Rep TargetRepresentation(U._grid);
-    TargetRepresentation.update_representation(U);
-    URep = TargetRepresentation.U;
-}
diff --git a/Hadrons/Modules/MGauge/FundtoHirep.hpp b/Hadrons/Modules/MGauge/FundtoHirep.hpp
deleted file mode 100644
index 345520f4..00000000
--- a/Hadrons/Modules/MGauge/FundtoHirep.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/FundtoHirep.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: pretidav <david.preti@csic.es>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGauge_FundtoHirep_hpp_
-#define Hadrons_MGauge_FundtoHirep_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Load a NERSC configuration                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class FundtoHirepPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FundtoHirepPar,
-                                    std::string, gaugeconf);
-};
-
-template <class Rep>
-class TFundtoHirep: public Module<FundtoHirepPar>
-{
-public:
-    // constructor
-    TFundtoHirep(const std::string name);
-    // destructor
-    virtual ~TFundtoHirep(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    void setup(void);
-    // execution
-    void execute(void);
-};
-
-//MODULE_REGISTER_TMP(FundtoAdjoint,   TFundtoHirep<AdjointRepresentation>, MGauge);
-//MODULE_REGISTER_TMP(FundtoTwoIndexSym, TFundtoHirep<TwoIndexSymmetricRepresentation>, MGauge);
-//MODULE_REGISTER_TMP(FundtoTwoIndexAsym, TFundtoHirep<TwoIndexAntiSymmetricRepresentation>, MGauge);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_FundtoHirep_hpp_
diff --git a/Hadrons/Modules/MGauge/GaugeFix.cc b/Hadrons/Modules/MGauge/GaugeFix.cc
deleted file mode 100644
index 3a90ec36..00000000
--- a/Hadrons/Modules/MGauge/GaugeFix.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/GaugeFix.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MGauge/GaugeFix.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TGaugeFix<GIMPL>;
diff --git a/Hadrons/Modules/MGauge/GaugeFix.hpp b/Hadrons/Modules/MGauge/GaugeFix.hpp
deleted file mode 100644
index f5ebb39f..00000000
--- a/Hadrons/Modules/MGauge/GaugeFix.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/GaugeFix.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Nils Asmussen <n.asmussen@soton.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGaugeFix_hpp_
-#define Hadrons_MGaugeFix_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/qcd/utils/GaugeFix.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              Fix gauge                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-GRID_SERIALIZABLE_ENUM(Fix, undef, coulomb, Nd - 1, landau, -1);
-
-class GaugeFixPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GaugeFixPar,
-                                    std::string, gauge,
-                                    Real,  alpha,
-                                    int, maxiter, 
-                                    Real, Omega_tol, 
-                                    Real, Phi_tol,
-                                    Fix,  gaugeFix,
-                                    bool, Fourier);
-};
-
-template <typename GImpl>
-class TGaugeFix: public Module<GaugeFixPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-    typedef typename GImpl::GaugeLinkField GaugeMat;
-public:
-    // constructor
-    TGaugeFix(const std::string name);
-    // destructor
-    virtual ~TGaugeFix(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(GaugeFix, TGaugeFix<GIMPL>, MGauge);
-
-/******************************************************************************
-*                            TGaugeFix implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TGaugeFix<GImpl>::TGaugeFix(const std::string name)
-: Module<GaugeFixPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TGaugeFix<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TGaugeFix<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName()+"_xform"};
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TGaugeFix<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-    envCreateLat(GaugeMat, getName()+"_xform");
-}
-
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TGaugeFix<GImpl>::execute(void)
-//Loads the gauge and fixes it
-{
-    std::cout << "executing" << std::endl;
-    LOG(Message) << "Fixing the Gauge " << par().gauge << " using "
-                 << par().gaugeFix << " guage fixing. " << Nd - 1 << std::endl;
-    auto &U     = envGet(GaugeField, par().gauge);
-    auto &Umu   = envGet(GaugeField, getName());
-    auto &xform = envGet(GaugeMat, getName()+"_xform");
-    LOG(Message) << "Gauge Field fetched" << std::endl;
-    //do we allow maxiter etc to be user set?
-    Real alpha     = par().alpha;
-    int  maxiter   = par().maxiter;
-    Real Omega_tol = par().Omega_tol;
-    Real Phi_tol   = par().Phi_tol;
-    int  gaugeFix  = par().gaugeFix;
-    bool Fourier   = par().Fourier;
-    Umu = U;
-    FourierAcceleratedGaugeFixer<PeriodicGimplR>::SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier,gaugeFix);
-    LOG(Message) << "Gauge Fixed" << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGaugeFix_hpp_
diff --git a/Hadrons/Modules/MGauge/Random.cc b/Hadrons/Modules/MGauge/Random.cc
deleted file mode 100644
index b5fa4b94..00000000
--- a/Hadrons/Modules/MGauge/Random.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Random.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Random.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TRandom<GIMPL>;
diff --git a/Hadrons/Modules/MGauge/Random.hpp b/Hadrons/Modules/MGauge/Random.hpp
deleted file mode 100644
index 358e3b79..00000000
--- a/Hadrons/Modules/MGauge/Random.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Random.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGauge_Random_hpp_
-#define Hadrons_MGauge_Random_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                             Random gauge                                   *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-template <typename GImpl>
-class TRandom: public Module<NoPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TRandom(const std::string name);
-    // destructor
-    virtual ~TRandom(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Random, TRandom<GIMPL>, MGauge);
-
-/******************************************************************************
-*                           TRandom implementation                            *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TRandom<GImpl>::TRandom(const std::string name)
-: Module<NoPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TRandom<GImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TRandom<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TRandom<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TRandom<GImpl>::execute(void)
-{
-    LOG(Message) << "Generating random gauge configuration" << std::endl;
-    
-    auto &U = envGet(GaugeField, getName());
-    GImpl::HotConfiguration(rng4d(), U);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_Random_hpp_
diff --git a/Hadrons/Modules/MGauge/StochEm.cc b/Hadrons/Modules/MGauge/StochEm.cc
deleted file mode 100644
index 3b718c9f..00000000
--- a/Hadrons/Modules/MGauge/StochEm.cc
+++ /dev/null
@@ -1,85 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StochEm.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/StochEm.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-/******************************************************************************
-*                  TStochEm implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TStochEm::TStochEm(const std::string name)
-: Module<StochEmPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TStochEm::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-std::vector<std::string> TStochEm::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TStochEm::setup(void)
-{
-    weightDone_ = env().hasCreatedObject("_" + getName() + "_weight");
-    envCacheLat(EmComp, "_" + getName() + "_weight");
-    envCreateLat(EmField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TStochEm::execute(void)
-{
-    LOG(Message) << "Generating stochastic EM potential..." << std::endl;
-
-    std::vector<Real> improvements = strToVec<Real>(par().improvement);
-    PhotonR photon(envGetGrid(EmField), par().gauge, par().zmScheme, improvements);
-    auto    &a = envGet(EmField, getName());
-    auto    &w = envGet(EmComp, "_" + getName() + "_weight");
-    
-    if (!weightDone_)
-    {
-        LOG(Message) << "Caching stochastic EM potential weight (gauge: "
-                     << par().gauge << ", zero-mode scheme: "
-                     << par().zmScheme << ")..." << std::endl;
-        photon.StochasticWeight(w);
-    }
-    photon.StochasticField(a, rng4d(), w);
-}
diff --git a/Hadrons/Modules/MGauge/StochEm.hpp b/Hadrons/Modules/MGauge/StochEm.hpp
deleted file mode 100644
index 2b521b17..00000000
--- a/Hadrons/Modules/MGauge/StochEm.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StochEm.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MGauge_StochEm_hpp_
-#define Hadrons_MGauge_StochEm_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         StochEm                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class StochEmPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StochEmPar,
-                                    PhotonR::Gauge,    gauge,
-                                    PhotonR::ZmScheme, zmScheme,
-                                    std::string,       improvement);
-};
-
-class TStochEm: public Module<StochEmPar>
-{
-public:
-    typedef PhotonR::GaugeField     EmField;
-    typedef PhotonR::GaugeLinkField EmComp;
-public:
-    // constructor
-    TStochEm(const std::string name);
-    // destructor
-    virtual ~TStochEm(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool    weightDone_;
-};
-
-MODULE_REGISTER(StochEm, TStochEm, MGauge);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_StochEm_hpp_
diff --git a/Hadrons/Modules/MGauge/StoutSmearing.cc b/Hadrons/Modules/MGauge/StoutSmearing.cc
deleted file mode 100644
index a17efb39..00000000
--- a/Hadrons/Modules/MGauge/StoutSmearing.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StoutSmearing.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/StoutSmearing.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TStoutSmearing<GIMPL>;
diff --git a/Hadrons/Modules/MGauge/StoutSmearing.hpp b/Hadrons/Modules/MGauge/StoutSmearing.hpp
deleted file mode 100644
index 661e0944..00000000
--- a/Hadrons/Modules/MGauge/StoutSmearing.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StoutSmearing.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MGauge_StoutSmearing_hpp_
-#define Hadrons_MGauge_StoutSmearing_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                            Stout smearing                                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class StoutSmearingPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StoutSmearingPar,
-                                    std::string, gauge,
-                                    unsigned int, steps,
-                                    double, rho);
-};
-
-template <typename GImpl>
-class TStoutSmearing: public Module<StoutSmearingPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TStoutSmearing(const std::string name);
-    // destructor
-    virtual ~TStoutSmearing(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(StoutSmearing, TStoutSmearing<GIMPL>, MGauge);
-
-/******************************************************************************
- *                     TStoutSmearing implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TStoutSmearing<GImpl>::TStoutSmearing(const std::string name)
-: Module<StoutSmearingPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TStoutSmearing<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TStoutSmearing<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TStoutSmearing<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-    envTmpLat(GaugeField, "buf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TStoutSmearing<GImpl>::execute(void)
-{
-    LOG(Message) << "Smearing '" << par().gauge << "' with " << par().steps
-                 << " step" << ((par().steps > 1) ? "s" : "") 
-                 << " of stout smearing and rho= " << par().rho << std::endl;
-
-    Smear_Stout<GImpl> smearer(par().rho);
-    auto               &U    = envGet(GaugeField, par().gauge);
-    auto               &Usmr = envGet(GaugeField, getName());
-
-    envGetTmp(GaugeField, buf);
-    buf = U;
-    LOG(Message) << "plaquette= " << WilsonLoops<GImpl>::avgPlaquette(U)
-                 << std::endl;
-    for (unsigned int n = 0; n < par().steps; ++n)
-    {
-        smearer.smear(Usmr, buf);
-        buf = Usmr;
-        LOG(Message) << "plaquette= " << WilsonLoops<GImpl>::avgPlaquette(Usmr)
-                     << std::endl;
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_StoutSmearing_hpp_
diff --git a/Hadrons/Modules/MGauge/Unit.cc b/Hadrons/Modules/MGauge/Unit.cc
deleted file mode 100644
index 087132b5..00000000
--- a/Hadrons/Modules/MGauge/Unit.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Unit.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Unit.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TUnit<GIMPL>;
diff --git a/Hadrons/Modules/MGauge/Unit.hpp b/Hadrons/Modules/MGauge/Unit.hpp
deleted file mode 100644
index ff0d116d..00000000
--- a/Hadrons/Modules/MGauge/Unit.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Unit.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGauge_Unit_hpp_
-#define Hadrons_MGauge_Unit_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              Unit gauge                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-template <typename GImpl>
-class TUnit: public Module<NoPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TUnit(const std::string name);
-    // destructor
-    virtual ~TUnit(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Unit, TUnit<GIMPL>, MGauge);
-
-/******************************************************************************
-*                            TUnit implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TUnit<GImpl>::TUnit(const std::string name)
-: Module<NoPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TUnit<GImpl>::getInput(void)
-{
-    return std::vector<std::string>();
-}
-
-template <typename GImpl>
-std::vector<std::string> TUnit<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TUnit<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TUnit<GImpl>::execute(void)
-{
-    LOG(Message) << "Creating unit gauge configuration" << std::endl;
-    
-    auto &U = envGet(GaugeField, getName());
-    GImpl::ColdConfiguration(rng4d(), U);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_Unit_hpp_
diff --git a/Hadrons/Modules/MGauge/UnitEm.cc b/Hadrons/Modules/MGauge/UnitEm.cc
deleted file mode 100644
index d551e0fe..00000000
--- a/Hadrons/Modules/MGauge/UnitEm.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/UnitEm.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/UnitEm.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-/******************************************************************************
-*                  TStochEm implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TUnitEm::TUnitEm(const std::string name)
-: Module<NoPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TUnitEm::getInput(void)
-{
-    return std::vector<std::string>();
-}
-
-std::vector<std::string> TUnitEm::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TUnitEm::setup(void)
-{
-    envCreateLat(EmField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TUnitEm::execute(void)
-{
-    PhotonR photon(envGetGrid(EmField), 0, 0); // Just chose arbitrary input values here
-    auto    &a = envGet(EmField, getName());
-    LOG(Message) << "Generating unit EM potential..." << std::endl;
-    photon.UnitField(a);
-}
diff --git a/Hadrons/Modules/MGauge/UnitEm.hpp b/Hadrons/Modules/MGauge/UnitEm.hpp
deleted file mode 100644
index 3277f211..00000000
--- a/Hadrons/Modules/MGauge/UnitEm.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/UnitEm.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MGauge_UnitEm_hpp_
-#define Hadrons_MGauge_UnitEm_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         StochEm                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class TUnitEm: public Module<NoPar>
-{
-public:
-    typedef PhotonR::GaugeField     EmField;
-    typedef PhotonR::GaugeLinkField EmComp;
-public:
-    // constructor
-    TUnitEm(const std::string name);
-    // destructor
-    virtual ~TUnitEm(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER(UnitEm, TUnitEm, MGauge);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_UnitEm_hpp_
diff --git a/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.cc b/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.cc
deleted file mode 100644
index 696e159c..00000000
--- a/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadA2AMatrixDiskVector<FIMPL>;
diff --git a/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.hpp b/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.hpp
deleted file mode 100644
index d7799a37..00000000
--- a/Hadrons/Modules/MIO/LoadA2AMatrixDiskVector.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-#ifndef Hadrons_MIO_LoadA2AMatrixDiskVector_hpp_
-#define Hadrons_MIO_LoadA2AMatrixDiskVector_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-#include <Hadrons/DiskVector.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         LoadA2AMatrixDiskVector                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadA2AMatrixDiskVectorPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadA2AMatrixDiskVectorPar,
-                                    std::string,  file,
-                                    std::string,  dataset,
-                                    std::string,  diskVectorDir,
-                                    int,  cacheSize);
-};
-
-template <typename FImpl>
-class TLoadA2AMatrixDiskVector: public Module<LoadA2AMatrixDiskVectorPar>
-{
-  public:
-    FERM_TYPE_ALIASES(FImpl, );
-    // constructor
-    TLoadA2AMatrixDiskVector(const std::string name);
-    // destructor
-    virtual ~TLoadA2AMatrixDiskVector(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadA2AMatrixDiskVector, TLoadA2AMatrixDiskVector<FIMPL>, MIO);
-
-/******************************************************************************
- *                 TLoadA2AMatrixDiskVector implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TLoadA2AMatrixDiskVector<FImpl>::TLoadA2AMatrixDiskVector(const std::string name)
-: Module<LoadA2AMatrixDiskVectorPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TLoadA2AMatrixDiskVector<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TLoadA2AMatrixDiskVector<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadA2AMatrixDiskVector<FImpl>::setup(void)
-{
-    int Ls = 1;
-
-    std::string dvDir = par().diskVectorDir;
-    std::string dataset = par().dataset;
-    std::string dvFile = dvDir + "/" + getName() + "." + std::to_string(vm().getTrajectory());
-
-    int nt = env().getDim(Tp);
-    int cacheSize = par().cacheSize;
-    bool clean = true;
-    GridBase *grid = envGetGrid(FermionField);
-
-    envCreate(EigenDiskVector<ComplexD>, getName(), Ls, dvFile, nt, cacheSize, clean, grid);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadA2AMatrixDiskVector<FImpl>::execute(void)
-{
-    int nt = env().getDim(Tp);
-    std::string file  = par().file;
-    std::string dataset  = par().dataset;
-    GridBase *grid = envGetGrid(FermionField);
-
-    auto &mesonFieldDV = envGet(EigenDiskVector<ComplexD>, getName());
-
-    int traj = vm().getTrajectory();
-    tokenReplace(file, "traj", traj);
-    LOG(Message) << "-- Loading '" << file << "'-- " << std::endl;
-    double t;
-    A2AMatrixIo<HADRONS_A2AM_IO_TYPE> mfIO(file, dataset, nt);
-    mfIO.load(mesonFieldDV, &t, grid);
-    LOG(Message) << "Read " << mfIO.getSize() << " bytes in " << t << " usec, " << mfIO.getSize() / t * 1.0e6 / 1024 / 1024 << " MB/s" << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadA2AMatrixDiskVector_hpp_
diff --git a/Hadrons/Modules/MIO/LoadA2AVectors.cc b/Hadrons/Modules/MIO/LoadA2AVectors.cc
deleted file mode 100644
index ba1df2ad..00000000
--- a/Hadrons/Modules/MIO/LoadA2AVectors.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadA2AVectors.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadA2AVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadA2AVectors<FIMPL>;
diff --git a/Hadrons/Modules/MIO/LoadA2AVectors.hpp b/Hadrons/Modules/MIO/LoadA2AVectors.hpp
deleted file mode 100644
index 997fc107..00000000
--- a/Hadrons/Modules/MIO/LoadA2AVectors.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadA2AVectors.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadA2AVectors_hpp_
-#define Hadrons_MIO_LoadA2AVectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AVectors.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                    Module to load all-to-all vectors                       *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadA2AVectorsPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadA2AVectorsPar,
-                                    std::string,  filestem,
-                                    bool,         multiFile,
-                                    unsigned int, size);
-};
-
-template <typename FImpl>
-class TLoadA2AVectors: public Module<LoadA2AVectorsPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TLoadA2AVectors(const std::string name);
-    // destructor
-    virtual ~TLoadA2AVectors(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadA2AVectors, TLoadA2AVectors<FIMPL>, MIO);
-
-/******************************************************************************
- *                      TLoadA2AVectors implementation                        *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TLoadA2AVectors<FImpl>::TLoadA2AVectors(const std::string name)
-: Module<LoadA2AVectorsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TLoadA2AVectors<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TLoadA2AVectors<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadA2AVectors<FImpl>::setup(void)
-{
-    envCreate(std::vector<FermionField>, getName(), 1, par().size, 
-              envGetGrid(FermionField));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadA2AVectors<FImpl>::execute(void)
-{
-    auto &vec = envGet(std::vector<FermionField>, getName());
-
-    A2AVectorsIo::read(vec, par().filestem, par().multiFile, vm().getTrajectory());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadA2AVectors_hpp_
diff --git a/Hadrons/Modules/MIO/LoadBinary.cc b/Hadrons/Modules/MIO/LoadBinary.cc
deleted file mode 100644
index 48a909e2..00000000
--- a/Hadrons/Modules/MIO/LoadBinary.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadBinary.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadBinary.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadBinary<GIMPL>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MIO/LoadBinary.hpp b/Hadrons/Modules/MIO/LoadBinary.hpp
deleted file mode 100644
index 48dfccdc..00000000
--- a/Hadrons/Modules/MIO/LoadBinary.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadBinary.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadBinary_hpp_
-#define Hadrons_MIO_LoadBinary_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Load a binary configurations                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadBinaryPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadBinaryPar,
-                                    std::string, file,
-                                    std::string, format);
-};
-
-template <typename Impl>
-class TLoadBinary: public Module<LoadBinaryPar>
-{
-public:
-    typedef typename Impl::Field                  Field;
-    typedef typename Impl::Simd                   Simd;
-    typedef typename Field::vector_object         vobj;
-    typedef typename vobj::scalar_object          sobj;
-    typedef typename sobj::DoublePrecision        sobj_double;
-    typedef BinarySimpleMunger<sobj_double, sobj> Munger;
-public:
-    // constructor
-    TLoadBinary(const std::string name);
-    // destructor
-    virtual ~TLoadBinary(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadBinary, TLoadBinary<GIMPL>, MIO);
-MODULE_REGISTER_TMP(LoadBinaryScalarSU2, TLoadBinary<ScalarNxNAdjImplR<2>>, MIO);
-MODULE_REGISTER_TMP(LoadBinaryScalarSU3, TLoadBinary<ScalarNxNAdjImplR<3>>, MIO);
-MODULE_REGISTER_TMP(LoadBinaryScalarSU4, TLoadBinary<ScalarNxNAdjImplR<4>>, MIO);
-MODULE_REGISTER_TMP(LoadBinaryScalarSU5, TLoadBinary<ScalarNxNAdjImplR<5>>, MIO);
-MODULE_REGISTER_TMP(LoadBinaryScalarSU6, TLoadBinary<ScalarNxNAdjImplR<6>>, MIO);
-
-/******************************************************************************
- *                         TLoadBinary implementation                         *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Impl>
-TLoadBinary<Impl>::TLoadBinary(const std::string name)
-: Module<LoadBinaryPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Impl>
-std::vector<std::string> TLoadBinary<Impl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename Impl>
-std::vector<std::string> TLoadBinary<Impl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Impl>
-void TLoadBinary<Impl>::setup(void)
-{
-    envCreateLat(Field, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Impl>
-void TLoadBinary<Impl>::execute(void)
-{
-    Munger      munge;
-    uint32_t    nersc_csum, scidac_csuma, scidac_csumb;
-    auto        &U = envGet(Field, getName());
-    std::string filename = par().file + "."
-                           + std::to_string(vm().getTrajectory());
-
-    LOG(Message) << "Loading " << par().format 
-                 << " binary configuration from file '" << filename
-                 << "'" << std::endl;
-    BinaryIO::readLatticeObject<vobj, sobj_double>(U, filename, munge, 0, 
-                                                   par().format, nersc_csum,
-                                                   scidac_csuma, scidac_csumb);
-    LOG(Message) << "Checksums:" << std::endl;
-    LOG(Message) << "  NERSC    " << nersc_csum << std::endl;
-    LOG(Message) << "  SciDAC A " << scidac_csuma << std::endl;
-    LOG(Message) << "  SciDAC B " << scidac_csumb << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadBinary_hpp_
diff --git a/Hadrons/Modules/MIO/LoadCoarseEigenPack.cc b/Hadrons/Modules/MIO/LoadCoarseEigenPack.cc
deleted file mode 100644
index 22bc55a6..00000000
--- a/Hadrons/Modules/MIO/LoadCoarseEigenPack.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCoarseEigenPack.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MIO::TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS, FIMPLF>>;
-#endif
diff --git a/Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp b/Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp
deleted file mode 100644
index 521b4814..00000000
--- a/Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadCoarseEigenPack_hpp_
-#define Hadrons_MIO_LoadCoarseEigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *              Load local coherence eigen vectors/values package             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadCoarseEigenPackPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadCoarseEigenPackPar,
-                                    std::string, filestem,
-                                    bool,         multiFile,
-                                    unsigned int, sizeFine,
-                                    unsigned int, sizeCoarse,
-                                    unsigned int, Ls,
-                                    std::vector<int>, blockSize);
-};
-
-template <typename Pack>
-class TLoadCoarseEigenPack: public Module<LoadCoarseEigenPackPar>
-{
-public:
-    typedef typename Pack::Field                Field;
-    typedef typename Pack::FieldIo              FieldIo;
-    typedef typename Pack::CoarseField          CoarseField;
-    typedef typename Pack::CoarseFieldIo        CoarseFieldIo;
-    typedef CoarseEigenPack<Field, CoarseField, FieldIo, CoarseFieldIo> BasePack;
-    template <typename vtype> 
-    using iImplScalar = iScalar<iScalar<iScalar<vtype>>>;
-    typedef iImplScalar<typename Pack::Field::vector_type> SiteComplex;
-public:
-    // constructor
-    TLoadCoarseEigenPack(const std::string name);
-    // destructor
-    virtual ~TLoadCoarseEigenPack(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadCoarseFermionEigenPack, 
-                    ARG(TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>>), MIO);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(LoadCoarseFermionEigenPackIo32, 
-                    ARG(TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS, FIMPLF>>), MIO);
-#endif
-
-/******************************************************************************
- *                 TLoadCoarseEigenPack implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Pack>
-TLoadCoarseEigenPack<Pack>::TLoadCoarseEigenPack(const std::string name)
-: Module<LoadCoarseEigenPackPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Pack>
-std::vector<std::string> TLoadCoarseEigenPack<Pack>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename Pack>
-std::vector<std::string> TLoadCoarseEigenPack<Pack>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadCoarseEigenPack<Pack>::setup(void)
-{
-    GridBase     *gridIo = nullptr, *gridCoarseIo = nullptr;
-
-    if (typeHash<Field>() != typeHash<FieldIo>())
-    {
-        gridIo = envGetRbGrid(FieldIo, par().Ls);
-    }
-    if (typeHash<CoarseField>() != typeHash<CoarseFieldIo>())
-    {
-        gridCoarseIo = envGetCoarseGrid(CoarseFieldIo, par().blockSize, par().Ls);
-    }
-    envCreateDerived(BasePack, Pack, getName(), par().Ls, par().sizeFine,
-                     par().sizeCoarse, envGetRbGrid(Field, par().Ls), 
-                     envGetCoarseGrid(CoarseField, par().blockSize, par().Ls),
-                     gridIo, gridCoarseIo);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadCoarseEigenPack<Pack>::execute(void)
-{
-    auto                 cg     = envGetCoarseGrid(CoarseField, par().blockSize, par().Ls);
-    auto                 &epack = envGetDerived(BasePack, Pack, getName());
-    Lattice<SiteComplex> dummy(cg);
-
-    epack.read(par().filestem, par().multiFile, vm().getTrajectory());
-    LOG(Message) << "Block Gramm-Schmidt pass 1"<< std::endl;
-    blockOrthogonalise(dummy, epack.evec);
-    LOG(Message) << "Block Gramm-Schmidt pass 2"<< std::endl;
-    blockOrthogonalise(dummy, epack.evec);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadCoarseEigenPack_hpp_
diff --git a/Hadrons/Modules/MIO/LoadCosmHol.cc b/Hadrons/Modules/MIO/LoadCosmHol.cc
deleted file mode 100644
index 79dc6119..00000000
--- a/Hadrons/Modules/MIO/LoadCosmHol.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCosmHol.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadCosmHol.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<6>>;
diff --git a/Hadrons/Modules/MIO/LoadCosmHol.hpp b/Hadrons/Modules/MIO/LoadCosmHol.hpp
deleted file mode 100644
index a8faa608..00000000
--- a/Hadrons/Modules/MIO/LoadCosmHol.hpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCosmHol.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadCosmHol_hpp_
-#define Hadrons_MIO_LoadCosmHol_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                    Load scalar SU(N) configurations                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadCosmHolPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadCosmHolPar,
-                                    std::string, file);
-};
-
-class ScalarActionParameters: Serializable 
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarActionParameters,
-                                    double, mass_squared,
-                                    double, lambda,
-                                    double, g);
-};
-
-template <typename SImpl>
-class TLoadCosmHol: public Module<LoadCosmHolPar>
-{
-public:
-    typedef typename SImpl::Field Field;
-public:
-    // constructor
-    TLoadCosmHol(const std::string name);
-    // destructor
-    virtual ~TLoadCosmHol(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadCosmHolSU2, TLoadCosmHol<ScalarNxNAdjImplR<2>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU3, TLoadCosmHol<ScalarNxNAdjImplR<3>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU4, TLoadCosmHol<ScalarNxNAdjImplR<4>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU5, TLoadCosmHol<ScalarNxNAdjImplR<5>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU6, TLoadCosmHol<ScalarNxNAdjImplR<6>>, MIO);
-
-/******************************************************************************
- *                       TLoadCosmHol implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TLoadCosmHol<SImpl>::TLoadCosmHol(const std::string name)
-: Module<LoadCosmHolPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TLoadCosmHol<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TLoadCosmHol<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TLoadCosmHol<SImpl>::setup(void)
-{
-    envCreateLat(Field, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TLoadCosmHol<SImpl>::execute(void)
-{
-    ScalarActionParameters    md;
-    std::string        filename = par().file + "."
-                                  + std::to_string(vm().getTrajectory());
-    ScidacReader       reader;
-    const unsigned int N    = SImpl::Group::Dimension;
-    auto               &phi = envGet(Field, getName());
-
-    LOG(Message) << "Loading CosmHol configuration from file '" << filename
-                 << "'" << std::endl;
-    reader.open(filename);
-    reader.readScidacFieldRecord(phi, md);
-    reader.close();
-    LOG(Message) << "tr(phi^2) = " 
-                 << -TensorRemove(sum(trace(phi*phi))).real()/env().getVolume() 
-                 << std::endl;
-    LOG(Message) << "Configuration parameters:" << std::endl;
-    LOG(Message) << "     N = " << N << std::endl;
-    LOG(Message) << "   m^2 = " << md.mass_squared << std::endl;
-    LOG(Message) << "lambda = " << md.lambda << std::endl;
-    LOG(Message) << "     g = " << md.g << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadCosmHol_hpp_
diff --git a/Hadrons/Modules/MIO/LoadDistilNoise.cc b/Hadrons/Modules/MIO/LoadDistilNoise.cc
deleted file mode 100644
index da532830..00000000
--- a/Hadrons/Modules/MIO/LoadDistilNoise.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MIO/LoadDistilNoise.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadDistilNoise<FIMPL>;
diff --git a/Hadrons/Modules/MIO/LoadDistilNoise.hpp b/Hadrons/Modules/MIO/LoadDistilNoise.hpp
deleted file mode 100644
index d23a0d02..00000000
--- a/Hadrons/Modules/MIO/LoadDistilNoise.hpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/LoadDistilNoise.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MIO_LoadDistilNoise_hpp_
-#define Hadrons_MIO_LoadDistilNoise_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MIO)
-
-/******************************************************************************
- *                         LoadDistilNoise                                 *
- ******************************************************************************/
-
-class LoadDistilNoisePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadDistilNoisePar,
-                                        std::string, NoiseFileName,
-                                        std::string, DistilParams);
-};
-
-template <typename FImpl>
-class TLoadDistilNoise: public Module<LoadDistilNoisePar>
-{
-public:
-    // constructor
-    TLoadDistilNoise(const std::string name);
-    // destructor
-    virtual ~TLoadDistilNoise(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadDistilNoise, TLoadDistilNoise<FIMPL>, MIO);
-
-/******************************************************************************
- *                 TLoadDistilNoise implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TLoadDistilNoise<FImpl>::TLoadDistilNoise(const std::string name) : Module<LoadDistilNoisePar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TLoadDistilNoise<FImpl>::getInput(void)
-{
-    return {par().DistilParams};
-}
-
-template <typename FImpl>
-std::vector<std::string> TLoadDistilNoise<FImpl>::getOutput(void)
-{
-    return {getName()};
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadDistilNoise<FImpl>::setup(void)
-{
-    const MDistil::DistilParameters &dp{envGet(MDistil::DistilParameters,  par().DistilParams)};
-    const int Nt{env().getDim(Tdir)};
-    envCreate(MDistil::NoiseTensor, getName(), 1, dp.nnoise, Nt, dp.nvec, Ns);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadDistilNoise<FImpl>::execute(void)
-{
-  auto &noises = envGet(MDistil::NoiseTensor, getName());
-  std::string sNoiseName{ par().NoiseFileName };
-  sNoiseName.append( 1, '.' );
-  sNoiseName.append( std::to_string( vm().getTrajectory() ) );
-  noises.read(sNoiseName.c_str());
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif
diff --git a/Hadrons/Modules/MIO/LoadEigenPack.cc b/Hadrons/Modules/MIO/LoadEigenPack.cc
deleted file mode 100644
index 0750d265..00000000
--- a/Hadrons/Modules/MIO/LoadEigenPack.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadEigenPack.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadEigenPack.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL>, GIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>, GIMPL>;
-#endif
diff --git a/Hadrons/Modules/MIO/LoadEigenPack.hpp b/Hadrons/Modules/MIO/LoadEigenPack.hpp
deleted file mode 100644
index d036e3d3..00000000
--- a/Hadrons/Modules/MIO/LoadEigenPack.hpp
+++ /dev/null
@@ -1,191 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadEigenPack.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadEigenPack_hpp_
-#define Hadrons_MIO_LoadEigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                   Load eigen vectors/values package                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadEigenPackPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadEigenPackPar,
-                                    std::string, filestem,
-                                    bool, multiFile,
-                                    unsigned int, size,
-                                    unsigned int, Ls,
-                                    std::string, gaugeXform);
-};
-
-template <typename Pack, typename GImpl>
-class TLoadEigenPack: public Module<LoadEigenPackPar>
-{
-public:
-    typedef typename Pack::Field   Field;
-    typedef typename Pack::FieldIo FieldIo;
-    typedef BaseEigenPack<Field>   BasePack;
-
-public:
-    GAUGE_TYPE_ALIASES(GImpl, );
-    typedef typename GImpl::GaugeLinkField GaugeMat;
-public:
-    // constructor
-    TLoadEigenPack(const std::string name);
-    // destructor
-    virtual ~TLoadEigenPack(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadFermionEigenPack, ARG(TLoadEigenPack<FermionEigenPack<FIMPL>, GIMPL>), MIO);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(LoadFermionEigenPackIo32, ARG(TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>, GIMPL>), MIO);
-#endif
-
-/******************************************************************************
- *                    TLoadEigenPack implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Pack, typename GImpl>
-TLoadEigenPack<Pack, GImpl>::TLoadEigenPack(const std::string name)
-: Module<LoadEigenPackPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Pack, typename GImpl>
-std::vector<std::string> TLoadEigenPack<Pack, GImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-
-    if (!par().gaugeXform.empty())
-    {
-        in = {par().gaugeXform};
-    }
-    
-    return in;
-}
-
-template <typename Pack, typename GImpl>
-std::vector<std::string> TLoadEigenPack<Pack, GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Pack, typename GImpl>
-void TLoadEigenPack<Pack, GImpl>::setup(void)
-{
-    GridBase *gridIo = nullptr;
-
-    if (typeHash<Field>() != typeHash<FieldIo>())
-    {
-        gridIo = envGetRbGrid(FieldIo, par().Ls);
-    }
-    envCreateDerived(BasePack, Pack, getName(), par().Ls, par().size, 
-                     envGetRbGrid(Field, par().Ls), gridIo);
-
-    if (!par().gaugeXform.empty())
-    {
-        if (par().Ls > 1)
-        {
-            LOG(Message) << "Setup 5d GaugeMat for Ls = " << par().Ls << std::endl;
-            envTmp(GaugeMat,    "tmpXform", par().Ls, envGetGrid5(Field, par().Ls));
-            envTmp(GaugeMat, "tmpXformOdd", par().Ls, envGetRbGrid5(Field, par().Ls));
-        }
-        else
-        {
-            LOG(Message) << "Setup 4d GaugeMat for Ls = " << par().Ls << std::endl;
-            envTmp(GaugeMat,    "tmpXform", par().Ls, envGetGrid(Field));
-            envTmp(GaugeMat, "tmpXformOdd", par().Ls, envGetRbGrid(Field));
-        }
-        
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Pack, typename GImpl>
-void TLoadEigenPack<Pack, GImpl>::execute(void)
-{
-    auto &epack = envGetDerived(BasePack, Pack, getName());
-
-    epack.read(par().filestem, par().multiFile, vm().getTrajectory());
-    epack.eval.resize(par().size);
-
-    if (!par().gaugeXform.empty())
-    {
-
-        LOG(Message) << "Applying gauge transformation to eigenvectors " << getName()
-                     << " using " << par().gaugeXform << std::endl;
-        auto &xform = envGet(GaugeMat, par().gaugeXform);
-        envGetTmp(GaugeMat,    tmpXform);
-        envGetTmp(GaugeMat, tmpXformOdd);
-
-        if (par().Ls > 1) 
-        {
-            LOG(Message) << "Creating 5d GaugeMat from " << par().gaugeXform << std::endl;
-            startTimer("5-d gauge transform creation");
-            for (unsigned int j = 0; j < par().Ls; j++)
-            {
-                InsertSlice(xform, tmpXform, j, 0);
-            }
-            stopTimer("5-d gauge transform creation");
-        }
-
-        pickCheckerboard(Odd, tmpXformOdd, tmpXform);
-        startTimer("Transform application");
-        for (unsigned int i = 0; i < par().size; i++)
-        {
-            LOG(Message) << "Applying gauge transformation to eigenvector i = " << i << "/" << par().size << std::endl;
-            epack.evec[i].Checkerboard() = Odd;
-            epack.evec[i] = tmpXformOdd * epack.evec[i];
-        }
-        stopTimer("Transform application");
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadEigenPack_hpp_
diff --git a/Hadrons/Modules/MIO/LoadNersc.cc b/Hadrons/Modules/MIO/LoadNersc.cc
deleted file mode 100644
index c624ce31..00000000
--- a/Hadrons/Modules/MIO/LoadNersc.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadNersc.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadNersc.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadNersc<GIMPL>;
diff --git a/Hadrons/Modules/MIO/LoadNersc.hpp b/Hadrons/Modules/MIO/LoadNersc.hpp
deleted file mode 100644
index facc2ecb..00000000
--- a/Hadrons/Modules/MIO/LoadNersc.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadNersc.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadNersc_hpp_
-#define Hadrons_MIO_LoadNersc_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Load a NERSC configuration                           *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadNerscPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadNerscPar,
-                                    std::string, file);
-};
-
-template <typename GImpl>
-class TLoadNersc: public Module<LoadNerscPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TLoadNersc(const std::string name);
-    // destructor
-    virtual ~TLoadNersc(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadNersc,  TLoadNersc<GIMPL>,  MIO);
-
-/******************************************************************************
-*                       TLoadNersc implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TLoadNersc<GImpl>::TLoadNersc(const std::string name)
-: Module<LoadNerscPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TLoadNersc<GImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TLoadNersc<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TLoadNersc<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TLoadNersc<GImpl>::execute(void)
-{
-    FieldMetaData header;
-    std::string   fileName = par().file + "."
-                             + std::to_string(vm().getTrajectory());
-    LOG(Message) << "Loading NERSC configuration from file '" << fileName
-                 << "'" << std::endl;
-
-    auto &U = envGet(GaugeField, getName());
-    NerscIO::readConfiguration(U, header, fileName);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadNersc_hpp_
diff --git a/Hadrons/Modules/MIO/LoadPerambulator.cc b/Hadrons/Modules/MIO/LoadPerambulator.cc
deleted file mode 100644
index 870d8da4..00000000
--- a/Hadrons/Modules/MIO/LoadPerambulator.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/LoadPerambulator.cc
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MIO/LoadPerambulator.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadPerambulator<FIMPL>;
diff --git a/Hadrons/Modules/MIO/LoadPerambulator.hpp b/Hadrons/Modules/MIO/LoadPerambulator.hpp
deleted file mode 100644
index cd5a4cc8..00000000
--- a/Hadrons/Modules/MIO/LoadPerambulator.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/Modules/MDistil/LoadPerambulator.hpp
- 
- Copyright (C) 2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MIO_LoadPerambulator_hpp_
-#define Hadrons_MIO_LoadPerambulator_hpp_
-
-#include <Hadrons/Modules/MDistil/Distil.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MIO)
-
-/******************************************************************************
- *                         LoadPerambulator                                 *
- ******************************************************************************/
-
-class LoadPerambulatorPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadPerambulatorPar,
-                                        std::string, PerambFileName,
-                                        std::string, DistilParams);
-};
-
-template <typename FImpl>
-class TLoadPerambulator: public Module<LoadPerambulatorPar>
-{
-public:
-    // constructor
-    TLoadPerambulator(const std::string name);
-    // destructor
-    virtual ~TLoadPerambulator(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadPerambulator, TLoadPerambulator<FIMPL>, MIO);
-
-/******************************************************************************
- *                 TLoadPerambulator implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TLoadPerambulator<FImpl>::TLoadPerambulator(const std::string name) : Module<LoadPerambulatorPar>(name) {}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TLoadPerambulator<FImpl>::getInput(void)
-{
-    return {par().DistilParams};
-}
-
-template <typename FImpl>
-std::vector<std::string> TLoadPerambulator<FImpl>::getOutput(void)
-{
-    return {getName()};
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadPerambulator<FImpl>::setup(void)
-{
-    const MDistil::DistilParameters &dp{envGet(MDistil::DistilParameters,  par().DistilParams)};
-    const int Nt{env().getDim(Tdir)}; 
-    const bool full_tdil{ dp.TI == Nt };
-    const int Nt_inv{ full_tdil ? 1 : dp.TI };
-    envCreate(MDistil::PerambTensor, getName(), 1, Nt,dp.nvec,dp.LI,dp.nnoise,Nt_inv,dp.SI);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TLoadPerambulator<FImpl>::execute(void)
-{
-  auto &perambulator = envGet(MDistil::PerambTensor, getName());
-  std::string sPerambName{ par().PerambFileName };
-  sPerambName.append( 1, '.' );
-  sPerambName.append( std::to_string( vm().getTrajectory() ) );
-  perambulator.read(sPerambName.c_str());
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif
diff --git a/Hadrons/Modules/MNPR/Amputate.cc b/Hadrons/Modules/MNPR/Amputate.cc
deleted file mode 100644
index a8cb7eb6..00000000
--- a/Hadrons/Modules/MNPR/Amputate.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Amputate.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/Amputate.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TAmputate<FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MNPR/Amputate.hpp b/Hadrons/Modules/MNPR/Amputate.hpp
deleted file mode 100644
index 7cbe45ef..00000000
--- a/Hadrons/Modules/MNPR/Amputate.hpp
+++ /dev/null
@@ -1,199 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Amputate.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Amputate_hpp_
-#define Hadrons_Amputate_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/Eigen/LU>
-//#include <Grid/qcd/utils/PropagatorUtils.h>
-//#include <Grid/serialisation/Serialisation.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TAmputate                                       *
-        Performs bilinear contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class AmputatePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(AmputatePar,
-                                    std::string,    Sin, //need to make this a propogator type?
-                                    std::string,    Sout, //same
-                                    std::string,    vertex,
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    std::string,    output,
-                                    std::string,    input);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TAmputate: public Module<AmputatePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<Complex>, Vamp,
-                                        ); 
-    };
-public:
-    // constructor
-    TAmputate(const std::string name);
-    // destructor
-    virtual ~TAmputate(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    virtual SpinColourMatrix invertspincolmat(SpinColourMatrix &scmat);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Amputate, ARG(TAmputate<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TAmputate implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TAmputate<FImpl1, FImpl2>::TAmputate(const std::string name)
-: Module<AmputatePar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TAmputate<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout, par().vertex};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TAmputate<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> output = {getName()};
-    return output;
-}
-
-// Invert spin colour matrix using Eigen
-template <typename Fimpl1, typename Fimpl2>
-SpinColourMatrix TAmputate<Fimpl1, Fimpl2>::invertspincolmat(SpinColourMatrix &scmat)
-{
-    Eigen::MatrixXcd scmat_2d(Ns*Nc,Ns*Nc);
-    for(int ic=0; ic<Nc; ic++){
-    for(int jc=0; jc<Nc; jc++){
-        for(int is=0; is<Ns; is++){
-        for(int js=0; js<Ns; js++){
-	  auto z =scmat()(is,js)(ic,jc);;
-	  scmat_2d(Ns*ic+is,Ns*jc+js) = std::complex<double>(real(z),imag(z));
-        }}
-    }}      
-    Eigen::MatrixXcd scmat_2d_inv = scmat_2d.inverse();
-    SpinColourMatrix scmat_inv;
-    for(int ic=0; ic<Nc; ic++){
-    for(int jc=0; jc<Nc; jc++){
-        for(int is=0; is<Ns; is++){
-        for(int js=0; js<Ns; js++){
-            scmat_inv()(is,js)(ic,jc) = scmat_2d_inv(Ns*ic+is,Ns*jc+js);
-        }}
-    }}      
-    return scmat_inv;
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TAmputate<FImpl1, FImpl2>::execute(void)
-{
-    LOG(Message) << "Computing bilinear amputations '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-    BinaryWriter                    writer(par().output);
-    PropagatorField1                &Sin = *env().template getObject<PropagatorField1>(par().Sin); //Do these have the phases taken into account?? Don't think so. FIX
-    PropagatorField2                &Sout = *env().template getObject<PropagatorField2>(par().Sout);
-    std::vector<int>                pin  = strToVec<int>(par().pin), pout = strToVec<int>(par().pout);
-    std::vector<Real>               latt_size(pin.begin(), pin.end()); 
-    LatticeComplex                  pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    LOG(Message) << "Propagators set up " << std::endl;
-    std::vector<SpinColourMatrix>   vertex; // Let's read from file here
-    Gamma                           g5(Gamma::Algebra::Gamma5);
-    Result                          result;
-    LOG(Message) << "reading file - "  << par().input << std::endl;
-    BinaryReader                    reader(par().input); 
-    Complex                         Ci(0.0,1.0);
-
-    std::string svertex;
-    read(reader,"vertex", vertex);
-    LOG(Message) << "vertex read" << std::endl;
-
-    pdotxin=Zero();
-    pdotxout=Zero();
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-
-    SpinColourMatrix Sin_mom = sum(Sin);
-    SpinColourMatrix Sout_mom = sum(Sout);
-    LOG(Message) << "summed over lattice" << std::endl;
-   
-    LOG(Message) << "Lattice -> spincolourmatrix conversion" << std::endl;
-
-    SpinColourMatrix Sin_inv = invertspincolmat(Sin_mom);
-    SpinColourMatrix Sout_inv = invertspincolmat(Sout_mom);
-    LOG(Message) << "Inversions done" << std::endl;
-
-    result.Vamp.resize(Gamma::nGamma/2);
-    for( int mu=0; mu < Gamma::nGamma/2; mu++){
-        Gamma::Algebra gam = mu;
-        result.Vamp[mu] = static_cast<Real>( 1 / 12.0 ) * trace(adj(Gamma(mu*2+1))*g5*Sout_inv*g5*vertex[mu]*Sin_inv)()()();
-        LOG(Message) << "Vamp[" << mu << "] - " << result.Vamp[mu] << std::endl;
-        }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Amputate_hpp_
diff --git a/Hadrons/Modules/MNPR/Bilinear.cc b/Hadrons/Modules/MNPR/Bilinear.cc
deleted file mode 100644
index 82086d5a..00000000
--- a/Hadrons/Modules/MNPR/Bilinear.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Bilinear.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/Bilinear.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TBilinear<FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MNPR/Bilinear.hpp b/Hadrons/Modules/MNPR/Bilinear.hpp
deleted file mode 100644
index 444d42a0..00000000
--- a/Hadrons/Modules/MNPR/Bilinear.hpp
+++ /dev/null
@@ -1,225 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Bilinear.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Bilinear_hpp_
-#define Hadrons_Bilinear_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-//#include <Grid/qcd/utils/PropagatorUtils.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TBilinear                                       *
-        Performs bilinear contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta in Rome-Southampton NPR
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class BilinearPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(BilinearPar,
-                                    std::string,    Sin,
-                                    std::string,    Sout,
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    std::string,    output);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TBilinear: public Module<BilinearPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result, 
-                                        std::vector<SpinColourMatrix>, bilinear);
-    };
-public:
-    // constructor
-    TBilinear(const std::string name);
-    // destructor
-    virtual ~TBilinear(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    //LatticeSpinColourMatrix PhaseProps(LatticeSpinColourMatrix S, std::vector<Real> p);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Bilinear, ARG(TBilinear<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TBilinear implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TBilinear<FImpl1, FImpl2>::TBilinear(const std::string name)
-: Module<BilinearPar>(name)
-{}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TBilinear<FImpl1, FImpl2>::setup(void)
-{
-    //env().template registerLattice<LatticeSpinColourMatrix>(getName());
-    //env().template registerObject<SpinColourMatrix>(getName());
-}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TBilinear<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TBilinear<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-/*
-/////Phase propagators//////////////////////////
-template <typename FImpl1, typename FImpl2>
-LatticeSpinColourMatrix TBilinear<FImpl1, FImpl2>::PhaseProps(LatticeSpinColourMatrix S, std::vector<Real> p)
-{
-    GridBase *grid = S._grid;
-    LatticeComplex      pdotx(grid),  coor(grid);
-    std::vector<int>   latt_size = grid->_fdimensions; 
-    Complex             Ci(0.0,1.0);
-    pdotx=Zero();
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotx = pdotx +(TwoPiL * p[mu]) * coor;
-    }
-    S = S*exp(-Ci*pdotx);
-    return S;
-}
-*/
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TBilinear<FImpl1, FImpl2>::execute(void)
-{
-/**************************************************************************
-
-Compute the bilinear vertex needed for the NPR.
-V(G) = sum_x  [ g5 * adj(S'(x,p2)) * g5 * G * S'(x,p1) ]_{si,sj,ci,cj}
-G is one of the 16 gamma vertices [I,gmu,g5,g5gmu,sig(mu,nu)]
-
-        * G
-       / \
-    p1/   \p2
-     /     \
-    /       \
-
-Returns a spin-colour matrix, with indices si,sj, ci,cj
-
-Conventions:
-p1 - incoming momenta
-p2 - outgoing momenta
-q = (p1-p2)
-**************************************************************************/
-
-    LOG(Message) << "Computing bilinear contractions '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-     
-    BinaryWriter             writer(par().output);
-    
-
-    // Propogators
-    LatticeSpinColourMatrix     &Sin = *env().template getObject<LatticeSpinColourMatrix>(par().Sin);
-    LatticeSpinColourMatrix     &Sout = *env().template getObject<LatticeSpinColourMatrix>(par().Sout);
-    LatticeComplex              pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    // momentum on legs
-    std::vector<Real>           pin  = strToVec<Real>(par().pin), pout = strToVec<Real>(par().pout);
-    std::vector<Real>           latt_size(pin.begin(), pin.end()); 
-    //bilinears
-    LatticeSpinColourMatrix     bilinear_x(env().getGrid());
-    SpinColourMatrix            bilinear;
-    Gamma                       g5(Gamma::Algebra::Gamma5);
-    Result                      result;
-    Complex                     Ci(0.0,1.0);
-
-    //
-
-    pdotxin=Zero();
-    pdotxout=Zero();
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-    
-    ////Set up gamma vector//////////////////////////
-    std::vector<Gamma> gammavector;
-    for( int i=0; i<Gamma::nGamma; i++){
-        Gamma::Algebra gam = i;
-        gammavector.push_back(Gamma(gam));
-    }
-    result.bilinear.resize(Gamma::nGamma);
-    /////////////////////////////////////////////////
-    //LatticeSpinMatrix temp = g5*Sout;
-    ////////Form Vertex//////////////////////////////
-    for (int i=0; i < Gamma::nGamma; i++){
-        bilinear_x = g5*adj(Sout)*g5*gammavector[i]*Sin; 
-        result.bilinear[i] = sum(bilinear_x); //sum over lattice sites
-    }
-    //////////////////////////////////////////////////
-    write(writer, par().output, result.bilinear);
-    LOG(Message) << "Complete. Writing results to " << par().output << std:: endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Bilinear_hpp_
diff --git a/Hadrons/Modules/MNPR/FourQuark.cc b/Hadrons/Modules/MNPR/FourQuark.cc
deleted file mode 100644
index 20ed2d7d..00000000
--- a/Hadrons/Modules/MNPR/FourQuark.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/FourQuark.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/FourQuark.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TFourQuark<FIMPL,FIMPL>;
-
diff --git a/Hadrons/Modules/MNPR/FourQuark.hpp b/Hadrons/Modules/MNPR/FourQuark.hpp
deleted file mode 100644
index 3fb687ca..00000000
--- a/Hadrons/Modules/MNPR/FourQuark.hpp
+++ /dev/null
@@ -1,264 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/FourQuark.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_FourQuark_hpp_
-#define Hadrons_FourQuark_hpp_
-
-#include <typeinfo>
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/serialisation/Serialisation.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TFourQuark                                       *
-        Performs fourquark contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class FourQuarkPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FourQuarkPar,
-                                    std::string,    Sin, //need to make this a propogator type?
-                                    std::string,    Sout, //same
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    bool,           fullbasis,
-                                    std::string,    output);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TFourQuark: public Module<FourQuarkPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<SpinColourSpinColourMatrix>, fourquark);
-    };
-public:
-    // constructor
-    TFourQuark(const std::string name);
-    // destructor
-    virtual ~TFourQuark(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void tensorprod(LatticeSpinColourSpinColourMatrix &lret, LatticeSpinColourMatrix a, LatticeSpinColourMatrix b);
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(FourQuark, ARG(TFourQuark<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TFourQuark implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TFourQuark<FImpl1, FImpl2>::TFourQuark(const std::string name)
-: Module<FourQuarkPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TFourQuark<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TFourQuark<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> output = {getName()};
-    
-    return output;
-}
-
-
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::tensorprod(LatticeSpinColourSpinColourMatrix &lret, LatticeSpinColourMatrix a, LatticeSpinColourMatrix b)
-{
-            // FIXME ; is there a general need for this construct ? In which case we should encapsulate the
-            //         below loops in a helper function.
-            //LOG(Message) << "sp co mat a is - " << a << std::endl;
-            //LOG(Message) << "sp co mat b is - " << b << std::endl;
-	    auto  lret_v = lret.View();
-	    auto  a_v = a.View();
-	    auto  b_v = b.View();
-#ifdef GRID_NVCC
-#warning "NVCC problem: Removed impossibly slow compile of simple NPR host code in FourQuark.hpp"
-#else
-            thread_foreach( site,lret_v,{
-		vTComplex left;
-                for(int si=0; si < Ns; ++si){
-                for(int sj=0; sj < Ns; ++sj){
-                    for (int ci=0; ci < Nc; ++ci){
-                    for (int cj=0; cj < Nc; ++cj){
-                      //LOG(Message) << "si, sj, ci, cj -  " << si << ", " << sj  << ", "<< ci  << ", "<< cj << std::endl;
-                      left()()() = a_v[site]()(si,sj)(ci,cj);
-                      //LOG(Message) << left << std::endl;
-                      lret_v[site]()(si,sj)(ci,cj)=left()*b_v[site]();
-                    }}
-                }}
-	      });
-#endif
-}
-
-
-
-
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::setup(void)
-{
-    envCreateLat(LatticeSpinColourMatrix, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::execute(void)
-{
-#ifndef GRID_NVCC
-
-/*********************************************************************************
-
-TFourQuark : Creates the four quark vertex required for the NPR of four-quark ops
-
-V_{Gamma_1,Gamma_2} = sum_x [ ( g5 * adj(S'(x,p2)) * g5 * G1 * S'(x,p1) )_ci,cj;si,sj x ( g5 * adj(S'(x,p2)) * g5 * G2 S'(x,p1) )_ck,cl;sk,cl ]
-
-Create a bilinear vertex for G1 and G2  the spin and colour indices are kept free. Where there are 16 potential Gs.
-We then find the outer product of V1 and V2, keeping the spin and colour indices uncontracted
-Then this is summed over the lattice coordinate
-Result is a SpinColourSpinColourMatrix - with 4 colour and 4 spin indices. 
-We have up to 256 of these including the offdiag (G1 != G2).
-
-        \         /
-         \p1   p1/
-          \     /
-           \   /
-         G1 * * G2
-           /   \
-          /     \
-         /p2   p2\
-        /         \
-
-*********************************************************************************/
-
-
-
-
-    LOG(Message) << "Computing fourquark contractions '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-    
-    BinaryWriter             writer(par().output);
-    
-    PropagatorField1                            &Sin = *env().template getObject<PropagatorField1>(par().Sin);
-    PropagatorField2                            &Sout = *env().template getObject<PropagatorField2>(par().Sout);
-    std::vector<Real>                           pin  = strToVec<Real>(par().pin), pout = strToVec<Real>(par().pout);
-    bool                                        fullbasis = par().fullbasis;
-    Gamma                                       g5(Gamma::Algebra::Gamma5);
-    Result                                      result;
-    std::vector<Real>                           latt_size(pin.begin(), pin.end());
-    LatticeComplex                              pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    LatticeSpinColourMatrix                     bilinear_mu(env().getGrid()), bilinear_nu(env().getGrid());
-    LatticeSpinColourSpinColourMatrix           lret(env().getGrid()); 
-    Complex                         Ci(0.0,1.0);
-
-    //Phase propagators
-    //Sin = Grid::QCD::PropUtils::PhaseProps(Sin,pin);
-    //Sout = Grid::QCD::PropUtils::PhaseProps(Sout,pout);
-    
-    //find p.x for in and out so phase can be accounted for in propagators
-    pdotxin=Zero();
-    pdotxout=Zero();
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-
-    //Set up Gammas 
-    std::vector<Gamma> gammavector;
-     for( int i=1; i<Gamma::nGamma; i+=2){
-         Gamma::Algebra gam = i;
-         gammavector.push_back(Gamma(gam));
-       }
-    
-    lret = Zero();
-    if (fullbasis == true){ // all combinations of mu and nu
-        result.fourquark.resize(Gamma::nGamma/2*Gamma::nGamma/2);
-        for( int mu=0; mu<Gamma::nGamma/2; mu++){ 
-            bilinear_mu = g5*adj(Sout)*g5*gammavector[mu]*Sin;
-            for ( int nu=0; nu<Gamma::nGamma; nu++){
-                LatticeSpinColourMatrix     bilinear_nu(env().getGrid());
-                bilinear_nu = g5*adj(Sout)*g5*gammavector[nu]*Sin;
-                LOG(Message) << "bilinear_nu for nu = " << nu << " is - " << bilinear_mu << std::endl;
-                result.fourquark[mu*Gamma::nGamma/2 + nu] = Zero();
-                tensorprod(lret,bilinear_mu,bilinear_nu);
-                result.fourquark[mu*Gamma::nGamma/2 + nu] = sum(lret);
-            }
-        }
-    } else {
-        result.fourquark.resize(Gamma::nGamma/2);
-        for ( int mu=0; mu<1; mu++){
-        //for( int mu=0; mu<Gamma::nGamma/2; mu++ ){
-            bilinear_mu = g5*adj(Sout)*g5*gammavector[mu]*Sin;
-            //LOG(Message) << "bilinear_mu for mu = " << mu << " is - " << bilinear_mu << std::endl;
-            result.fourquark[mu] = Zero();
-            tensorprod(lret,bilinear_mu,bilinear_mu); //tensor outer product
-            result.fourquark[mu] = sum(lret);
-        }
-    }
-    write(writer, "fourquark", result.fourquark);
-#endif
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_FourQuark_hpp_
diff --git a/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc b/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc
deleted file mode 100644
index b58fdc9c..00000000
--- a/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc
+++ /dev/null
@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNoise;
-
-template class Grid::Hadrons::MNoise::TFullVolumeSpinColorDiagonal<FIMPL>;
-template class Grid::Hadrons::MNoise::TFullVolumeSpinColorDiagonal<ZFIMPL>;
diff --git a/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp b/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp
deleted file mode 100644
index c7f3afa0..00000000
--- a/Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_
-#define Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *             Generate full volume spin-color diagonal noise                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNoise)
-
-class FullVolumeSpinColorDiagonalPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FullVolumeSpinColorDiagonalPar,
-                                    unsigned int, nsrc);
-};
-
-template <typename FImpl>
-class TFullVolumeSpinColorDiagonal: public Module<FullVolumeSpinColorDiagonalPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TFullVolumeSpinColorDiagonal(const std::string name);
-    // destructor
-    virtual ~TFullVolumeSpinColorDiagonal(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(FullVolumeSpinColorDiagonal, TFullVolumeSpinColorDiagonal<FIMPL>, MNoise);
-MODULE_REGISTER_TMP(ZFullVolumeSpinColorDiagonal, TFullVolumeSpinColorDiagonal<ZFIMPL>, MNoise);
-
-/******************************************************************************
- *              TFullVolumeSpinColorDiagonal implementation                  *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TFullVolumeSpinColorDiagonal<FImpl>::TFullVolumeSpinColorDiagonal(const std::string name)
-: Module<FullVolumeSpinColorDiagonalPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TFullVolumeSpinColorDiagonal<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TFullVolumeSpinColorDiagonal<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFullVolumeSpinColorDiagonal<FImpl>::setup(void)
-{
-    envCreateDerived(DilutedNoise<FImpl>, 
-                     FullVolumeSpinColorDiagonalNoise<FImpl>,
-                     getName(), 1, envGetGrid(FermionField), par().nsrc);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFullVolumeSpinColorDiagonal<FImpl>::execute(void)
-{
-    auto &noise = envGet(DilutedNoise<FImpl>, getName());
-    LOG(Message) << "Generating full volume, spin-color diagonal noise" << std::endl;
-    noise.generateNoise(rng4d());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_
diff --git a/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.cc b/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.cc
deleted file mode 100644
index 22ddf06f..00000000
--- a/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.cc
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <Hadrons/Modules/MNoise/SparseSpinColorDiagonal.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNoise;
-
-template class Grid::Hadrons::MNoise::TSparseSpinColorDiagonal<FIMPL>;
-template class Grid::Hadrons::MNoise::TSparseSpinColorDiagonal<ZFIMPL>;
diff --git a/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.hpp b/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.hpp
deleted file mode 100644
index a78115db..00000000
--- a/Hadrons/Modules/MNoise/SparseSpinColorDiagonal.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-#ifndef Hadrons_MNoise_SparseSpinColorDiagonal_hpp_
-#define Hadrons_MNoise_SparseSpinColorDiagonal_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         SparseSpinColorDiagonal                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNoise)
-
-class SparseSpinColorDiagonalPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SparseSpinColorDiagonalPar,
-                                    unsigned int, nsrc,
-                                    unsigned int, nsparse);
-};
-
-template <typename FImpl>
-class TSparseSpinColorDiagonal: public Module<SparseSpinColorDiagonalPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TSparseSpinColorDiagonal(const std::string name);
-    // destructor
-    virtual ~TSparseSpinColorDiagonal(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(SparseSpinColorDiagonal, TSparseSpinColorDiagonal<FIMPL>, MNoise);
-MODULE_REGISTER_TMP(ZSparseSpinColorDiagonal, TSparseSpinColorDiagonal<ZFIMPL>, MNoise);
-
-/******************************************************************************
- *                 TSparseSpinColorDiagonal implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSparseSpinColorDiagonal<FImpl>::TSparseSpinColorDiagonal(const std::string name)
-: Module<SparseSpinColorDiagonalPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSparseSpinColorDiagonal<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSparseSpinColorDiagonal<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSparseSpinColorDiagonal<FImpl>::setup(void)
-{
-    envCreateDerived(DilutedNoise<FImpl>, 
-                     SparseSpinColorDiagonalNoise<FImpl>,
-                     getName(), 1, envGetGrid(FermionField), par().nsrc, par().nsparse);
-    
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSparseSpinColorDiagonal<FImpl>::execute(void)
-{
-    auto &noise = envGet(DilutedNoise<FImpl>, getName());
-    LOG(Message) << "Generating sparse, spin-color diagonal noise with nSparse = "
-                    << par().nsparse << std::endl;
-    noise.generateNoise(rng4d());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MNoise_SparseSpinColorDiagonal_hpp_
diff --git a/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc b/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc
deleted file mode 100644
index c680a44b..00000000
--- a/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNoise;
-
-template class Grid::Hadrons::MNoise::TTimeDilutedSpinColorDiagonal<FIMPL>;
-template class Grid::Hadrons::MNoise::TTimeDilutedSpinColorDiagonal<ZFIMPL>;
diff --git a/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp b/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp
deleted file mode 100644
index 306efa10..00000000
--- a/Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_
-#define Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *             Generate time diluted spin-color diagonal noise                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNoise)
-
-template <typename FImpl>
-class TTimeDilutedSpinColorDiagonal: public Module<NoPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TTimeDilutedSpinColorDiagonal(const std::string name);
-    // destructor
-    virtual ~TTimeDilutedSpinColorDiagonal(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TimeDilutedSpinColorDiagonal, TTimeDilutedSpinColorDiagonal<FIMPL>, MNoise);
-MODULE_REGISTER_TMP(ZTimeDilutedSpinColorDiagonal, TTimeDilutedSpinColorDiagonal<ZFIMPL>, MNoise);
-
-/******************************************************************************
- *              TTimeDilutedSpinColorDiagonal implementation                  *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TTimeDilutedSpinColorDiagonal<FImpl>::TTimeDilutedSpinColorDiagonal(const std::string name)
-: Module<NoPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TTimeDilutedSpinColorDiagonal<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TTimeDilutedSpinColorDiagonal<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTimeDilutedSpinColorDiagonal<FImpl>::setup(void)
-{
-    envCreateDerived(DilutedNoise<FImpl>, 
-                     TimeDilutedSpinColorDiagonalNoise<FImpl>,
-                     getName(), 1, envGetGrid(FermionField));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTimeDilutedSpinColorDiagonal<FImpl>::execute(void)
-{
-    auto &noise = envGet(DilutedNoise<FImpl>, getName());
-
-    LOG(Message) << "Generating time-diluted, spin-color diagonal noise" << std::endl;
-    noise.generateNoise(rng4d());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_
diff --git a/Hadrons/Modules/MScalar/ChargedProp.cc b/Hadrons/Modules/MScalar/ChargedProp.cc
deleted file mode 100644
index cde5e3ba..00000000
--- a/Hadrons/Modules/MScalar/ChargedProp.cc
+++ /dev/null
@@ -1,312 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/ChargedProp.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/ChargedProp.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/******************************************************************************
-*                     TChargedProp implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TChargedProp::TChargedProp(const std::string name)
-: Module<ChargedPropPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TChargedProp::getInput(void)
-{
-    std::vector<std::string> in = {par().source, par().emField};
-    
-    return in;
-}
-
-std::vector<std::string> TChargedProp::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName()+"_0", getName()+"_Q",
-                                    getName()+"_Sun", getName()+"_Tad"};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TChargedProp::setup(void)
-{
-    freeMomPropName_ = FREEMOMPROP(par().mass);
-    phaseName_.clear();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        phaseName_.push_back("_shiftphase_" + std::to_string(mu));
-    }
-    GFSrcName_ = getName() + "_DinvSrc";
-	prop0Name_ = getName() + "_0";
-    propQName_ = getName() + "_Q";
-    propSunName_ = getName() + "_Sun";
-    propTadName_ = getName() + "_Tad";
-    fftName_   = getName() + "_fft";
-
-    freeMomPropDone_ = env().hasCreatedObject(freeMomPropName_);
-    GFSrcDone_       = env().hasCreatedObject(GFSrcName_);
-    phasesDone_      = env().hasCreatedObject(phaseName_[0]);
-	prop0Done_		 = env().hasCreatedObject(prop0Name_);
-    envCacheLat(ScalarField, freeMomPropName_);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        envCacheLat(ScalarField, phaseName_[mu]);
-    }
-    envCacheLat(ScalarField, GFSrcName_);
-	envCacheLat(ScalarField, prop0Name_);
-    envCreateLat(ScalarField, getName());
-    envCreateLat(ScalarField, propQName_);
-    envCreateLat(ScalarField, propSunName_);
-    envCreateLat(ScalarField, propTadName_);
-    envTmpLat(ScalarField, "buf");
-    envTmpLat(ScalarField, "result");
-    envTmpLat(ScalarField, "Amu");
-    envCache(FFT, fftName_, 1, env().getGrid());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TChargedProp::execute(void)
-{
-    // CACHING ANALYTIC EXPRESSIONS
-    makeCaches();
-
-    // PROPAGATOR CALCULATION
-    LOG(Message) << "Computing charged scalar propagator"
-                 << " (mass= " << par().mass
-                 << ", charge= " << par().charge << ")..." << std::endl;
-    
-    auto   &prop    = envGet(ScalarField, getName());
-	auto   &prop0   = envGet(ScalarField, prop0Name_);
-	auto   &propQ   = envGet(ScalarField, propQName_);
-	auto   &propSun = envGet(ScalarField, propSunName_);
-	auto   &propTad = envGet(ScalarField, propTadName_);
-    auto   &GFSrc   = envGet(ScalarField, GFSrcName_);
-    auto   &G       = envGet(ScalarField, freeMomPropName_);
-    auto   &fft     = envGet(FFT, fftName_);
-    double q        = par().charge;
-    envGetTmp(ScalarField, buf);
-
-    // -G*momD1*G*F*Src (momD1 = F*D1*Finv)
-    propQ = GFSrc;
-    momD1(propQ, fft);
-    propQ = -G*propQ;
-    propSun = -propQ;
-    fft.FFT_dim(propQ, propQ, env().getNd()-1, FFT::backward);
-
-    // G*momD1*G*momD1*G*F*Src (here buf = G*momD1*G*F*Src)
-    momD1(propSun, fft);
-    propSun = G*propSun;
-    fft.FFT_dim(propSun, propSun, env().getNd()-1, FFT::backward);
-
-    // -G*momD2*G*F*Src (momD2 = F*D2*Finv)
-    propTad = GFSrc;
-    momD2(propTad, fft);
-    propTad = -G*propTad;
-    fft.FFT_dim(propTad, propTad, env().getNd()-1, FFT::backward);
-    
-    // full charged scalar propagator
-    fft.FFT_dim(buf, GFSrc, env().getNd()-1, FFT::backward);
-    prop = buf + q*propQ + q*q*propSun + q*q*propTad;
-
-    // OUTPUT IF NECESSARY
-    if (!par().output.empty())
-    {
-        Result result;
-        TComplex            site;
-        std::vector<int>    siteCoor;
-
-        LOG(Message) << "Saving momentum-projected propagator to '"
-                     << RESULT_FILE_NAME(par().output, vm().getTrajectory()) << "'..."
-                     << std::endl;
-        result.projection.resize(par().outputMom.size());
-        result.lattice_size = env().getGrid()->FullDimensions().toVector();
-        result.mass = par().mass;
-        result.charge = q;
-        siteCoor.resize(env().getNd());
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            result.projection[i_p].momentum = strToVec<int>(par().outputMom[i_p]);
-
-            LOG(Message) << "Calculating (" << par().outputMom[i_p]
-                         << ") momentum projection" << std::endl;
-
-            result.projection[i_p].corr_0.resize(env().getGrid()->FullDimensions()[env().getNd()-1]);
-            result.projection[i_p].corr.resize(env().getGrid()->FullDimensions()[env().getNd()-1]);
-            result.projection[i_p].corr_Q.resize(env().getGrid()->FullDimensions()[env().getNd()-1]);
-            result.projection[i_p].corr_Sun.resize(env().getGrid()->FullDimensions()[env().getNd()-1]);
-            result.projection[i_p].corr_Tad.resize(env().getGrid()->FullDimensions()[env().getNd()-1]);
-
-            for (unsigned int j = 0; j < env().getNd()-1; ++j)
-            {
-                siteCoor[j] = result.projection[i_p].momentum[j];
-            }
-
-            for (unsigned int t = 0; t < result.projection[i_p].corr.size(); ++t)
-            {
-                siteCoor[env().getNd()-1] = t;
-                peekSite(site, prop, siteCoor);
-                result.projection[i_p].corr[t]=TensorRemove(site);
-                peekSite(site, buf, siteCoor);
-                result.projection[i_p].corr_0[t]=TensorRemove(site);
-                peekSite(site, propQ, siteCoor);
-                result.projection[i_p].corr_Q[t]=TensorRemove(site);
-                peekSite(site, propSun, siteCoor);
-                result.projection[i_p].corr_Sun[t]=TensorRemove(site);
-                peekSite(site, propTad, siteCoor);
-                result.projection[i_p].corr_Tad[t]=TensorRemove(site);
-            }
-        }
-        saveResult(par().output, "prop", result);
-    }
-
-    std::vector<int> mask(env().getNd(),1);
-    mask[env().getNd()-1] = 0;
-    fft.FFT_dim_mask(prop, prop, mask, FFT::backward);
-    fft.FFT_dim_mask(propQ, propQ, mask, FFT::backward);
-    fft.FFT_dim_mask(propSun, propSun, mask, FFT::backward);
-    fft.FFT_dim_mask(propTad, propTad, mask, FFT::backward);
-}
-
-void TChargedProp::makeCaches(void)
-{
-    auto &freeMomProp = envGet(ScalarField, freeMomPropName_);
-    auto &GFSrc       = envGet(ScalarField, GFSrcName_);
-	auto &prop0		  = envGet(ScalarField, prop0Name_);
-    auto &fft         = envGet(FFT, fftName_);
-
-    if (!freeMomPropDone_)
-    {
-        LOG(Message) << "Caching momentum-space free scalar propagator"
-                     << " (mass= " << par().mass << ")..." << std::endl;
-        SIMPL::MomentumSpacePropagator(freeMomProp, par().mass);
-    }
-    if (!GFSrcDone_)
-    {   
-        auto &source = envGet(ScalarField, par().source);
-        
-        LOG(Message) << "Caching G*F*src..." << std::endl;
-        fft.FFT_all_dim(GFSrc, source, FFT::forward);
-        GFSrc = freeMomProp*GFSrc;
-    }
-	if (!prop0Done_)
-	{
-		LOG(Message) << "Caching position-space free scalar propagator..."
-                     << std::endl;
-		fft.FFT_all_dim(prop0, GFSrc, FFT::backward);
-	}
-    if (!phasesDone_)
-    {
-        auto l = env().getGrid()->FullDimensions();
-        Complex          ci(0.0,1.0);
-        
-        LOG(Message) << "Caching shift phases..." << std::endl;
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            Real twoPiL = M_PI*2./l[mu];
-            auto &phmu  = envGet(ScalarField, phaseName_[mu]);
-            
-            LatticeCoordinate(phmu, mu);
-            phmu = exp(ci*twoPiL*phmu);
-            phase_.push_back(&phmu);
-        }
-    }
-    else
-    {
-        phase_.clear();
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            phase_.push_back(env().getObject<ScalarField>(phaseName_[mu]));
-        }
-    }
-}
-
-void TChargedProp::momD1(ScalarField &s, FFT &fft)
-{
-    auto        &A = envGet(EmField, par().emField);
-    Complex     ci(0.0,1.0);
-
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-
-    result = Zero();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = (*phase_[mu])*s;
-        fft.FFT_all_dim(buf, buf, FFT::backward);
-        buf = Amu*buf;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result - ci*buf;
-    }
-    fft.FFT_all_dim(s, s, FFT::backward);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = Amu*s;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result + ci*adj(*phase_[mu])*buf;
-    }
-
-    s = result;
-}
-
-void TChargedProp::momD2(ScalarField &s, FFT &fft)
-{
-    auto &A = envGet(EmField, par().emField);
-
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-
-    result = Zero();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = (*phase_[mu])*s;
-        fft.FFT_all_dim(buf, buf, FFT::backward);
-        buf = Amu*Amu*buf;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result + .5*buf;
-    }
-    fft.FFT_all_dim(s, s, FFT::backward);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);        
-        buf = Amu*Amu*s;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result + .5*adj(*phase_[mu])*buf;
-    }
-
-    s = result;
-}
diff --git a/Hadrons/Modules/MScalar/ChargedProp.hpp b/Hadrons/Modules/MScalar/ChargedProp.hpp
deleted file mode 100644
index ec7f641b..00000000
--- a/Hadrons/Modules/MScalar/ChargedProp.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/ChargedProp.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_ChargedProp_hpp_
-#define Hadrons_MScalar_ChargedProp_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Charged scalar propagator                            *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class ChargedPropPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ChargedPropPar,
-                                    std::string, emField,
-                                    std::string, source,
-                                    double,      mass,
-                                    double,      charge,
-                                    std::string, output,
-                                    std::vector<std::string>, outputMom);
-};
-
-class TChargedProp: public Module<ChargedPropPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-    typedef PhotonR::GaugeField     EmField;
-    typedef PhotonR::GaugeLinkField EmComp;
-    class Result: Serializable
-    {
-    public:
-        class Projection: Serializable
-        {
-        public:
-            GRID_SERIALIZABLE_CLASS_MEMBERS(Projection,
-                                            std::vector<int>,     momentum,
-                                            std::vector<Complex>, corr,
-                                            std::vector<Complex>, corr_0,
-                                            std::vector<Complex>, corr_Q,
-                                            std::vector<Complex>, corr_Sun,
-                                            std::vector<Complex>, corr_Tad);
-        };
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<int>,        lattice_size,
-                                        double,                  mass,
-                                        double,                  charge,
-                                        std::vector<Projection>, projection);
-    };
-public:
-    // constructor
-    TChargedProp(const std::string name);
-    // destructor
-    virtual ~TChargedProp(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    void makeCaches(void);
-    void momD1(ScalarField &s, FFT &fft);
-    void momD2(ScalarField &s, FFT &fft);
-private:
-    bool                       freeMomPropDone_, GFSrcDone_, prop0Done_,
-                               phasesDone_;
-    std::string                freeMomPropName_, GFSrcName_, prop0Name_,
-                               propQName_, propSunName_, propTadName_, fftName_;
-    std::vector<std::string>   phaseName_;
-    std::vector<ScalarField *> phase_;
-};
-
-MODULE_REGISTER(ChargedProp, TChargedProp, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_ChargedProp_hpp_
diff --git a/Hadrons/Modules/MScalar/FreeProp.cc b/Hadrons/Modules/MScalar/FreeProp.cc
deleted file mode 100644
index cbae8219..00000000
--- a/Hadrons/Modules/MScalar/FreeProp.cc
+++ /dev/null
@@ -1,97 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/FreeProp.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/FreeProp.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/******************************************************************************
-*                        TFreeProp implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TFreeProp::TFreeProp(const std::string name)
-: Module<FreePropPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TFreeProp::getInput(void)
-{
-    std::vector<std::string> in = {par().source};
-    
-    return in;
-}
-
-std::vector<std::string> TFreeProp::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TFreeProp::setup(void)
-{
-    freeMomPropName_ = FREEMOMPROP(par().mass);
-    
-    freePropDone_ = env().hasCreatedObject(freeMomPropName_);
-    envCacheLat(ScalarField, freeMomPropName_);
-    envCreateLat(ScalarField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TFreeProp::execute(void)
-{
-    auto &freeMomProp = envGet(ScalarField, freeMomPropName_);
-    auto &prop        = envGet(ScalarField, getName());
-    auto &source      = envGet(ScalarField, par().source);
-
-    if (!freePropDone_)
-    {
-        LOG(Message) << "Caching momentum space free scalar propagator"
-                     << " (mass= " << par().mass << ")..." << std::endl;
-        SIMPL::MomentumSpacePropagator(freeMomProp, par().mass);
-    }
-    LOG(Message) << "Computing free scalar propagator..." << std::endl;
-    SIMPL::FreePropagator(source, prop, freeMomProp);
-    
-    if (!par().output.empty())
-    {
-        std::vector<TComplex> buf;
-        std::vector<Complex>  result;
-        
-        sliceSum(prop, buf, Tp);
-        result.resize(buf.size());
-        for (unsigned int t = 0; t < buf.size(); ++t)
-        {
-            result[t] = TensorRemove(buf[t]);
-        }
-        saveResult(par().output, "freeprop", result);
-    }
-}
diff --git a/Hadrons/Modules/MScalar/FreeProp.hpp b/Hadrons/Modules/MScalar/FreeProp.hpp
deleted file mode 100644
index 68e8a8e6..00000000
--- a/Hadrons/Modules/MScalar/FreeProp.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/FreeProp.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_FreeProp_hpp_
-#define Hadrons_MScalar_FreeProp_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                               FreeProp                                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class FreePropPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FreePropPar,
-                                    std::string, source,
-                                    double,      mass,
-                                    std::string, output);
-};
-
-class TFreeProp: public Module<FreePropPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-public:
-    // constructor
-    TFreeProp(const std::string name);
-    // destructor
-    virtual ~TFreeProp(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::string freeMomPropName_;
-    bool        freePropDone_;
-};
-
-MODULE_REGISTER(FreeProp, TFreeProp, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_FreeProp_hpp_
diff --git a/Hadrons/Modules/MScalar/Scalar.hpp b/Hadrons/Modules/MScalar/Scalar.hpp
deleted file mode 100644
index 69ca47a7..00000000
--- a/Hadrons/Modules/MScalar/Scalar.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/Scalar.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_Scalar_hpp_
-#define Hadrons_Scalar_hpp_
-
-#define FREEMOMPROP(m) "_scalar_mom_prop_" + std::to_string(m)
-
-#endif // Hadrons_Scalar_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/Div.cc b/Hadrons/Modules/MScalarSUN/Div.cc
deleted file mode 100644
index 9819a453..00000000
--- a/Hadrons/Modules/MScalarSUN/Div.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Div.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/Div.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/Div.hpp b/Hadrons/Modules/MScalarSUN/Div.hpp
deleted file mode 100644
index af68d696..00000000
--- a/Hadrons/Modules/MScalarSUN/Div.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Div.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_Div_hpp_
-#define Hadrons_MScalarSUN_Div_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Divergence of a vector field                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class DivPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DivPar,
-                                    std::vector<std::string>, op,
-                                    DiffType,                 type,
-                                    std::string,              output);
-};
-
-class DivResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(DivResult,
-                                    DiffType, type,
-                                    Complex,  value);
-};
-
-template <typename SImpl>
-class TDiv: public Module<DivPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TDiv(const std::string name);
-    // destructor
-    virtual ~TDiv(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(DivSU2, TDiv<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(DivSU3, TDiv<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(DivSU4, TDiv<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(DivSU5, TDiv<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(DivSU6, TDiv<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                           TDiv implementation                              *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TDiv<SImpl>::TDiv(const std::string name)
-: Module<DivPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TDiv<SImpl>::getInput(void)
-{
-    return par().op;
-}
-
-template <typename SImpl>
-std::vector<std::string> TDiv<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TDiv<SImpl>::setup(void)
-{
-    if (par().op.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "the number of components differs from number of dimensions");
-    }
-    envCreateLat(ComplexField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TDiv<SImpl>::execute(void)
-{
-    const auto nd = env().getNd();
-
-    LOG(Message) << "Computing the " << par().type << " divergence of [";
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        std::cout << "'" << par().op[mu] << ((mu == nd - 1) ? "']" : "', ");
-    }
-    std::cout << std::endl;
-
-    auto &div = envGet(ComplexField, getName());
-    div = Zero();
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        auto &op = envGet(ComplexField, par().op[mu]);
-        dmuAcc(div, op, mu, par().type);
-    }
-    if (!par().output.empty())
-    {
-        DivResult r;
-
-        r.type  = par().type;
-        r.value = TensorRemove(sum(div));
-        saveResult(par().output, "div", r);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_Div_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/EMT.cc b/Hadrons/Modules/MScalarSUN/EMT.cc
deleted file mode 100644
index 65859244..00000000
--- a/Hadrons/Modules/MScalarSUN/EMT.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/EMT.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/EMT.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/EMT.hpp b/Hadrons/Modules/MScalarSUN/EMT.hpp
deleted file mode 100644
index bb6a5e7c..00000000
--- a/Hadrons/Modules/MScalarSUN/EMT.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/EMT.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_EMT_hpp_
-#define Hadrons_MScalarSUN_EMT_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Energy-momentum tensor                             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class EMTPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(EMTPar,
-                                    std::string, kinetic,
-                                    std::string, phiPow,
-                                    std::string, improvement,
-                                    double     , m2,
-                                    double     , lambda,
-                                    double     , g,
-                                    double     , xi,
-                                    std::string, output);
-};
-
-class EMTResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(EMTResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    double,                            m2,
-                                    double,                            lambda,
-                                    double,                            g,
-                                    double,                            xi);
-};
-
-template <typename SImpl>
-class TEMT: public Module<EMTPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TEMT(const std::string name);
-    // destructor
-    virtual ~TEMT(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(EMTSU2, TEMT<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU3, TEMT<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU4, TEMT<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU5, TEMT<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU6, TEMT<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                           TEMT implementation                              *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TEMT<SImpl>::TEMT(const std::string name)
-: Module<EMTPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TEMT<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        in.push_back(varName(par().kinetic, mu, nu));
-        if (!par().improvement.empty())
-        {
-            in.push_back(varName(par().improvement, mu, nu));
-        }
-    }
-    in.push_back(varName(par().kinetic, "sum"));
-    in.push_back(varName(par().phiPow, 2));
-    in.push_back(varName(par().phiPow, 4));
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TEMT<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TEMT<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TEMT<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing energy-momentum tensor" << std::endl;
-    LOG(Message) << "  kinetic terms: '" << par().kinetic << "'" << std::endl;
-    LOG(Message) << "      tr(phi^n): '" << par().phiPow << "'" << std::endl;
-    if (!par().improvement.empty())
-    {
-        LOG(Message) << "    improvement: '" << par().improvement << "'" << std::endl;
-    }
-    LOG(Message) << "            m^2= " << par().m2 << std::endl;
-    LOG(Message) << "         lambda= " << par().lambda << std::endl;
-    LOG(Message) << "              g= " << par().g << std::endl;
-    if (!par().improvement.empty())
-    {
-        LOG(Message) << "             xi= " << par().xi << std::endl;
-    }
-
-    const unsigned int N = SImpl::Group::Dimension, nd = env().getNd();
-    auto               &trphi2 = envGet(ComplexField, varName(par().phiPow, 2));
-    auto               &trphi4 = envGet(ComplexField, varName(par().phiPow, 4));
-    auto               &sumkin = envGet(ComplexField, varName(par().kinetic, "sum"));
-    EMTResult          result;
-
-    if (!par().output.empty())
-    {
-        result.m2     = par().m2;
-        result.g      = par().g;
-        result.lambda = par().lambda;
-        result.xi     = par().xi;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out   = envGet(ComplexField, varName(getName(), mu, nu));
-        auto &trkin = envGet(ComplexField, varName(par().kinetic, mu, nu));
-        
-        out = 2.*trkin;
-        if (!par().improvement.empty())
-        {
-            auto &imp = envGet(ComplexField, varName(par().improvement, mu, nu));
-
-            out += par().xi*imp;
-        }
-        if (mu == nu)
-        {
-            out -= sumkin + par().m2*trphi2 + par().lambda*trphi4;
-        }
-        out *= N/par().g;
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "emt", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_EMT_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/Grad.cc b/Hadrons/Modules/MScalarSUN/Grad.cc
deleted file mode 100644
index 03160857..00000000
--- a/Hadrons/Modules/MScalarSUN/Grad.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Grad.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/Grad.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<6>>;
diff --git a/Hadrons/Modules/MScalarSUN/Grad.hpp b/Hadrons/Modules/MScalarSUN/Grad.hpp
deleted file mode 100644
index a8b3911f..00000000
--- a/Hadrons/Modules/MScalarSUN/Grad.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Grad.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_Grad_hpp_
-#define Hadrons_MScalarSUN_Grad_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Gradient of a complex field                          *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class GradPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GradPar,
-                                    std::string, op,
-                                    DiffType,    type,
-                                    std::string, output);
-};
-
-class GradResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GradResult,
-                                    DiffType,              type,
-                                    std::vector<Complex>,  value);
-};
-
-template <typename SImpl>
-class TGrad: public Module<GradPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TGrad(const std::string name);
-    // destructor
-    virtual ~TGrad(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(GradSU2, TGrad<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU3, TGrad<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU4, TGrad<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU5, TGrad<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU6, TGrad<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                         TGrad implementation                               *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TGrad<SImpl>::TGrad(const std::string name)
-: Module<GradPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TGrad<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().op};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TGrad<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    const auto               nd = env().getNd();
-
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        out.push_back(varName(getName(), mu));
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TGrad<SImpl>::setup(void)
-{
-    const auto nd = env().getNd();
-
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TGrad<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing the " << par().type << " gradient of '"
-                 << par().op << "'" << std::endl;
-
-    const unsigned int nd = env().getNd();
-    GradResult         result;
-    auto               &op = envGet(ComplexField, par().op);
-
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd);
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        auto &der = envGet(ComplexField, varName(getName(), mu));
-
-        dmu(der, op, mu, par().type);
-        if (!par().output.empty())
-        {
-            result.value[mu] = TensorRemove(sum(der));
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "grad", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_Grad_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/StochFreeField.cc b/Hadrons/Modules/MScalarSUN/StochFreeField.cc
deleted file mode 100644
index 7166d179..00000000
--- a/Hadrons/Modules/MScalarSUN/StochFreeField.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/StochFreeField.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/StochFreeField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<6>>;
diff --git a/Hadrons/Modules/MScalarSUN/StochFreeField.hpp b/Hadrons/Modules/MScalarSUN/StochFreeField.hpp
deleted file mode 100644
index a66f010c..00000000
--- a/Hadrons/Modules/MScalarSUN/StochFreeField.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/StochFreeField.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_StochFreeField_hpp_
-#define Hadrons_MScalarSUN_StochFreeField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      stochastic free SU(N) scalar field                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class StochFreeFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StochFreeFieldPar,
-                                    double, m2,
-                                    double, g,
-                                    double, smearing);
-};
-
-template <typename SImpl>
-class TStochFreeField: public Module<StochFreeFieldPar>
-{
-public:
-    typedef typename SImpl::Field                    Field;
-    typedef typename SImpl::ComplexField             ComplexField;
-    typedef typename SImpl::Group                    Group;
-    typedef typename SImpl::SiteField::scalar_object Site;
-public:
-    // constructor
-    TStochFreeField(const std::string name);
-    // destructor
-    virtual ~TStochFreeField(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool create_weight;
-};
-
-MODULE_REGISTER_TMP(StochFreeFieldSU2, TStochFreeField<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU3, TStochFreeField<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU4, TStochFreeField<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU5, TStochFreeField<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU6, TStochFreeField<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                 TStochFreeField implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TStochFreeField<SImpl>::TStochFreeField(const std::string name)
-: Module<StochFreeFieldPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TStochFreeField<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TStochFreeField<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TStochFreeField<SImpl>::setup(void)
-{
-    create_weight = false; 
-    if (!env().hasCreatedObject("_" + getName() + "_weight"))
-    {
-        envCacheLat(ComplexField, "_" + getName() + "_weight");
-        envTmpLat(ComplexField, "smear");
-        create_weight = true;
-    }
-    envTmpLat(Field, "phift");
-    envTmpLat(ComplexField, "ca");
-    envCreateLat(Field, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TStochFreeField<SImpl>::execute(void)
-{
-    LOG(Message) << "Generating stochastic scalar field" << std::endl;
-    
-    const   unsigned int N    = Group::Dimension;
-    const   unsigned int Nadj = Group::AdjointDimension;
-    auto    &phi              = envGet(Field, getName());
-    auto    &w                = envGet(ComplexField, "_" + getName() + "_weight");
-    auto    &rng              = rng4d();
-    double  trphi2;
-    FFT     fft(envGetGrid(Field));
-    Integer vol;
-
-    vol = 1;
-    for(int d = 0; d < env().getNd(); d++)
-    {
-        vol = vol*env().getDim(d);
-    }
-    if (create_weight)
-    {
-        LOG(Message) << "Caching momentum-space scalar action" << std::endl;
-        
-        envGetTmp(ComplexField, smear);
-        SImpl::MomentaSquare(smear);
-        smear = exp(-par().smearing*smear);
-        SImpl::MomentumSpacePropagator(w, sqrt(par().m2));
-        w *= par().g/N*smear;
-        w  = sqrt(vol)*sqrt(w);
-    }
-    LOG(Message) << "Generating random momentum-space field" << std::endl;
-    envGetTmp(Field, phift);
-    envGetTmp(ComplexField, ca);
-    phift = Zero();
-    for (int a = 0; a < Nadj; ++a) 
-    {
-        Site ta;
-
-        gaussian(rng, ca);
-        Group::generator(a, ta);
-        phift += ca*ta;
-    }
-    phift *= w;
-    LOG(Message) << "Field Fourier transform" << std::endl;
-    fft.FFT_all_dim(phi, phift, FFT::backward);
-    phi = 0.5*(phi - adj(phi));
-    trphi2 = -TensorRemove(sum(trace(phi*phi))).real()/vol;
-    LOG(Message) << "tr(phi^2)= " << trphi2 << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_StochFreeField_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TrKinetic.cc b/Hadrons/Modules/MScalarSUN/TrKinetic.cc
deleted file mode 100644
index 10ae8a39..00000000
--- a/Hadrons/Modules/MScalarSUN/TrKinetic.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrKinetic.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrKinetic.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/TrKinetic.hpp b/Hadrons/Modules/MScalarSUN/TrKinetic.hpp
deleted file mode 100644
index f26a0f91..00000000
--- a/Hadrons/Modules/MScalarSUN/TrKinetic.hpp
+++ /dev/null
@@ -1,178 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrKinetic.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TrKinetic_hpp_
-#define Hadrons_MScalarSUN_TrKinetic_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Trace of kinetic term                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TrKineticPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrKineticPar,
-                                    std::string,  field,
-                                    DiffType,     type,
-                                    std::string,  output);
-};
-
-class TrKineticResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrKineticResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    DiffType,                          type);
-};
-
-template <typename SImpl>
-class TTrKinetic: public Module<TrKineticPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TTrKinetic(const std::string name);
-    // destructor
-    virtual ~TTrKinetic(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TrKineticSU2, TTrKinetic<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU3, TTrKinetic<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU4, TTrKinetic<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU5, TTrKinetic<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU6, TTrKinetic<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                      TTrKinetic implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTrKinetic<SImpl>::TTrKinetic(const std::string name)
-: Module<TrKineticPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTrKinetic<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTrKinetic<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out ;
-
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-    out.push_back(varName(getName(), "sum"));
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrKinetic<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-    envCreateLat(ComplexField, varName(getName(), "sum"));
-    envTmp(std::vector<Field>, "der", 1, env().getNd(), envGetGrid(Field));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrKinetic<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing tr(d_mu phi*d_nu phi) using " << par().type
-                 << " derivative" << std::endl; 
-
-    const unsigned int nd = env().getNd();
-    TrKineticResult    result;
-    auto               &phi    = envGet(Field, par().field);
-    auto               &sumkin = envGet(ComplexField, varName(getName(), "sum"));
-
-    envGetTmp(std::vector<Field>, der);
-    sumkin = Zero();
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        dmu(der[mu], phi, mu, par().type);
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out = envGet(ComplexField, varName(getName(), mu, nu));
-
-        out = -trace(der[mu]*der[nu]);
-        if (mu == nu)
-        {
-            sumkin += out;
-        }
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    saveResult(par().output, "trkinetic", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TrKinetic_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TrMag.cc b/Hadrons/Modules/MScalarSUN/TrMag.cc
deleted file mode 100644
index 45fbf1bf..00000000
--- a/Hadrons/Modules/MScalarSUN/TrMag.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrMag.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrMag.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/TrMag.hpp b/Hadrons/Modules/MScalarSUN/TrMag.hpp
deleted file mode 100644
index 84eb2231..00000000
--- a/Hadrons/Modules/MScalarSUN/TrMag.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrMag.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TrMag_hpp_
-#define Hadrons_MScalarSUN_TrMag_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                     Trace of powers of the magnetisation                   *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TrMagPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrMagPar,
-                                    std::string,  field,
-                                    unsigned int, maxPow,
-                                    std::string,  output);
-};
-
-class TrMagResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrMagResult,
-                                    std::string, op,
-                                    Real,        value);
-};
-
-template <typename SImpl>
-class TTrMag: public Module<TrMagPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TTrMag(const std::string name);
-    // destructor
-    virtual ~TTrMag(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TrMagSU2, TTrMag<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrMagSU3, TTrMag<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrMagSU4, TTrMag<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrMagSU5, TTrMag<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrMagSU6, TTrMag<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                         TTrMag implementation                              *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTrMag<SImpl>::TTrMag(const std::string name)
-: Module<TrMagPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTrMag<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTrMag<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrMag<SImpl>::setup(void)
-{}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrMag<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing tr(mag^n) for n even up to " << par().maxPow
-                 << std::endl;
-
-    std::vector<TrMagResult> result;
-    auto                     &phi = envGet(Field, par().field);
-
-    auto m2 = sum(phi);
-    auto mn = m2;
-
-    m2 = -m2*m2;
-    mn = 1.;
-    for (unsigned int n = 2; n <= par().maxPow; n += 2)
-    {
-        TrMagResult r;
-
-        mn = mn*m2;
-        r.op    = "tr(mag^" + std::to_string(n) + ")";
-        r.value = TensorRemove(trace(mn)).real();
-        result.push_back(r);
-    }
-    saveResult(par().output, "trmag", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TrMag_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TrPhi.cc b/Hadrons/Modules/MScalarSUN/TrPhi.cc
deleted file mode 100644
index ee112f46..00000000
--- a/Hadrons/Modules/MScalarSUN/TrPhi.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrPhi.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrPhi.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/TrPhi.hpp b/Hadrons/Modules/MScalarSUN/TrPhi.hpp
deleted file mode 100644
index b92a1343..00000000
--- a/Hadrons/Modules/MScalarSUN/TrPhi.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrPhi.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TrPhi_hpp_
-#define Hadrons_MScalarSUN_TrPhi_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      Trace of powers of a scalar field                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TrPhiPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrPhiPar,
-                                    std::string,  field,
-                                    unsigned int, maxPow,
-                                    std::string,  output);
-};
-
-class TrPhiResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrPhiResult,
-                                    std::string, op,
-                                    Real,        value);
-};
-
-template <typename SImpl>
-class TTrPhi: public Module<TrPhiPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-
-public:
-    // constructor
-    TTrPhi(const std::string name);
-    // destructor
-    virtual ~TTrPhi(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TrPhiSU2, TTrPhi<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrPhiSU3, TTrPhi<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrPhiSU4, TTrPhi<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrPhiSU5, TTrPhi<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrPhiSU6, TTrPhi<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                          TTrPhi implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTrPhi<SImpl>::TTrPhi(const std::string name)
-: Module<TrPhiPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTrPhi<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTrPhi<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-
-    for (unsigned int n = 2; n <= par().maxPow; n += 2)
-    {
-        out.push_back(varName(getName(), n));
-    }
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrPhi<SImpl>::setup(void)
-{
-    if (par().maxPow < 2)
-    {
-        HADRONS_ERROR(Size, "'maxPow' should be at least equal to 2");
-    }
-    envTmpLat(Field, "phi2");
-    envTmpLat(Field, "buf");
-    for (unsigned int n = 2; n <= par().maxPow; n += 2)
-    {
-        envCreateLat(ComplexField, varName(getName(), n));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrPhi<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing tr(phi^n) for n even up to " << par().maxPow
-                 << std::endl; 
-
-    std::vector<TrPhiResult> result;
-    auto                     &phi = envGet(Field, par().field);
-
-    envGetTmp(Field, phi2);
-    envGetTmp(Field, buf);
-    buf  = 1.;
-    phi2 = -phi*phi; 
-    for (unsigned int n = 2; n <= par().maxPow; n += 2)
-    {
-        auto &phin = envGet(ComplexField, varName(getName(), n));
-
-        buf  = buf*phi2;
-        phin = trace(buf);
-        if (!par().output.empty())
-        {
-            TrPhiResult r;
-
-            r.op    = "tr(phi^" + std::to_string(n) + ")";
-            r.value = TensorRemove(sum(phin)).real();
-            result.push_back(r);
-        }
-    }
-    if (result.size() > 0)
-    {
-        saveResult(par().output, "trphi", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TrPhi_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TransProj.cc b/Hadrons/Modules/MScalarSUN/TransProj.cc
deleted file mode 100644
index e77f53fb..00000000
--- a/Hadrons/Modules/MScalarSUN/TransProj.cc
+++ /dev/null
@@ -1,40 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TransProj.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TransProj.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<6>>;
-
-    
diff --git a/Hadrons/Modules/MScalarSUN/TransProj.hpp b/Hadrons/Modules/MScalarSUN/TransProj.hpp
deleted file mode 100644
index 22ecfffb..00000000
--- a/Hadrons/Modules/MScalarSUN/TransProj.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TransProj.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TransProj_hpp_
-#define Hadrons_MScalarSUN_TransProj_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Transverse projection                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TransProjPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TransProjPar,
-                                    std::string,  op,
-                                    DiffType,     type,
-                                    std::string,  output);
-};
-
-class TransProjResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TransProjResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    DiffType,                          type);
-};
-
-template <typename SImpl>
-class TTransProj: public Module<TransProjPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TTransProj(const std::string name);
-    // destructor
-    virtual ~TTransProj(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TransProjSU2, TTransProj<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU3, TTransProj<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU4, TTransProj<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU5, TTransProj<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU6, TTransProj<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                        TTransProj implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTransProj<SImpl>::TTransProj(const std::string name)
-: Module<TransProjPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTransProj<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().op};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTransProj<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTransProj<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-    envTmpLat(ComplexField, "buf1");
-    envTmpLat(ComplexField, "buf2");
-    envTmpLat(ComplexField, "lap");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTransProj<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing (delta_mu,nu d^2 - d_mu*d_nu)*op using " 
-                 << par().type << " derivatives and op= '" << par().op 
-                 << "'" << std::endl; 
-
-    const unsigned int nd = env().getNd();
-    TransProjResult    result;
-    auto               &op = envGet(ComplexField, par().op);
-
-    envGetTmp(ComplexField, buf1);
-    envGetTmp(ComplexField, buf2);
-    envGetTmp(ComplexField, lap);
-    lap = Zero();
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        dmu(buf1, op, mu, par().type);
-        dmu(buf2, buf1, mu, par().type);
-        lap += buf2;
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out = envGet(ComplexField, varName(getName(), mu, nu));
-        dmu(buf1, op, mu, par().type);
-        dmu(buf2, buf1, nu, par().type);
-        out = -buf2;
-        if (mu == nu)
-        {
-            out += lap;
-        }
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "transproj", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TransProj_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TwoPoint.cc b/Hadrons/Modules/MScalarSUN/TwoPoint.cc
deleted file mode 100644
index dd485515..00000000
--- a/Hadrons/Modules/MScalarSUN/TwoPoint.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPoint.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TwoPoint.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<6>>;
-
diff --git a/Hadrons/Modules/MScalarSUN/TwoPoint.hpp b/Hadrons/Modules/MScalarSUN/TwoPoint.hpp
deleted file mode 100644
index b22e38c9..00000000
--- a/Hadrons/Modules/MScalarSUN/TwoPoint.hpp
+++ /dev/null
@@ -1,226 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPoint.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TwoPoint_hpp_
-#define Hadrons_MScalarSUN_TwoPoint_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                 2-pt functions for a given set of operators                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TwoPointPar: Serializable
-{
-public:
-    typedef std::pair<std::string, std::string> OpPair;
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointPar,
-                                    std::vector<OpPair>,      op,
-                                    std::vector<std::string>, mom,
-                                    std::string,              output);
-};
-
-class TwoPointResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointResult,
-                                    std::string, sink,
-                                    std::string, source,
-                                    std::vector<int>, mom,
-                                    std::vector<Complex>, data);
-};
-
-template <typename SImpl>
-class TTwoPoint: public Module<TwoPointPar>
-{
-public:
-    typedef typename SImpl::Field         Field;
-    typedef typename SImpl::ComplexField  ComplexField;
-    typedef          std::vector<Complex> SlicedOp;
-public:
-    // constructor
-    TTwoPoint(const std::string name);
-    // destructor
-    virtual ~TTwoPoint(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::vector<std::vector<int>> mom_;
-};
-
-MODULE_REGISTER_TMP(TwoPointSU2, TTwoPoint<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU3, TTwoPoint<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU4, TTwoPoint<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU5, TTwoPoint<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU6, TTwoPoint<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                       TTwoPoint implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTwoPoint<SImpl>::TTwoPoint(const std::string name)
-: Module<TwoPointPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTwoPoint<SImpl>::getInput(void)
-{   
-    std::vector<std::string> in;
-    std::set<std::string>    ops;
-
-    for (auto &p: par().op)
-    {
-        ops.insert(p.first);
-        ops.insert(p.second);
-    }
-    for (auto &o: ops)
-    {
-        in.push_back(o);
-    }
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTwoPoint<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPoint<SImpl>::setup(void)
-{
-    const unsigned int nd = env().getDim().size();
-
-    mom_.resize(par().mom.size());
-    for (unsigned int i = 0; i < mom_.size(); ++i)
-    {
-        mom_[i] = strToVec<int>(par().mom[i]);
-        if (mom_[i].size() != nd - 1)
-        {
-            HADRONS_ERROR(Size, "momentum number of components different from " 
-                               + std::to_string(nd-1));
-        }
-        for (unsigned int j = 0; j < nd - 1; ++j)
-        {
-            mom_[i][j] = (mom_[i][j] + env().getDim(j)) % env().getDim(j);
-        }
-    }
-    envTmpLat(ComplexField, "ftBuf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPoint<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing 2-point functions" << std::endl;
-    for (auto &p: par().op)
-    {
-        LOG(Message) << "  <" << p.first << " " << p.second << ">" << std::endl;
-    }
-
-    const unsigned int                           nd      = env().getNd();
-    const unsigned int                           nt      = env().getDim().back();
-    const unsigned int                           nop     = par().op.size();
-    const unsigned int                           nmom    = mom_.size();
-    double                                       partVol = 1.;
-    std::vector<int>                             dMask(nd, 1);
-    std::set<std::string>                        ops;
-    std::vector<TwoPointResult>                  result;
-    std::map<std::string, std::vector<SlicedOp>> slicedOp;
-    FFT                                          fft(envGetGrid(Field));
-    TComplex                                     buf;
-
-    envGetTmp(ComplexField, ftBuf);
-    dMask[nd - 1] = 0;
-    for (unsigned int mu = 0; mu < nd - 1; ++mu)
-    {
-        partVol *= env().getDim()[mu];
-    }
-    for (auto &p: par().op)
-    {
-        ops.insert(p.first);
-        ops.insert(p.second);
-    }
-    for (auto &o: ops)
-    {
-        auto &op = envGet(ComplexField, o);
-
-        slicedOp[o].resize(nmom);
-        LOG(Message) << "Operator '" << o << "' FFT" << std::endl;
-        fft.FFT_dim_mask(ftBuf, op, dMask, FFT::forward);
-        for (unsigned int m = 0; m < nmom; ++m)
-        {
-            auto qt = mom_[m];
-
-            qt.resize(nd);
-            slicedOp[o][m].resize(nt);
-            for (unsigned int t = 0; t < nt; ++t)
-            {
-                qt[nd - 1] = t;
-                peekSite(buf, ftBuf, qt);
-                slicedOp[o][m][t] = TensorRemove(buf);
-            }
-        }
-    }
-    LOG(Message) << "Making contractions" << std::endl;
-    for (unsigned int m = 0; m < nmom; ++m)
-    for (auto &p: par().op)
-    {
-        TwoPointResult r;
-
-        r.sink   = p.first;
-        r.source = p.second;
-        r.mom    = mom_[m];
-        r.data   = makeTwoPoint(slicedOp[p.first][m], slicedOp[p.second][m], 
-                                1./partVol);
-        result.push_back(r);
-    }
-    saveResult(par().output, "twopt", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TwoPoint_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/TwoPointNPR.cc b/Hadrons/Modules/MScalarSUN/TwoPointNPR.cc
deleted file mode 100644
index b94d331f..00000000
--- a/Hadrons/Modules/MScalarSUN/TwoPointNPR.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPointNPR.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<6>>;
diff --git a/Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp b/Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp
deleted file mode 100644
index dd1e7215..00000000
--- a/Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TwoPointNPR_hpp_
-#define Hadrons_MScalarSUN_TwoPointNPR_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         TwoPointNPR                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TwoPointNPRPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointNPRPar,
-                                    std::vector<std::string>, op,
-                                    std::string,              field,
-                                    std::string,              output);
-};
-
-class TwoPointNPRResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointNPRResult,
-                                    std::string,          op,
-                                    std::vector<Complex>, data);
-};
-
-template <typename SImpl>
-class TTwoPointNPR: public Module<TwoPointNPRPar>
-{
-public:
-    typedef typename SImpl::Field                    Field;
-    typedef typename SImpl::SiteField::scalar_object Site;
-    typedef typename SImpl::ComplexField             ComplexField;
-public:
-    // constructor
-    TTwoPointNPR(const std::string name);
-    // destructor
-    virtual ~TTwoPointNPR(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TwoPointNPRSU2, TTwoPointNPR<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU3, TTwoPointNPR<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU4, TTwoPointNPR<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU5, TTwoPointNPR<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU6, TTwoPointNPR<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                 TTwoPointNPR implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTwoPointNPR<SImpl>::TTwoPointNPR(const std::string name)
-: Module<TwoPointNPRPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTwoPointNPR<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = par().op;
-
-    in.push_back(par().field);
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTwoPointNPR<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPointNPR<SImpl>::setup(void)
-{
-    const unsigned int nl = env().getDim(0);
-
-    for (unsigned int mu = 1; mu < env().getNd(); ++mu)
-    {
-        if (nl != env().getDim(mu))
-        {
-            HADRONS_ERROR(Size, "non-cubic grid");
-        }
-    }
-    envTmpLat(ComplexField, "ftBuf");
-    envTmpLat(Field, "ftMatBuf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPointNPR<SImpl>::execute(void)
-{
-    const unsigned int             nd   = env().getNd();
-    const unsigned int             nl   = env().getDim(0);
-    const Real                     invV = 1./env().getVolume();
-    FFT                            fft(envGetGrid(Field));
-    std::vector<TwoPointNPRResult> result;
-    TwoPointNPRResult              twoPtp1, twoPtp2, twoPtDisc;
-    auto                           &phi    = envGet(Field, par().field);
-    bool                           doAux = true;
-
-    envGetTmp(ComplexField, ftBuf);
-    envGetTmp(Field, ftMatBuf);
-    LOG(Message) << "FFT: field '" << par().field << "'" << std::endl;
-    fft.FFT_all_dim(ftMatBuf, phi, FFT::forward);
-    for (auto &opName: par().op)
-    {
-        auto              &op = envGet(ComplexField, opName);
-        std::vector<int>  p1, p2, p;
-        Site              phip1, phip2;
-        TComplex          opp;
-        TwoPointNPRResult r, rDisc;
-
-        LOG(Message) << "FFT: operator '" << opName << "'" << std::endl;
-        fft.FFT_all_dim(ftBuf, op, FFT::forward);
-        LOG(Message) << "Generating vertex function" << std::endl;
-        r.op = opName;
-        r.data.resize(nl);
-        rDisc.op = opName + "_disc";
-        rDisc.data.resize(nl);
-        if (doAux)
-        {
-            twoPtp1.op = "phi_prop_p1";
-            twoPtp1.data.resize(nl);
-            twoPtp2.op = "phi_prop_p2";
-            twoPtp2.data.resize(nl);
-            twoPtDisc.op = "phi_prop_disc";
-            twoPtDisc.data.resize(nl);
-        }
-        for (unsigned int n = 0; n < nl; ++n)
-        {
-            p1.assign(nd, 0);
-            p2.assign(nd, 0);
-            p.assign(nd, 0);
-            // non-exceptional RI/SMOM kinematic
-            // p1 = mu*(1,1,0): in mom
-            // p2 = mu*(0,1,1): out mom
-            // p  = p1 - p2 = mu*(1,0,-1)
-            // mu = 2*n*pi/L
-            p1[0] = n;
-            p1[1] = n;
-            p2[1] = n;
-            p2[2] = n;
-            p[0]  = n;
-            p[2]  = (nl - n) % nl;
-            peekSite(phip1, ftMatBuf, p1);
-            peekSite(phip2, ftMatBuf, p2);
-            peekSite(opp, ftBuf, p);
-            if (doAux)
-            {
-                twoPtp1.data[n]   = invV*TensorRemove(trace(phip1*adj(phip1)));
-                twoPtp2.data[n]   = invV*TensorRemove(trace(phip2*adj(phip2)));
-                twoPtDisc.data[n] = invV*TensorRemove(trace(phip2*adj(phip1)));
-            }
-            r.data[n]     = invV*TensorRemove(trace(phip2*adj(phip1))*opp);
-            rDisc.data[n] = invV*TensorRemove(trace(phip1*adj(phip1))*opp);
-        }
-        if (doAux)
-        {
-            result.push_back(twoPtp1);
-            result.push_back(twoPtp2);
-            result.push_back(twoPtDisc);
-        }
-        result.push_back(r);
-        result.push_back(rDisc);
-        doAux = false;
-    }
-    saveResult(par().output, "twoptnpr", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TwoPointNPR_hpp_
diff --git a/Hadrons/Modules/MScalarSUN/Utils.hpp b/Hadrons/Modules/MScalarSUN/Utils.hpp
deleted file mode 100644
index 869bc8e7..00000000
--- a/Hadrons/Modules/MScalarSUN/Utils.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Utils.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_Utils_hpp_
-#define Hadrons_MScalarSUN_Utils_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-GRID_SERIALIZABLE_ENUM(DiffType, undef, forward, 1, backward, 2, central, 3);
-
-template <typename Field>
-inline void dmu(Field &out, const Field &in, const unsigned int mu, const DiffType type)
-{
-    auto & env = Environment::getInstance();
-
-    if (mu >= env.getNd())
-    {
-        HADRONS_ERROR(Range, "Derivative direction out of range");
-    }
-    switch(type)
-    {
-        case DiffType::backward:
-            out = in - Cshift(in, mu, -1);
-            break;
-        case DiffType::forward:
-            out = Cshift(in, mu, 1) - in;
-            break;
-        case DiffType::central:
-            out = 0.5*(Cshift(in, mu, 1) - Cshift(in, mu, -1));
-            break;
-        default:
-            HADRONS_ERROR(Argument, "Derivative type invalid");
-            break;
-    }
-}
-
-template <typename Field>
-inline void dmuAcc(Field &out, const Field &in, const unsigned int mu, const DiffType type)
-{
-    auto & env = Environment::getInstance();
-
-    if (mu >= env.getNd())
-    {
-        HADRONS_ERROR(Range, "Derivative direction out of range");
-    }
-    switch(type)
-    {
-        case DiffType::backward:
-            out += in - Cshift(in, mu, -1);
-            break;
-        case DiffType::forward:
-            out += Cshift(in, mu, 1) - in;
-            break;
-        case DiffType::central:
-            out += 0.5*(Cshift(in, mu, 1) - Cshift(in, mu, -1));
-            break;
-        default:
-            HADRONS_ERROR(Argument, "Derivative type invalid");
-            break;
-    }
-}
-
-template <class SinkSite, class SourceSite>
-std::vector<Complex> makeTwoPoint(const std::vector<SinkSite>   &sink,
-                                  const std::vector<SourceSite> &source,
-                                  const double factor = 1.)
-{
-    assert(sink.size() == source.size());
-    
-    unsigned int         nt = sink.size();
-    std::vector<Complex> res(nt, 0.);
-    
-    for (unsigned int dt = 0; dt < nt; ++dt)
-    {
-        for (unsigned int t  = 0; t < nt; ++t)
-        {
-            res[dt] += trace(sink[(t+dt)%nt]*adj(source[t]));
-        }
-        res[dt] *= factor/static_cast<double>(nt);
-    }
-    
-    return res;
-}
-
-inline std::string varName(const std::string name, const std::string suf)
-{
-    return name + "_" + suf;
-}
-
-inline std::string varName(const std::string name, const unsigned int mu)
-{
-    return varName(name, std::to_string(mu));
-}
-
-inline std::string varName(const std::string name, const unsigned int mu, 
-                           const unsigned int nu)
-{
-    return varName(name, std::to_string(mu) + "_" + std::to_string(nu));
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_Utils_hpp_
diff --git a/Hadrons/Modules/MSink/Point.cc b/Hadrons/Modules/MSink/Point.cc
deleted file mode 100644
index 333e56b1..00000000
--- a/Hadrons/Modules/MSink/Point.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSink/Point.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSink/Point.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSink;
-
-template class Grid::Hadrons::MSink::TPoint<FIMPL>;
-template class Grid::Hadrons::MSink::TPoint<ScalarImplCR>;
-
diff --git a/Hadrons/Modules/MSink/Point.hpp b/Hadrons/Modules/MSink/Point.hpp
deleted file mode 100644
index a8359eae..00000000
--- a/Hadrons/Modules/MSink/Point.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSink/Point.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Guido Cossu <guido.cossu@ed.ac.uk>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSink_Point_hpp_
-#define Hadrons_MSink_Point_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                   Point                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSink)
-
-class PointPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(PointPar,
-                                    std::string, mom);
-};
-
-template <typename FImpl>
-class TPoint: public Module<PointPar>
-{
-public:
-    BASIC_TYPE_ALIASES(FImpl,);
-    SINK_TYPE_ALIASES();
-public:
-    // constructor
-    TPoint(const std::string name);
-    // destructor
-    virtual ~TPoint(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasPhase_{false}; 
-    std::string momphName_;
-};
-
-MODULE_REGISTER_TMP(Point,       TPoint<FIMPL>,        MSink);
-MODULE_REGISTER_TMP(ScalarPoint, TPoint<ScalarImplCR>, MSink);
-
-/******************************************************************************
- *                          TPoint implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TPoint<FImpl>::TPoint(const std::string name)
-: Module<PointPar>(name)
-, momphName_ (name + "_momph")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TPoint<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TPoint<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPoint<FImpl>::setup(void)
-{
-    envTmpLat(LatticeComplex, "coor");
-    envCacheLat(LatticeComplex, momphName_);
-    envCreate(SinkFn, getName(), 1, nullptr);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPoint<FImpl>::execute(void)
-{   
-    LOG(Message) << "Setting up point sink function for momentum ["
-                 << par().mom << "]" << std::endl;
-
-    auto &ph = envGet(LatticeComplex, momphName_);
-    
-    if (!hasPhase_)
-    {
-        Complex           i(0.0,1.0);
-        std::vector<Real> p;
-
-        envGetTmp(LatticeComplex, coor);
-        p  = strToVec<Real>(par().mom);
-        ph = Zero();
-        for(unsigned int mu = 0; mu < p.size(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            ph = ph + (p[mu]/env().getDim(mu))*coor;
-        }
-        ph = exp((Real)(2*M_PI)*i*ph);
-        hasPhase_ = true;
-    }
-    auto sink = [&ph](const PropagatorField &field)
-    {
-        SlicedPropagator res;
-        PropagatorField  tmp = ph*field;
-        
-        sliceSum(tmp, res, Tp);
-        
-        return res;
-    };
-    envGet(SinkFn, getName()) = sink;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSink_Point_hpp_
diff --git a/Hadrons/Modules/MSink/Smear.cc b/Hadrons/Modules/MSink/Smear.cc
deleted file mode 100644
index b7a99025..00000000
--- a/Hadrons/Modules/MSink/Smear.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSink/Smear.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSink/Smear.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSink;
-
-template class Grid::Hadrons::MSink::TSmear<FIMPL>;
-
diff --git a/Hadrons/Modules/MSink/Smear.hpp b/Hadrons/Modules/MSink/Smear.hpp
deleted file mode 100644
index 47f91d3a..00000000
--- a/Hadrons/Modules/MSink/Smear.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSink/Smear.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSink_Smear_hpp_
-#define Hadrons_MSink_Smear_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                 Smear                                      *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSink)
-
-class SmearPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SmearPar,
-                                    std::string, q,
-                                    std::string, sink);
-};
-
-template <typename FImpl>
-class TSmear: public Module<SmearPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SINK_TYPE_ALIASES();
-public:
-    // constructor
-    TSmear(const std::string name);
-    // destructor
-    virtual ~TSmear(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Smear, TSmear<FIMPL>, MSink);
-
-/******************************************************************************
- *                          TSmear implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSmear<FImpl>::TSmear(const std::string name)
-: Module<SmearPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSmear<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q, par().sink};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSmear<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSmear<FImpl>::setup(void)
-{
-    envCreate(SlicedPropagator, getName(), 1, env().getDim(Tp));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSmear<FImpl>::execute(void)
-{
-    LOG(Message) << "Sink smearing propagator '" << par().q
-                 << "' using sink function '" << par().sink << "'."
-                 << std::endl;
-
-    auto &sink = envGet(SinkFn, par().sink);
-    auto &q    = envGet(PropagatorField, par().q);
-    auto &out  = envGet(SlicedPropagator, getName());
-    
-    out = sink(q);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSink_Smear_hpp_
diff --git a/Hadrons/Modules/MSolver/A2AAslashVectors.cc b/Hadrons/Modules/MSolver/A2AAslashVectors.cc
deleted file mode 100644
index d7e60db5..00000000
--- a/Hadrons/Modules/MSolver/A2AAslashVectors.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/A2AAslashVectors.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSolver/A2AAslashVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSolver;
-
-template class Grid::Hadrons::MSolver::TA2AAslashVectors<FIMPL>;
-template class Grid::Hadrons::MSolver::TA2AAslashVectors<ZFIMPL>;
diff --git a/Hadrons/Modules/MSolver/A2AAslashVectors.hpp b/Hadrons/Modules/MSolver/A2AAslashVectors.hpp
deleted file mode 100644
index fa222228..00000000
--- a/Hadrons/Modules/MSolver/A2AAslashVectors.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/A2AAslashVectors.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MSolver_A2AAslashVectors_hpp_
-#define Hadrons_MSolver_A2AAslashVectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-#include <Hadrons/A2AVectors.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Create all-to-all V & W vectors                      *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-/****************************************************************************
-*  Calculate a sequential propagator on an insertion of i*g_mu*A_mu 
-*  on an A2A vector
-*
-*  vv_i(y) = S(y,x) * i * g_mu*A_mu(x) * v_i(x)
-*
-*  with
-*
-*  - vector: A2A vector v_i(x)
-*  - emField: A_mu(x): electromagnetic photon field
-*  - solver: the solver for calculating the sequential propagator
-*
-*****************************************************************************/
-
-class A2AAslashVectorsPar: Serializable
-{
-public:
-  GRID_SERIALIZABLE_CLASS_MEMBERS(A2AAslashVectorsPar,
-                                  std::string, vector,
-                                  std::string, emField,
-                                  std::string, solver,
-                                  std::string, output,
-                                  bool,        multiFile);
-};
-
-template <typename FImpl>
-class TA2AAslashVectors : public Module<A2AAslashVectorsPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-public:
-    typedef PhotonR::GaugeField EmField;
-public:
-    // constructor
-    TA2AAslashVectors(const std::string name);
-    // destructor
-    virtual ~TA2AAslashVectors(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(A2AAslashVectors, TA2AAslashVectors<FIMPL>, MSolver);
-MODULE_REGISTER_TMP(ZA2AAslashVectors, TA2AAslashVectors<ZFIMPL>, MSolver);
-
-/******************************************************************************
- *                       TA2AAslashVectors implementation                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TA2AAslashVectors<FImpl>::TA2AAslashVectors(const std::string name)
-: Module<A2AAslashVectorsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TA2AAslashVectors<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().vector, par().emField, par().solver};
-
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TA2AAslashVectors<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AAslashVectors<FImpl>::setup(void)
-{
-    Ls_  = env().getObjectLs(par().solver);
-    auto &vvector = envGet(std::vector<FermionField>, par().vector);
-    unsigned int Nmodes = vvector.size();
-    envCreate(std::vector<FermionField>, getName(), 1, 
-              Nmodes, envGetGrid(FermionField));
-   
-    envTmpLat(FermionField, "v4dtmp");
-    envTmpLat(FermionField, "v5dtmp", Ls_);
-    envTmpLat(FermionField, "v5dtmp_sol", Ls_);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AAslashVectors<FImpl>::execute(void)
-{
-    auto &solver = envGet(Solver, par().solver);
-    auto &stoch_photon = envGet(EmField,  par().emField);
-    auto &vvector = envGet(std::vector<FermionField>, par().vector);
-    auto &Aslashv = envGet(std::vector<FermionField>, getName());
-    unsigned int Nmodes = vvector.size();
-    auto &mat = solver.getFMat();
-    envGetTmp(FermionField, v4dtmp);
-    envGetTmp(FermionField, v5dtmp);
-    envGetTmp(FermionField, v5dtmp_sol);
-
-    Complex ci(0.0,1.0);
-
-    startTimer("Seq Aslash");
-    LOG(Message) << "Calculate Sequential propagator on Aslash * v with the A2A vector " 
-                 << par().vector << " and the photon field " << par().emField << std::endl;
-    for(unsigned int i=0; i<Nmodes; i++)
-    {
-        v4dtmp = Zero();
-        startTimer("Multiply Aslash");
-        for(unsigned int mu=0;mu<=3;mu++)
-        {
-            Gamma gmu(Gamma::gmu[mu]);
-            v4dtmp +=  ci * PeekIndex<LorentzIndex>(stoch_photon, mu) * (gmu * vvector[i]);
-        }
-        stopTimer("Multiply Aslash");
-
-        startTimer("Inversion");
-        if (Ls_ == 1)
-        {
-            solver(Aslashv[i], v4dtmp);
-        }
-        else
-        {
-            mat.ImportPhysicalFermionSource(v4dtmp, v5dtmp);
-            solver(v5dtmp_sol, v5dtmp);
-            mat.ExportPhysicalFermionSolution(v5dtmp_sol, v4dtmp);
-            Aslashv[i] = v4dtmp;
-        }
-        stopTimer("Inversion");
-    }
-    stopTimer("Seq Aslash");
-    if (!par().output.empty())
-    {
-        startTimer("I/O");
-        A2AVectorsIo::write(par().output, Aslashv, par().multiFile, vm().getTrajectory());
-        stopTimer("I/O");
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSolver_A2AAslashVectors_hpp_
diff --git a/Hadrons/Modules/MSolver/A2AVectors.cc b/Hadrons/Modules/MSolver/A2AVectors.cc
deleted file mode 100644
index c7d92006..00000000
--- a/Hadrons/Modules/MSolver/A2AVectors.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/A2AVectors.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: fionnoh <fionnoh@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSolver/A2AVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSolver;
-
-template class Grid::Hadrons::MSolver::TA2AVectors<FIMPL, BaseFermionEigenPack<FIMPL>>;
-template class Grid::Hadrons::MSolver::TA2AVectors<ZFIMPL, BaseFermionEigenPack<ZFIMPL>>;
diff --git a/Hadrons/Modules/MSolver/A2AVectors.hpp b/Hadrons/Modules/MSolver/A2AVectors.hpp
deleted file mode 100644
index 0d419f85..00000000
--- a/Hadrons/Modules/MSolver/A2AVectors.hpp
+++ /dev/null
@@ -1,258 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/A2AVectors.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: fionnoh <fionnoh@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MSolver_A2AVectors_hpp_
-#define Hadrons_MSolver_A2AVectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-#include <Hadrons/EigenPack.hpp>
-#include <Hadrons/A2AVectors.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Create all-to-all V & W vectors                      *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-class A2AVectorsPar: Serializable
-{
-public:
-  GRID_SERIALIZABLE_CLASS_MEMBERS(A2AVectorsPar,
-                                  std::string, noise,
-                                  std::string, action,
-                                  std::string, eigenPack,
-                                  std::string, solver,
-                                  std::string, output,
-                                  bool,        multiFile);
-};
-
-template <typename FImpl, typename Pack>
-class TA2AVectors : public Module<A2AVectorsPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-    typedef HADRONS_DEFAULT_SCHUR_A2A<FImpl> A2A;
-public:
-    // constructor
-    TA2AVectors(const std::string name);
-    // destructor
-    virtual ~TA2AVectors(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::string  solverName_;
-    unsigned int Nl_{0};
-};
-
-MODULE_REGISTER_TMP(A2AVectors, 
-    ARG(TA2AVectors<FIMPL, BaseFermionEigenPack<FIMPL>>), MSolver);
-MODULE_REGISTER_TMP(ZA2AVectors, 
-    ARG(TA2AVectors<ZFIMPL, BaseFermionEigenPack<ZFIMPL>>), MSolver);
-
-/******************************************************************************
- *                       TA2AVectors implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl, typename Pack>
-TA2AVectors<FImpl, Pack>::TA2AVectors(const std::string name)
-: Module<A2AVectorsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl, typename Pack>
-std::vector<std::string> TA2AVectors<FImpl, Pack>::getInput(void)
-{
-    std::string              sub_string;
-    std::vector<std::string> in;
-
-    if (!par().eigenPack.empty())
-    {
-        in.push_back(par().eigenPack);
-        sub_string = (!par().eigenPack.empty()) ? "_subtract" : "";
-    }
-    in.push_back(par().solver + sub_string);
-    in.push_back(par().noise);
-
-    return in;
-}
-
-template <typename FImpl, typename Pack>
-std::vector<std::string> TA2AVectors<FImpl, Pack>::getOutput(void)
-{
-    std::vector<std::string> out = {getName() + "_v", getName() + "_w"};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl, typename Pack>
-void TA2AVectors<FImpl, Pack>::setup(void)
-{
-    bool        hasLowModes = (!par().eigenPack.empty());
-    std::string sub_string  = (hasLowModes) ? "_subtract" : "";
-    auto        &noise      = envGet(DilutedNoise<FImpl>, par().noise);
-    auto        &action     = envGet(FMat, par().action);
-    auto        &solver     = envGet(Solver, par().solver + sub_string);
-    int         Ls          = env().getObjectLs(par().action);
-
-    if (hasLowModes)
-    {
-        auto &epack = envGet(Pack, par().eigenPack);
-        Nl_ = epack.evec.size();
-    }
-    envCreate(std::vector<FermionField>, getName() + "_v", 1, 
-              Nl_ + noise.size(), envGetGrid(FermionField));
-    envCreate(std::vector<FermionField>, getName() + "_w", 1, 
-              Nl_ + noise.size(), envGetGrid(FermionField));
-    if (Ls > 1)
-    {
-        envTmpLat(FermionField, "f5", Ls);
-    }
-    envTmp(A2A, "a2a", 1, action, solver);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl, typename Pack>
-void TA2AVectors<FImpl, Pack>::execute(void)
-{
-    std::string sub_string = (Nl_ > 0) ? "_subtract" : "";
-    auto        &action    = envGet(FMat, par().action);
-    auto        &solver    = envGet(Solver, par().solver + sub_string);
-    auto        &noise     = envGet(DilutedNoise<FImpl>, par().noise);
-    auto        &v         = envGet(std::vector<FermionField>, getName() + "_v");
-    auto        &w         = envGet(std::vector<FermionField>, getName() + "_w");
-    int         Ls         = env().getObjectLs(par().action);
-
-    envGetTmp(A2A, a2a);
-
-    if (Nl_ > 0)
-    {
-        LOG(Message) << "Computing all-to-all vectors "
-                     << " using eigenpack '" << par().eigenPack << "' ("
-                     << Nl_ << " low modes) and noise '"
-                     << par().noise << "' (" << noise.size() 
-                     << " noise vectors)" << std::endl;
-    }
-    else
-    {
-        LOG(Message) << "Computing all-to-all vectors "
-                     << " using noise '" << par().noise << "' (" << noise.size() 
-                     << " noise vectors)" << std::endl;
-    }
-    // Low modes
-    for (unsigned int il = 0; il < Nl_; il++)
-    {
-        auto &epack  = envGet(Pack, par().eigenPack);
-
-        startTimer("V low mode");
-        LOG(Message) << "V vector i = " << il << " (low mode)" << std::endl;
-        if (Ls == 1)
-        {
-            a2a.makeLowModeV(v[il], epack.evec[il], epack.eval[il]);
-        }
-        else
-        {
-            envGetTmp(FermionField, f5);
-            a2a.makeLowModeV5D(v[il], f5, epack.evec[il], epack.eval[il]);
-        }
-        stopTimer("V low mode");
-        startTimer("W low mode");
-        LOG(Message) << "W vector i = " << il << " (low mode)" << std::endl;
-        if (Ls == 1)
-        {
-            a2a.makeLowModeW(w[il], epack.evec[il], epack.eval[il]);
-        }
-        else
-        {
-            envGetTmp(FermionField, f5);
-            a2a.makeLowModeW5D(w[il], f5, epack.evec[il], epack.eval[il]);
-        }
-        stopTimer("W low mode");
-    }
-
-    // High modes
-    for (unsigned int ih = 0; ih < noise.size(); ih++)
-    {
-        startTimer("V high mode");
-        LOG(Message) << "V vector i = " << Nl_ + ih
-                     << " (" << ((Nl_ > 0) ? "high " : "") 
-                     << "stochastic mode)" << std::endl;
-        if (Ls == 1)
-        {
-            a2a.makeHighModeV(v[Nl_ + ih], noise[ih]);
-        }
-        else
-        {
-            envGetTmp(FermionField, f5);
-            a2a.makeHighModeV5D(v[Nl_ + ih], f5, noise[ih]);
-        }
-        stopTimer("V high mode");
-        startTimer("W high mode");
-        LOG(Message) << "W vector i = " << Nl_ + ih
-                     << " (" << ((Nl_ > 0) ? "high " : "") 
-                     << "stochastic mode)" << std::endl;
-        if (Ls == 1)
-        {
-            a2a.makeHighModeW(w[Nl_ + ih], noise[ih]);
-        }
-        else
-        {
-            envGetTmp(FermionField, f5);
-            a2a.makeHighModeW5D(w[Nl_ + ih], f5, noise[ih]);
-        }
-        stopTimer("W high mode");
-    }
-
-    // I/O if necessary
-    if (!par().output.empty())
-    {
-        startTimer("V I/O");
-        A2AVectorsIo::write(par().output + "_v", v, par().multiFile, vm().getTrajectory());
-        stopTimer("V I/O");
-        startTimer("W I/O");
-        A2AVectorsIo::write(par().output + "_w", w, par().multiFile, vm().getTrajectory());
-        stopTimer("W I/O");
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSolver_A2AVectors_hpp_
diff --git a/Hadrons/Modules/MSolver/Guesser.hpp b/Hadrons/Modules/MSolver/Guesser.hpp
deleted file mode 100644
index 9e2c68c3..00000000
--- a/Hadrons/Modules/MSolver/Guesser.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/Guesser.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MSolver_Guesser_hpp_
-#define Hadrons_MSolver_Guesser_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-template <typename FImpl, int nBasis>
-std::shared_ptr<LinearFunction<typename FImpl::FermionField>> 
-makeGuesser(const std::string epackName)
-{
-    typedef typename FImpl::FermionField                  FermionField;
-    typedef BaseFermionEigenPack<FImpl>                   EPack;
-    typedef CoarseFermionEigenPack<FImpl, nBasis>         CoarseEPack;
-    typedef DeflatedGuesser<FermionField>                 FineGuesser;
-    typedef LocalCoherenceDeflatedGuesser<
-        FermionField, typename CoarseEPack::CoarseField>  CoarseGuesser;
-
-    std::shared_ptr<LinearFunction<typename FImpl::FermionField>> guesserPt;
-
-    DEFINE_ENV_LAMBDA;
-
-    if (epackName.empty())
-    {
-        guesserPt.reset(new ZeroGuesser<FermionField>());
-    }
-    else
-    {
-        try
-        {
-            auto &epack = envGetDerived(EPack, CoarseEPack, epackName);
-            
-            LOG(Message) << "using low-mode deflation with coarse eigenpack '"
-                         << epackName << "' (" 
-                         << epack.evecCoarse.size() << " modes)" << std::endl;
-            guesserPt.reset(new CoarseGuesser(epack.evec, epack.evecCoarse,
-                                              epack.evalCoarse));
-        }
-        catch (Exceptions::ObjectType &e)
-        {
-            auto &epack = envGet(EPack, epackName);
-
-            LOG(Message) << "using low-mode deflation with eigenpack '"
-                         << epackName << "' (" 
-                         << epack.evec.size() << " modes)" << std::endl;
-            guesserPt.reset(new FineGuesser(epack.evec, epack.eval));
-        }
-    }
-
-    return guesserPt;
-}
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-
-#endif
diff --git a/Hadrons/Modules/MSolver/LocalCoherenceLanczos.cc b/Hadrons/Modules/MSolver/LocalCoherenceLanczos.cc
deleted file mode 100644
index 38bea68e..00000000
--- a/Hadrons/Modules/MSolver/LocalCoherenceLanczos.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/LocalCoherenceLanczos.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSolver;
-
-template class Grid::Hadrons::MSolver::TLocalCoherenceLanczos<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>;
-template class Grid::Hadrons::MSolver::TLocalCoherenceLanczos<ZFIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MSolver::TLocalCoherenceLanczos<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS, FIMPLF>;
-template class Grid::Hadrons::MSolver::TLocalCoherenceLanczos<ZFIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS, ZFIMPLF>;
-#endif
diff --git a/Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp b/Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp
deleted file mode 100644
index 72045313..00000000
--- a/Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp
+++ /dev/null
@@ -1,203 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MSolver_LocalCoherenceLanczos_hpp_
-#define Hadrons_MSolver_LocalCoherenceLanczos_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                    Local coherence Lanczos eigensolver                     *
- *****************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-class LocalCoherenceLanczosPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LocalCoherenceLanczosPar,
-                                    std::string,   action,
-                                    bool,          doCoarse,
-                                    LanczosParams, fineParams,
-                                    LanczosParams, coarseParams,
-                                    ChebyParams,   smoother,
-                                    RealD,         coarseRelaxTol,
-                                    std::string,   blockSize,
-                                    std::string,   output,
-                                    bool,          multiFile);
-};
-
-template <typename FImpl, int nBasis, typename FImplIo = FImpl>
-class TLocalCoherenceLanczos: public Module<LocalCoherenceLanczosPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef LocalCoherenceLanczos<typename FImpl::SiteSpinor, 
-                                  typename FImpl::SiteComplex, 
-                                  nBasis>                  LCL;
-    typedef BaseFermionEigenPack<FImpl>                    BasePack;
-    typedef CoarseFermionEigenPack<FImpl, nBasis, FImplIo> CoarsePack;
-    typedef typename CoarsePack::Field                     Field;
-    typedef typename CoarsePack::FieldIo                   FieldIo;
-    typedef typename CoarsePack::CoarseField               CoarseField;
-    typedef typename CoarsePack::CoarseFieldIo             CoarseFieldIo;
-    typedef HADRONS_DEFAULT_SCHUR_OP<FMat, FermionField>   SchurFMat;
-public:
-    // constructor
-    TLocalCoherenceLanczos(const std::string name);
-    // destructor
-    virtual ~TLocalCoherenceLanczos(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LocalCoherenceLanczos, ARG(TLocalCoherenceLanczos<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-MODULE_REGISTER_TMP(ZLocalCoherenceLanczos, ARG(TLocalCoherenceLanczos<ZFIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(LocalCoherenceLanczosIo32, ARG(TLocalCoherenceLanczos<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS, FIMPLF>), MSolver);
-MODULE_REGISTER_TMP(ZLocalCoherenceLanczosIo32, ARG(TLocalCoherenceLanczos<ZFIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS, ZFIMPLF>), MSolver);
-#endif
-
-/******************************************************************************
- *                 TLocalCoherenceLanczos implementation                      *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis, typename FImplIo>
-TLocalCoherenceLanczos<FImpl, nBasis, FImplIo>::TLocalCoherenceLanczos(const std::string name)
-: Module<LocalCoherenceLanczosPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl, int nBasis, typename FImplIo>
-std::vector<std::string> TLocalCoherenceLanczos<FImpl, nBasis, FImplIo>::getInput(void)
-{
-    std::vector<std::string> in = {par().action};
-    
-    return in;
-}
-
-template <typename FImpl, int nBasis, typename FImplIo>
-std::vector<std::string> TLocalCoherenceLanczos<FImpl, nBasis, FImplIo>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis, typename FImplIo>
-void TLocalCoherenceLanczos<FImpl, nBasis, FImplIo>::setup(void)
-{
-    LOG(Message) << "Setting up local coherence Lanczos eigensolver for"
-                 << " action '" << par().action << "' (" << nBasis
-                 << " eigenvectors)..." << std::endl;
-    
-    unsigned int Ls        = env().getObjectLs(par().action);
-    auto         blockSize = strToVec<int>(par().blockSize);
-    GridBase     *gridIo = nullptr, *gridCoarseIo = nullptr;
-
-    if (typeHash<Field>() != typeHash<FieldIo>())
-    {
-        gridIo       = envGetRbGrid(FieldIo, Ls);
-    }
-    if (typeHash<CoarseField>() != typeHash<CoarseFieldIo>())
-    {
-        gridCoarseIo = envGetCoarseGrid(CoarseFieldIo, blockSize, Ls);
-    }
-
-    auto cg  = envGetCoarseGrid(CoarseField, blockSize, Ls);
-    int  cNm = (par().doCoarse) ? par().coarseParams.Nm : 0;
-
-    LOG(Message) << "Coarse grid: " << cg->GlobalDimensions() << std::endl;
-    envCreateDerived(BasePack, CoarsePack, getName(), Ls,
-                     par().fineParams.Nm, cNm, envGetRbGrid(Field, Ls), cg,
-                     gridIo, gridCoarseIo);
-
-    auto &epack = envGetDerived(BasePack, CoarsePack, getName());
-
-    envTmp(SchurFMat, "mat", Ls, envGet(FMat, par().action));
-    envGetTmp(SchurFMat, mat);
-    envTmp(LCL, "solver", Ls, envGetRbGrid(Field, Ls), cg, mat, 
-           Odd, epack.evec, epack.evecCoarse, epack.eval, epack.evalCoarse);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis, typename FImplIo>
-void TLocalCoherenceLanczos<FImpl, nBasis, FImplIo>::execute(void)
-{
-    auto &finePar   = par().fineParams;
-    auto &coarsePar = par().coarseParams;
-    auto &epack     = envGetDerived(BasePack, CoarsePack, getName());
-
-    epack.record.operatorXml = vm().getModule(par().action)->parString();
-    epack.record.solverXml   = parString();
-    envGetTmp(LCL, solver);
-    LOG(Message) << "Performing fine grid IRL -- Nstop= " 
-                 << finePar.Nstop << ", Nk= " << finePar.Nk << ", Nm= " 
-                 << finePar.Nm << std::endl;
-    solver.calcFine(finePar.Cheby, finePar.Nstop, finePar.Nk, finePar.Nm,
-                    finePar.resid,finePar.MaxIt, finePar.betastp, 
-                    finePar.MinRes);
-    solver.testFine(finePar.resid*100.0);
-    if (!par().output.empty())
-    {
-        epack.writeFine(par().output, par().multiFile, vm().getTrajectory());
-    }
-    if (par().doCoarse)
-    {
-        LOG(Message) << "Orthogonalising" << std::endl;
-        solver.Orthogonalise();
-        LOG(Message) << "Performing coarse grid IRL -- Nstop= " 
-                    << coarsePar.Nstop << ", Nk= " << coarsePar.Nk << ", Nm= " 
-                    << coarsePar.Nm << std::endl;
-        solver.calcCoarse(coarsePar.Cheby, par().smoother, par().coarseRelaxTol,
-                          coarsePar.Nstop, coarsePar.Nk, coarsePar.Nm, 
-                          coarsePar.resid, coarsePar.MaxIt, coarsePar.betastp, 
-                          coarsePar.MinRes);
-        solver.testCoarse(coarsePar.resid*100.0, par().smoother, 
-                        par().coarseRelaxTol);
-        if (!par().output.empty())
-        {
-            epack.writeCoarse(par().output, par().multiFile, vm().getTrajectory());
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSolver_LocalCoherenceLanczos_hpp_
diff --git a/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.cc b/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.cc
deleted file mode 100644
index a5286af6..00000000
--- a/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSolver;
-
-template class Grid::Hadrons::MSolver::TMixedPrecisionRBPrecCG<FIMPLF, FIMPLD, HADRONS_DEFAULT_LANCZOS_NBASIS>;
-template class Grid::Hadrons::MSolver::TMixedPrecisionRBPrecCG<ZFIMPLF, ZFIMPLD, HADRONS_DEFAULT_LANCZOS_NBASIS>;
diff --git a/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp b/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp
deleted file mode 100644
index 5a041c79..00000000
--- a/Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MSolver_MixedPrecisionRBPrecCG_hpp_
-#define Hadrons_MSolver_MixedPrecisionRBPrecCG_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-#include <Hadrons/EigenPack.hpp>
-#include <Hadrons/Modules/MSolver/Guesser.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *              Mixed precision schur red-black preconditioned CG             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-class MixedPrecisionRBPrecCGPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(MixedPrecisionRBPrecCGPar,
-                                    std::string , innerAction,
-                                    std::string , outerAction,
-                                    unsigned int, maxInnerIteration,
-                                    unsigned int, maxOuterIteration,
-                                    double      , residual,
-                                    std::string , eigenPack);
-};
-
-template <typename FImplInner, typename FImplOuter, int nBasis>
-class TMixedPrecisionRBPrecCG: public Module<MixedPrecisionRBPrecCGPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImplInner, Inner);
-    FERM_TYPE_ALIASES(FImplOuter, Outer);
-    SOLVER_TYPE_ALIASES(FImplOuter,);
-    typedef HADRONS_DEFAULT_SCHUR_OP<FMatInner, FermionFieldInner> SchurFMatInner;
-    typedef HADRONS_DEFAULT_SCHUR_OP<FMatOuter, FermionFieldOuter> SchurFMatOuter;
-private:
-    template <typename Field>
-    class OperatorFunctionWrapper: public OperatorFunction<Field>
-    {
-    public:
-        using OperatorFunction<Field>::operator();
-        OperatorFunctionWrapper(LinearFunction<Field> &fn): fn_(fn) {};
-        virtual ~OperatorFunctionWrapper(void) = default;
-        virtual void operator()(LinearOperatorBase<Field> &op, 
-                                const Field &in, Field &out)
-        {
-            fn_(in, out);
-        }
-    private:
-        LinearFunction<Field> &fn_;
-    };
-public:
-    // constructor
-    TMixedPrecisionRBPrecCG(const std::string name);
-    // destructor
-    virtual ~TMixedPrecisionRBPrecCG(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getReference(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(MixedPrecisionRBPrecCG, 
-    ARG(TMixedPrecisionRBPrecCG<FIMPLF, FIMPLD, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-MODULE_REGISTER_TMP(ZMixedPrecisionRBPrecCG, 
-    ARG(TMixedPrecisionRBPrecCG<ZFIMPLF, ZFIMPLD, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-
-/******************************************************************************
- *                 TMixedPrecisionRBPrecCG implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImplInner, typename FImplOuter, int nBasis>
-TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::TMixedPrecisionRBPrecCG(const std::string name)
-: Module<MixedPrecisionRBPrecCGPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImplInner, typename FImplOuter, int nBasis>
-std::vector<std::string> TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImplInner, typename FImplOuter, int nBasis>
-std::vector<std::string> TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::getReference(void)
-{
-    std::vector<std::string> ref = {par().innerAction, par().outerAction};
-    
-    if (!par().eigenPack.empty())
-    {
-        ref.push_back(par().eigenPack);
-    }
-    
-    return ref;
-}
-
-template <typename FImplInner, typename FImplOuter, int nBasis>
-std::vector<std::string> TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName() + "_subtract"};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImplInner, typename FImplOuter, int nBasis>
-void TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::setup(void)
-{
-    LOG(Message) << "Setting up Schur red-black preconditioned mixed-precision "
-                 << "CG for inner/outer action '" << par().innerAction 
-                 << "'/'" << par().outerAction << "', residual "
-                 << par().residual << ", and maximum inner/outer iteration " 
-                 << par().maxInnerIteration << "/" << par().maxOuterIteration
-                 << std::endl;
-
-    auto Ls        = env().getObjectLs(par().innerAction);
-    auto &imat     = envGet(FMatInner, par().innerAction);
-    auto &omat     = envGet(FMatOuter, par().outerAction);
-    auto guesserPt = makeGuesser<FImplOuter, nBasis>(par().eigenPack);
-
-    auto makeSolver = [&imat, &omat, guesserPt, Ls, this](bool subGuess) 
-    {
-        return [&imat, &omat, guesserPt, subGuess, Ls, this]
-        (FermionFieldOuter &sol, const FermionFieldOuter &source) 
-        {
-            typedef typename FermionFieldInner::vector_type VTypeInner;
-
-            SchurFMatInner simat(imat);
-            SchurFMatOuter somat(omat);
-            MixedPrecisionConjugateGradient<FermionFieldOuter, FermionFieldInner> 
-                mpcg(par().residual, par().maxInnerIteration, 
-                     par().maxOuterIteration, 
-                     env().template getRbGrid<VTypeInner>(Ls),
-                     simat, somat);
-            OperatorFunctionWrapper<FermionFieldOuter> wmpcg(mpcg);
-            HADRONS_DEFAULT_SCHUR_SOLVE<FermionFieldOuter> schurSolver(wmpcg);
-            schurSolver.subtractGuess(subGuess);
-            schurSolver(omat, source, sol, *guesserPt);
-        };
-    };
-    auto solver = makeSolver(false);
-    envCreate(Solver, getName(), Ls, solver, omat);
-    auto solver_subtract = makeSolver(true);
-    envCreate(Solver, getName() + "_subtract", Ls, solver_subtract, omat);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImplInner, typename FImplOuter, int nBasis>
-void TMixedPrecisionRBPrecCG<FImplInner, FImplOuter, nBasis>
-::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSolver_MixedPrecisionRBPrecCG_hpp_
diff --git a/Hadrons/Modules/MSolver/RBPrecCG.cc b/Hadrons/Modules/MSolver/RBPrecCG.cc
deleted file mode 100644
index bf3b0868..00000000
--- a/Hadrons/Modules/MSolver/RBPrecCG.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/RBPrecCG.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSolver/RBPrecCG.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSolver;
-
-template class Grid::Hadrons::MSolver::TRBPrecCG<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>;
-template class Grid::Hadrons::MSolver::TRBPrecCG<ZFIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>;
-
diff --git a/Hadrons/Modules/MSolver/RBPrecCG.hpp b/Hadrons/Modules/MSolver/RBPrecCG.hpp
deleted file mode 100644
index a1ef2f7f..00000000
--- a/Hadrons/Modules/MSolver/RBPrecCG.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSolver/RBPrecCG.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: fionnoh <fionnoh@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSolver_RBPrecCG_hpp_
-#define Hadrons_MSolver_RBPrecCG_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Solver.hpp>
-#include <Hadrons/EigenPack.hpp>
-#include <Hadrons/Modules/MSolver/Guesser.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                     Schur red-black preconditioned CG                      *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSolver)
-
-class RBPrecCGPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(RBPrecCGPar ,
-                                    std::string , action,
-                                    unsigned int, maxIteration,
-                                    double      , residual,
-                                    std::string , eigenPack);
-};
-
-template <typename FImpl, int nBasis>
-class TRBPrecCG: public Module<RBPrecCGPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TRBPrecCG(const std::string name);
-    // destructor
-    virtual ~TRBPrecCG(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getReference(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(RBPrecCG, ARG(TRBPrecCG<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-MODULE_REGISTER_TMP(ZRBPrecCG, ARG(TRBPrecCG<ZFIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>), MSolver);
-
-/******************************************************************************
- *                      TRBPrecCG template implementation                     *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis>
-TRBPrecCG<FImpl, nBasis>::TRBPrecCG(const std::string name)
-: Module(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl, int nBasis>
-std::vector<std::string> TRBPrecCG<FImpl, nBasis>::getInput(void)
-{
-    std::vector<std::string> in = {};
-    
-    return in;
-}
-
-template <typename FImpl, int nBasis>
-std::vector<std::string> TRBPrecCG<FImpl, nBasis>::getReference(void)
-{
-    std::vector<std::string> ref = {par().action};
-    
-    if (!par().eigenPack.empty())
-    {
-        ref.push_back(par().eigenPack);
-    }
-
-    return ref;
-}
-
-template <typename FImpl, int nBasis>
-std::vector<std::string> TRBPrecCG<FImpl, nBasis>::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName() + "_subtract"};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis>
-void TRBPrecCG<FImpl, nBasis>::setup(void)
-{
-    if (par().maxIteration == 0)
-    {
-        HADRONS_ERROR(Argument, "zero maximum iteration");
-    }
-
-    LOG(Message) << "setting up Schur red-black preconditioned CG for"
-                 << " action '" << par().action << "' with residual "
-                 << par().residual << ", maximum iteration " 
-                 << par().maxIteration << std::endl;
-
-    auto Ls        = env().getObjectLs(par().action);
-    auto &mat      = envGet(FMat, par().action);
-    auto guesserPt = makeGuesser<FImpl, nBasis>(par().eigenPack);
-
-    auto makeSolver = [&mat, guesserPt, this](bool subGuess) {
-        return [&mat, guesserPt, subGuess, this](FermionField &sol,
-                                     const FermionField &source) {
-            ConjugateGradient<FermionField> cg(par().residual,
-                                               par().maxIteration);
-            HADRONS_DEFAULT_SCHUR_SOLVE<FermionField> schurSolver(cg);
-            schurSolver.subtractGuess(subGuess);
-            schurSolver(mat, source, sol, *guesserPt);
-        };
-    };
-    auto solver = makeSolver(false);
-    envCreate(Solver, getName(), Ls, solver, mat);
-    auto solver_subtract = makeSolver(true);
-    envCreate(Solver, getName() + "_subtract", Ls, solver_subtract, mat);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl, int nBasis>
-void TRBPrecCG<FImpl, nBasis>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSolver_RBPrecCG_hpp_
diff --git a/Hadrons/Modules/MSource/Convolution.cc b/Hadrons/Modules/MSource/Convolution.cc
deleted file mode 100644
index b8ffecf8..00000000
--- a/Hadrons/Modules/MSource/Convolution.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MSource/Convolution.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TConvolution<FIMPL>;
diff --git a/Hadrons/Modules/MSource/Convolution.hpp b/Hadrons/Modules/MSource/Convolution.hpp
deleted file mode 100644
index 646b9417..00000000
--- a/Hadrons/Modules/MSource/Convolution.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-#ifndef Hadrons_MSource_Convolution_hpp_
-#define Hadrons_MSource_Convolution_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Convolution                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class ConvolutionPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ConvolutionPar,
-                                    std::string, field,
-                                    std::string, filter,
-                                    std::string, mom);
-};
-
-template <typename FImpl>
-class TConvolution: public Module<ConvolutionPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TConvolution(const std::string name);
-    // destructor
-    virtual ~TConvolution(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::vector<int> mom_;
-};
-
-MODULE_REGISTER_TMP(Convolution, TConvolution<FIMPL>, MSource);
-
-/******************************************************************************
- *                 TConvolution implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TConvolution<FImpl>::TConvolution(const std::string name)
-: Module<ConvolutionPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TConvolution<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field, par().filter};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TConvolution<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TConvolution<FImpl>::setup(void)
-{
-     mom_ = strToVec<int>(par().mom);
-     if(mom_.size() != env().getNd()) {
-         HADRONS_ERROR(Size, std::string("momentum has ")
-                 + std::to_string(mom_.size()) + " instead of "
-                 + std::to_string(env().getNd()) + " components");
-     }
-
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(ComplexField, "momfield");
-    envTmp(FFT, "fft", 1, env().getGrid());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TConvolution<FImpl>::execute(void)
-{
-    auto &filter = envGet(ComplexField, par().filter);
-    auto &field  = envGet(PropagatorField, par().field);
-    auto &out    = envGet(PropagatorField, getName());
-    envGetTmp(ComplexField, momfield);
-    envGetTmp(FFT, fft);
-
-    std::vector<int> mask(env().getNd(), 1);
-    mask.back()=0; //transform only the spatial dimensions
-
-    startTimer("Fourier transform");
-    fft.FFT_dim_mask(momfield, filter, mask, FFT::forward);
-    fft.FFT_dim_mask(out,      field, mask, FFT::forward);
-    stopTimer("Fourier transform");
-
-    startTimer("momentum-space multiplication");
-    out=momfield*out;
-    stopTimer("momentum-space multiplication");
-
-    startTimer("inserting momentum");
-    for(int mu=0; mu<env().getNd(); mu++)
-    {
-       if(mom_[mu]!=0)
-       {
-          out=Cshift(out, mu, -mom_[mu]);
-       }
-    }
-    stopTimer("inserting momentum");
-
-    startTimer("Fourier transform");
-    fft.FFT_dim_mask(out, out, mask, FFT::backward);
-    stopTimer("Fourier transform");
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_Convolution_hpp_
diff --git a/Hadrons/Modules/MSource/Gauss.cc b/Hadrons/Modules/MSource/Gauss.cc
deleted file mode 100644
index 5b469f70..00000000
--- a/Hadrons/Modules/MSource/Gauss.cc
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <Hadrons/Modules/MSource/Gauss.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TGauss<FIMPL>;
-template class Grid::Hadrons::MSource::TGauss<ScalarImplCR>;
diff --git a/Hadrons/Modules/MSource/Gauss.hpp b/Hadrons/Modules/MSource/Gauss.hpp
deleted file mode 100644
index 8957288d..00000000
--- a/Hadrons/Modules/MSource/Gauss.hpp
+++ /dev/null
@@ -1,173 +0,0 @@
-#ifndef Hadrons_MSource_Gauss_hpp_
-#define Hadrons_MSource_Gauss_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Gauss                                              *
- * result[n] = 1/(sqrt(2*pi)*width)^dim                                       *
- *            * exp(-|n-position|^2/(2*width^2))                              *
- *            * exp(i*2*pi/L*mom*n)                                           *
- * where:                                                                     *
- *   n=(n[0],n[1],...,n[dim-1])  (lattice coordinate)                         *
- *   dim=Nd-1                                                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class GaussPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GaussPar,
-                                    std::string, position,
-                                    std::string, mom,
-                                    Integer,     tA,
-                                    Integer,     tB,
-                                    double,      width);
-};
-
-template <typename FImpl>
-class TGauss: public Module<GaussPar>
-{
-    BASIC_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TGauss(const std::string name);
-    // destructor
-    virtual ~TGauss(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::vector<int> position_;
-    std::vector<int> mom_;
-};
-
-MODULE_REGISTER_TMP(Gauss, TGauss<FIMPL>, MSource);
-MODULE_REGISTER_TMP(ScalarGauss, TGauss<ScalarImplCR>, MSource);
-
-/******************************************************************************
- *                 TGauss implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TGauss<FImpl>::TGauss(const std::string name)
-: Module<GaussPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TGauss<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TGauss<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TGauss<FImpl>::setup(void)
-{
-    auto parse_vector = [](const std::string &vec, int dim,
-            const std::string &desc)
-    {
-        std::vector<int> res = strToVec<int>(vec);
-        if(res.size() != dim) {
-            HADRONS_ERROR(Size, desc + " has "
-                    + std::to_string(res.size()) + " instead of "
-                    + std::to_string(dim) + " components");
-        }
-        return res;
-    };
-    position_ = parse_vector(par().position, env().getNd()-1, "position");
-    mom_      = parse_vector(par().mom,      env().getNd(),   "momentum");
-
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(ComplexField, "component");
-    envTmpLat(ComplexField, "ScalarRho");
-    envTmp(LatticeInteger, "compHelper", 1, envGetGrid(ComplexField));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TGauss<FImpl>::execute(void)
-{
-    auto &rho = envGet(PropagatorField, getName());
-    envGetTmp(ComplexField, component);
-    envGetTmp(ComplexField, ScalarRho);
-    envGetTmp(LatticeInteger, compHelper);
-    const int dim=env().getNd()-1;
-    const Real fact=-0.5/std::pow(par().width,2);
-    const Complex i(0.0, 1.0);
-    const Real Pi(M_PI);
-    const SitePropagator idMat=[](){ SitePropagator s; s=1.; return s; }();
-
-    ScalarRho=Zero();
-    for(int mu=0; mu<dim; mu++) {
-        assert(env().getDim(mu)%2==0);
-        assert(position_[mu]>=0 && position_[mu]<env().getDim(mu));
-
-        const int Lmu=env().getDim(mu);
-        const int LmuHalf=Lmu/2;
-        const int posMu=position_[mu];
-
-        LatticeCoordinate(component, mu);
-        LatticeCoordinate(compHelper, mu);
-
-        //spatial dimensions of momentum phase
-        ScalarRho+=(i*(mom_[mu]*2*Pi/Lmu))*component;
-
-        //Gauss distribution
-        component-=Complex(posMu);
-        if(posMu<LmuHalf)
-        {
-            component=where((compHelper>Integer(posMu+LmuHalf)),
-                    component-Complex(Lmu),
-                    component);
-        }
-        else
-        {
-            component=where((compHelper<=Integer(posMu-LmuHalf)),
-                    component+Complex(Lmu),
-                    component);
-        }
-        ScalarRho+=component*component*fact;
-    }
-
-    //time component of momentum phase
-    LatticeCoordinate(component, dim);
-    ScalarRho+=(i*(mom_.at(dim)*2*Pi/env().getDim(dim)))*component;
-
-    //compute scalar result
-    ScalarRho=exp(ScalarRho)*Complex(std::pow(sqrt(2*Pi)*par().width,-dim));
-
-    //select time slices
-    LatticeCoordinate(compHelper, dim);
-    ScalarRho=where((compHelper>=par().tA && compHelper<=par().tB),
-          ScalarRho,
-          0.*ScalarRho);
-
-    //compute output field rho
-    rho=ScalarRho*idMat;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_Gauss_hpp_
diff --git a/Hadrons/Modules/MSource/JacobiSmear.cc b/Hadrons/Modules/MSource/JacobiSmear.cc
deleted file mode 100644
index e9b37f1b..00000000
--- a/Hadrons/Modules/MSource/JacobiSmear.cc
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/MSource/JacobiSmear.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TJacobiSmear<FIMPL>;
diff --git a/Hadrons/Modules/MSource/JacobiSmear.hpp b/Hadrons/Modules/MSource/JacobiSmear.hpp
deleted file mode 100644
index 5aa5c705..00000000
--- a/Hadrons/Modules/MSource/JacobiSmear.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef Hadrons_MSource_JacobiSmear_hpp_
-#define Hadrons_MSource_JacobiSmear_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         JacobiSmear                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class JacobiSmearPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(JacobiSmearPar,
-                                    std::string, gauge,
-                                    double, width,
-                                    int, iterations,
-                                    int, orthog,
-                                    std::string, source);
-};
-
-template <typename FImpl>
-class TJacobiSmear: public Module<JacobiSmearPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef typename FImpl::GaugeLinkField GaugeMat;
-public:
-    // constructor
-    TJacobiSmear(const std::string name);
-    // destructor
-    virtual ~TJacobiSmear(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(JacobiSmear, TJacobiSmear<FIMPL>, MSource);
-
-/******************************************************************************
- *                 TJacobiSmear implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TJacobiSmear<FImpl>::TJacobiSmear(const std::string name)
-: Module<JacobiSmearPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TJacobiSmear<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().source, par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TJacobiSmear<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TJacobiSmear<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envTmp(std::vector<GaugeMat>, "Umu", 1, 4, envGetGrid(LatticeColourMatrix));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TJacobiSmear<FImpl>::execute(void)
-{
-    auto &out = envGet(PropagatorField, getName());
-    auto &src = envGet(PropagatorField, par().source);
-    auto &U = envGet(GaugeField, par().gauge);
-    envGetTmp(std::vector<GaugeMat>, Umu);
-    for(int mu=0; mu<4; mu++)
-    {
-       Umu.at(mu)=peekLorentz(U,mu);
-    }
-    CovariantSmearing<FImpl> covsmear;
-    out=src;
-    startTimer("Jacobi iteration");
-    covsmear.GaussianSmear(Umu, out, par().width, par().iterations, par().orthog);
-    stopTimer("Jacobi iteration");
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_JacobiSmear_hpp_
diff --git a/Hadrons/Modules/MSource/Momentum.cc b/Hadrons/Modules/MSource/Momentum.cc
deleted file mode 100644
index ca72092f..00000000
--- a/Hadrons/Modules/MSource/Momentum.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Momentum.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/Momentum.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TMomentum<FIMPL>;
-
diff --git a/Hadrons/Modules/MSource/Momentum.hpp b/Hadrons/Modules/MSource/Momentum.hpp
deleted file mode 100644
index 87a19fe5..00000000
--- a/Hadrons/Modules/MSource/Momentum.hpp
+++ /dev/null
@@ -1,149 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Momentum.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_Momentum_hpp_
-#define Hadrons_Momentum_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/* 
-Plane Wave source
------------------
-src_x = e^i2pi/L * p *position
-*/
-
-/******************************************************************************
- *                          Plane Wave source                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class MomentumPar: Serializable
-{
-public:
-//What is meant by serializable in this context
-GRID_SERIALIZABLE_CLASS_MEMBERS(MomentumPar,
-std::string, mom);
-};
-
-
-template <typename FImpl>
-class TMomentum: public Module<MomentumPar>
-{
-public:
-FERM_TYPE_ALIASES(FImpl,);
-public:
-// constructor
-TMomentum(const std::string name);
-// destructor
-virtual ~TMomentum(void) {};
-// dependency relation
-virtual std::vector<std::string> getInput(void);
-virtual std::vector<std::string> getOutput(void);
-// setup
-virtual void setup(void);
-// execution
-virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Momentum, TMomentum<FIMPL>, MSource);
-//MODULE_REGISTER_NS(Momentum, TMomentum, MSource);
-
-/******************************************************************************
-*                       TMomentum template implementation                     *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TMomentum<FImpl>::TMomentum(const std::string name)
-: Module<MomentumPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TMomentum<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TMomentum<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    return out;
-}
-
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMomentum<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-}
-
-
-//execution//////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMomentum<FImpl>::execute(void)
-{
-    LOG(Message) << "Generating planewave momentum source with momentum " << par().mom << std::endl;
-    //what does this env do?
-    PropagatorField &src = envGet(PropagatorField, getName());
-    Lattice<iScalar<vInteger>> t(env().getGrid());
-    LatticeComplex             C(env().getGrid()), coor(env().getGrid());
-    std::vector<Real>          p;
-    std::vector<Real> latt_size(GridDefaultLatt().begin(), GridDefaultLatt().end()); 
-    Complex                    i(0.0,1.0);
-
-    LOG(Message) << " " << std::endl;
-    //get the momentum from parameters
-    p  = strToVec<Real>(par().mom);
-    C = Zero();
-    LOG(Message) << "momentum converted from string - " << std::to_string(p[0]) <<std::to_string(p[1]) <<std::to_string(p[2]) <<   std::to_string(p[3]) << std::endl;
-    for(int mu=0;mu<4;mu++){
-    Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-    LatticeCoordinate(coor,mu);
-    C = C +(TwoPiL * p[mu]) * coor;
-    }
-    C = exp(C*i);
-    LOG(Message) << "exponential of pdotx taken " << std::endl;
-    src = src + C;
-    LOG(Message) << "source created" << std::endl;
-
-}
-
-
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Momentum_hpp_
diff --git a/Hadrons/Modules/MSource/MomentumPhase.cc b/Hadrons/Modules/MSource/MomentumPhase.cc
deleted file mode 100644
index f1ff48d6..00000000
--- a/Hadrons/Modules/MSource/MomentumPhase.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/MomentumPhase.cc
-
-Copyright (C) 2015-2019
-
-Author: Felix Erben <ferben@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/MomentumPhase.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TMomentumPhase<FIMPL>;
-template class Grid::Hadrons::MSource::TMomentumPhase<ZFIMPL>;
diff --git a/Hadrons/Modules/MSource/MomentumPhase.hpp b/Hadrons/Modules/MSource/MomentumPhase.hpp
deleted file mode 100644
index f2f94af1..00000000
--- a/Hadrons/Modules/MSource/MomentumPhase.hpp
+++ /dev/null
@@ -1,160 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/MomentumPhase.hpp
-
-Copyright (C) 2015-2019
-
-Author: Felix Erben <ferben@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_MomentumPhase_hpp_
-#define Hadrons_MSource_MomentumPhase_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Multiply source field by momentum phase
- -----------------------------
- * can be used to multiply a Z2-wall source by a phase e^{ipx}, which is needed for 
- * 2pt-correlation functions of mesons with nonzero momenta.
- 
- */
-
-/******************************************************************************
- *                         MomentumPhase                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class MomentumPhasePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(MomentumPhasePar,
-                                    std::string,    src,
-                                    std::string,    mom);
-};
-
-template <typename FImpl>
-class TMomentumPhase: public Module<MomentumPhasePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TMomentumPhase(const std::string name);
-    // destructor
-    virtual ~TMomentumPhase(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasPhase_{false};
-    std::string momphName_, tName_;
-};
-
-MODULE_REGISTER_TMP(MomentumPhase, TMomentumPhase<FIMPL>, MSource);
-MODULE_REGISTER_TMP(ZMomentumPhase, TMomentumPhase<ZFIMPL>, MSource);
-
-/******************************************************************************
- *                         TMomentumPhase implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TMomentumPhase<FImpl>::TMomentumPhase(const std::string name)
-: Module<MomentumPhasePar>(name)
-, momphName_ (name + "_momph")
-, tName_ (name + "_t")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TMomentumPhase<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().src};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TMomentumPhase<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMomentumPhase<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
-    envCacheLat(LatticeComplex, momphName_);
-    envTmpLat(LatticeComplex, "coor");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMomentumPhase<FImpl>::execute(void)
-{
-    LOG(Message) << "Multiplying source field " << par().src
-                 << " by momentum phase "
-                 << par().mom << std::endl;
-    auto  &out = envGet(PropagatorField, getName());
-    auto  &src   = envGet(PropagatorField, par().src);
-    auto  &ph  = envGet(LatticeComplex, momphName_);
-    auto  &t   = envGet(Lattice<iScalar<vInteger>>, tName_);
-    
-    if (!hasPhase_)
-    {
-        Complex           i(0.0,1.0);
-        std::vector<Real> p;
-
-        envGetTmp(LatticeComplex, coor);
-        p  = strToVec<Real>(par().mom);
-        ph = Zero();
-        for(unsigned int mu = 0; mu < env().getNd(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            ph = ph + (p[mu]/env().getDim(mu))*coor;
-        }
-        ph = exp((Real)(2*M_PI)*i*ph);
-        LatticeCoordinate(t, Tp);
-        hasPhase_ = true;
-    }
-    out = ph*src;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_MomentumPhase_hpp_
diff --git a/Hadrons/Modules/MSource/Point.cc b/Hadrons/Modules/MSource/Point.cc
deleted file mode 100644
index 52fc9399..00000000
--- a/Hadrons/Modules/MSource/Point.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Point.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/Point.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TPoint<FIMPL>;
-template class Grid::Hadrons::MSource::TPoint<ScalarImplCR>;
-
diff --git a/Hadrons/Modules/MSource/Point.hpp b/Hadrons/Modules/MSource/Point.hpp
deleted file mode 100644
index a33c5308..00000000
--- a/Hadrons/Modules/MSource/Point.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Point.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_Point_hpp_
-#define Hadrons_MSource_Point_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Point source
- ------------
- * src_x = delta_x,position
- 
- * options:
- - position: space-separated integer sequence (e.g. "0 1 1 0")
- 
- */
-
-/******************************************************************************
- *                                  TPoint                                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class PointPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(PointPar,
-                                    std::string, position);
-};
-
-template <typename FImpl>
-class TPoint: public Module<PointPar>
-{
-public:
-    BASIC_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TPoint(const std::string name);
-    // destructor
-    virtual ~TPoint(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Point,       TPoint<FIMPL>,        MSource);
-MODULE_REGISTER_TMP(ScalarPoint, TPoint<ScalarImplCR>, MSource);
-
-/******************************************************************************
- *                       TPoint template implementation                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TPoint<FImpl>::TPoint(const std::string name)
-: Module<PointPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TPoint<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TPoint<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPoint<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TPoint<FImpl>::execute(void)
-{
-    LOG(Message) << "Creating point source at position [" << par().position
-                << "]" << std::endl;
-
-    std::vector<int> position = strToVec<int>(par().position);
-    auto             &src     = envGet(PropagatorField, getName());
-    SitePropagator   id;
-    
-    if (position.size() != env().getNd())
-    {
-        HADRONS_ERROR(Size, "position has " + std::to_string(position.size())
-                      + " components (must have " + std::to_string(env().getNd()) + ")");
-    }
-    id  = 1.;
-    src = Zero();
-    pokeSite(id, src, position);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_Point_hpp_
diff --git a/Hadrons/Modules/MSource/SeqAslash.cc b/Hadrons/Modules/MSource/SeqAslash.cc
deleted file mode 100644
index 6586f2f2..00000000
--- a/Hadrons/Modules/MSource/SeqAslash.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqAslash.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/SeqAslash.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TSeqAslash<FIMPL>;
-
diff --git a/Hadrons/Modules/MSource/SeqAslash.hpp b/Hadrons/Modules/MSource/SeqAslash.hpp
deleted file mode 100644
index ccca15d9..00000000
--- a/Hadrons/Modules/MSource/SeqAslash.hpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqAslash.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_SeqAslash_hpp_
-#define Hadrons_MSource_SeqAslash_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Sequential source
- -----------------------------
- * src_x = q_x * theta(x_3 - tA) * theta(tB - x_3) * i * A_mu g_mu * exp(i x.mom)
- 
- * options:
- - q: input propagator (string)
- - tA: begin timeslice (integer)
- - tB: end timesilce (integer)
- - emField: input photon field (string)
- - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.")
- 
- */
-
-/******************************************************************************
- *                         SeqAslash                             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class SeqAslashPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SeqAslashPar,
-                                    std::string,    q,
-                                    unsigned int,   tA,
-                                    unsigned int,   tB,
-                                    std::string,    emField,
-                                    std::string,    mom);
-};
-
-template <typename FImpl>
-class TSeqAslash: public Module<SeqAslashPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    typedef PhotonR::GaugeField     EmField;
-public:
-    // constructor
-    TSeqAslash(const std::string name);
-    // destructor
-    virtual ~TSeqAslash(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasPhase_{false};
-    std::string momphName_, tName_;
-};
-
-MODULE_REGISTER_TMP(SeqAslash, TSeqAslash<FIMPL>, MSource);
-
-/******************************************************************************
- *                         TSeqAslash implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSeqAslash<FImpl>::TSeqAslash(const std::string name)
-: Module<SeqAslashPar>(name)
-, momphName_ (name + "_momph")
-, tName_ (name + "_t")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSeqAslash<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q,par().emField};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSeqAslash<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqAslash<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
-    envCacheLat(LatticeComplex, momphName_);
-    envTmpLat(LatticeComplex, "coor");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqAslash<FImpl>::execute(void)
-{
-    if (par().tA == par().tB)
-    {
-        LOG(Message) << "Generating Aslash sequential source at t= " << par().tA 
-		     << " using the photon field " << par().emField << std::endl; 
-    }
-    else
-    {
-        LOG(Message) << "Generating Aslash sequential source for "
-                     << par().tA << " <= t <= " << par().tB 
-		     << " using the photon field " << par().emField << std::endl;
-    }
-    auto  &src = envGet(PropagatorField, getName()); src=Zero();
-    auto  &q   = envGet(PropagatorField, par().q);
-    auto  &ph  = envGet(LatticeComplex, momphName_);
-    auto  &t   = envGet(Lattice<iScalar<vInteger>>, tName_);
-
-    if (!hasPhase_)
-    {
-        Complex           i(0.0,1.0);
-        std::vector<Real> p;
-
-        envGetTmp(LatticeComplex, coor);
-        p  = strToVec<Real>(par().mom);
-        ph = Zero();
-        for(unsigned int mu = 0; mu < env().getNd(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            ph = ph + (p[mu]/env().getDim(mu))*coor;
-        }
-        ph = exp((Real)(2*M_PI)*i*ph);
-        LatticeCoordinate(t, Tp);
-        hasPhase_ = true;
-    }
-    auto &stoch_photon = envGet(EmField,  par().emField);
-    Complex ci(0.0,1.0);
-    for(unsigned int mu=0;mu<=3;mu++)
-    {
-	Gamma gmu(Gamma::gmu[mu]);
-	src = src + where((t >= par().tA) and (t <= par().tB), ci * PeekIndex<LorentzIndex>(stoch_photon, mu) *ph*(gmu*q), 0.*q);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_SeqAslash_hpp_
diff --git a/Hadrons/Modules/MSource/SeqConserved.cc b/Hadrons/Modules/MSource/SeqConserved.cc
deleted file mode 100644
index fbef504f..00000000
--- a/Hadrons/Modules/MSource/SeqConserved.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqConserved.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/SeqConserved.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TSeqConserved<FIMPL>;
-template class Grid::Hadrons::MSource::TSeqConserved<ZFIMPL>;
diff --git a/Hadrons/Modules/MSource/SeqConserved.hpp b/Hadrons/Modules/MSource/SeqConserved.hpp
deleted file mode 100644
index c8d5121d..00000000
--- a/Hadrons/Modules/MSource/SeqConserved.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqConserved.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_SeqConserved_hpp_
-#define Hadrons_MSource_SeqConserved_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Sequential source with insertion of conserved current. 
- Additionally optional insertion of a photon field A_\mu(x).
- -----------------------------
- * src_x = sum_{mu=mu_min}^{mu_max} 
-     q_x * theta(x_3 - tA) * theta(tB - x_3) * J_mu * exp(i x.mom) (* A_\mu(x))
- 
- * options:
- - q: input propagator (string)
- - action: fermion action used for propagator q (string)
- - tA: begin timeslice (integer)
- - tB: end timesilce (integer)
- - curr_type: type of conserved current to insert (Current)
- - mu_min: begin Lorentz Index (integer)
- - mu_max: end Lorentz Index (integer)
- - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.")
- - photon: optional photon field (string)
- 
- */
-
-/******************************************************************************
- *                              SeqConserved                                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class SeqConservedPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SeqConservedPar,
-                                    std::string,  q,
-                                    std::string,  action,
-                                    unsigned int, tA,
-                                    unsigned int, tB,
-                                    Current,      curr_type,
-                                    unsigned int, mu_min,
-                                    unsigned int, mu_max,
-                                    std::string,  mom,
-                                    std::string,  photon);
-};
-
-template <typename FImpl>
-class TSeqConserved: public Module<SeqConservedPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    typedef PhotonR::GaugeField     EmField;
-public:
-    // constructor
-    TSeqConserved(const std::string name);
-    // destructor
-    virtual ~TSeqConserved(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        SeqhasPhase_{false}; 
-    std::string SeqmomphName_;
-};
-
-MODULE_REGISTER_TMP(SeqConserved, TSeqConserved<FIMPL>, MSource);
-MODULE_REGISTER_TMP(ZSeqConserved, TSeqConserved<ZFIMPL>, MSource);
-
-
-/******************************************************************************
- *                      TSeqConserved implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSeqConserved<FImpl>::TSeqConserved(const std::string name)
-: Module<SeqConservedPar>(name)
-, SeqmomphName_ (name + "_Seqmomph")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSeqConserved<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q, par().action};
-    if (!par().photon.empty()) in.push_back(par().photon);
-        
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSeqConserved<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-   return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqConserved<FImpl>::setup(void)
-{
-    auto Ls_ = env().getObjectLs(par().action);
-    envCreateLat(PropagatorField, getName(), Ls_);
-    envTmpLat(PropagatorField, "src_tmp",Ls_);
-    envCacheLat(LatticeComplex, SeqmomphName_);
-    envTmpLat(LatticeComplex, "coor");
-    envTmpLat(LatticeComplex, "latt_compl");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqConserved<FImpl>::execute(void)
-{
-    if (par().tA == par().tB)
-    {
-        LOG(Message) << "Generating sequential source with conserved "
-                     << par().curr_type << " current at " 
-		     << "t = " << par().tA << " summed over the indices " 
-		     << par().mu_min << " <= mu <= " << par().mu_max 
-		     << std::endl;
-    }
-    else
-    {
-        LOG(Message) << "Generating sequential source with conserved "
-                     << par().curr_type << " current for " 
-                     << par().tA << " <= t <= " 
-                     << par().tB << " summed over the indices " 
-		     << par().mu_min << " <= mu <= " << par().mu_max
-	             << std::endl;
-    }
-    auto &src = envGet(PropagatorField, getName());
-    envGetTmp(PropagatorField, src_tmp);
-    src_tmp = src;
-    auto &q   = envGet(PropagatorField, par().q);
-    auto &mat = envGet(FMat, par().action);
-    envGetTmp(LatticeComplex, latt_compl);
-
-    src = Zero();
-
-    //exp(ipx)
-    auto &mom_phase = envGet(LatticeComplex, SeqmomphName_);
-    if (!SeqhasPhase_)
-    {    
-        std::vector<Real> mom = strToVec<Real>(par().mom);
-        mom_phase = Zero();
-        Complex           i(0.0,1.0);
-        envGetTmp(LatticeComplex, coor);
-        for(unsigned int mu = 0; mu < env().getNd(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            mom_phase = mom_phase + (mom[mu]/env().getDim(mu))*coor;
-        }
-        mom_phase = exp((Real)(2*M_PI)*i*mom_phase);
-        SeqhasPhase_ = true;
-    }
-    LOG(Message) << "Inserting momentum " << strToVec<Real>(par().mom) << std::endl;
-
-
-
-    if (!par().photon.empty())    	
-    {
-	 LOG(Message) << "Inserting the stochastic photon field " << par().photon << std::endl;
-    }
-
-    for(unsigned int mu=par().mu_min;mu<=par().mu_max;mu++)
-    {
-        if (!par().photon.empty())    	
-        {
-	    //Get the stochastic photon field, if required
-            auto &stoch_photon = envGet(EmField,  par().photon);
-    	    latt_compl =  PeekIndex<LorentzIndex>(stoch_photon, mu) * mom_phase;
-        }
-        else
-        {
-            latt_compl = mom_phase;
-        } 
-
-    	mat.SeqConservedCurrent(q, src_tmp, par().curr_type, mu, 
-                             par().tA, par().tB, latt_compl);
-	src += src_tmp;
-
-    }	
-
- 
-}
-
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_SeqConserved_hpp_
diff --git a/Hadrons/Modules/MSource/SeqGamma.cc b/Hadrons/Modules/MSource/SeqGamma.cc
deleted file mode 100644
index c2ae2322..00000000
--- a/Hadrons/Modules/MSource/SeqGamma.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqGamma.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/SeqGamma.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TSeqGamma<FIMPL>;
-template class Grid::Hadrons::MSource::TSeqGamma<ZFIMPL>;
diff --git a/Hadrons/Modules/MSource/SeqGamma.hpp b/Hadrons/Modules/MSource/SeqGamma.hpp
deleted file mode 100644
index 4d125848..00000000
--- a/Hadrons/Modules/MSource/SeqGamma.hpp
+++ /dev/null
@@ -1,179 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/SeqGamma.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_SeqGamma_hpp_
-#define Hadrons_MSource_SeqGamma_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Sequential source
- -----------------------------
- * src_x = q_x * theta(x_3 - tA) * theta(tB - x_3) * gamma * exp(i x.mom)
- 
- * options:
- - q: input propagator (string)
- - tA: begin timeslice (integer)
- - tB: end timesilce (integer)
- - gamma: gamma product to insert (integer)
- - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.")
- 
- */
-
-/******************************************************************************
- *                         SeqGamma                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class SeqGammaPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(SeqGammaPar,
-                                    std::string,    q,
-                                    unsigned int,   tA,
-                                    unsigned int,   tB,
-                                    Gamma::Algebra, gamma,
-                                    std::string,    mom);
-};
-
-template <typename FImpl>
-class TSeqGamma: public Module<SeqGammaPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TSeqGamma(const std::string name);
-    // destructor
-    virtual ~TSeqGamma(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasPhase_{false};
-    std::string momphName_, tName_;
-};
-
-MODULE_REGISTER_TMP(SeqGamma, TSeqGamma<FIMPL>, MSource);
-MODULE_REGISTER_TMP(ZSeqGamma, TSeqGamma<ZFIMPL>, MSource);
-
-/******************************************************************************
- *                         TSeqGamma implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TSeqGamma<FImpl>::TSeqGamma(const std::string name)
-: Module<SeqGammaPar>(name)
-, momphName_ (name + "_momph")
-, tName_ (name + "_t")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TSeqGamma<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().q};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TSeqGamma<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqGamma<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
-    envCacheLat(LatticeComplex, momphName_);
-    envTmpLat(LatticeComplex, "coor");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TSeqGamma<FImpl>::execute(void)
-{
-    if (par().tA == par().tB)
-    {
-        LOG(Message) << "Generating gamma_" << par().gamma
-                     << " sequential source at t= " << par().tA << std::endl;
-    }
-    else
-    {
-        LOG(Message) << "Generating gamma_" << par().gamma
-                     << " sequential source for "
-                     << par().tA << " <= t <= " << par().tB << std::endl;
-    }
-    auto  &src = envGet(PropagatorField, getName());
-    auto  &q   = envGet(PropagatorField, par().q);
-    auto  &ph  = envGet(LatticeComplex, momphName_);
-    auto  &t   = envGet(Lattice<iScalar<vInteger>>, tName_);
-    Gamma g(par().gamma);
-    
-    if (!hasPhase_)
-    {
-        Complex           i(0.0,1.0);
-        std::vector<Real> p;
-
-        envGetTmp(LatticeComplex, coor);
-        p  = strToVec<Real>(par().mom);
-        ph = Zero();
-        for(unsigned int mu = 0; mu < env().getNd(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            ph = ph + (p[mu]/env().getDim(mu))*coor;
-        }
-        ph = exp((Real)(2*M_PI)*i*ph);
-        LatticeCoordinate(t, Tp);
-        hasPhase_ = true;
-    }
-    src = where((t >= par().tA) and (t <= par().tB), ph*(g*q), 0.*q);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_SeqGamma_hpp_
diff --git a/Hadrons/Modules/MSource/Wall.cc b/Hadrons/Modules/MSource/Wall.cc
deleted file mode 100644
index 4b36145f..00000000
--- a/Hadrons/Modules/MSource/Wall.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Wall.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/Wall.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TWall<FIMPL>;
-
diff --git a/Hadrons/Modules/MSource/Wall.hpp b/Hadrons/Modules/MSource/Wall.hpp
deleted file mode 100644
index d6a223cf..00000000
--- a/Hadrons/Modules/MSource/Wall.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Wall.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_WallSource_hpp_
-#define Hadrons_MSource_WallSource_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Wall source
- -----------------------------
- * src_x = delta(x_3 - tW) * exp(i x.mom)
- 
- * options:
- - tW: source timeslice (integer)
- - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.")
- 
- */
-
-/******************************************************************************
- *                         Wall                                               *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class WallPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(WallPar,
-                                    unsigned int, tW,
-                                    std::string, mom);
-};
-
-template <typename FImpl>
-class TWall: public Module<WallPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TWall(const std::string name);
-    // destructor
-    virtual ~TWall(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasPhase_{false};
-    std::string momphName_, tName_;
-};
-
-MODULE_REGISTER_TMP(Wall, TWall<FIMPL>, MSource);
-
-/******************************************************************************
- *                 TWall implementation                                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TWall<FImpl>::TWall(const std::string name)
-: Module<WallPar>(name)
-, momphName_ (name + "_momph")
-, tName_ (name + "_t")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TWall<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TWall<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWall<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
-    envCacheLat(LatticeComplex, momphName_);
-    envTmpLat(LatticeComplex, "coor");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TWall<FImpl>::execute(void)
-{    
-    LOG(Message) << "Generating wall source at t = " << par().tW 
-                 << " with momentum " << par().mom << std::endl;
-    
-    auto  &src = envGet(PropagatorField, getName());
-    auto  &ph  = envGet(LatticeComplex, momphName_);
-    auto  &t   = envGet(Lattice<iScalar<vInteger>>, tName_);
-    
-    if (!hasPhase_)
-    {
-        Complex           i(0.0,1.0);
-        std::vector<Real> p;
-
-        envGetTmp(LatticeComplex, coor);
-        p  = strToVec<Real>(par().mom);
-        ph = Zero();
-        for(unsigned int mu = 0; mu < p.size(); mu++)
-        {
-            LatticeCoordinate(coor, mu);
-            ph = ph + (p[mu]/env().getDim(mu))*coor;
-        }
-        ph = exp((Real)(2*M_PI)*i*ph);
-        LatticeCoordinate(t, Tp);
-        hasPhase_ = true;
-    }
-
-    src = 1.;
-    src = where((t == par().tW), src*ph, 0.*src);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_WallSource_hpp_
diff --git a/Hadrons/Modules/MSource/Z2.cc b/Hadrons/Modules/MSource/Z2.cc
deleted file mode 100644
index bd63d02a..00000000
--- a/Hadrons/Modules/MSource/Z2.cc
+++ /dev/null
@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Z2.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MSource/Z2.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MSource;
-
-template class Grid::Hadrons::MSource::TZ2<FIMPL>;
-template class Grid::Hadrons::MSource::TZ2<ScalarImplCR>;
-
diff --git a/Hadrons/Modules/MSource/Z2.hpp b/Hadrons/Modules/MSource/Z2.hpp
deleted file mode 100644
index f943072f..00000000
--- a/Hadrons/Modules/MSource/Z2.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MSource/Z2.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MSource_Z2_hpp_
-#define Hadrons_MSource_Z2_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/*
- 
- Z_2 stochastic source
- -----------------------------
- * src_x = eta_x * theta(x_3 - tA) * theta(tB - x_3)
- 
- the eta_x are independent uniform random numbers in {+/- 1 +/- i}
- 
- * options:
- - tA: begin timeslice (integer)
- - tB: end timesilce (integer)
- 
- */
- 
-/******************************************************************************
- *                          Z2 stochastic source                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MSource)
-
-class Z2Par: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(Z2Par,
-                                    unsigned int, tA,
-                                    unsigned int, tB);
-};
-
-template <typename FImpl>
-class TZ2: public Module<Z2Par>
-{
-public:
-    BASIC_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TZ2(const std::string name);
-    // destructor
-    virtual ~TZ2(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool        hasT_{false};
-    std::string tName_;
-};
-
-MODULE_REGISTER_TMP(Z2,       TZ2<FIMPL>,        MSource);
-MODULE_REGISTER_TMP(ScalarZ2, TZ2<ScalarImplCR>, MSource);
-
-/******************************************************************************
- *                       TZ2 template implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TZ2<FImpl>::TZ2(const std::string name)
-: Module<Z2Par>(name)
-, tName_ (name + "_t")
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TZ2<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TZ2<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZ2<FImpl>::setup(void)
-{
-    envCreateLat(PropagatorField, getName());
-    envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
-    envTmpLat(LatticeComplex, "eta");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZ2<FImpl>::execute(void)
-{
-    if (par().tA == par().tB)
-    {
-        LOG(Message) << "Generating Z_2 wall source at t= " << par().tA
-                     << std::endl;
-    }
-    else
-    {
-        LOG(Message) << "Generating Z_2 band for " << par().tA << " <= t <= "
-                     << par().tB << std::endl;
-    }
-    
-    auto    &src = envGet(PropagatorField, getName());
-    auto    &t   = envGet(Lattice<iScalar<vInteger>>, tName_);
-    Complex shift(1., 1.);
-
-    if (!hasT_)
-    {
-        LatticeCoordinate(t, Tp);
-        hasT_ = true;
-    }
-    envGetTmp(LatticeComplex, eta);
-    bernoulli(rng4d(), eta);
-    eta = (2.*eta - shift)*(1./::sqrt(2.));
-    eta = where((t >= par().tA) and (t <= par().tB), eta, 0.*eta);
-    src = 1.;
-    src = src*eta;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MSource_Z2_hpp_
diff --git a/Hadrons/Modules/MUtilities/PrecisionCast.cc b/Hadrons/Modules/MUtilities/PrecisionCast.cc
deleted file mode 100644
index d1235070..00000000
--- a/Hadrons/Modules/MUtilities/PrecisionCast.cc
+++ /dev/null
@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MUtilities/PrecisionCast.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MUtilities/PrecisionCast.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MUtilities;
-
-template class Grid::Hadrons::MUtilities::TPrecisionCast<GIMPLD::GaugeField, GIMPLF::GaugeField>;
-template class Grid::Hadrons::MUtilities::TPrecisionCast<FIMPLD::FermionField, FIMPLF::FermionField>;
diff --git a/Hadrons/Modules/MUtilities/PrecisionCast.hpp b/Hadrons/Modules/MUtilities/PrecisionCast.hpp
deleted file mode 100644
index ce3321a1..00000000
--- a/Hadrons/Modules/MUtilities/PrecisionCast.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MUtilities/PrecisionCast.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MUtilities_PrecisionCast_hpp_
-#define Hadrons_MUtilities_PrecisionCast_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                          Precision cast module                             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MUtilities)
-
-class PrecisionCastPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(PrecisionCastPar,
-                                    std::string, field);
-};
-
-template <typename FieldIn, typename FieldOut>
-class TPrecisionCast: public Module<PrecisionCastPar>
-{
-public:
-    // constructor
-    TPrecisionCast(const std::string name);
-    // destructor
-    virtual ~TPrecisionCast(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(GaugeSinglePrecisionCast, 
-                    ARG(TPrecisionCast<GIMPLD::GaugeField, GIMPLF::GaugeField>),
-                    MUtilities);
-MODULE_REGISTER_TMP(FermionSinglePrecisionCast, 
-                    ARG(TPrecisionCast<FIMPLD::FermionField, FIMPLF::FermionField>),
-                    MUtilities);
-
-/******************************************************************************
- *                     TPrecisionCast implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FieldIn, typename FieldOut>
-TPrecisionCast<FieldIn, FieldOut>::TPrecisionCast(const std::string name)
-: Module<PrecisionCastPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FieldIn, typename FieldOut>
-std::vector<std::string> TPrecisionCast<FieldIn, FieldOut>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename FieldIn, typename FieldOut>
-std::vector<std::string> TPrecisionCast<FieldIn, FieldOut>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FieldIn, typename FieldOut>
-void TPrecisionCast<FieldIn, FieldOut>::setup(void)
-{
-    envCreateLat(FieldOut, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FieldIn, typename FieldOut>
-void TPrecisionCast<FieldIn, FieldOut>::execute(void)
-{
-    LOG(Message) << "Casting field '" << par().field << "'" << std::endl;
-    LOG(Message) << "In  type: " << typeName<FieldIn>() << std::endl;
-    LOG(Message) << "Out type: " << typeName<FieldOut>() << std::endl;
-
-    auto &in  = envGet(FieldIn,  par().field);
-    auto &out = envGet(FieldOut, getName());
-
-    precisionChange(out, in);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MUtilities_PrecisionCast_hpp_
diff --git a/Hadrons/Modules/MUtilities/RandomVectors.cc b/Hadrons/Modules/MUtilities/RandomVectors.cc
deleted file mode 100644
index 9676ddc0..00000000
--- a/Hadrons/Modules/MUtilities/RandomVectors.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MUtilities/RandomVectors.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MUtilities/RandomVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MUtilities;
-
-template class Grid::Hadrons::MUtilities::TRandomVectors<FIMPL::FermionField>;
diff --git a/Hadrons/Modules/MUtilities/RandomVectors.hpp b/Hadrons/Modules/MUtilities/RandomVectors.hpp
deleted file mode 100644
index 9bb4bdce..00000000
--- a/Hadrons/Modules/MUtilities/RandomVectors.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MUtilities/RandomVectors.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MUtilities_RandomVectors_hpp_
-#define Hadrons_MUtilities_RandomVectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AVectors.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *           Module generating random lattices for testing purposes           *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MUtilities)
-
-class RandomVectorsPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(RandomVectorsPar,
-                                    unsigned int, size,
-                                    unsigned int, Ls,
-                                    std::string,  output,
-                                    bool,         multiFile);
-};
-
-template <typename Field>
-class TRandomVectors: public Module<RandomVectorsPar>
-{
-public:
-    // constructor
-    TRandomVectors(const std::string name);
-    // destructor
-    virtual ~TRandomVectors(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(RandomFermions, TRandomVectors<FIMPL::FermionField>, MUtilities);
-
-/******************************************************************************
- *                      TRandomVectors implementation                         *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Field>
-TRandomVectors<Field>::TRandomVectors(const std::string name)
-: Module<RandomVectorsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Field>
-std::vector<std::string> TRandomVectors<Field>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename Field>
-std::vector<std::string> TRandomVectors<Field>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Field>
-void TRandomVectors<Field>::setup(void)
-{
-    if (par().Ls > 1)
-    {
-        envCreate(std::vector<Field>, getName(), par().Ls, par().size, 
-                  envGetGrid(Field, par().Ls));
-    }
-    else
-    {
-        envCreate(std::vector<Field>, getName(), 1, par().size, envGetGrid(Field));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Field>
-void TRandomVectors<Field>::execute(void)
-{
-    LOG(Message) << "Generating " << par().size << " random vectors" << std::endl;
-
-    auto &vec = envGet(std::vector<Field>, getName());
-    
-    for (unsigned int i = 0; i < vec.size(); ++i)
-    {
-        random(rng4d(), vec[i]);
-    }
-    // I/O if necessary
-    if (!par().output.empty())
-    {
-        A2AVectorsIo::write(par().output, vec, par().multiFile, vm().getTrajectory());
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MUtilities_RandomVectors_hpp_
diff --git a/Hadrons/Modules/templates/Module_in_NS.cc.template b/Hadrons/Modules/templates/Module_in_NS.cc.template
deleted file mode 100644
index 477148e0..00000000
--- a/Hadrons/Modules/templates/Module_in_NS.cc.template
+++ /dev/null
@@ -1,40 +0,0 @@
-#include <Hadrons/Modules/___NAMESPACE___/___FILEBASENAME___.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace ___NAMESPACE___;
-
-/******************************************************************************
-*                  T___FILEBASENAME___ implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-T___FILEBASENAME___::T___FILEBASENAME___(const std::string name)
-: Module<___FILEBASENAME___Par>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> T___FILEBASENAME___::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-std::vector<std::string> T___FILEBASENAME___::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void T___FILEBASENAME___::setup(void)
-{
-
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void T___FILEBASENAME___::execute(void)
-{
-
-}
diff --git a/Hadrons/Modules/templates/Module_in_NS.hpp.template b/Hadrons/Modules/templates/Module_in_NS.hpp.template
deleted file mode 100644
index 982babda..00000000
--- a/Hadrons/Modules/templates/Module_in_NS.hpp.template
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef Hadrons____NAMESPACE_______FILEBASENAME____hpp_
-#define Hadrons____NAMESPACE_______FILEBASENAME____hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         ___FILEBASENAME___                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(___NAMESPACE___)
-
-class ___FILEBASENAME___Par: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(___FILEBASENAME___Par,
-                                    unsigned int, i);
-};
-
-class T___FILEBASENAME___: public Module<___FILEBASENAME___Par>
-{
-public:
-    // constructor
-    T___FILEBASENAME___(const std::string name);
-    // destructor
-    virtual ~T___FILEBASENAME___(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER(___FILEBASENAME___, T___FILEBASENAME___, ___NAMESPACE___);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons____NAMESPACE_______FILEBASENAME____hpp_
diff --git a/Hadrons/Modules/templates/Module_tmp_in_NS.cc.template b/Hadrons/Modules/templates/Module_tmp_in_NS.cc.template
deleted file mode 100644
index d8a19618..00000000
--- a/Hadrons/Modules/templates/Module_tmp_in_NS.cc.template
+++ /dev/null
@@ -1,7 +0,0 @@
-#include <Hadrons/Modules/___NAMESPACE___/___FILEBASENAME___.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace ___NAMESPACE___;
-
-template class Grid::Hadrons::___NAMESPACE___::T___FILEBASENAME___<FIMPL>;
diff --git a/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template b/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template
deleted file mode 100644
index da5bc370..00000000
--- a/Hadrons/Modules/templates/Module_tmp_in_NS.hpp.template
+++ /dev/null
@@ -1,85 +0,0 @@
-#ifndef Hadrons____NAMESPACE_______FILEBASENAME____hpp_
-#define Hadrons____NAMESPACE_______FILEBASENAME____hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         ___FILEBASENAME___                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(___NAMESPACE___)
-
-class ___FILEBASENAME___Par: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(___FILEBASENAME___Par,
-                                    unsigned int, i);
-};
-
-template <typename FImpl>
-class T___FILEBASENAME___: public Module<___FILEBASENAME___Par>
-{
-public:
-    // constructor
-    T___FILEBASENAME___(const std::string name);
-    // destructor
-    virtual ~T___FILEBASENAME___(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(___FILEBASENAME___, T___FILEBASENAME___<FIMPL>, ___NAMESPACE___);
-
-/******************************************************************************
- *                 T___FILEBASENAME___ implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-T___FILEBASENAME___<FImpl>::T___FILEBASENAME___(const std::string name)
-: Module<___FILEBASENAME___Par>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> T___FILEBASENAME___<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> T___FILEBASENAME___<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void T___FILEBASENAME___<FImpl>::setup(void)
-{
-    
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void T___FILEBASENAME___<FImpl>::execute(void)
-{
-    
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons____NAMESPACE_______FILEBASENAME____hpp_
diff --git a/Hadrons/NamedTensor.hpp b/Hadrons/NamedTensor.hpp
deleted file mode 100644
index 53e10e04..00000000
--- a/Hadrons/NamedTensor.hpp
+++ /dev/null
@@ -1,204 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Hadrons/NamedTensor.hpp
- 
- Copyright (C) 2015-2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_NamedTensor_hpp_
-#define Hadrons_NamedTensor_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- NamedTensor contains:
- 1) Name of the tensor. By default, this is the tag name used for save / load
- 2) Eigen::Tensor of type Scalar_ and rank NumIndices_ (row-major order)
- 3) Name for each index
- They can be persisted to / restored from disk. During restore, these validations are performed:
-   1) Tensor dimensionality must match
-   2) IndexNames are validated against current values
-   3) If the tensor has non-zero size, the tensor being loaded must have same extent in each dimension
- ******************************************************************************/
-
-extern const std::string NamedTensorFileExtension;
-
-template<typename Scalar_, int NumIndices_>
-class NamedTensor : Serializable
-{
-public:
-    using Scalar = Scalar_;
-    static constexpr int NumIndices = NumIndices_;
-    using ET = Eigen::Tensor<Scalar_, NumIndices_, Eigen::RowMajor>;
-    using Index = typename ET::Index;
-    GRID_SERIALIZABLE_CLASS_MEMBERS(NamedTensor,
-                                    ET,                       tensor,
-                                    std::vector<std::string>, IndexNames );
-
-    // Name of the object and Index names as set in the constructor
-    const std::string                          &Name_;
-    const std::array<std::string, NumIndices_> &DefaultIndexNames_;
-
-    // Default constructor (assumes tensor will be loaded from file)
-    NamedTensor(const std::string &Name,
-                                                      const std::array<std::string, NumIndices_> &indexNames)
-    : IndexNames{indexNames.begin(), indexNames.end()}, Name_{Name}, DefaultIndexNames_{indexNames} {}
-    
-    // Construct a named tensor explicitly specifying size of each dimension
-    template<typename... IndexTypes>
-    NamedTensor(const std::string &Name,
-                                                      const std::array<std::string, NumIndices_> &indexNames,
-                                                      Eigen::Index firstDimension, IndexTypes... otherDimensions)
-    : tensor(firstDimension, otherDimensions...),
-      IndexNames{indexNames.begin(), indexNames.end()}, Name_{Name}, DefaultIndexNames_{indexNames}
-    {
-        if(sizeof...(otherDimensions) + 1 != NumIndices_)
-	{
-            HADRONS_ERROR(Argument, "NamedTensor: dimensions != tensor rank");
-	}
-    }
-
-    // Do my index names match the default for my type?
-    template<typename array_or_vector_of_string>
-    bool ValidateIndexNames( const array_or_vector_of_string &CheckNames ) const
-    {
-        return IndexNames.size() == CheckNames.size() && std::equal( IndexNames.begin(), IndexNames.end(), CheckNames.begin(),
-            [](const std::string &s1, const std::string &s2)
-            {
-                 return s1.size() == s2.size() && std::equal( s1.begin(), s1.end(), s2.begin(),
-                     [](const char & c1, const char & c2)
-                     { return c1 == c2 || std::toupper(c1) == std::toupper(c2); }); // case insensitive
-            });
-    }
-    bool ValidateIndexNames() const { return ValidateIndexNames(DefaultIndexNames_); }
-
-#ifdef HAVE_HDF5
-    using Default_Reader = Grid::Hdf5Reader;
-    using Default_Writer = Grid::Hdf5Writer;
-#else
-    using Default_Reader = Grid::BinaryReader;
-    using Default_Writer = Grid::BinaryWriter;
-#endif
-    
-    void write(const std::string &FileName, const std::string &Tag) const
-    {
-        std::string FileName_{FileName};
-        FileName_.append( NamedTensorFileExtension );
-        LOG(Message) << "Writing " << Name_ << " to file " << FileName_ << " tag " << Tag << std::endl;
-        Default_Writer w( FileName_ );
-        write( w, Tag, *this );
-    }
-    void write(const std::string &FileName) const { return write(FileName, Name_); }
-
-    // Read tensor.
-    // Validate:
-    //  1) index names (if requested)
-    //  2) index dimensions (if they are non-zero when called)
-    template<typename Reader> void read(Reader &r, bool bValidate, const std::string &Tag)
-    {
-        // Grab index names and dimensions
-        std::vector<std::string> OldIndexNames{std::move(IndexNames)};
-        const typename ET::Dimensions OldDimensions{tensor.dimensions()};
-        read(r, Tag, *this);
-        const typename ET::Dimensions & NewDimensions{tensor.dimensions()};
-        for (int i = 0; i < NumIndices_; i++)
-            if(OldDimensions[i] && OldDimensions[i] != NewDimensions[i])
-            {
-                HADRONS_ERROR(Size,"NamedTensor::read dimension size");
-            }
-        if (bValidate && !ValidateIndexNames(OldIndexNames))
-        {
-            HADRONS_ERROR(Definition,"NamedTensor::read dimension name");
-        }
-    }
-    template<typename Reader> void read(Reader &r, bool bValidate = true) { read(r, bValidate, Name_); }
-
-    inline void read (const std::string &FileName, bool bValidate, const std::string &Tag)
-    {
-        Default_Reader r(FileName + NamedTensorFileExtension);
-        read(r, bValidate, Tag);
-    }
-    inline void read (const std::string &FileName, bool bValidate= true) { return read(FileName, bValidate, Name_); }
-};
-
-/******************************************************************************
- Common elements for distillation
- ******************************************************************************/
-
-BEGIN_MODULE_NAMESPACE(MDistil)
-
-//Eigenvectors of the Laplacian
-using LapEvecs = Grid::Hadrons::EigenPack<LatticeColourVector>;
-
-// Noise vector (index order: nnoise, nt, nvec, ns)
-
-class NoiseTensor : public NamedTensor<Complex, 4>
-{
-    public:
-    static const std::string                Name__;
-    static const std::array<std::string, 4> DefaultIndexNames__;
-    // Default constructor (assumes tensor will be loaded from file)
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NoiseTensor() : NamedTensor{Name__, DefaultIndexNames__} {}
-
-    // Construct a named tensor explicitly specifying size of each dimension
-    template<typename... IndexTypes>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE NoiseTensor(Eigen::Index nNoise, Eigen::Index nT, Eigen::Index nVec, Eigen::Index nS)
-    : NamedTensor{Name__, DefaultIndexNames__, nNoise, nT, nVec, nS} {}
-};
-
-class PerambTensor : public NamedTensor<SpinVector, 6>
-{
-    public:
-    static const std::string                Name__;
-    static const std::array<std::string, 6> DefaultIndexNames__;
-    // Default constructor (assumes tensor will be loaded from file)
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PerambTensor() : NamedTensor{Name__, DefaultIndexNames__} {}
-
-    // Construct a named tensor explicitly specifying size of each dimension
-    template<typename... IndexTypes>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE PerambTensor(Eigen::Index nT, Eigen::Index nVec, Eigen::Index LI, Eigen::Index nNoise, Eigen::Index nT_inv, Eigen::Index SI)
-    : NamedTensor{Name__, DefaultIndexNames__, nT, nVec, LI, nNoise, nT_inv, SI} {}
-};
-
-class TimesliceEvals : public NamedTensor<RealD, 2>
-{
-    public:
-    static const std::string                Name__;
-    static const std::array<std::string, 2> DefaultIndexNames__;
-    // Default constructor (assumes tensor will be loaded from file)
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TimesliceEvals() : NamedTensor{Name__, DefaultIndexNames__} {}
-
-    // Construct a named tensor explicitly specifying size of each dimension
-    template<typename... IndexTypes>
-    EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TimesliceEvals(Eigen::Index nT, Eigen::Index nVec)
-    : NamedTensor{Name__, DefaultIndexNames__, nT, nVec} {}
-};
-
-END_MODULE_NAMESPACE
-END_HADRONS_NAMESPACE
-#endif // Hadrons_NamedTensor_hpp_
diff --git a/Hadrons/Solver.hpp b/Hadrons/Solver.hpp
deleted file mode 100644
index 22af6309..00000000
--- a/Hadrons/Solver.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Solver.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_Solver_hpp_
-#define Hadrons_Solver_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-template <typename FImpl>
-class Solver
-{
-public:
-    typedef typename FImpl::FermionField                      FermionField;
-    typedef FermionOperator<FImpl>                            FMat; 
-    typedef std::function<void(FermionField &, 
-                               const FermionField &)>         SolverFn;
-public:
-    Solver(SolverFn fn, FMat &mat): mat_(mat), fn_(fn) {}
-
-    void operator()(FermionField &sol, const FermionField &src)
-    {
-        fn_(sol, src);
-    }
-
-    FMat & getFMat(void)
-    {
-        return mat_;
-    }
-private:
-    FMat     &mat_;
-    SolverFn fn_;
-};
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Solver_hpp_
diff --git a/Hadrons/TimerArray.cc b/Hadrons/TimerArray.cc
deleted file mode 100644
index caf72fc1..00000000
--- a/Hadrons/TimerArray.cc
+++ /dev/null
@@ -1,125 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/TimerArray.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/TimerArray.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-void TimerArray::startTimer(const std::string &name)
-{
-    if (!name.empty())
-    {
-        timer_[name].Start();
-    }
-}
-
-GridTime TimerArray::getTimer(const std::string &name)
-{
-    GridTime t;
-    
-    if (!name.empty())
-    {
-        try
-        {
-            bool running = timer_.at(name).isRunning();
-
-            if (running) stopTimer(name);
-            t = timer_.at(name).Elapsed();
-            if (running) startTimer(name);
-        }
-        catch (std::out_of_range &)
-        {
-            t = GridTime::zero();
-        }
-    }
-    else
-    {
-        t = GridTime::zero();
-    }
-
-    return t;
-}
-
-double TimerArray::getDTimer(const std::string &name)
-{
-    return static_cast<double>(getTimer(name).count());
-}
-
-void TimerArray::startCurrentTimer(const std::string &name)
-{
-    if (!name.empty())
-    {
-        stopCurrentTimer();
-        startTimer(name);
-        currentTimer_ = name;
-    }
-}
-
-void TimerArray::stopTimer(const std::string &name)
-{
-    if (timer_.at(name).isRunning())
-    {
-        timer_.at(name).Stop();
-    }
-}
-
-void TimerArray::stopCurrentTimer(void)
-{
-    if (!currentTimer_.empty())
-    {
-        stopTimer(currentTimer_);
-        currentTimer_ = "";
-    }
-}
-
-void TimerArray::stopAllTimers(void)
-{
-    for (auto &t: timer_)
-    {
-        stopTimer(t.first);
-    }
-    currentTimer_ = "";
-}
-
-void TimerArray::resetTimers(void)
-{
-    timer_.clear();
-    currentTimer_ = "";
-}
-
-std::map<std::string, GridTime> TimerArray::getTimings(void)
-{
-    std::map<std::string, GridTime> timing;
-
-    for (auto &t: timer_)
-    {
-        timing[t.first] = t.second.Elapsed();
-    }
-
-    return timing;
-}
diff --git a/Hadrons/TimerArray.hpp b/Hadrons/TimerArray.hpp
deleted file mode 100644
index a4a5b3a4..00000000
--- a/Hadrons/TimerArray.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/TimerArray.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_TimerArray_hpp_
-#define Hadrons_TimerArray_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-class TimerArray
-{
-public:
-    TimerArray(void) = default;
-    virtual ~TimerArray(void) = default;
-    void                            startTimer(const std::string &name);
-    GridTime                        getTimer(const std::string &name);
-    double                          getDTimer(const std::string &name);
-    void                            startCurrentTimer(const std::string &name);
-    void                            stopTimer(const std::string &name);
-    void                            stopCurrentTimer(void);
-    void                            stopAllTimers(void);
-    void                            resetTimers(void);
-    std::map<std::string, GridTime> getTimings(void);
-private:
-    std::string                          currentTimer_;
-    std::map<std::string, GridStopWatch> timer_; 
-};
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_TimerArray_hpp_
diff --git a/Hadrons/Utilities/Contractor.cc b/Hadrons/Utilities/Contractor.cc
deleted file mode 100644
index 7e4b8b26..00000000
--- a/Hadrons/Utilities/Contractor.cc
+++ /dev/null
@@ -1,457 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/Contractor.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Global.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-#include <Hadrons/DiskVector.hpp>
-#include <Hadrons/TimerArray.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-#define TIME_MOD(t) (((t) + par.global.nt) % par.global.nt)
-
-namespace Contractor
-{
-    class TrajRange: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(TrajRange,
-                                        unsigned int, start,
-                                        unsigned int, end,
-                                        unsigned int, step);
-    };
-    
-    class GlobalPar: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(GlobalPar,
-                                        TrajRange, trajCounter,
-                                        unsigned int, nt,
-                                        std::string, diskVectorDir,
-                                        std::string, output);
-    };
-
-    class A2AMatrixPar: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(A2AMatrixPar,
-                                        std::string, file,
-                                        std::string, dataset,
-                                        unsigned int, cacheSize,
-                                        std::string, name);
-    };
-
-    class ProductPar: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(ProductPar,
-                                        std::string, terms,
-                                        std::vector<std::string>, times,
-                                        std::string, translations,
-                                        bool, translationAverage);
-    };
-
-    class CorrelatorResult: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(CorrelatorResult,
-                                        std::vector<Contractor::A2AMatrixPar>,  a2aMatrix,
-                                        ProductPar, contraction,
-                                        std::vector<unsigned int>, times,
-                                        std::vector<ComplexD>, correlator);
-    };
-}
-
-struct ContractorPar
-{
-    Contractor::GlobalPar                  global;
-    std::vector<Contractor::A2AMatrixPar>  a2aMatrix;
-    std::vector<Contractor::ProductPar>    product;
-};
-
-void makeTimeSeq(std::vector<std::vector<unsigned int>> &timeSeq, 
-                 const std::vector<std::set<unsigned int>> &times,
-                 std::vector<unsigned int> &current,
-                 const unsigned int depth)
-{
-    if (depth > 0)
-    {
-        for (auto t: times[times.size() - depth])
-        {
-            current[times.size() - depth] = t;
-            makeTimeSeq(timeSeq, times, current, depth - 1);
-        }
-    }
-    else
-    {
-        timeSeq.push_back(current);
-    }
-}
-
-void makeTimeSeq(std::vector<std::vector<unsigned int>> &timeSeq, 
-                 const std::vector<std::set<unsigned int>> &times)
-{
-    std::vector<unsigned int> current(times.size());
-
-    makeTimeSeq(timeSeq, times, current, times.size());
-}
-
-void saveCorrelator(const Contractor::CorrelatorResult &result, const std::string dir, 
-                    const unsigned int dt, const unsigned int traj)
-{
-    std::string              fileStem = "", filename;
-    std::vector<std::string> terms = strToVec<std::string>(result.contraction.terms);
-
-    for (unsigned int i = 0; i < terms.size() - 1; i++)
-    {
-        fileStem += terms[i] + "_" + std::to_string(result.times[i]) + "_";
-    }
-    fileStem += terms.back();
-    if (!result.contraction.translationAverage)
-    {
-        fileStem += "_dt_" + std::to_string(dt);
-    }
-    filename = dir + "/" + RESULT_FILE_NAME(fileStem, traj);
-    std::cout << "Saving correlator to '" << filename << "'" << std::endl;
-    makeFileDir(dir);
-    ResultWriter writer(filename);
-    write(writer, fileStem, result);
-}
-
-std::set<unsigned int> parseTimeRange(const std::string str, const unsigned int nt)
-{
-    std::regex               rex("([0-9]+)|(([0-9]+)\\.\\.([0-9]+))");
-    std::smatch              sm;
-    std::vector<std::string> rstr = strToVec<std::string>(str);
-    std::set<unsigned int>   tSet;
-
-    for (auto &s: rstr)
-    {
-        std::regex_match(s, sm, rex);
-        if (sm[1].matched)
-        {
-            unsigned int t;
-            
-            t = std::stoi(sm[1].str());
-            if (t >= nt)
-            {
-                HADRONS_ERROR(Range, "time out of range (from expression '" + str + "')");
-            }
-            tSet.insert(t);
-        }
-        else if (sm[2].matched)
-        {
-            unsigned int ta, tb;
-
-            ta = std::stoi(sm[3].str());
-            tb = std::stoi(sm[4].str());
-            if ((ta >= nt) or (tb >= nt))
-            {
-                HADRONS_ERROR(Range, "time out of range (from expression '" + str + "')");
-            }
-            for (unsigned int ti = ta; ti <= tb; ++ti)
-            {
-                tSet.insert(ti);
-            }
-        }
-    }
-
-    return tSet;
-}
-
-struct Sec
-{
-    Sec(const double usec)
-    {
-        seconds = usec/1.0e6;
-    }
-    
-    double seconds;
-};
-
-inline std::ostream & operator<< (std::ostream& s, const Sec &&sec)
-{
-    s << std::setw(10) << sec.seconds << " sec";
-
-    return s;
-}
-
-struct Flops
-{
-    Flops(const double flops, const double fusec)
-    {
-        gFlopsPerSec = flops/fusec/1.0e3;
-    }
-    
-    double gFlopsPerSec;
-};
-
-inline std::ostream & operator<< (std::ostream& s, const Flops &&f)
-{
-    s << std::setw(10) << f.gFlopsPerSec << " GFlop/s";
-
-    return s;
-}
-
-struct Bytes
-{
-    Bytes(const double bytes, const double busec)
-    {
-        gBytesPerSec = bytes/busec*1.0e6/1024/1024/1024;
-    }
-    
-    double gBytesPerSec;
-};
-
-inline std::ostream & operator<< (std::ostream& s, const Bytes &&b)
-{
-    s << std::setw(10) << b.gBytesPerSec << " GB/s";
-
-    return s;
-}
-
-int main(int argc, char* argv[])
-{
-    // parse command line
-    std::string   parFilename;
-
-    if (argc != 2)
-    {
-        std::cerr << "usage: " << argv[0] << " <parameter file>";
-        std::cerr << std::endl;
-        
-        return EXIT_FAILURE;
-    }
-    parFilename = argv[1];
-
-    // parse parameter file
-    ContractorPar par;
-    //    unsigned int  nMat,nCont;
-    XmlReader     reader(parFilename);
-
-    read(reader, "global",    par.global);
-    read(reader, "a2aMatrix", par.a2aMatrix);
-    read(reader, "product",   par.product);
-    //    nMat  = par.a2aMatrix.size();
-    //    nCont = par.product.size();
-
-    // create diskvectors
-    std::map<std::string, EigenDiskVector<ComplexD>> a2aMat;
-    //    unsigned int                                     cacheSize;
-
-    for (auto &p: par.a2aMatrix)
-    {
-        std::string dirName = par.global.diskVectorDir + "/" + p.name;
-
-        a2aMat.emplace(p.name, EigenDiskVector<ComplexD>(dirName, par.global.nt, p.cacheSize));
-    }
-
-    // trajectory loop
-    for (unsigned int traj = par.global.trajCounter.start; 
-         traj < par.global.trajCounter.end; traj += par.global.trajCounter.step)
-    {
-        std::cout << ":::::::: Trajectory " << traj << std::endl;
-
-        // load data
-        for (auto &p: par.a2aMatrix)
-        {
-            std::string filename = p.file;
-            double      t;
-	    //	    double  size;
-
-            tokenReplace(filename, "traj", traj);
-            std::cout << "======== Loading '" << filename << "'" << std::endl;
-
-            A2AMatrixIo<HADRONS_A2AM_IO_TYPE> a2aIo(filename, p.dataset, par.global.nt);
-
-            a2aIo.load(a2aMat.at(p.name), &t);
-            std::cout << "Read " << a2aIo.getSize() << " bytes in " << t/1.0e6 
-                    << " sec, " << a2aIo.getSize()/t*1.0e6/1024/1024 << " MB/s" << std::endl;
-        }
-
-        // contract
-        EigenDiskVector<ComplexD>::Matrix buf;
-
-        for (auto &p: par.product)
-        {
-            std::vector<std::string>               term = strToVec<std::string>(p.terms);
-            std::vector<std::set<unsigned int>>    times;
-            std::vector<std::vector<unsigned int>> timeSeq;
-            std::set<unsigned int>                 translations;
-            std::vector<A2AMatrixTr<ComplexD>>     lastTerm(par.global.nt);
-            A2AMatrix<ComplexD>                    prod, buf, tmp;
-            TimerArray                             tAr;
-            double                                 fusec, busec, flops, bytes;
-	    //	    double  tusec;
-            Contractor::CorrelatorResult           result;             
-
-            tAr.startTimer("Total");
-            std::cout << "======== Contraction tr(";
-            for (unsigned int g = 0; g < term.size(); ++g)
-            {
-                std::cout << term[g] << ((g == term.size() - 1) ? ')' : '*');
-            }
-            std::cout << std::endl;
-            if (term.size() != p.times.size() + 1)
-            {
-                HADRONS_ERROR(Size, "number of terms (" + std::to_string(term.size()) 
-                            + ") different from number of times (" 
-                            + std::to_string(p.times.size() + 1) + ")");
-            }
-            for (auto &s: p.times)
-            {
-                times.push_back(parseTimeRange(s, par.global.nt));
-            }
-            for (auto &m: par.a2aMatrix)
-            {
-                if (std::find(result.a2aMatrix.begin(), result.a2aMatrix.end(), m) == result.a2aMatrix.end())
-                {
-                    result.a2aMatrix.push_back(m);
-                    tokenReplace(result.a2aMatrix.back().file, "traj", traj);
-                }
-            }
-            result.contraction = p;
-            result.correlator.resize(par.global.nt, 0.);
-
-            translations = parseTimeRange(p.translations, par.global.nt);
-            makeTimeSeq(timeSeq, times);
-            std::cout << timeSeq.size()*translations.size()*(term.size() - 2) << " A*B, "
-                    << timeSeq.size()*translations.size()*par.global.nt << " tr(A*B)"
-                    << std::endl;
-
-            std::cout << "* Caching transposed last term" << std::endl;
-            for (unsigned int t = 0; t < par.global.nt; ++t)
-            {
-                tAr.startTimer("Disk vector overhead");
-                const A2AMatrix<ComplexD> &ref = a2aMat.at(term.back())[t];
-                tAr.stopTimer("Disk vector overhead");
-
-                tAr.startTimer("Transpose caching");
-                lastTerm[t].resize(ref.rows(), ref.cols());
-                thread_for( j,ref.cols(),{
-                  for (unsigned int i = 0; i < ref.rows(); ++i)
-                  {
-                      lastTerm[t](i, j) = ref(i, j);
-                  }
-		});
-                tAr.stopTimer("Transpose caching");
-            }
-            bytes = par.global.nt*lastTerm[0].rows()*lastTerm[0].cols()*sizeof(ComplexD);
-            std::cout << Sec(tAr.getDTimer("Transpose caching")) << " " 
-                      << Bytes(bytes, tAr.getDTimer("Transpose caching")) << std::endl;
-            for (unsigned int i = 0; i < timeSeq.size(); ++i)
-            {
-                unsigned int dti = 0;
-                auto         &t = timeSeq[i];
-
-                result.times = t;
-                for (unsigned int tLast = 0; tLast < par.global.nt; ++tLast)
-                {
-                    result.correlator[tLast] = 0.;
-                }
-                for (auto &dt: translations)
-                {
-                    std::cout << "* Step " << i*translations.size() + dti + 1
-                            << "/" << timeSeq.size()*translations.size()
-                            << " -- positions= " << t << ", dt= " << dt << std::endl;
-                    if (term.size() > 2)
-                    {
-                        std::cout << std::setw(8) << "products";
-                    }
-                    flops  = 0.;
-                    bytes  = 0.;
-                    fusec  = tAr.getDTimer("A*B algebra");
-                    busec  = tAr.getDTimer("A*B total");
-                    tAr.startTimer("Linear algebra");
-                    tAr.startTimer("Disk vector overhead");
-                    prod = a2aMat.at(term[0])[TIME_MOD(t[0] + dt)];
-                    tAr.stopTimer("Disk vector overhead");
-                    for (unsigned int j = 1; j < term.size() - 1; ++j)
-                    {
-                        tAr.startTimer("Disk vector overhead");
-                        const A2AMatrix<ComplexD> &ref = a2aMat.at(term[j])[TIME_MOD(t[j] + dt)];
-                        tAr.stopTimer("Disk vector overhead");
-                        
-                        tAr.startTimer("A*B total");
-                        tAr.startTimer("A*B algebra");
-                        A2AContraction::mul(tmp, prod, ref);
-                        tAr.stopTimer("A*B algebra");
-                        flops += A2AContraction::mulFlops(prod, ref);
-                        prod   = tmp;
-                        tAr.stopTimer("A*B total");
-                        bytes += 3.*tmp.rows()*tmp.cols()*sizeof(ComplexD);
-                    }
-                    if (term.size() > 2)
-                    {
-                        std::cout << Sec(tAr.getDTimer("A*B total") - busec) << " "
-                                << Flops(flops, tAr.getDTimer("A*B algebra") - fusec) << " " 
-                                << Bytes(bytes, tAr.getDTimer("A*B total") - busec) << std::endl;
-                    }
-                    std::cout << std::setw(8) << "traces";
-                    flops  = 0.;
-                    bytes  = 0.;
-                    fusec  = tAr.getDTimer("tr(A*B)");
-                    busec  = tAr.getDTimer("tr(A*B)");
-                    for (unsigned int tLast = 0; tLast < par.global.nt; ++tLast)
-                    {
-                        tAr.startTimer("tr(A*B)");
-                        A2AContraction::accTrMul(result.correlator[TIME_MOD(tLast - dt)], prod, lastTerm[tLast]);
-                        tAr.stopTimer("tr(A*B)");
-                        flops += A2AContraction::accTrMulFlops(prod, lastTerm[tLast]);
-                        bytes += 2.*prod.rows()*prod.cols()*sizeof(ComplexD);
-                    }
-                    tAr.stopTimer("Linear algebra");
-                    std::cout << Sec(tAr.getDTimer("tr(A*B)") - busec) << " "
-                            << Flops(flops, tAr.getDTimer("tr(A*B)") - fusec) << " " 
-                            << Bytes(bytes, tAr.getDTimer("tr(A*B)") - busec) << std::endl;
-                    if (!p.translationAverage)
-                    {
-                        saveCorrelator(result, par.global.output, dt, traj);
-                        for (unsigned int tLast = 0; tLast < par.global.nt; ++tLast)
-                        {
-                            result.correlator[tLast] = 0.;
-                        }
-                    }
-                    dti++;
-                }
-                if (p.translationAverage)
-                {
-                    for (unsigned int tLast = 0; tLast < par.global.nt; ++tLast)
-                    {
-                        result.correlator[tLast] /= translations.size();
-                    }
-                    saveCorrelator(result, par.global.output, 0, traj);
-                }
-            }
-            tAr.stopTimer("Total");
-            printTimeProfile(tAr.getTimings(), tAr.getTimer("Total"));
-        }
-    }
-    
-    return EXIT_SUCCESS;
-}
diff --git a/Hadrons/Utilities/Contractor.hpp b/Hadrons/Utilities/Contractor.hpp
deleted file mode 100644
index decd13aa..00000000
--- a/Hadrons/Utilities/Contractor.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/Contractor.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef  Hadrons_Contractor_hpp_
-#define Hadrons_Contractor_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Contractor_hpp_
diff --git a/Hadrons/Utilities/ContractorBenchmark.cc b/Hadrons/Utilities/ContractorBenchmark.cc
deleted file mode 100644
index d387cfec..00000000
--- a/Hadrons/Utilities/ContractorBenchmark.cc
+++ /dev/null
@@ -1,462 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/ContractorBenchmark.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Global.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-#ifdef USE_MKL
-#include "mkl.h"
-#include "mkl_cblas.h"
-#endif
-
-using namespace Grid;
-using namespace Hadrons;
-const int RowMajor = Eigen::RowMajor;
-const int ColMajor = Eigen::ColMajor;
-
-#ifdef GRID_COMMS_MPI3
-#define GET_RANK(rank, nMpi) \
-MPI_Comm_size(MPI_COMM_WORLD, &(nMpi));\
-MPI_Comm_rank(MPI_COMM_WORLD, &(rank));\
-assert(rank<nMpi)
-
-#define BARRIER() MPI_Barrier(MPI_COMM_WORLD)
-#define INIT() MPI_Init(NULL, NULL)
-#define FINALIZE() MPI_Finalize()
-#else
-#define GET_RANK(rank, nMpi) (nMpi) = 1; (rank) = 0 ; assert(rank<nMpi)
-#define BARRIER()
-#define INIT()
-#define FINALIZE()
-#endif
-
-template <typename Function, typename MatLeft, typename MatRight>
-inline void trBenchmark(const std::string name, const MatLeft &left,
-                        const MatRight &right, const ComplexD ref, Function fn)
-{
-    double       t, flops, bytes, n = left[0].rows()*left[0].cols();
-    unsigned int nMat = left.size();
-    int          nMpi, rank;
-    ComplexD     buf;
-
-    t = 0.;
-    GET_RANK(rank, nMpi);
-    t = -usecond();
-    BARRIER();
-    for (unsigned int i = rank*nMat/nMpi; i < (rank+1)*nMat/nMpi; ++i)
-    {
-        fn(buf, left[i], right[i]);      
-    }
-    BARRIER();
-    t += usecond();
-    flops = nMat*(6.*n + 2.*(n - 1.));
-    bytes = nMat*(2.*n*sizeof(ComplexD));
-
-    if (rank == 0)
-    {
-        std::cout << std::setw(34) << name << ": diff= "
-                  << std::setw(12) << abs(buf-ref)
-                  << std::setw(10) << t/1.0e6 << " sec "
-                  << std::setw(10) << flops/t/1.0e3 << " GFlop/s " 
-                  << std::setw(10) << bytes/t*1.0e6/1024/1024/1024 << " GB/s "
-                  << std::endl;
-    }
-    ::sleep(1);
-}
-
-template <typename Function, typename MatV, typename Mat>
-inline void mulBenchmark(const std::string name, const MatV &left,
-                         const MatV &right, const Mat &ref, Function fn)
-{
-    double       t, flops, bytes;
-    double       nr = left[0].rows(), nc = left[0].cols();
-    //    double        n = nr*nc;
-    unsigned int nMat = left.size();
-    int          nMpi, rank;
-    Mat          buf(left[0].rows(), left[0].rows());
-
-    t = 0.;
-    GET_RANK(rank, nMpi);
-    t = -usecond();
-    BARRIER();
-    for (unsigned int i = rank*nMat/nMpi; i < (rank+1)*nMat/nMpi; ++i)
-    {
-        fn(buf, left[i], right[i]);
-    }
-    BARRIER();
-    t += usecond();
-    flops = nMat*(nr*nr*(6.*nc + 2.*(nc - 1.)));
-    bytes = nMat*(2*nc*nr*sizeof(ComplexD));
-
-    if (rank == 0)
-    {
-        std::cout << std::setw(34) << name << ": diff= "
-                  << std::setw(12) << (buf-ref).squaredNorm()
-                  << std::setw(10) << t/1.0e6 << " sec "
-                  << std::setw(10) << flops/t/1.0e3 << " GFlop/s " 
-                  << std::setw(10) << bytes/t*1.0e6/1024/1024/1024 << " GB/s "
-                  << std::endl;
-    }
-    ::sleep(1);
-}
-
-#ifdef USE_MKL
-template <typename MatLeft, typename MatRight>
-static inline void zdotuRow(ComplexD &res, const unsigned int aRow,
-                            const MatLeft &a, const MatRight &b)
-{
-    const ComplexD *aPt, *bPt;
-    unsigned int   aInc, bInc;
-
-    if (MatLeft::Options == RowMajor)
-    {
-        aPt  = a.data() + aRow*a.cols();
-        aInc = 1;
-    }
-    else if (MatLeft::Options == ColMajor)
-    {
-        aPt  = a.data() + aRow;
-        aInc = a.rows();
-    }
-    if (MatRight::Options == RowMajor)
-    {
-        bPt  = b.data() + aRow;
-        bInc = b.cols();
-    }
-    else if (MatRight::Options == ColMajor)
-    {
-        bPt  = b.data() + aRow*b.rows();
-        bInc = 1;
-    }
-    cblas_zdotu_sub(a.cols(), aPt, aInc, bPt, bInc, &res);
-}
-
-template <typename MatLeft, typename MatRight>
-static inline void zdotuCol(ComplexD &res, const unsigned int aCol,
-                            const MatLeft &a, const MatRight &b)
-{
-    const ComplexD *aPt, *bPt;
-    unsigned int   aInc, bInc;
-
-    if (MatLeft::Options == RowMajor)
-    {
-        aPt  = a.data() + aCol;
-        aInc = a.cols();
-    }
-    else if (MatLeft::Options == ColMajor)
-    {
-        aPt  = a.data() + aCol*a.rows();
-        aInc = 1;
-    }
-    if (MatRight::Options == RowMajor)
-    {
-        bPt  = b.data() + aCol*b.cols();
-        bInc = 1;
-    }
-    else if (MatRight::Options == ColMajor)
-    {
-        bPt  = b.data() + aCol;
-        bInc = b.rows();
-    }
-    cblas_zdotu_sub(a.rows(), aPt, aInc, bPt, bInc, &res);
-}
-#endif
-
-template <typename MatLeft, typename MatRight>
-void fullTrBenchmark(const unsigned int ni, const unsigned int nj, const unsigned int nMat)
-{
-    std::vector<MatLeft>  left;
-    std::vector<MatRight> right;
-    MatRight              buf;
-    ComplexD              ref;
-    int                   rank, nMpi;
-
-    left.resize(nMat, MatLeft::Random(ni, nj));
-    right.resize(nMat, MatRight::Random(nj, ni));
-    GET_RANK(rank, nMpi);
-    if (rank == 0)
-    {
-        std::cout << "==== tr(A*B) benchmarks" << std::endl;
-        std::cout << "A matrices use ";
-        if (MatLeft::Options == RowMajor)
-        {
-            std::cout << "row-major ordering" << std::endl;
-        }
-        else if (MatLeft::Options == ColMajor)
-        {
-            std::cout << "col-major ordering" << std::endl;
-        }
-        std::cout << "B matrices use ";
-        if (MatRight::Options == RowMajor)
-        {
-            std::cout << "row-major ordering" << std::endl;
-        }
-        else if (MatRight::Options == ColMajor)
-        {
-            std::cout << "col-major ordering" << std::endl;
-        }
-        std::cout << std::endl;
-    }
-    BARRIER();
-    ref = (left.back()*right.back()).trace();
-    trBenchmark("Hadrons A2AContraction::accTrMul", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    { 
-        res = 0.;
-        A2AContraction::accTrMul(res, a, b);
-    });
-    trBenchmark("Naive loop rows first", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    { 
-        auto nr = a.rows(), nc = a.cols();
-        
-        res = 0.;
-        thread_for(i,nr,
-        {
-            ComplexD tmp = 0.;
-
-            for (unsigned int j = 0; j < nc; ++j)
-            {
-                tmp += a(i, j)*b(j, i);
-            }
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-    trBenchmark("Naive loop cols first", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    {
-        auto nr = a.rows(), nc = a.cols();
-        
-        res = 0.;
-        thread_for(j,nc,
-        {
-            ComplexD tmp = 0.;
-
-            for (unsigned int i = 0; i < nr; ++i)
-            {
-                tmp += a(i, j)*b(j, i);
-            }        
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-    trBenchmark("Eigen tr(A*B)", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    { 
-        res = (a*b).trace();
-    });
-    trBenchmark("Eigen row-wise dot", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    {
-        res = 0.;
-        thread_for(r,a.rows(),
-        {
-            ComplexD tmp;
-
-            tmp = a.row(r).conjugate().dot(b.col(r));
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-    trBenchmark("Eigen col-wise dot", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    {
-        res = 0.;
-        thread_for(c,a.cols(),
-        {
-            ComplexD tmp;
-
-            tmp = a.col(c).conjugate().dot(b.row(c));
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-    trBenchmark("Eigen Hadamard", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    { 
-        res = a.cwiseProduct(b.transpose()).sum();
-    });
-#ifdef USE_MKL
-    trBenchmark("MKL row-wise zdotu", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    {
-        res = 0.;
-        thread_for(r,a.rows(),
-        {
-            ComplexD tmp;
-
-            zdotuRow(tmp, r, a, b);
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-    trBenchmark("MKL col-wise zdotu", left, right, ref,
-    [](ComplexD &res, const MatLeft &a, const MatRight &b)
-    {
-        res = 0.;
-        thread_for(c,a.cols(),
-        {
-            ComplexD tmp;
-
-            zdotuCol(tmp, c, a, b);
-            thread_critical
-            {
-                res += tmp;
-            }
-        });
-    });
-#endif
-    BARRIER();
-    if (rank == 0)
-    {
-        std::cout << std::endl;
-    }
-}
-
-template <typename Mat>
-void fullMulBenchmark(const unsigned int ni, const unsigned int nj, const unsigned int nMat)
-{
-    std::vector<Mat> left, right;
-    Mat              ref;
-    int              rank, nMpi;
-
-    left.resize(nMat, Mat::Random(ni, nj));
-    right.resize(nMat, Mat::Random(nj, ni));
-    GET_RANK(rank, nMpi);
-    if (rank == 0)
-    {
-        std::cout << "==== A*B benchmarks" << std::endl;
-        std::cout << "all matrices use ";
-        if (Mat::Options == RowMajor)
-        {
-            std::cout << "row-major ordering" << std::endl;
-        }
-        else if (Mat::Options == ColMajor)
-        {
-            std::cout << "col-major ordering" << std::endl;
-        }
-        std::cout << std::endl;
-    }
-    BARRIER();
-    ref = left.back()*right.back();
-    mulBenchmark("Hadrons A2AContraction::mul", left, right, ref,
-    [](Mat &res, const Mat &a, const Mat &b)
-    { 
-        A2AContraction::mul(res, a, b);
-    });
-    mulBenchmark("Eigen A*B", left, right, ref,
-    [](Mat &res, const Mat &a, const Mat &b)
-    { 
-        res = a*b;
-    });
-#ifdef USE_MKL
-    mulBenchmark("MKL A*B", left, right, ref,
-    [](Mat &res, const Mat &a, const Mat &b)
-    {
-        const ComplexD one(1., 0.), zero(0., 0.);
-        if (Mat::Options == RowMajor)
-        {
-            cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.cols(), b.data(), b.cols(), &zero,
-                        res.data(), res.cols());
-        }
-        else if (Mat::Options == ColMajor)
-        {
-            cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.rows(), b.data(), b.rows(), &zero,
-                        res.data(), res.rows());
-        }
-    });
-#endif
-    BARRIER();
-    if (rank == 0)
-    {
-        std::cout << std::endl;
-    }
-}
-
-int main(int argc, char *argv[])
-{
-    // parse command line
-    Eigen::Index ni, nj, nMat;
-    int          nMpi, rank;
-
-    if (argc != 4)
-    {
-        std::cerr << "usage: " << argv[0] << " <Ni> <Nj> <#matrices>";
-        std::cerr << std::endl;
-        
-        return EXIT_FAILURE;
-    }
-    ni   = std::stoi(argv[1]);
-    nj   = std::stoi(argv[2]);
-    nMat = std::stoi(argv[3]);
-
-    INIT();
-    GET_RANK(rank, nMpi);
-    if (rank == 0)
-    {
-        std::cout << "\n*** ALL-TO-ALL MATRIX CONTRACTION BENCHMARK ***\n" << std::endl;
-        std::cout << nMat << " couples of " << ni << "x" << nj << " matrices\n" << std::endl;
-
-        std::cout << nMpi << " MPI processes" << std::endl;
-#ifdef GRID_OMP
-	std::cout << omp_get_num_threads() << " threads\n" << std::endl; 
-#else
-        std::cout << "Single-threaded\n" << std::endl; 
-#endif
-
-#ifdef EIGEN_USE_MKL_ALL
-        std::cout << "Eigen uses the MKL" << std::endl;
-#endif
-        std::cout << "Eigen uses " << Eigen::nbThreads() << " threads" << std::endl;
-#ifdef USE_MKL
-        std::cout << "MKL   uses " << mkl_get_max_threads() << " threads" << std::endl;
-#endif
-        std::cout << std::endl;
-    }
-
-    fullTrBenchmark<A2AMatrix<ComplexD>, A2AMatrix<ComplexD>>(ni, nj, nMat);
-    fullTrBenchmark<A2AMatrix<ComplexD>, A2AMatrixTr<ComplexD>>(ni, nj, nMat);
-    fullTrBenchmark<A2AMatrixTr<ComplexD>, A2AMatrix<ComplexD>>(ni, nj, nMat);
-    fullTrBenchmark<A2AMatrixTr<ComplexD>, A2AMatrixTr<ComplexD>>(ni, nj, nMat);
-    fullMulBenchmark<A2AMatrix<ComplexD>>(ni, nj, nMat);
-    fullMulBenchmark<A2AMatrixTr<ComplexD>>(ni, nj, nMat);
-    FINALIZE();
-
-    return EXIT_SUCCESS;
-}
diff --git a/Hadrons/Utilities/EigenPackCast.cc b/Hadrons/Utilities/EigenPackCast.cc
deleted file mode 100644
index 09a9cc43..00000000
--- a/Hadrons/Utilities/EigenPackCast.cc
+++ /dev/null
@@ -1,216 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/EigenPackCast.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/EigenPack.hpp>
-#include <Hadrons/Environment.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-template <typename FOut, typename FIn>
-void convert(const std::string outFilename, const std::string inFilename, 
-             const unsigned int Ls, const bool rb, const unsigned int size, 
-             const bool multiFile, const bool testRead)
-{
-    assert(outFilename != inFilename);
-    
-    typedef EigenPack<FOut>            EPOut;
-    typedef EigenPack<FIn>             EPIn;
-    typedef typename FOut::vector_type VTypeOut;
-    typedef typename FIn::vector_type  VTypeIn;
-
-    std::shared_ptr<GridCartesian>         gInBase, gOutBase, gIn5, gOut5;
-    std::shared_ptr<GridRedBlackCartesian> rbgIn, rbgOut;
-    GridBase                               *gIn, *gOut;
-
-    auto         dim     = GridDefaultLatt();
-    unsigned int nd      = dim.size();
-    auto         simdOut = GridDefaultSimd(nd, VTypeOut::Nsimd());
-    auto         simdIn  = GridDefaultSimd(nd, VTypeIn::Nsimd());
-
-    gOutBase.reset(SpaceTimeGrid::makeFourDimGrid(dim, simdOut, GridDefaultMpi()));
-    gInBase.reset(SpaceTimeGrid::makeFourDimGrid(dim, simdIn, GridDefaultMpi()));
-    if (rb)
-    {
-        if (Ls > 1)
-        {
-            rbgOut.reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, gOutBase.get()));
-            rbgIn.reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, gInBase.get()));
-        }
-        else
-        {
-            rbgOut.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(gOutBase.get()));
-            rbgIn.reset(SpaceTimeGrid::makeFourDimRedBlackGrid(gInBase.get()));
-        }
-        gOut = rbgOut.get();
-        gIn  = rbgIn.get();
-    }
-    else
-    {
-        if (Ls > 1)
-        {
-            gOut5.reset(SpaceTimeGrid::makeFiveDimGrid(Ls, gOutBase.get()));
-            gIn5.reset(SpaceTimeGrid::makeFiveDimGrid(Ls, gInBase.get()));
-            gOut = gOut5.get();
-            gIn  = gIn5.get();
-        }
-        else
-        {
-            gOut = gOutBase.get();
-            gIn  = gInBase.get();
-        }
-    }
-
-    FOut         bufOut(gOut);
-    FIn          bufIn(gIn), testIn(gIn);
-    ScidacWriter binWriter(gOut->IsBoss());
-    ScidacReader binReader;
-    PackRecord   record;
-    RealD        eval;
-
-    LOG(Message) << "==== EIGENPACK CONVERSION" << std::endl;
-    LOG(Message) << "Lattice       : " << gIn->GlobalDimensions() << std::endl;
-    LOG(Message) << "Checkerboarded: " << (rb ? "yes" : "no") << std::endl;
-    LOG(Message) << "In path       : " << inFilename  << std::endl;
-    LOG(Message) << "In type       : " << typeName<FIn>() << std::endl;
-    LOG(Message) << "Out path      : " << outFilename << std::endl;
-    LOG(Message) << "Out type      : " << typeName<FOut>() << std::endl;
-    LOG(Message) << "#vectors      : " << size << std::endl;
-    LOG(Message) << "Multifile     : " << (multiFile ? "yes" : "no") << std::endl;
-    LOG(Message) << "Test read     : " << (testRead ? "yes" : "no") << std::endl;
-    if (multiFile)
-    {
-        for(unsigned int k = 0; k < size; ++k)
-        {
-            std::string  outV = outFilename + "/v" + std::to_string(k) + ".bin";
-            std::string  inV  = inFilename + "/v" + std::to_string(k) + ".bin";
-
-            LOG(Message) << "==== Converting vector " << k << std::endl;
-            LOG(Message) << "In : " << inV  << std::endl;
-            LOG(Message) << "Out: " << outV << std::endl;
-            // conversion
-            LOG(Message) << "-- Doing conversion" << std::endl;
-            makeFileDir(outV, gOut);
-            binWriter.open(outV);
-            binReader.open(inV);
-            EigenPackIo::readHeader(record, binReader);
-            EigenPackIo::writeHeader(binWriter, record);
-            EigenPackIo::readElement<FIn>(bufIn, eval, k, binReader);
-            EigenPackIo::writeElement<FIn, FOut>(binWriter, bufIn, eval, k, &bufOut, &testIn);
-            binWriter.close();
-            binReader.close();
-            // read test
-            if (testRead)
-            {
-                LOG(Message) << "-- Test read" << std::endl;
-                binReader.open(outV);
-                EigenPackIo::readElement<FOut>(bufOut, eval, k, binReader);
-                binReader.close();
-            }
-        }
-    }
-    else
-    {
-        // conversion
-        LOG(Message) << "-- Doing conversion" << std::endl;
-        makeFileDir(outFilename, gOut);
-        binWriter.open(outFilename);
-        binReader.open(inFilename);
-        EigenPackIo::readHeader(record, binReader);
-        EigenPackIo::writeHeader(binWriter, record);
-        for(unsigned int k = 0; k < size; ++k)
-        {
-            EigenPackIo::readElement<FIn>(bufIn, eval, k, binReader);
-            EigenPackIo::writeElement<FIn, FOut>(binWriter, bufIn, eval, k, &bufOut, &testIn);
-        }
-        binWriter.close();
-        binReader.close();
-        // read test
-        if (testRead)
-        {
-            LOG(Message) << "-- Test read" << std::endl;
-            binReader.open(outFilename);
-            EigenPackIo::readHeader(record, binReader);
-            for(unsigned int k = 0; k < size; ++k)
-            {
-                EigenPackIo::readElement<FOut>(bufOut, eval, k, binReader);
-            }
-            binReader.close();
-        }
-    }
-}
-
-#ifndef FOUT
-#warning "FOUT undefined (set to WilsonImplF::FermionField by default)"
-#define FOUT WilsonImplF::FermionField
-#endif
-#ifndef FIN
-#warning "FIN undefined (set to WilsonImplD::FermionField by default)"
-#define FIN WilsonImplD::FermionField
-#endif
-
-int main(int argc, char *argv[])
-{
-    // parse command line
-    std::string  outFilename, inFilename;
-    unsigned int size, Ls;
-    bool         rb, multiFile, testRead;
-    
-    if (argc < 8)
-    {
-        std::cerr << "usage: " << argv[0] << " <out eigenpack> <in eigenpack> <Ls> <red-black {0|1}> <#vector> <multifile {0|1}> <test read {0|1}> [Grid options]";
-        std::cerr << std::endl;
-        std::exit(EXIT_FAILURE);
-    }
-    outFilename = argv[1];
-    inFilename  = argv[2];
-    Ls          = std::stoi(std::string(argv[3]));
-    rb          = (std::string(argv[4]) != "0");
-    size        = std::stoi(std::string(argv[5]));
-    multiFile   = (std::string(argv[6]) != "0");
-    testRead    = (std::string(argv[7]) != "0");
-    
-    // initialization
-    Grid_init(&argc, &argv);
-    initLogger();
-
-    // execution
-    try
-    {
-        convert<FOUT, FIN>(outFilename, inFilename, Ls, rb, size, multiFile, testRead);
-    }
-    catch (const std::exception& e)
-    {
-        Exceptions::abort(e);
-    }
-
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/Hadrons/Utilities/HadronsXmlRun.cc b/Hadrons/Utilities/HadronsXmlRun.cc
deleted file mode 100644
index a81139af..00000000
--- a/Hadrons/Utilities/HadronsXmlRun.cc
+++ /dev/null
@@ -1,69 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/HadronsXmlRun.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-
-using namespace Grid;
- 
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // parse command line
-    std::string parameterFileName;
-    
-    if (argc < 2)
-    {
-        std::cerr << "usage: " << argv[0] << " <parameter file> [Grid options]";
-        std::cerr << std::endl;
-        std::exit(EXIT_FAILURE);
-    }
-    parameterFileName = argv[1];
-    
-    // initialization
-    Grid_init(&argc, &argv);
-    
-    // execution
-    try
-    {
-        Application application(parameterFileName);
-        
-        application.parseParameterFile(parameterFileName);
-        application.run();
-    }
-    catch (const std::exception& e)
-    {
-        Exceptions::abort(e);
-    }
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/Hadrons/Utilities/HadronsXmlValidate.cc b/Hadrons/Utilities/HadronsXmlValidate.cc
deleted file mode 100644
index fa2bfe3a..00000000
--- a/Hadrons/Utilities/HadronsXmlValidate.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Utilities/HadronsXmlValidate.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // parse command line
-    std::string parameterFileName;
-    
-    if (argc != 2)
-    {
-        std::cerr << "usage: " << argv[0] << " <parameter file>";
-        std::cerr << std::endl;
-        std::exit(EXIT_FAILURE);
-    }
-    parameterFileName = argv[1];
-    
-    try
-    {
-        Application application(parameterFileName);
-        
-        application.parseParameterFile(parameterFileName);
-        auto &vm = VirtualMachine::getInstance();
-        vm.getModuleGraph();
-        LOG(Message) << "Application valid (check XML warnings though)" 
-                     << std::endl;
-    }
-    catch (const std::exception& e)
-    {
-        Exceptions::abort(e);
-    }
-    
-    return EXIT_SUCCESS;
-}
diff --git a/Hadrons/Utilities/Makefile.am b/Hadrons/Utilities/Makefile.am
deleted file mode 100644
index 6c48d966..00000000
--- a/Hadrons/Utilities/Makefile.am
+++ /dev/null
@@ -1,17 +0,0 @@
-bin_PROGRAMS = HadronsXmlRun HadronsXmlValidate HadronsFermionEP64To32 HadronsContractor HadronsContractorBenchmark
-
-HadronsXmlRun_SOURCES = HadronsXmlRun.cc
-HadronsXmlRun_LDADD   = ../libHadrons.a ../../Grid/libGrid.a
-
-HadronsXmlValidate_SOURCES = HadronsXmlValidate.cc
-HadronsXmlValidate_LDADD   = ../libHadrons.a ../../Grid/libGrid.a
-
-HadronsFermionEP64To32_SOURCES  = EigenPackCast.cc
-HadronsFermionEP64To32_CXXFLAGS = $(AM_CXXFLAGS) -DFIN=WilsonImplD::FermionField -DFOUT=WilsonImplF::FermionField
-HadronsFermionEP64To32_LDADD    = ../libHadrons.a ../../Grid/libGrid.a
-
-HadronsContractor_SOURCES = Contractor.cc
-HadronsContractor_LDADD   = ../libHadrons.a ../../Grid/libGrid.a
-
-HadronsContractorBenchmark_SOURCES = ContractorBenchmark.cc
-HadronsContractorBenchmark_LDADD   = ../libHadrons.a ../../Grid/libGrid.a
diff --git a/Hadrons/VirtualMachine.cc b/Hadrons/VirtualMachine.cc
deleted file mode 100644
index e09dfdee..00000000
--- a/Hadrons/VirtualMachine.cc
+++ /dev/null
@@ -1,736 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/VirtualMachine.cc
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/VirtualMachine.hpp>
-#include <Hadrons/GeneticScheduler.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-using namespace Grid;
- 
-using namespace Hadrons;
-
-/******************************************************************************
- *                      VirtualMachine implementation                         *
- ******************************************************************************/
-// trajectory counter //////////////////////////////////////////////////////////
-void VirtualMachine::setTrajectory(const unsigned int traj)
-{
-    traj_ = traj;
-}
-
-unsigned int VirtualMachine::getTrajectory(void) const
-{
-    return traj_;
-}
-
-// run tag /////////////////////////////////////////////////////////////////////
-void VirtualMachine::setRunId(const std::string id)
-{
-    runId_ = id;
-}
-
-std::string VirtualMachine::getRunId(void) const
-{
-    return runId_;
-}
-
-// module management ///////////////////////////////////////////////////////////
-void VirtualMachine::pushModule(VirtualMachine::ModPt &pt)
-{
-    std::string name = pt->getName();
-    
-    if (!hasModule(name))
-    {
-        std::vector<unsigned int> inputAddress;
-        unsigned int              address;
-        ModuleInfo                m;
-        
-        // module registration -------------------------------------------------
-        m.data = std::move(pt);
-        m.type = typeIdPt(*m.data.get());
-        m.name = name;
-        // input dependencies
-        for (auto &in: m.data->getInput())
-        {
-            if (!env().hasObject(in))
-            {
-                // if object does not exist, add it with no creator module
-                env().addObject(in , -1);
-            }
-            m.input.push_back(env().getObjectAddress(in));
-        }
-        // reference dependencies
-        for (auto &ref: m.data->getReference())
-        {
-            if (!env().hasObject(ref))
-            {
-                // if object does not exist, add it with no creator module
-                env().addObject(ref , -1);
-            }
-            m.input.push_back(env().getObjectAddress(ref));
-        }
-        auto inCopy = m.input;
-        // if module has inputs with references, they need to be added as
-        // an input
-        for (auto &in: inCopy)
-        {
-            int inm = env().getObjectModule(in);
-
-            if (inm > 0)
-            {
-                if (getModule(inm)->getReference().size() > 0)
-                {
-                    for (auto &rin: getModule(inm)->getReference())
-                    {
-                        m.input.push_back(env().getObjectAddress(rin));
-                    }
-                }
-            }
-        }
-        module_.push_back(std::move(m));
-        address              = static_cast<unsigned int>(module_.size() - 1);
-        moduleAddress_[name] = address;
-        // connecting outputs to potential inputs ------------------------------
-        for (auto &out: getModule(address)->getOutput())
-        {
-            if (!env().hasObject(out))
-            {
-                // output does not exists, add it
-                env().addObject(out, address);
-                module_[address].output.push_back(env().getObjectAddress(out));
-            }
-            else
-            {
-                if (env().getObjectModule(env().getObjectAddress(out)) < 0)
-                {
-                    // output exists but without creator, correct it
-                    env().setObjectModule(env().getObjectAddress(out), address);
-                }
-                else
-                {
-                    // output already fully registered, error
-                    HADRONS_ERROR_REF(ObjectDefinition, "object '" + out
-                                 + "' is already produced by module '"
-                                 + module_[env().getObjectModule(out)].name
-                                 + "' (while pushing module '" + name + "')",
-                                 env().getObjectAddress(out));
-                }
-                if (getModule(address)->getReference().size() > 0)
-                {
-                    // module has references, dependency should be propagated
-                    // to children modules; find module with `out` as an input
-                    // and add references to their input
-                    auto pred = [this, out](const ModuleInfo &n)
-                    {
-                        auto &in = n.input;
-                        auto it  = std::find(in.begin(), in.end(), 
-                                             env().getObjectAddress(out));
-                        
-                        return (it != in.end());
-                    };
-                    auto it = std::find_if(module_.begin(), module_.end(), pred);
-                    while (it != module_.end())
-                    {
-                        for (auto &ref: getModule(address)->getReference())
-                        {
-                            it->input.push_back(env().getObjectAddress(ref));
-                        }
-                        it = std::find_if(++it, module_.end(), pred);
-                    }   
-                }
-            }
-        }
-        graphOutdated_         = true;
-        memoryProfileOutdated_ = true;
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "module '" + name + "' already exists");
-    }
-}
-
-unsigned int VirtualMachine::getNModule(void) const
-{
-    return module_.size();
-}
-
-void VirtualMachine::createModule(const std::string name, const std::string type,
-                                  XmlReader &reader)
-{
-    auto &factory = ModuleFactory::getInstance();
-    auto pt       = factory.create(type, name);
-    
-    pt->parseParameters(reader, "options");
-    pushModule(pt);
-}
-
-ModuleBase * VirtualMachine::getModule(const unsigned int address) const
-{
-    if (hasModule(address))
-    {
-        return module_[address].data.get();
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "no module with address " + std::to_string(address));
-    }
-}
-
-ModuleBase * VirtualMachine::getModule(const std::string name) const
-{
-    return getModule(getModuleAddress(name));
-}
-
-unsigned int VirtualMachine::getModuleAddress(const std::string name) const
-{
-    if (hasModule(name))
-    {
-        return moduleAddress_.at(name);
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "no module with name '" + name + "'");
-    }
-}
-
-std::string VirtualMachine::getModuleName(const unsigned int address) const
-{
-    if (hasModule(address))
-    {
-        return module_[address].name;
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "no module with address " + std::to_string(address));
-    }
-}
-
-std::string VirtualMachine::getModuleType(const unsigned int address) const
-{
-    if (hasModule(address))
-    {
-        return typeName(module_[address].type);
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "no module with address " + std::to_string(address));
-    }
-}
-
-std::string VirtualMachine::getModuleType(const std::string name) const
-{
-    return getModuleType(getModuleAddress(name));
-}
-
-std::string VirtualMachine::getModuleNamespace(const unsigned int address) const
-{
-    std::string type = getModuleType(address), ns;
-    
-    auto pos2 = type.rfind("::");
-    auto pos1 = type.rfind("::", pos2 - 2);
-    
-    return type.substr(pos1 + 2, pos2 - pos1 - 2);
-}
-
-std::string VirtualMachine::getModuleNamespace(const std::string name) const
-{
-    return getModuleNamespace(getModuleAddress(name));
-}
-
-int VirtualMachine::getCurrentModule(void) const
-{
-    return currentModule_;
-}
-
-bool VirtualMachine::hasModule(const unsigned int address) const
-{
-    return (address < module_.size());
-}
-
-bool VirtualMachine::hasModule(const std::string name) const
-{
-    return (moduleAddress_.find(name) != moduleAddress_.end());
-}
-
-// print VM content ////////////////////////////////////////////////////////////
-void VirtualMachine::printContent(void) const
-{
-    LOG(Debug) << "Modules: " << std::endl;
-    for (unsigned int i = 0; i < module_.size(); ++i)
-    {
-        LOG(Debug) << std::setw(4) << i << ": "
-                   << getModuleName(i) << std::endl;
-    }
-}
-
-// module graph ////////////////////////////////////////////////////////////////
-Graph<unsigned int> VirtualMachine::getModuleGraph(void)
-{
-    if (graphOutdated_)
-    {
-        makeModuleGraph();
-        graphOutdated_ = false;
-    }
-
-    return graph_;
-}
-
-void VirtualMachine::makeModuleGraph(void)
-{
-    Graph<unsigned int> graph;
-    
-    // create vertices
-    for (unsigned int m = 0; m < module_.size(); ++m)
-    {
-        graph.addVertex(m);
-    }
-    // create edges
-    for (unsigned int m = 0; m < module_.size(); ++m)
-    {
-        for (auto &in: module_[m].input)
-        {
-            int min = env().getObjectModule(in);
-
-            if (min < 0)
-            {
-                HADRONS_ERROR_REF(ObjectDefinition, "dependency '" 
-                             + env().getObjectName(in) + "' (address " 
-                             + std::to_string(in)
-                             + ") is not produced by any module", in);
-            }
-            else
-            {
-                graph.addEdge(min, m);
-            }
-        }
-    }
-    graph_ = graph;
-}
-
-// dump GraphViz graph /////////////////////////////////////////////////////////
-void VirtualMachine::dumpModuleGraph(std::ostream &out)
-{
-    makeModuleGraph();
-    out << "digraph hadrons {" << std::endl;
-    out << "node [shape=record, fontname=\"Courier\", fontsize=\"11\"];" << std::endl;
-    out << "graph [fontname = \"Courier\", fontsize=\"11\"];" << std::endl;
-    out << "edge [fontname = \"Courier\", fontsize=\"11\"];"<< std::endl;
-    for (unsigned int m = 0; m < module_.size(); ++m)
-    {
-
-    }
-    for (unsigned int m = 0; m < module_.size(); ++m)
-    {
-        for (auto &in: module_[m].input)
-        {
-            int min = env().getObjectModule(in);
-
-            out << min << " -> " << m << " [ label = \""
-                << env().getObjectName(in) << "\" ];" << std::endl;
-        }
-    }
-    for (unsigned int m = 0; m < module_.size(); ++m)
-    {
-        out <<  m << " [ label = \"{<f0> " << getModule(m)->getRegisteredName()
-            << " |<f1> " << getModuleName(m) << "}\" ];" << std::endl;
-    }
-    out << "}\n" << std::endl;
-}
-
-void VirtualMachine::dumpModuleGraph(void)
-{
-    dumpModuleGraph(std::cout);
-}
-
-void VirtualMachine::dumpModuleGraph(const std::string filename)
-{
-    std::ofstream f(filename);
-
-    dumpModuleGraph(f);
-}
-
-// memory profile //////////////////////////////////////////////////////////////
-const VirtualMachine::MemoryProfile & VirtualMachine::getMemoryProfile(void)
-{
-    if (memoryProfileOutdated_)
-    {
-        makeMemoryProfile();
-        memoryProfileOutdated_ = false;
-    }
-
-    return profile_;
-}
-
-void VirtualMachine::makeMemoryProfile(void)
-{
-    bool protect = env().objectsProtected();
-    bool hmsg    = HadronsLogMessage.isActive();
-    bool gmsg    = GridLogMessage.isActive();
-    bool err     = HadronsLogError.isActive();
-    auto program = getModuleGraph().topoSort();
-
-    resetProfile();
-    profile_.module.resize(getNModule());
-    env().protectObjects(false);
-    GridLogMessage.Active(false);
-    HadronsLogMessage.Active(false);
-    for (auto it = program.rbegin(); it != program.rend(); ++it) 
-    {
-        auto a = *it;
-
-        if (profile_.module[a].empty())
-        {
-            LOG(Debug) << "Profiling memory for module '" << module_[a].name
-                       << "' (" << a << ")" << std::endl;
-            memoryProfile(a);
-            env().freeAll();
-        }
-    }
-    env().protectObjects(protect);
-    GridLogMessage.Active(gmsg);
-    HadronsLogMessage.Active(hmsg);
-    LOG(Debug) << "Memory profile:" << std::endl;
-    LOG(Debug) << "----------------" << std::endl;
-    for (unsigned int a = 0; a < profile_.module.size(); ++a)
-    {
-        LOG(Debug) << getModuleName(a) << " (" << a << ")" << std::endl;
-        for (auto &o: profile_.module[a])
-        {
-            LOG(Debug) << "|__ " << env().getObjectName(o.first) << " ("
-                       << sizeString(o.second) << ")" << std::endl;
-        }
-        LOG(Debug) << std::endl;
-    }
-    LOG(Debug) << "----------------" << std::endl;
-}
-
-void VirtualMachine::resetProfile(void)
-{
-    profile_.module.clear();
-    profile_.object.clear();
-}
-
-void VirtualMachine::resizeProfile(void)
-{
-    if (env().getMaxAddress() > profile_.object.size())
-    {
-        MemoryPrint empty;
-
-        empty.size   = 0;
-        empty.module = -1;
-        profile_.object.resize(env().getMaxAddress(), empty);
-    }
-}
-
-void VirtualMachine::updateProfile(const unsigned int address)
-{
-    resizeProfile();
-    for (unsigned int a = 0; a < env().getMaxAddress(); ++a)
-    {
-        if (env().hasCreatedObject(a) and (profile_.object[a].module == -1))
-        {
-            profile_.object[a].size     = env().getObjectSize(a);
-            profile_.object[a].storage  = env().getObjectStorage(a);
-            profile_.object[a].module   = address;
-            profile_.module[address][a] = profile_.object[a].size;
-            if (env().getObjectModule(a) < 0)
-            {
-                env().setObjectModule(a, address);
-            }
-        }
-    }
-}
-
-void VirtualMachine::cleanEnvironment(void)
-{
-    resizeProfile();
-    for (unsigned int a = 0; a < env().getMaxAddress(); ++a)
-    {
-        if (env().hasCreatedObject(a) and (profile_.object[a].module == -1))
-        {
-            env().freeObject(a);
-        }
-    }
-}
-
-void VirtualMachine::memoryProfile(const unsigned int address)
-{
-    auto m = getModule(address);
-
-    LOG(Debug) << "Setting up module '" << m->getName() 
-               << "' (" << address << ")" << std::endl;
-    try
-    {
-        currentModule_ = address;
-        m->setup();
-        currentModule_ = -1;
-        updateProfile(address);
-    }
-    catch (Exceptions::ObjectDefinition &exc)
-    {
-        cleanEnvironment();
-        if (!env().hasCreatedObject(exc.getAddress()))
-        {
-            LOG(Debug) << "Object '" << env().getObjectName(exc.getAddress())
-                       << "' missing for setup of '" << m->getName() 
-                       << "' (" << address << ")" << std::endl;
-            memoryProfile(env().getObjectModule(exc.getAddress()));
-        }
-        memoryProfile(address);
-    }
-}
-
-void VirtualMachine::memoryProfile(const std::string name)
-{
-    memoryProfile(getModuleAddress(name));
-}
-
-// garbage collector ///////////////////////////////////////////////////////////
-VirtualMachine::GarbageSchedule 
-VirtualMachine::makeGarbageSchedule(const Program &p) const
-{
-    GarbageSchedule freeProg;
-    
-    freeProg.resize(p.size());
-    for (unsigned int a = 0; a < env().getMaxAddress(); ++a)
-    {
-        if (env().getObjectStorage(a) == Environment::Storage::temporary)
-        {
-            auto it = std::find(p.begin(), p.end(), env().getObjectModule(a));
-
-            if (it != p.end())
-            {
-                freeProg[std::distance(p.begin(), it)].insert(a);
-            }
-        }
-        else if (env().getObjectStorage(a) == Environment::Storage::object)
-        {
-            auto pred = [a, this](const unsigned int b)
-            {
-                auto &in = module_[b].input;
-                auto it  = std::find(in.begin(), in.end(), a);
-                
-                return (it != in.end()) or (b == env().getObjectModule(a));
-            };
-            auto it = std::find_if(p.rbegin(), p.rend(), pred);
-            if (it != p.rend())
-            {
-                freeProg[std::distance(it, p.rend()) - 1].insert(a);
-            }
-        }
-    }
-
-    return freeProg;
-}
-
-// high-water memory function //////////////////////////////////////////////////
-VirtualMachine::Size VirtualMachine::memoryNeeded(const Program &p)
-{
-    const MemoryProfile &profile = getMemoryProfile();
-    GarbageSchedule     freep    = makeGarbageSchedule(p);
-    Size                current = 0, max = 0;
-
-    for (unsigned int i = 0; i < p.size(); ++i)
-    {
-        for (auto &o: profile.module[p[i]])
-        {
-            current += o.second;
-        }
-        max = std::max(current, max);
-        for (auto &o: freep[i])
-        {
-            current -= profile.object[o].size;
-        }
-    }
-
-    return max;
-}
-
-// genetic scheduler ///////////////////////////////////////////////////////////
-VirtualMachine::Program VirtualMachine::schedule(const GeneticPar &par)
-{
-    typedef GeneticScheduler<Size, unsigned int> Scheduler;
-
-    auto graph = getModuleGraph();
-
-    //constrained topological sort using a genetic algorithm
-    LOG(Message) << "Scheduling computation..." << std::endl;
-    LOG(Message) << "               #module= " << graph.size() << std::endl;
-    LOG(Message) << "       population size= " << par.popSize << std::endl;
-    LOG(Message) << "       max. generation= " << par.maxGen << std::endl;
-    LOG(Message) << "  max. cst. generation= " << par.maxCstGen << std::endl;
-    LOG(Message) << "         mutation rate= " << par.mutationRate << std::endl;
-    
-    unsigned int          gen, prevPeak, nCstPeak = 0;
-    std::random_device    rd;
-    Scheduler::Parameters gpar;
-    
-    gpar.popSize      = par.popSize;
-    gpar.mutationRate = par.mutationRate;
-    gpar.seed         = rd();
-    CartesianCommunicator::BroadcastWorld(0, &(gpar.seed), sizeof(gpar.seed));
-    Scheduler::ObjFunc memPeak = [this](const Program &p)->Size
-    {
-        return memoryNeeded(p);
-    };
-    Scheduler scheduler(graph, memPeak, gpar);
-    gen = 0;
-    scheduler.initPopulation();
-    LOG(Message) << "Start: " << sizeString(scheduler.getMinValue()) 
-                 << std::endl;
-    do
-    {
-        scheduler.nextGeneration();
-        if (gen != 0)
-        {
-            if (prevPeak == scheduler.getMinValue())
-            {
-                nCstPeak++;
-            }
-            else
-            {
-                nCstPeak = 0;
-            }
-        }
-        
-        prevPeak = scheduler.getMinValue();
-        if (gen % 10 == 0)
-        {
-            LOG(Message) << "Generation " << gen << ": "
-                         << sizeString(scheduler.getMinValue()) << std::endl;
-        }
-        
-        gen++;
-    } while ((gen < par.maxGen) and (nCstPeak < par.maxCstGen));
-    
-    return scheduler.getMinSchedule();
-}
-
-// general execution ///////////////////////////////////////////////////////////
-#define BIG_SEP   "================"
-#define SEP       "----------------"
-#define SMALL_SEP "................"
-#define MEM_MSG(size) sizeString(size)
-
-void VirtualMachine::executeProgram(const Program &p)
-{
-    Size            memPeak = 0, sizeBefore, sizeAfter;
-    GarbageSchedule freeProg;
-    
-    // build garbage collection schedule
-    LOG(Debug) << "Building garbage collection schedule..." << std::endl;
-    freeProg = makeGarbageSchedule(p);
-    for (unsigned int i = 0; i < freeProg.size(); ++i)
-    {
-        std::string msg = "";
-
-        for (auto &a: freeProg[i])
-        {
-            msg += env().getObjectName(a) + " ";
-        }
-        msg += "]";
-        LOG(Debug) << std::setw(4) << i + 1 << ": [" << msg << std::endl;
-    }
-
-    // program execution
-    LOG(Debug) << "Executing program..." << std::endl;
-    totalTime_ = GridTime::zero();
-    for (unsigned int i = 0; i < p.size(); ++i)
-    {
-        // execute module
-        LOG(Message) << SEP << " Measurement step " << i + 1 << "/"
-                     << p.size() << " (module '" << module_[p[i]].name
-                     << "') " << SEP << std::endl;
-        LOG(Message) << SMALL_SEP << " Module execution" << std::endl;
-        currentModule_ = p[i];
-        (*module_[p[i]].data)();
-        currentModule_ = -1;
-        sizeBefore = env().getTotalSize();
-        // print time profile after execution
-        LOG(Message) << SMALL_SEP << " Timings" << std::endl;
-
-        std::map<std::string, GridTime> ctiming, gtiming;
-        GridTime                        total;
-
-        ctiming  = module_[p[i]].data->getTimings();
-        total    = ctiming.at("_total");
-        gtiming["total"]     = ctiming["_total"];   ctiming.erase("_total");
-        gtiming["setup"]     = ctiming["_setup"];   ctiming.erase("_setup");
-        gtiming["execution"] = ctiming["_execute"]; ctiming.erase("_execute");
-        LOG(Message) << "* GLOBAL TIMERS" << std::endl;
-        printTimeProfile(gtiming, total);
-        if (!ctiming.empty())
-        {
-            LOG(Message) << "* CUSTOM TIMERS" << std::endl;
-            printTimeProfile(ctiming, total);
-        }
-        timeProfile_[module_[p[i]].name] = total;
-        totalTime_ += total;
-        // print used memory after execution
-        LOG(Message) << SMALL_SEP << " Memory management" << std::endl;
-        LOG(Message) << "Allocated objects: " << MEM_MSG(sizeBefore)
-                     << std::endl;
-        if (sizeBefore > memPeak)
-        {
-            memPeak = sizeBefore;
-        }
-        // garbage collection for step i
-        LOG(Message) << "Garbage collection..." << std::endl;
-        for (auto &j: freeProg[i])
-        {
-            env().freeObject(j);
-        }
-        // print used memory after garbage collection if necessary
-        sizeAfter = env().getTotalSize();
-        if (sizeBefore != sizeAfter)
-        {
-            LOG(Message) << "Allocated objects: " << MEM_MSG(sizeAfter)
-                            << std::endl;
-        }
-        else
-        {
-            LOG(Message) << "Nothing to free" << std::endl;
-        }
-    }
-    // print total time profile
-     LOG(Message) << SEP << " Measurement time profile" << SEP << std::endl;
-     LOG(Message) << "Total measurement time: " << totalTime_ << " us" << std::endl;
-     LOG(Message) << SMALL_SEP << " Module breakdown" << std::endl;
-     printTimeProfile(timeProfile_, totalTime_);
-}
-
-void VirtualMachine::executeProgram(const std::vector<std::string> &p)
-{
-    Program pAddress;
-    
-    for (auto &n: p)
-    {
-        pAddress.push_back(getModuleAddress(n));
-    }
-    executeProgram(pAddress);
-}
diff --git a/Hadrons/VirtualMachine.hpp b/Hadrons/VirtualMachine.hpp
deleted file mode 100644
index dff72aa6..00000000
--- a/Hadrons/VirtualMachine.hpp
+++ /dev/null
@@ -1,219 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/VirtualMachine.hpp
-
-Copyright (C) 2015-2019
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_VirtualMachine_hpp_
-#define Hadrons_VirtualMachine_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Graph.hpp>
-#include <Hadrons/Environment.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-#define DEFINE_VM_ALIAS \
-inline VirtualMachine & vm(void) const\
-{\
-    return VirtualMachine::getInstance();\
-}
-
-/******************************************************************************
- *                   Virtual machine for module execution                     *
- ******************************************************************************/
-// forward declaration of Module
-class ModuleBase;
-
-class VirtualMachine
-{
-    SINGLETON_DEFCTOR(VirtualMachine);
-public:
-    typedef SITE_SIZE_TYPE                      Size;
-    typedef std::unique_ptr<ModuleBase>         ModPt;
-    typedef std::vector<std::set<unsigned int>> GarbageSchedule;
-    typedef std::vector<unsigned int>           Program;
-    struct MemoryPrint
-    {
-        Size                 size;
-        Environment::Storage storage;
-        int                  module;
-    };
-    struct MemoryProfile
-    {
-        std::vector<std::map<unsigned int, Size>> module;
-        std::vector<MemoryPrint>                  object;
-    };
-    class GeneticPar: Serializable
-    {
-    public:
-        GeneticPar(void):
-            popSize{20}, maxGen{1000}, maxCstGen{100}, mutationRate{.1} {};
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(GeneticPar,
-                                        unsigned int, popSize,
-                                        unsigned int, maxGen,
-                                        unsigned int, maxCstGen,
-                                        double      , mutationRate);
-    };
-private:
-    struct ModuleInfo
-    {
-        const std::type_info      *type{nullptr};
-        std::string               name;
-        ModPt                     data{nullptr};
-        std::vector<unsigned int> input, output;
-        size_t                    maxAllocated;
-    };
-public:
-    // trajectory counter
-    void                setTrajectory(const unsigned int traj);
-    unsigned int        getTrajectory(void) const;
-    // run tag
-    void                setRunId(const std::string id);
-    std::string         getRunId(void) const;
-    // module management
-    void                pushModule(ModPt &pt);
-    template <typename M>
-    void                createModule(const std::string name);
-    template <typename M>
-    void                createModule(const std::string name,
-                                         const typename M::Par &par);
-    void                createModule(const std::string name,
-                                         const std::string type,
-                                         XmlReader &reader);
-    unsigned int        getNModule(void) const;
-    ModuleBase *        getModule(const unsigned int address) const;
-    ModuleBase *        getModule(const std::string name) const;
-    template <typename M>
-    M *                 getModule(const unsigned int address) const;
-    template <typename M>
-    M *                 getModule(const std::string name) const;
-    unsigned int        getModuleAddress(const std::string name) const;
-    std::string         getModuleName(const unsigned int address) const;
-    std::string         getModuleType(const unsigned int address) const;
-    std::string         getModuleType(const std::string name) const;
-    std::string         getModuleNamespace(const unsigned int address) const;
-    std::string         getModuleNamespace(const std::string name) const;
-    int                 getCurrentModule(void) const;
-    bool                hasModule(const unsigned int address) const;
-    bool                hasModule(const std::string name) const;
-    // print VM content
-    void                printContent(void) const;
-    // module graph (could be a const reference if topoSort was const)
-    Graph<unsigned int> getModuleGraph(void);
-    // dump GraphViz graph
-    void                dumpModuleGraph(std::ostream &out);
-    void                dumpModuleGraph(void);
-    void                dumpModuleGraph(const std::string filename);
-    // memory profile
-    const MemoryProfile &getMemoryProfile(void);
-    // garbage collector
-    GarbageSchedule     makeGarbageSchedule(const Program &p) const;
-    // high-water memory function
-    Size                memoryNeeded(const Program &p);
-    // genetic scheduler
-    Program             schedule(const GeneticPar &par);
-    // general execution
-    void                executeProgram(const Program &p);
-    void                executeProgram(const std::vector<std::string> &p);
-private:
-    // environment shortcut
-    DEFINE_ENV_ALIAS;
-    // module graph
-    void makeModuleGraph(void);
-    // memory profile
-    void makeMemoryProfile(void);
-    void resetProfile(void);
-    void resizeProfile(void);
-    void updateProfile(const unsigned int address);
-    void cleanEnvironment(void);
-    void memoryProfile(const std::string name);
-    void memoryProfile(const unsigned int address);
-private:
-    // general
-    std::string                         runId_;
-    unsigned int                        traj_;
-    // module and related maps
-    std::vector<ModuleInfo>             module_;
-    std::map<std::string, unsigned int> moduleAddress_;
-    int                                 currentModule_{-1};
-    // module graph
-    bool                                graphOutdated_{true};
-    Graph<unsigned int>                 graph_;
-    // memory profile
-    bool                                memoryProfileOutdated_{true};
-    MemoryProfile                       profile_;     
-    // time profile
-    GridTime                            totalTime_;
-    std::map<std::string, GridTime>     timeProfile_;               
-};
-
-/******************************************************************************
- *                   VirtualMachine template implementation                   *
- ******************************************************************************/
-// module management ///////////////////////////////////////////////////////////
-template <typename M>
-void VirtualMachine::createModule(const std::string name)
-{
-    ModPt pt(new M(name));
-    
-    pushModule(pt);
-}
-
-template <typename M>
-void VirtualMachine::createModule(const std::string name,
-                               const typename M::Par &par)
-{
-    ModPt pt(new M(name));
-    
-    static_cast<M *>(pt.get())->setPar(par);
-    pushModule(pt);
-}
-
-template <typename M>
-M * VirtualMachine::getModule(const unsigned int address) const
-{
-    if (auto *pt = dynamic_cast<M *>(getModule(address)))
-    {
-        return pt;
-    }
-    else
-    {
-        HADRONS_ERROR(Definition, "module '" + module_[address].name
-                     + "' does not have type " + typeid(M).name()
-                     + "(has type: " + getModuleType(address) + ")");
-    }
-}
-
-template <typename M>
-M * VirtualMachine::getModule(const std::string name) const
-{
-    return getModule<M>(getModuleAddress(name));
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_VirtualMachine_hpp_
diff --git a/Hadrons/add_module.sh b/Hadrons/add_module.sh
deleted file mode 100755
index e37d19b1..00000000
--- a/Hadrons/add_module.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-
-if (( $# != 2 )); then
-    echo "usage: `basename $0` <module name> <namespace>" 1>&2
-    exit 1
-fi
-NAME=$1
-NS=$2
-
-mkdir -p Modules/${NS}
-if [ -e "Modules/${NS}/${NAME}.cc" ] || [ -e "Modules/${NS}/${NAME}.hpp" ]; then
-	echo "error: files Modules/${NS}/${NAME}.* already exists" 1>&2
-	exit 1
-fi
-TMPCC=".${NS}.${NAME}.tmp.cc"
-TMPHPP=".${NS}.${NAME}.tmp.hpp"
-sed "s/___FILEBASENAME___/${NAME}/g" Modules/templates/Module_in_NS.cc.template  > ${TMPCC}
-sed "s/___FILEBASENAME___/${NAME}/g" Modules/templates/Module_in_NS.hpp.template > ${TMPHPP}
-sed "s/___NAMESPACE___/${NS}/g" ${TMPCC}  > Modules/${NS}/${NAME}.cc
-sed "s/___NAMESPACE___/${NS}/g" ${TMPHPP} > Modules/${NS}/${NAME}.hpp
-rm -f ${TMPCC} ${TMPHPP}
-./make_module_list.sh
diff --git a/Hadrons/add_module_template.sh b/Hadrons/add_module_template.sh
deleted file mode 100755
index 8ba112dd..00000000
--- a/Hadrons/add_module_template.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/usr/bin/env bash
-
-if (( $# != 2)); then
-    echo "usage: `basename $0` <module name> <namespace>" 1>&2
-    exit 1
-fi
-NAME=$1
-NS=$2
-
-mkdir -p Modules/${NS}
-if [ -e "Modules/${NS}/${NAME}.cc" ] || [ -e "Modules/${NS}/${NAME}.hpp" ]; then
-	echo "error: files Modules/${NS}/${NAME}.* already exists" 1>&2
-	exit 1
-fi
-TMPCC=".${NS}.${NAME}.tmp.cc"
-TMPHPP=".${NS}.${NAME}.tmp.hpp"
-sed "s/___FILEBASENAME___/${NAME}/g" Modules/templates/Module_tmp_in_NS.cc.template  > ${TMPCC}
-sed "s/___FILEBASENAME___/${NAME}/g" Modules/templates/Module_tmp_in_NS.hpp.template > ${TMPHPP}
-sed "s/___NAMESPACE___/${NS}/g" ${TMPCC}  > Modules/${NS}/${NAME}.cc
-sed "s/___NAMESPACE___/${NS}/g" ${TMPHPP} > Modules/${NS}/${NAME}.hpp
-rm -f ${TMPCC} ${TMPHPP}
-./make_module_list.sh
diff --git a/Hadrons/make_module_inst.sh b/Hadrons/make_module_inst.sh
deleted file mode 100755
index 32ead3f0..00000000
--- a/Hadrons/make_module_inst.sh
+++ /dev/null
@@ -1,27 +0,0 @@
-#!/usr/bin/env bash
-
-for m in `find Modules -name '*.hpp' -type f -print`; do
-    echo "====== ${m}"
-    CCFILE=`echo $m | sed -E s/\.hpp/.cc/g`
-    NS=`echo $m | awk -F '/' '{print $2}'`
-    NMOD=`grep -E 'MODULE_REGISTER_TMP.+<.+>.?' $m | wc -l`
-    if [ ! -e ${CCFILE} ] && (( NMOD != 0 )); then
-        echo "#include <Grid/Hadrons/${m}>" >> ${CCFILE}
-        echo "" >> ${CCFILE}
-        echo "using namespace Grid;" >> ${CCFILE}
-        echo "using namespace Hadrons;" >> ${CCFILE}
-        echo "using namespace ${NS};" >> ${CCFILE}
-        echo "" >> ${CCFILE}
-        for i in `grep -E 'MODULE_REGISTER_TMP.+<.+>.?' $m | sed -E 's/ +//g'`
-        do
-            TMPARG=`echo ${i} | grep -oE 'ARG\(.+>\)' | sed -E 's/^ARG\(//g' | sed -E 's/\)$//g'`
-            SUB=`echo ${i} | sed -E 's/ARG\(.+>\)/@arg@/g' | sed -E 's/,/|/g'`
-            SUB=`echo ${SUB} | sed -E 's/.+\(//g' | sed -E 's/\);//g'`
-            SUB=`echo ${SUB} | sed -E "s/@arg@/${TMPARG}/g"`
-            NAME=`echo ${SUB} | awk -F '|' '{print $1}'`
-            TYPE=`echo ${SUB} | awk -F '|' '{print $2}'`
-            echo "template class Grid::Hadrons::${NS}::${TYPE};" >> ${CCFILE}
-        done
-        echo "" >> ${CCFILE}
-    fi
-done
\ No newline at end of file
diff --git a/Hadrons/make_module_list.sh b/Hadrons/make_module_list.sh
deleted file mode 100755
index 6b483ca5..00000000
--- a/Hadrons/make_module_list.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/usr/bin/env bash
-
-echo 'modules_cc =\' > modules.inc
-find Modules -name '*.cc' -type f -print | sort | sed 's/^/  /;$q;s/$/ \\/' >> modules.inc
-echo '' >> modules.inc
-echo 'modules_hpp =\' >> modules.inc
-find Modules -name '*.hpp' -type f -print | sort | sed 's/^/  /;$q;s/$/ \\/' >> modules.inc
-echo '' >> modules.inc
-rm -f Modules.hpp
-for f in `find Modules -name '*.hpp' | sort`; do
-	echo "#include <Hadrons/${f}>" >> Modules.hpp
-done
diff --git a/Hadrons/modules.inc b/Hadrons/modules.inc
deleted file mode 100644
index 8bc87fd3..00000000
--- a/Hadrons/modules.inc
+++ /dev/null
@@ -1,174 +0,0 @@
-modules_cc =\
-  Modules/MAction/DWF.cc \
-  Modules/MAction/MobiusDWF.cc \
-  Modules/MAction/ScaledDWF.cc \
-  Modules/MAction/Wilson.cc \
-  Modules/MAction/WilsonClover.cc \
-  Modules/MAction/ZMobiusDWF.cc \
-  Modules/MContraction/A2AAslashField.cc \
-  Modules/MContraction/A2AFourQuarkContraction.cc \
-  Modules/MContraction/A2ALoop.cc \
-  Modules/MContraction/A2AMesonField.cc \
-  Modules/MContraction/Baryon.cc \
-  Modules/MContraction/DiscLoop.cc \
-  Modules/MContraction/Gamma3pt.cc \
-  Modules/MContraction/Meson.cc \
-  Modules/MContraction/SigmaToNucleonEye.cc \
-  Modules/MContraction/SigmaToNucleonNonEye.cc \
-  Modules/MContraction/WeakEye3pt.cc \
-  Modules/MContraction/WeakMesonDecayKl2.cc \
-  Modules/MContraction/WeakNonEye3pt.cc \
-  Modules/MDistil/DistilPar.cc \
-  Modules/MDistil/DistilVectors.cc \
-  Modules/MDistil/LapEvec.cc \
-  Modules/MDistil/Noises.cc \
-  Modules/MDistil/PerambFromSolve.cc \
-  Modules/MDistil/Perambulator.cc \
-  Modules/MFermion/EMLepton.cc \
-  Modules/MFermion/FreeProp.cc \
-  Modules/MFermion/GaugeProp.cc \
-  Modules/MGauge/Electrify.cc \
-  Modules/MGauge/FundtoHirep.cc \
-  Modules/MGauge/GaugeFix.cc \
-  Modules/MGauge/Random.cc \
-  Modules/MGauge/StochEm.cc \
-  Modules/MGauge/StoutSmearing.cc \
-  Modules/MGauge/Unit.cc \
-  Modules/MGauge/UnitEm.cc \
-  Modules/MIO/LoadA2AMatrixDiskVector.cc \
-  Modules/MIO/LoadA2AVectors.cc \
-  Modules/MIO/LoadBinary.cc \
-  Modules/MIO/LoadCoarseEigenPack.cc \
-  Modules/MIO/LoadCosmHol.cc \
-  Modules/MIO/LoadDistilNoise.cc \
-  Modules/MIO/LoadEigenPack.cc \
-  Modules/MIO/LoadNersc.cc \
-  Modules/MIO/LoadPerambulator.cc \
-  Modules/MNoise/FullVolumeSpinColorDiagonal.cc \
-  Modules/MNoise/SparseSpinColorDiagonal.cc \
-  Modules/MNoise/TimeDilutedSpinColorDiagonal.cc \
-  Modules/MNPR/Amputate.cc \
-  Modules/MNPR/Bilinear.cc \
-  Modules/MNPR/FourQuark.cc \
-  Modules/MScalar/ChargedProp.cc \
-  Modules/MScalar/FreeProp.cc \
-  Modules/MScalarSUN/Div.cc \
-  Modules/MScalarSUN/EMT.cc \
-  Modules/MScalarSUN/Grad.cc \
-  Modules/MScalarSUN/StochFreeField.cc \
-  Modules/MScalarSUN/TransProj.cc \
-  Modules/MScalarSUN/TrKinetic.cc \
-  Modules/MScalarSUN/TrMag.cc \
-  Modules/MScalarSUN/TrPhi.cc \
-  Modules/MScalarSUN/TwoPoint.cc \
-  Modules/MScalarSUN/TwoPointNPR.cc \
-  Modules/MSink/Point.cc \
-  Modules/MSink/Smear.cc \
-  Modules/MSolver/A2AAslashVectors.cc \
-  Modules/MSolver/A2AVectors.cc \
-  Modules/MSolver/LocalCoherenceLanczos.cc \
-  Modules/MSolver/MixedPrecisionRBPrecCG.cc \
-  Modules/MSolver/RBPrecCG.cc \
-  Modules/MSource/Convolution.cc \
-  Modules/MSource/Gauss.cc \
-  Modules/MSource/JacobiSmear.cc \
-  Modules/MSource/Momentum.cc \
-  Modules/MSource/MomentumPhase.cc \
-  Modules/MSource/Point.cc \
-  Modules/MSource/SeqAslash.cc \
-  Modules/MSource/SeqConserved.cc \
-  Modules/MSource/SeqGamma.cc \
-  Modules/MSource/Wall.cc \
-  Modules/MSource/Z2.cc \
-  Modules/MUtilities/PrecisionCast.cc \
-  Modules/MUtilities/RandomVectors.cc
-
-modules_hpp =\
-  Modules/MAction/DWF.hpp \
-  Modules/MAction/MobiusDWF.hpp \
-  Modules/MAction/ScaledDWF.hpp \
-  Modules/MAction/WilsonClover.hpp \
-  Modules/MAction/Wilson.hpp \
-  Modules/MAction/ZMobiusDWF.hpp \
-  Modules/MContraction/A2AAslashField.hpp \
-  Modules/MContraction/A2AFourQuarkContraction.hpp \
-  Modules/MContraction/A2ALoop.hpp \
-  Modules/MContraction/A2AMesonField.hpp \
-  Modules/MContraction/Baryon.hpp \
-  Modules/MContraction/DiscLoop.hpp \
-  Modules/MContraction/Gamma3pt.hpp \
-  Modules/MContraction/Meson.hpp \
-  Modules/MContraction/SigmaToNucleonEye.hpp \
-  Modules/MContraction/SigmaToNucleonNonEye.hpp \
-  Modules/MContraction/WeakEye3pt.hpp \
-  Modules/MContraction/WeakMesonDecayKl2.hpp \
-  Modules/MContraction/WeakNonEye3pt.hpp \
-  Modules/MDistil/Distil.hpp \
-  Modules/MDistil/DistilPar.hpp \
-  Modules/MDistil/DistilVectors.hpp \
-  Modules/MDistil/LapEvec.hpp \
-  Modules/MDistil/Noises.hpp \
-  Modules/MDistil/PerambFromSolve.hpp \
-  Modules/MDistil/Perambulator.hpp \
-  Modules/MFermion/EMLepton.hpp \
-  Modules/MFermion/FreeProp.hpp \
-  Modules/MFermion/GaugeProp.hpp \
-  Modules/MGauge/Electrify.hpp \
-  Modules/MGauge/FundtoHirep.hpp \
-  Modules/MGauge/GaugeFix.hpp \
-  Modules/MGauge/Random.hpp \
-  Modules/MGauge/StochEm.hpp \
-  Modules/MGauge/StoutSmearing.hpp \
-  Modules/MGauge/UnitEm.hpp \
-  Modules/MGauge/Unit.hpp \
-  Modules/MIO/LoadA2AMatrixDiskVector.hpp \
-  Modules/MIO/LoadA2AVectors.hpp \
-  Modules/MIO/LoadBinary.hpp \
-  Modules/MIO/LoadCoarseEigenPack.hpp \
-  Modules/MIO/LoadCosmHol.hpp \
-  Modules/MIO/LoadDistilNoise.hpp \
-  Modules/MIO/LoadEigenPack.hpp \
-  Modules/MIO/LoadNersc.hpp \
-  Modules/MIO/LoadPerambulator.hpp \
-  Modules/MNoise/FullVolumeSpinColorDiagonal.hpp \
-  Modules/MNoise/SparseSpinColorDiagonal.hpp \
-  Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp \
-  Modules/MNPR/Amputate.hpp \
-  Modules/MNPR/Bilinear.hpp \
-  Modules/MNPR/FourQuark.hpp \
-  Modules/MScalar/ChargedProp.hpp \
-  Modules/MScalar/FreeProp.hpp \
-  Modules/MScalar/Scalar.hpp \
-  Modules/MScalarSUN/Div.hpp \
-  Modules/MScalarSUN/EMT.hpp \
-  Modules/MScalarSUN/Grad.hpp \
-  Modules/MScalarSUN/StochFreeField.hpp \
-  Modules/MScalarSUN/TransProj.hpp \
-  Modules/MScalarSUN/TrKinetic.hpp \
-  Modules/MScalarSUN/TrMag.hpp \
-  Modules/MScalarSUN/TrPhi.hpp \
-  Modules/MScalarSUN/TwoPoint.hpp \
-  Modules/MScalarSUN/TwoPointNPR.hpp \
-  Modules/MScalarSUN/Utils.hpp \
-  Modules/MSink/Point.hpp \
-  Modules/MSink/Smear.hpp \
-  Modules/MSolver/A2AAslashVectors.hpp \
-  Modules/MSolver/A2AVectors.hpp \
-  Modules/MSolver/Guesser.hpp \
-  Modules/MSolver/LocalCoherenceLanczos.hpp \
-  Modules/MSolver/MixedPrecisionRBPrecCG.hpp \
-  Modules/MSolver/RBPrecCG.hpp \
-  Modules/MSource/Convolution.hpp \
-  Modules/MSource/Gauss.hpp \
-  Modules/MSource/JacobiSmear.hpp \
-  Modules/MSource/Momentum.hpp \
-  Modules/MSource/MomentumPhase.hpp \
-  Modules/MSource/Point.hpp \
-  Modules/MSource/SeqAslash.hpp \
-  Modules/MSource/SeqConserved.hpp \
-  Modules/MSource/SeqGamma.hpp \
-  Modules/MSource/Wall.hpp \
-  Modules/MSource/Z2.hpp \
-  Modules/MUtilities/PrecisionCast.hpp \
-  Modules/MUtilities/RandomVectors.hpp
-
diff --git a/Makefile.am b/Makefile.am
index 710514bc..33b25026 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,5 @@
 # additional include paths necessary to compile the C++ library
-SUBDIRS = Grid HMC Hadrons benchmarks tests
+SUBDIRS = Grid HMC benchmarks tests
 
 include $(top_srcdir)/doxygen.inc
 
diff --git a/README.md b/README.md
index 4b0a86f8..9f690ce0 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Grid [![Teamcity status](http://ci.cliath.ph.ed.ac.uk/app/rest/builds/aggregated/strob:(buildType:(affectedProject(id:Grid)),branch:name:develop)/statusIcon.svg)](http://ci.cliath.ph.ed.ac.uk/project.html?projectId=Grid&tab=projectOverview) [![Travis status](https://travis-ci.org/paboyle/Grid.svg?branch=develop)](https://travis-ci.org/paboyle/Grid)
+# Grid [![Teamcity status](http://ci.cliath.ph.ed.ac.uk/app/rest/builds/aggregated/strob:(buildType:(affectedProject(id:GridBasedSoftware_Grid)),branch:name:develop)/statusIcon.svg)](http://ci.cliath.ph.ed.ac.uk/project.html?projectId=GridBasedSoftware_Grid&tab=projectOverview) [![Travis status](https://travis-ci.org/paboyle/Grid.svg?branch=develop)](https://travis-ci.org/paboyle/Grid)
 
 **Data parallel C++ mathematical object library.**
 
diff --git a/configure.ac b/configure.ac
index f4a5e503..3d4ee383 100644
--- a/configure.ac
+++ b/configure.ac
@@ -153,7 +153,7 @@ AC_ARG_ENABLE([mkl],
     [ac_MKL=${enable_mkl}], [ac_MKL=no])
 AC_ARG_ENABLE([ipp],
     [AC_HELP_STRING([--enable-ipp=yes|no|prefix], [enable Intel IPP for fast CRC32C])],
-    [ac_IPP=${enable_mkl}], [ac_IPP=no])
+    [ac_IPP=${enable_ipp}], [ac_IPP=no])
 
 case ${ac_MKL} in
     no)
@@ -280,7 +280,8 @@ case ${CXX} in
 #    CXXLD="nvcc -v -link"
     CXX="nvcc -x cu "
     CXXLD="nvcc -link"
-    CXXFLAGS="$CXXFLAGS -Xcompiler -fno-strict-aliasing -Xcompiler -Wno-unusable-partial-specialization --expt-extended-lambda --expt-relaxed-constexpr"
+#    CXXFLAGS="$CXXFLAGS -Xcompiler -fno-strict-aliasing -Xcompiler -Wno-unusable-partial-specialization --expt-extended-lambda --expt-relaxed-constexpr"
+    CXXFLAGS="$CXXFLAGS -Xcompiler -fno-strict-aliasing --expt-extended-lambda --expt-relaxed-constexpr"
     if test $ac_openmp = yes; then
        CXXFLAGS="$CXXFLAGS -Xcompiler -fopenmp"
     fi
@@ -617,7 +618,6 @@ AC_CONFIG_FILES(tests/IO/Makefile)
 AC_CONFIG_FILES(tests/core/Makefile)
 AC_CONFIG_FILES(tests/debug/Makefile)
 AC_CONFIG_FILES(tests/forces/Makefile)
-AC_CONFIG_FILES(tests/hadrons/Makefile)
 AC_CONFIG_FILES(tests/hmc/Makefile)
 AC_CONFIG_FILES(tests/solver/Makefile)
 AC_CONFIG_FILES(tests/lanczos/Makefile)
@@ -625,8 +625,6 @@ AC_CONFIG_FILES(tests/smearing/Makefile)
 AC_CONFIG_FILES(tests/qdpxx/Makefile)
 AC_CONFIG_FILES(tests/testu01/Makefile)
 AC_CONFIG_FILES(benchmarks/Makefile)
-AC_CONFIG_FILES(Hadrons/Makefile)
-AC_CONFIG_FILES(Hadrons/Utilities/Makefile)
 AC_OUTPUT
 
 echo ""
diff --git a/tests/core/Test_qed.cc b/tests/core/Test_qed.cc
index 775d6307..2630ef66 100644
--- a/tests/core/Test_qed.cc
+++ b/tests/core/Test_qed.cc
@@ -76,7 +76,7 @@ int main(int argc, char *argv[])
 
       std::cout << GridLogMessage << "Spatial zero-mode norm 2" << std::endl;
       sliceSum(a, zm, grid.Nd() - 1);
-      for (unsigned int t = 0; t < latt_size.size(); ++t)
+      for (unsigned int t = 0; t < latt_size[Tp]; ++t)
       {
         std::cout << GridLogMessage << "t = " << t << " " << std::sqrt(norm2(zm[t])) << std::endl;
       }
diff --git a/tests/hadrons/Makefile.am b/tests/hadrons/Makefile.am
deleted file mode 100644
index 1e6a9fb4..00000000
--- a/tests/hadrons/Makefile.am
+++ /dev/null
@@ -1,3 +0,0 @@
-AM_LDFLAGS += -L../../Hadrons
-
-include Make.inc
diff --git a/tests/hadrons/Test_QED.cc b/tests/hadrons/Test_QED.cc
deleted file mode 100644
index 9053c6ed..00000000
--- a/tests/hadrons/Test_QED.cc
+++ /dev/null
@@ -1,265 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_QED.cc
-
-Copyright (C) 2015-2018
-
- Author: Antonin Portelli <antonin.portelli@me.com>
- Author: Vera Guelpers    <v.m.guelpers@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // initialization //////////////////////////////////////////////////////////
-    Grid_init(&argc, &argv);
-    HadronsLogError.Active(GridLogError.isActive());
-    HadronsLogWarning.Active(GridLogWarning.isActive());
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    LOG(Message) << "Grid initialized" << std::endl;
-
-
-    // run setup ///////////////////////////////////////////////////////////////
-    Application              application;
-    std::vector<std::string> flavour = {"h"}; //{"l", "s", "c1", "c2", "c3"};
-    std::vector<double>      mass    = {.2}; //{.01, .04, .2  , .25 , .3  };
-
-    unsigned int  nt    = GridDefaultLatt()[Tp];
-    
-    // global parameters
-    Application::GlobalPar globalPar;
-    globalPar.trajCounter.start = 1500;
-    globalPar.trajCounter.end   = 1520;
-    globalPar.trajCounter.step  = 20;
-    globalPar.runId             = "test";
-    application.setPar(globalPar);
-    // gauge field
-    application.createModule<MGauge::Unit>("gauge");
-    // pt source
-    MSource::Point::Par ptPar;
-    ptPar.position = "0 0 0 0";
-    application.createModule<MSource::Point>("pt", ptPar);
-    // sink
-    MSink::Point::Par sinkPar;
-    sinkPar.mom = "0 0 0";
-    application.createModule<MSink::ScalarPoint>("sink", sinkPar);
-    
-    // set fermion boundary conditions to be periodic space, antiperiodic time.
-    std::string boundary = "1 1 1 -1";
-    std::string twist    = "0. 0. 0. 0.";
-
-    //stochastic photon field
-    MGauge::StochEm::Par photonPar;
-    photonPar.gauge = PhotonR::Gauge::feynman;
-    photonPar.zmScheme = PhotonR::ZmScheme::qedL;
-    application.createModule<MGauge::StochEm>("ph_field", photonPar);
-
-
-
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    {
-        // actions
-        MAction::DWF::Par actionPar;
-        actionPar.gauge = "gauge";
-        actionPar.Ls    = 8;
-        actionPar.M5    = 1.8;
-        actionPar.mass  = mass[i];
-        actionPar.boundary = boundary;
-        actionPar.twist = "0. 0. 0. 0.";
-        application.createModule<MAction::DWF>("DWF_" + flavour[i], actionPar);
-
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar;
-        solverPar.action       = "DWF_" + flavour[i];
-        solverPar.residual     = 1.0e-8;
-        solverPar.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("CG_" + flavour[i],
-                                                    solverPar);
-        
-        // propagators
-        MFermion::GaugeProp::Par quarkPar;
-        quarkPar.solver = "CG_" + flavour[i];
-        quarkPar.source = "pt";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i],
-							 quarkPar);
-
-
-	//seq sources with tadpole insertion
-        MSource::SeqConserved::Par seqPar_T;
-        seqPar_T.q         = "Qpt_" + flavour[i] + "_5d";
-        seqPar_T.action    = "DWF_" + flavour[i];
-        seqPar_T.tA        = 0;
-        seqPar_T.tB        = nt-1;
-        seqPar_T.curr_type = Current::Tadpole;
-	seqPar_T.mu_min	   = 0;
-	seqPar_T.mu_max	   = 3;
-        seqPar_T.mom       = "0. 0. 0. 0.";
-        application.createModule<MSource::SeqConserved>("Qpt_" + flavour[i]
-							 + "_seq_T", seqPar_T);
-        // seq propagator with tadpole insertion
-        MFermion::GaugeProp::Par quarkPar_seq_T;
-        quarkPar_seq_T.solver = "CG_" + flavour[i];
-        quarkPar_seq_T.source = "Qpt_" + flavour[i] + "_seq_T";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i]
-							+ "_seq_T" + flavour[i],
-							quarkPar_seq_T);
-
-
-
-	//seq sources with conserved vector and photon insertion
-        MSource::SeqConserved::Par seqPar_V;
-        seqPar_V.q         = "Qpt_" + flavour[i] + "_5d";
-        seqPar_V.action    = "DWF_" + flavour[i];
-        seqPar_V.tA        = 0;
-        seqPar_V.tB        = nt-1;
-        seqPar_V.curr_type = Current::Vector;
-	seqPar_V.mu_min	   = 0;
-	seqPar_V.mu_max	   = 3;
-        seqPar_V.mom       = "0. 0. 0. 0.";
-	seqPar_V.photon	   = "ph_field";
-        application.createModule<MSource::SeqConserved>("Qpt_" + flavour[i] 
-						    + "_seq_V_ph", seqPar_V);
-        // seq propagator with conserved vector and photon insertion
-        MFermion::GaugeProp::Par quarkPar_seq_V;
-        quarkPar_seq_V.solver = "CG_" + flavour[i];
-        quarkPar_seq_V.source = "Qpt_" + flavour[i] + "_seq_V_ph";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i] 
-						+ "_seq_V_ph_" + flavour[i], 
-							quarkPar_seq_V);
-
-
-
-	//double seq sources with conserved vector and photon insertion
-	//(for self energy)
-        MSource::SeqConserved::Par seqPar_VV;
-        seqPar_VV.q         = "Qpt_" + flavour[i] + "_seq_V_ph_" 
-				+ flavour[i] + "_5d";
-        seqPar_VV.action    = "DWF_" + flavour[i];
-        seqPar_VV.tA        = 0;
-        seqPar_VV.tB        = nt-1;
-        seqPar_VV.curr_type = Current::Vector;
-	seqPar_VV.mu_min    = 0;
-	seqPar_VV.mu_max    = 3;
-        seqPar_VV.mom       = "0. 0. 0. 0.";
-	seqPar_VV.photon    = "ph_field";
-        application.createModule<MSource::SeqConserved>("Qpt_" + flavour[i] 
-						+ "_seq_V_ph" + flavour[i] 
-						+ "_seq_V_ph", seqPar_VV);
-        //double seq propagator with conserved vector and photon insertion
-        MFermion::GaugeProp::Par quarkPar_seq_VV;
-        quarkPar_seq_VV.solver = "CG_" + flavour[i];
-        quarkPar_seq_VV.source = "Qpt_" + flavour[i] + "_seq_V_ph" 
-						+ flavour[i] + "_seq_V_ph";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i] 
-						+ "_seq_V_ph_" + flavour[i] 
-						+ "_seq_V_ph_" + flavour[i], 
-							quarkPar_seq_VV);
-
-
-
-    }
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    for (unsigned int j = i; j < flavour.size(); ++j)
-    {
-        //2pt function contraction
-        MContraction::Meson::Par mesPar;
-        mesPar.output  = "QED/pt_" + flavour[i] + flavour[j];
-        mesPar.q1      = "Qpt_" + flavour[i];
-        mesPar.q2      = "Qpt_" + flavour[j];
-        mesPar.gammas  = "(Gamma5 Gamma5)";
-        mesPar.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_pt_"
-                                                      + flavour[i] + flavour[j],
-                                                      mesPar);
-
-
-
-        //tadpole contraction
-        MContraction::Meson::Par mesPar_seq_T;
-        mesPar_seq_T.output  = "QED/tadpole_pt_" + flavour[i] + "_T_" 
-					+ flavour[i] + "__" + flavour[j];
-        mesPar_seq_T.q1      = "Qpt_" + flavour[i] + "_seq_T" + flavour[i];
-        mesPar_seq_T.q2      = "Qpt_" + flavour[j];
-        mesPar_seq_T.gammas  = "(Gamma5 Gamma5)";
-        mesPar_seq_T.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_tadpole_pt_" +
-                                                      flavour[i] + "_seq_T" 
-						      + flavour[i] + flavour[j],
-                                                      mesPar_seq_T);
-
-
-
-        //photon exchange contraction
-        MContraction::Meson::Par mesPar_seq_E;
-        mesPar_seq_E.output  = "QED/exchange_pt_" + flavour[i] + "_V_ph_" 
-				+ flavour[i] + "__" + flavour[j] + "_V_ph_"
-				+ flavour[j];
-        mesPar_seq_E.q1      = "Qpt_" + flavour[i] + "_seq_V_ph_" + flavour[i];
-        mesPar_seq_E.q2      = "Qpt_" + flavour[j] + "_seq_V_ph_" + flavour[j];
-        mesPar_seq_E.gammas  = "(Gamma5 Gamma5)";
-        mesPar_seq_E.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_exchange_pt_" 
-					+ flavour[i] + "_seq_V_ph_" + flavour[i] 
-					+ flavour[j] + "_seq_V_ph_" + flavour[j],
-                                                      mesPar_seq_E);
-
-
-
-        //self energy contraction
-        MContraction::Meson::Par mesPar_seq_S;
-        mesPar_seq_S.output  = "QED/selfenergy_pt_" + flavour[i] + "_V_ph_" 
-				+ flavour[i] + "_V_ph_" + flavour[i] + "__" 
-				+  flavour[j];
-        mesPar_seq_S.q1      = "Qpt_" + flavour[i] + "_seq_V_ph_" + flavour[i] 
-				+ "_seq_V_ph_" + flavour[i];
-        mesPar_seq_S.q2      = "Qpt_" + flavour[j];
-        mesPar_seq_S.gammas  = "(Gamma5 Gamma5)";
-        mesPar_seq_S.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_selfenergy_pt_" 
-						    + flavour[i] + "_seq_V_ph_" 
-						    + flavour[i] + "_seq_V_ph_" 
-						    + flavour[i] + flavour[j],
-                                                       mesPar_seq_S);
-
-    }
-
-
-
-    
-    // execution
-    application.saveParameterFile("QED.xml");
-    application.run();
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_diskvector.cc b/tests/hadrons/Test_diskvector.cc
deleted file mode 100644
index 9ec97a22..00000000
--- a/tests/hadrons/Test_diskvector.cc
+++ /dev/null
@@ -1,113 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_diskvector.cc
-
-Copyright (C) 2015-2018
-
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#define DV_DEBUG
-#include <Hadrons/DiskVector.hpp>
-
-using namespace Grid;
-using namespace Grid::Hadrons;
-
-GRID_SERIALIZABLE_ENUM(Enum, undef, red, 1, blue, 2, green, 3);
-
-class Object: Serializable {
-public:
-  GRID_SERIALIZABLE_CLASS_MEMBERS(Object,
-                                  Enum, e,
-                                  SpinColourMatrix, scm);
-};
-
-#ifdef HAVE_HDF5
-typedef Hdf5Reader TestReader;
-typedef Hdf5Writer TestWriter;
-#else
-typedef BinaryReader TestReader;
-typedef BinaryWriter TestWriter;
-#endif
-
-int main(int argc, char *argv[])
-{
-    Grid_init(&argc, &argv);
-
-    GridSerialRNG rng;
-    Object        obj, v2w, v2r, v13w, v13r;
-
-    SerializableDiskVector<Object, TestReader, TestWriter> v("diskvector_test", 1000, 4);
-
-    obj.e = Enum::red;
-    random(rng, obj.scm);
-    v[32] = obj;
-    random(rng, obj.scm);
-    v[2] = obj;
-    v2w  = obj;
-    random(rng, obj.scm);
-    v[6] = obj;
-    random(rng, obj.scm);
-    v[7] = obj;
-    random(rng, obj.scm);
-    v[8] = obj;
-    random(rng, obj.scm);
-    v[9] = obj;
-    random(rng, obj.scm);
-    v[10] = obj;
-    random(rng, obj.scm);
-    v[11] = obj;
-    random(rng, obj.scm);
-    v[12] = obj;
-    random(rng, obj.scm);
-    v[13] = obj;
-    v13w  = obj;
-    random(rng, obj.scm);
-    v[14] = obj;
-    random(rng, obj.scm);
-    v[15] = obj;
-
-    v2r = v[2];
-    LOG(Message) << "v[2] correct? " 
-                 << ((v2r == v2w) ? "yes" : "no" ) << std::endl;
-    v13r = v[13];
-    LOG(Message) << "v[13] correct? " 
-                 << ((v13r == v13w) ? "yes" : "no" ) << std::endl;
-    LOG(Message) << "hit ratio " << v.hitRatio() << std::endl;
-
-    EigenDiskVector<ComplexD>         w("eigendiskvector_test", 1000, 4);
-    EigenDiskVector<ComplexD>::Matrix m,n;
-
-    w[2] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    m    = w[2];
-    w[3] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    w[4] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    w[5] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    w[6] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    w[7] = EigenDiskVectorMat<ComplexD>::Random(2000, 2000);
-    n    = w[2];
-    LOG(Message) << "w[2] correct? " 
-                 << ((m == n) ? "yes" : "no" ) << std::endl;
-    LOG(Message) << "hit ratio " << w.hitRatio() << std::endl;
-
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_distil.cc b/tests/hadrons/Test_distil.cc
deleted file mode 100644
index 0156f340..00000000
--- a/tests/hadrons/Test_distil.cc
+++ /dev/null
@@ -1,382 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: Tests/Hadrons/Test_hadrons_distil.cc
- 
- Copyright (C) 2015-2019
- 
- Author: Felix Erben <ferben@ed.ac.uk>
- Author: Michael Marshall <Michael.Marshall@ed.ac.uk>
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-
-#include <typeinfo>
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-// Very simple iterators for Eigen tensors
-// The only way I could get these iterators to work is to put the begin() and end() functions in the Eigen namespace
-// So if Eigen ever defines these, we'll have a conflict and have to change this
-namespace Eigen {
-  template <typename ET>
-  inline typename std::enable_if<EigenIO::is_tensor<ET>::value, typename EigenIO::Traits<ET>::scalar_type *>::type
-  begin( ET & et ) { return reinterpret_cast<typename Grid::EigenIO::Traits<ET>::scalar_type *>(et.data()); }
-  template <typename ET>
-  inline typename std::enable_if<EigenIO::is_tensor<ET>::value, typename EigenIO::Traits<ET>::scalar_type *>::type
-  end( ET & et ) { return begin(et) + et.size() * EigenIO::Traits<ET>::count; }
-}
-
-/////////////////////////////////////////////////////////////
-// Test creation of laplacian eigenvectors
-/////////////////////////////////////////////////////////////
-
-void test_Global(Application &application)
-{
-  // global parameters
-  Application::GlobalPar globalPar;
-  globalPar.trajCounter.start = 1100;
-  globalPar.trajCounter.end   = 1120;
-  globalPar.trajCounter.step  = 20;
-  globalPar.runId             = "test";
-  globalPar.graphFile         = "";
-  globalPar.scheduleFile      = "";
-  globalPar.saveSchedule      = "false";
-  globalPar.parallelWriteMaxRetry      = -1;
-  application.setPar(globalPar);
-}
-
-/////////////////////////////////////////////////////////////
-// Create a random gauge with the correct name
-/////////////////////////////////////////////////////////////
-
-std::string test_Gauge(Application &application )
-{
-  std::string sGaugeName{ "gauge" };
-  application.createModule<MGauge::Random>( sGaugeName );
-  return sGaugeName;
-}
-
-/////////////////////////////////////////////////////////////
-// Test creation of laplacian eigenvectors
-/////////////////////////////////////////////////////////////
-
-void test_LapEvec(Application &application)
-{
-  const char szModuleName[] = "LapEvec";
-  test_Gauge( application );
-  MDistil::LapEvecPar p;
-  p.gauge = "gauge";
-  p.Stout.steps = 3;
-  p.Stout.rho = 0.2;
-  p.Cheby.PolyOrder = 11;
-  p.Cheby.alpha = 0.55;
-  p.Cheby.beta = 35.5;
-  p.Lanczos.Nvec = 5;
-  p.Lanczos.Nk = 6;
-  p.Lanczos.Np = 2;
-  p.Lanczos.MaxIt = 1000;
-  p.Lanczos.resid = 1e-2;
-  p.Lanczos.IRLLog = 0;
-  application.createModule<MDistil::LapEvec>(szModuleName,p);
-}
-
-/////////////////////////////////////////////////////////////
-// Test creation Solver
-/////////////////////////////////////////////////////////////
-
-std::string SolverName( const char * pSuffix = nullptr ) {
-  std::string sSolverName{ "CG" };
-  if( pSuffix && pSuffix[0] ) {
-    sSolverName.append( "_" );
-    sSolverName.append( pSuffix );
-  }
-  return sSolverName;
-}
-
-std::string test_Solver(Application &application, const char * pSuffix = nullptr )
-{
-  std::string sActionName{ "DWF" };
-  if( pSuffix && pSuffix[0] ) {
-    sActionName.append( "_" );
-    sActionName.append( pSuffix );
-  }
-  MAction::DWF::Par actionPar;
-  actionPar.gauge = "gauge";
-  actionPar.Ls    = 16;
-  actionPar.M5    = 1.8;
-  actionPar.mass  = 0.005;
-  actionPar.boundary = "1 1 1 -1";
-  actionPar.twist = "0. 0. 0. 0.";
-  application.createModule<MAction::DWF>( sActionName, actionPar );
-  MSolver::RBPrecCG::Par solverPar;
-  solverPar.action       = sActionName;
-  solverPar.residual     = 1.0e-2;
-  solverPar.maxIteration = 10000;
-  std::string sSolverName{ SolverName( pSuffix ) };
-  application.createModule<MSolver::RBPrecCG>( sSolverName, solverPar );
-  return sSolverName;
-}
-
-/////////////////////////////////////////////////////////////
-// DistilParameters
-/////////////////////////////////////////////////////////////
-
-std::string test_DPar(Application &application) {
-  MDistil::DistilParameters DPar;
-  DPar.nvec = 5;
-  DPar.nnoise = 1;
-  DPar.tsrc = 0;
-  DPar.LI = 5;
-  DPar.TI = 8;
-  DPar.SI = 4;
-  std::string sDParName{"DPar_l"};
-  application.createModule<MDistil::DistilPar>(sDParName,DPar);
-  return sDParName;
-}
-/////////////////////////////////////////////////////////////
-// Noises
-/////////////////////////////////////////////////////////////
-
-std::string test_Noises(Application &application, const std::string &sNoiseBaseName ) {
-  MDistil::NoisesPar NoisePar;
-  NoisePar.DistilParams = "DPar_l";
-  NoisePar.NoiseFileName = "noise";
-  std::string sNoiseName{"noise"};
-  application.createModule<MDistil::Noises>(sNoiseName,NoisePar);
-  return sNoiseName;
-}
-
-/////////////////////////////////////////////////////////////
-// Perambulators
-/////////////////////////////////////////////////////////////
-
-std::string PerambulatorName( const char * pszSuffix = nullptr )
-{
-  std::string sPerambulatorName{ "Peramb" };
-  if( pszSuffix && pszSuffix[0] )
-    sPerambulatorName.append( pszSuffix );
-  return sPerambulatorName;
-}
-
-void test_LoadPerambulators( Application &application, const char * pszSuffix = nullptr )
-{
-  std::string sModuleName{ "Peramb_load" };
-  MIO::LoadPerambulator::Par PerambPar;
-  PerambPar.PerambFileName = "Peramb";
-  PerambPar.DistilParams = "DPar_l";
-  test_Noises(application, sModuleName); // I want these written after solver stuff
-  application.createModule<MIO::LoadPerambulator>( sModuleName, PerambPar );
-}
-
-void test_Perambulators( Application &application, const char * pszSuffix = nullptr )
-{
-  std::string sModuleName{ PerambulatorName( pszSuffix ) };
-  // Perambulator parameters
-  MDistil::Perambulator::Par PerambPar;
-  PerambPar.lapevec = "LapEvec";
-  PerambPar.PerambFileName = sModuleName;
-  PerambPar.solver = test_Solver( application, pszSuffix );
-  PerambPar.DistilParams = "DPar_l";
-  PerambPar.noise = "noise";
-  test_Noises(application, sModuleName); // I want these written after solver stuff
-  application.createModule<MDistil::Perambulator>( sModuleName, PerambPar );
-}
-
-/////////////////////////////////////////////////////////////
-// DistilVectors
-/////////////////////////////////////////////////////////////
-
-void test_DistilVectors(Application &application, const char * pszSuffix = nullptr, const char * pszNvec = nullptr )
-{
-  std::string sModuleName{"DistilVecs"};
-  if( pszSuffix )
-    sModuleName.append( pszSuffix );
-  std::string sPerambName{"Peramb"};
-  if( pszSuffix )
-    sPerambName.append( pszSuffix );
-  MDistil::DistilVectors::Par DistilVecPar;
-  DistilVecPar.noise = "noise";
-  DistilVecPar.rho = "rho";
-  DistilVecPar.phi = "phi";
-  DistilVecPar.perambulator = sPerambName;
-  DistilVecPar.lapevec = "LapEvec";
-  DistilVecPar.DistilParams = "DPar_l";
-  application.createModule<MDistil::DistilVectors>(sModuleName,DistilVecPar);
-}
-
-/////////////////////////////////////////////////////////////
-// MesonSink
-/////////////////////////////////////////////////////////////
-
-void test_MesonSink(Application &application)
-{
-  // DistilVectors parameters
-  MContraction::A2AMesonField::Par A2AMesonFieldPar;
-  //A2AMesonFieldPar.left="Peramb_unsmeared_sink";
-  A2AMesonFieldPar.left="g5phi";
-  A2AMesonFieldPar.right="Peramb_unsmeared_sink";
-  A2AMesonFieldPar.output="DistilFields";
-  A2AMesonFieldPar.gammas="Identity";
-  A2AMesonFieldPar.mom={"0 0 0"};
-  A2AMesonFieldPar.cacheBlock=2;
-  A2AMesonFieldPar.block=4;
-  application.createModule<MContraction::A2AMesonField>("DistilMesonSink",A2AMesonFieldPar);
-}
-/////////////////////////////////////////////////////////////
-// MesonFields
-/////////////////////////////////////////////////////////////
-
-void test_MesonField(Application &application, const char * pszFileSuffix,
-                     const char * pszObjectLeft = nullptr, const char * pszObjectRight = nullptr )
-{
-  // DistilVectors parameters
-  if( pszObjectLeft == nullptr )
-    pszObjectLeft = pszFileSuffix;
-  if( pszObjectRight == nullptr )
-    pszObjectRight = pszObjectLeft;
-  MContraction::A2AMesonField::Par A2AMesonFieldPar;
-  A2AMesonFieldPar.left="";
-  A2AMesonFieldPar.right=A2AMesonFieldPar.left;
-  A2AMesonFieldPar.left.append( pszObjectLeft );
-  A2AMesonFieldPar.right.append( pszObjectRight );
-  A2AMesonFieldPar.output="MesonSinks";
-  A2AMesonFieldPar.output.append( pszFileSuffix );
-  A2AMesonFieldPar.gammas="Identity";
-  A2AMesonFieldPar.mom={"0 0 0"};
-  A2AMesonFieldPar.cacheBlock=2;
-  A2AMesonFieldPar.block=4;
-  std::string sObjectName{"DistilMesonField"};
-  sObjectName.append( pszFileSuffix );
-  application.createModule<MContraction::A2AMesonField>(sObjectName, A2AMesonFieldPar);
-}
-
-bool bNumber( int &ri, const char * & pstr, bool bGobbleWhiteSpace = true )
-{
-  if( bGobbleWhiteSpace )
-    while( std::isspace(static_cast<unsigned char>(*pstr)) )
-      pstr++;
-  const char * p = pstr;
-  bool bMinus = false;
-  char c = * p++;
-  if( c == '+' )
-    c = * p++;
-  else if( c == '-' ) {
-    bMinus = true;
-    c = * p++;
-  }
-  int n = c - '0';
-  if( n < 0 || n > 9 )
-    return false;
-  while( * p >= '0' && * p <= '9' ) {
-    n = n * 10 + ( * p ) - '0';
-    p++;
-  }
-  if( bMinus )
-    n *= -1;
-  ri = n;
-  pstr = p;
-  return true;
-}
-
-int main(int argc, char *argv[])
-{
-  // Decode command-line parameters. 1st one is which test to run
-  int iTestNum = -1;
-
-  for(int i = 1 ; i < argc ; i++ ) {
-    std::cout << "argv[" << i << "]=\"" << argv[i] << "\"" << std::endl;
-    const char * p = argv[i];
-    if( * p == '/' || * p == '-' ) {
-      p++;
-      char c = * p++;
-      switch(toupper(c)) {
-        case 'T':
-          if( bNumber( iTestNum, p ) ) {
-            std::cout << "Test " << iTestNum << " requested";
-            if( * p )
-              std::cout << " (ignoring trailer \"" << p << "\")";
-            std::cout << std::endl;
-          }
-          else
-            std::cout << "Invalid test \"" << &argv[i][2] << "\"" << std::endl;
-          break;
-        default:
-          std::cout << "Ignoring switch \"" << &argv[i][1] << "\"" << std::endl;
-          break;
-      }
-    }
-  }
-
-  // initialization //////////////////////////////////////////////////////////
-  Grid_init(&argc, &argv);
-  HadronsLogError.Active(GridLogError.isActive());
-  HadronsLogWarning.Active(GridLogWarning.isActive());
-  HadronsLogMessage.Active(GridLogMessage.isActive());
-  HadronsLogIterative.Active(GridLogIterative.isActive());
-  HadronsLogDebug.Active(GridLogDebug.isActive());
-  LOG(Message) << "Grid initialized" << std::endl;
-  
-  // run setup ///////////////////////////////////////////////////////////////
-  Application              application;
-
-  // For now perform free propagator test - replace this with distillation test(s)
-  LOG(Message) << "====== Creating xml for test " << iTestNum << " ======" << std::endl;
-  
-  switch(iTestNum) {
-    default: // 0
-      LOG(Message) << "Computing Meson 2pt-function" << std::endl;
-      test_Global( application );
-      test_LapEvec( application );
-      test_DPar( application );
-      test_Perambulators( application );
-      test_DistilVectors( application );
-      test_MesonField( application, "Phi", "phi" );
-      test_MesonField( application, "Rho", "rho" );
-      break;
-    case 1:
-      LOG(Message) << "Computing Meson 2pt-function by loading perambulators" << std::endl;
-      test_Global( application );
-      test_LapEvec( application );
-      test_DPar( application );
-      test_LoadPerambulators( application );
-      test_DistilVectors( application, "_load" );
-      test_MesonField( application, "Phi", "phi" );
-      test_MesonField( application, "Rho", "rho" );
-      break;
-  }
-  // execution
-  static const char XmlFileName[] = "test_distil.xml";
-  application.saveParameterFile( XmlFileName );
-
-  const Grid::Coordinate &lat{GridDefaultLatt()};
-  if( lat.size() == 4 && lat[0] == 4 && lat[1] == 4 && lat[2] == 4 && lat[3] == 8 )
-    application.run();
-  else
-    LOG(Warning) << "The parameters in " << XmlFileName << " are designed to run on a laptop usid --grid 4.4.4.8" << std::endl;
-  
-  // epilogue
-  LOG(Message) << "Grid is finalizing now" << std::endl;
-  Grid_finalize();
-  
-  return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_free_prop.cc b/tests/hadrons/Test_free_prop.cc
deleted file mode 100644
index abf05e33..00000000
--- a/tests/hadrons/Test_free_prop.cc
+++ /dev/null
@@ -1,246 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_free_prop.cc
-
-Copyright (C) 2015-2018
-
- Author: Antonin Portelli <antonin.portelli@me.com>
- Author: Vera Guelpers    <v.m.guelpers@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // initialization //////////////////////////////////////////////////////////
-    Grid_init(&argc, &argv);
-    HadronsLogError.Active(GridLogError.isActive());
-    HadronsLogWarning.Active(GridLogWarning.isActive());
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    LOG(Message) << "Grid initialized" << std::endl;
-
-
-    // run setup ///////////////////////////////////////////////////////////////
-    Application              application;
-    std::vector<std::string> flavour = {"h"}; //{"l", "s", "c1", "c2", "c3"};
-    std::vector<double>      mass    = {.2}; //{.01, .04, .2  , .25 , .3  };
-    std::vector<std::string> lepton_flavour    = {"mu"};
-    std::vector<double>      lepton_mass    = {.2};
-
-    unsigned int  nt    = GridDefaultLatt()[Tp];
-    
-    // global parameters
-    Application::GlobalPar globalPar;
-    globalPar.trajCounter.start = 1500;
-    globalPar.trajCounter.end   = 1520;
-    globalPar.trajCounter.step  = 20;
-    globalPar.runId             = "test";
-    application.setPar(globalPar);
-    // gauge field
-    application.createModule<MGauge::Unit>("gauge");
-    // unit gauge field for lepton 
-    application.createModule<MGauge::Unit>("free_gauge");
-    // pt source
-    MSource::Point::Par ptPar;
-    ptPar.position = "0 0 0 0";
-    application.createModule<MSource::Point>("pt", ptPar);
-    // sink
-    MSink::Point::Par sinkPar;
-    sinkPar.mom = "0 0 0";
-    application.createModule<MSink::ScalarPoint>("sink", sinkPar);
-    
-    // set fermion boundary conditions to be periodic space, antiperiodic time.
-    std::string boundary = "1 1 1 -1";
-
-
-    //Propagators from FFT and Feynman rules
-    for (unsigned int i = 0; i < lepton_mass.size(); ++i)
-    {
-        //DWF actions
-        MAction::DWF::Par actionPar_lep;
-        actionPar_lep.gauge = "free_gauge";
-        actionPar_lep.Ls    = 8;
-        actionPar_lep.M5    = 1.8;
-        actionPar_lep.mass  = lepton_mass[i];
-        actionPar_lep.boundary = boundary;
-        application.createModule<MAction::DWF>("free_DWF_" + lepton_flavour[i], actionPar_lep);
-
-        //DWF free propagators
-        MFermion::FreeProp::Par freePar;
-        freePar.source = "pt";
-	freePar.action = "free_DWF_" + lepton_flavour[i];
-	freePar.twist = "0 0 0 0.5";
-        freePar.mass = lepton_mass[i];
-        application.createModule<MFermion::FreeProp>("Lpt_" + lepton_flavour[i],
-							 freePar);
-
-        //Wilson actions
-        MAction::Wilson::Par actionPar_lep_W;
-        actionPar_lep_W.gauge = "free_gauge";
-        actionPar_lep_W.mass  = lepton_mass[i];
-        actionPar_lep_W.boundary = boundary;
-        application.createModule<MAction::Wilson>("free_W_" + lepton_flavour[i], actionPar_lep_W);
-
-        //Wilson free propagators
-        MFermion::FreeProp::Par freePar_W;
-        freePar_W.source = "pt";
-	freePar_W.action = "free_W_" + lepton_flavour[i];
-	freePar_W.twist = "0 0 0 0.5";
-        freePar_W.mass = lepton_mass[i];
-        application.createModule<MFermion::FreeProp>("W_Lpt_" + lepton_flavour[i],
-							 freePar_W);
-
-
-    }
-
-
-
-    //Propagators from inversion
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    {
-        //DWF actions
-        MAction::DWF::Par actionPar;
-        actionPar.gauge = "gauge";
-        actionPar.Ls    = 8;
-        actionPar.M5    = 1.8;
-        actionPar.mass  = mass[i];
-        actionPar.boundary = boundary;
-        application.createModule<MAction::DWF>("DWF_" + flavour[i], actionPar);
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar;
-        solverPar.action       = "DWF_" + flavour[i];
-        solverPar.residual     = 1.0e-8;
-        solverPar.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("CG_" + flavour[i],
-                                                    solverPar);
-        
-        //DWF propagators
-        MFermion::GaugeProp::Par quarkPar;
-        quarkPar.solver = "CG_" + flavour[i];
-        quarkPar.source = "pt";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i],
-							 quarkPar);
-
-
-
-        //Wilson actions
-        MAction::Wilson::Par actionPar_W;
-        actionPar_W.gauge = "gauge";
-        actionPar_W.mass  = mass[i];
-        actionPar_W.boundary = boundary;
-        application.createModule<MAction::Wilson>("W_" + flavour[i], actionPar_W);
-
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar_W;
-        solverPar_W.action       = "W_" + flavour[i];
-        solverPar_W.residual     = 1.0e-8;
-        solverPar_W.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("W_CG_" + flavour[i],
-                                                    solverPar_W);
-        
-        //Wilson propagators
-        MFermion::GaugeProp::Par quarkPar_W;
-        quarkPar_W.solver = "W_CG_" + flavour[i];
-        quarkPar_W.source = "pt";
-        application.createModule<MFermion::GaugeProp>("W_Qpt_" + flavour[i],
-							 quarkPar_W);
-
-    }
-
-
-    //2pt contraction for Propagators from FFT and Feynman rules
-    for (unsigned int i = 0; i < lepton_flavour.size(); ++i)
-    for (unsigned int j = i; j < lepton_flavour.size(); ++j)
-    {
-        //2pt function contraction DWF
-        MContraction::Meson::Par freemesPar;
-        freemesPar.output  = "2pt_free/DWF_L_pt_" + lepton_flavour[i] + lepton_flavour[j];
-        freemesPar.q1      = "Lpt_" + lepton_flavour[i];
-        freemesPar.q2      = "Lpt_" + lepton_flavour[j];
-        freemesPar.gammas  = "(Gamma5 Gamma5)";
-        freemesPar.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_L_pt_"
-                                                      + lepton_flavour[i] + lepton_flavour[j],
-                                                      freemesPar);
-
-        //2pt function contraction Wilson
-        MContraction::Meson::Par freemesPar_W;
-        freemesPar_W.output  = "2pt_free/W_L_pt_" + lepton_flavour[i] + lepton_flavour[j];
-        freemesPar_W.q1      = "W_Lpt_" + lepton_flavour[i];
-        freemesPar_W.q2      = "W_Lpt_" + lepton_flavour[j];
-        freemesPar_W.gammas  = "(Gamma5 Gamma5)";
-        freemesPar_W.sink    = "sink";
-        application.createModule<MContraction::Meson>("W_meson_L_pt_"
-                                                      + lepton_flavour[i] + lepton_flavour[j],
-                                                      freemesPar_W);
-
-    }
-
-    //2pt contraction for Propagators from inverion
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    for (unsigned int j = i; j < flavour.size(); ++j)
-    {
-        //2pt function contraction DWF
-        MContraction::Meson::Par mesPar;
-        mesPar.output  = "2pt_free/DWF_pt_" + flavour[i] + flavour[j];
-        mesPar.q1      = "Qpt_" + flavour[i];
-        mesPar.q2      = "Qpt_" + flavour[j];
-        mesPar.gammas  = "(Gamma5 Gamma5)";
-        mesPar.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_pt_"
-                                                      + flavour[i] + flavour[j],
-                                                      mesPar);
-
-
-        //2pt function contraction Wilson
-        MContraction::Meson::Par mesPar_W;
-        mesPar_W.output  = "2pt_free/W_pt_" + flavour[i] + flavour[j];
-        mesPar_W.q1      = "W_Qpt_" + flavour[i];
-        mesPar_W.q2      = "W_Qpt_" + flavour[j];
-        mesPar_W.gammas  = "(Gamma5 Gamma5)";
-        mesPar_W.sink    = "sink";
-        application.createModule<MContraction::Meson>("W_meson_pt_"
-                                                      + flavour[i] + flavour[j],
-                                                      mesPar_W);
-
-    }
-
-
-
-    // execution
-    application.saveParameterFile("free_prop.xml");
-    application.run();
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_hadrons_meson_3pt.cc b/tests/hadrons/Test_hadrons_meson_3pt.cc
deleted file mode 100644
index 741e2a7c..00000000
--- a/tests/hadrons/Test_hadrons_meson_3pt.cc
+++ /dev/null
@@ -1,188 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_hadrons_meson_3pt.cc
-
-Copyright (C) 2015-2018
-
- Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // initialization //////////////////////////////////////////////////////////
-    Grid_init(&argc, &argv);
-    HadronsLogError.Active(GridLogError.isActive());
-    HadronsLogWarning.Active(GridLogWarning.isActive());
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    LOG(Message) << "Grid initialized" << std::endl;
-    
-    // run setup ///////////////////////////////////////////////////////////////
-    Application              application;
-    std::vector<std::string> flavour = {"l", "s", "c1", "c2", "c3"};
-    std::vector<double>      mass    = {.01, .04, .2  , .25 , .3  };
-    unsigned int             nt      = GridDefaultLatt()[Tp];
-    
-    // global parameters
-    Application::GlobalPar globalPar;
-    globalPar.trajCounter.start    = 1500;
-    globalPar.trajCounter.end      = 1520;
-    globalPar.trajCounter.step     = 20;
-    globalPar.runId                = "test";
-    globalPar.genetic.maxGen       = 1000;
-    globalPar.genetic.maxCstGen    = 200;
-    globalPar.genetic.popSize      = 20;
-    globalPar.genetic.mutationRate = .1;
-    application.setPar(globalPar);
-    
-    // gauge field
-    application.createModule<MGauge::Unit>("gauge");
-    
-    // set fermion boundary conditions to be periodic space, antiperiodic time.
-    std::string boundary = "1 1 1 -1";
-    std::string twist = "0. 0. 0. 0.";
-
-    // sink
-    MSink::Point::Par sinkPar;
-    sinkPar.mom = "0 0 0";
-    application.createModule<MSink::ScalarPoint>("sink", sinkPar);
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    {
-        // actions
-        MAction::DWF::Par actionPar;
-        actionPar.gauge = "gauge";
-        actionPar.Ls    = 12;
-        actionPar.M5    = 1.8;
-        actionPar.mass  = mass[i];
-        actionPar.boundary = boundary;
-        actionPar.twist = twist;
-        application.createModule<MAction::DWF>("DWF_" + flavour[i], actionPar);
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar;
-        solverPar.action       = "DWF_" + flavour[i];
-        solverPar.residual     = 1.0e-8;
-        solverPar.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("CG_" + flavour[i],
-                                                    solverPar);
-    }
-    for (unsigned int t = 0; t < nt; t += 1)
-    {
-        std::string                           srcName;
-        std::vector<std::string>              qName;
-        std::vector<std::vector<std::string>> seqName;
-        
-        // Z2 source
-        MSource::Z2::Par z2Par;
-        z2Par.tA = t;
-        z2Par.tB = t;
-        srcName  = "z2_" + std::to_string(t);
-        application.createModule<MSource::Z2>(srcName, z2Par);
-        for (unsigned int i = 0; i < flavour.size(); ++i)
-        {
-            // sequential sources
-            MSource::SeqGamma::Par seqPar;
-            qName.push_back("QZ2_" + flavour[i] + "_" + std::to_string(t));
-            seqPar.q   = qName[i];
-            seqPar.tA  = (t + nt/4) % nt;
-            seqPar.tB  = (t + nt/4) % nt;
-            seqPar.mom = "1. 0. 0. 0.";
-            seqName.push_back(std::vector<std::string>(Nd));
-            for (unsigned int mu = 0; mu < Nd; ++mu)
-            {
-                seqPar.gamma   = 0x1 << mu;
-                seqName[i][mu] = "G" + std::to_string(seqPar.gamma)
-                                 + "_" + std::to_string(seqPar.tA) + "-"
-                                 + qName[i];
-                application.createModule<MSource::SeqGamma>(seqName[i][mu], seqPar);
-            }
-            
-            // propagators
-            MFermion::GaugeProp::Par quarkPar;
-            quarkPar.solver = "CG_" + flavour[i];
-            quarkPar.source = srcName;
-            application.createModule<MFermion::GaugeProp>(qName[i], quarkPar);
-            for (unsigned int mu = 0; mu < Nd; ++mu)
-            {
-                quarkPar.source = seqName[i][mu];
-                seqName[i][mu]  = "Q_" + flavour[i] + "-" + seqName[i][mu];
-                application.createModule<MFermion::GaugeProp>(seqName[i][mu], quarkPar);
-            }
-        }
-        
-        // contractions
-        MContraction::Meson::Par mesPar;
-        for (unsigned int i = 0; i < flavour.size(); ++i)
-        for (unsigned int j = i; j < flavour.size(); ++j)
-        {
-            mesPar.output = "mesons/Z2_" + flavour[i] + flavour[j];
-            mesPar.q1     = qName[i];
-            mesPar.q2     = qName[j];
-            mesPar.gammas = "all";
-            mesPar.sink   = "sink";
-            application.createModule<MContraction::Meson>("meson_Z2_"
-                                                          + std::to_string(t)
-                                                          + "_"
-                                                          + flavour[i]
-                                                          + flavour[j],
-                                                          mesPar);
-        }
-        for (unsigned int i = 0; i < flavour.size(); ++i)
-        for (unsigned int j = 0; j < flavour.size(); ++j)
-        for (unsigned int mu = 0; mu < Nd; ++mu)
-        {
-            MContraction::Meson::Par mesPar;
-            
-            mesPar.output = "3pt/Z2_" + flavour[i] + flavour[j] + "_"
-                            + std::to_string(mu);
-            mesPar.q1     = qName[i];
-            mesPar.q2     = seqName[j][mu];
-            mesPar.gammas = "all";
-            mesPar.sink   = "sink";
-            application.createModule<MContraction::Meson>("3pt_Z2_"
-                                                          + std::to_string(t)
-                                                          + "_"
-                                                          + flavour[i]
-                                                          + flavour[j]
-                                                          + "_"
-                                                          + std::to_string(mu),
-                                                          mesPar);
-        }
-    }
-    
-    // execution
-    application.saveParameterFile("meson3pt.xml");
-    application.run();
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_hadrons_spectrum.cc b/tests/hadrons/Test_hadrons_spectrum.cc
deleted file mode 100644
index 7650397b..00000000
--- a/tests/hadrons/Test_hadrons_spectrum.cc
+++ /dev/null
@@ -1,155 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_hadrons_spectrum.cc
-
-Copyright (C) 2015-2018
-
- Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // initialization //////////////////////////////////////////////////////////
-    Grid_init(&argc, &argv);
-    HadronsLogError.Active(GridLogError.isActive());
-    HadronsLogWarning.Active(GridLogWarning.isActive());
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    LOG(Message) << "Grid initialized" << std::endl;
-    
-    // run setup ///////////////////////////////////////////////////////////////
-    Application              application;
-    std::vector<std::string> flavour = {"l", "s", "c1", "c2", "c3"};
-    std::vector<std::string> flavour_baryon = {"l", "s", "a", "b", "c"}; //needs to be a single character
-    std::vector<double>      mass    = {.01, .04, .2  , .25 , .3  };
-    
-    // global parameters
-    Application::GlobalPar globalPar;
-    globalPar.trajCounter.start = 1500;
-    globalPar.trajCounter.end   = 1520;
-    globalPar.trajCounter.step  = 20;
-    globalPar.runId             = "test";
-    application.setPar(globalPar);
-    // gauge field
-    application.createModule<MGauge::Unit>("gauge");
-    // sources
-    MSource::Z2::Par z2Par;
-    z2Par.tA = 0;
-    z2Par.tB = 0;
-    application.createModule<MSource::Z2>("z2", z2Par);
-    MSource::Point::Par ptPar;
-    ptPar.position = "0 0 0 0";
-    application.createModule<MSource::Point>("pt", ptPar);
-    // sink
-    MSink::Point::Par sinkPar;
-    sinkPar.mom = "0 0 0";
-    application.createModule<MSink::ScalarPoint>("sink", sinkPar);
-    
-    // set fermion boundary conditions to be periodic space, antiperiodic time.
-    std::string boundary = "1 1 1 -1";
-    std::string twist = "0. 0. 0. 0.";
-
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    {
-        // actions
-        MAction::DWF::Par actionPar;
-        actionPar.gauge = "gauge";
-        actionPar.Ls    = 12;
-        actionPar.M5    = 1.8;
-        actionPar.mass  = mass[i];
-        actionPar.boundary = boundary;
-        actionPar.twist = twist;
-        application.createModule<MAction::DWF>("DWF_" + flavour[i], actionPar);
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar;
-        solverPar.action       = "DWF_" + flavour[i];
-        solverPar.residual     = 1.0e-8;
-        solverPar.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("CG_" + flavour[i],
-                                                    solverPar);
-        
-        // propagators
-        MFermion::GaugeProp::Par quarkPar;
-        quarkPar.solver = "CG_" + flavour[i];
-        quarkPar.source = "pt";
-        application.createModule<MFermion::GaugeProp>("Qpt_" + flavour[i], quarkPar);
-        quarkPar.source = "z2";
-        application.createModule<MFermion::GaugeProp>("QZ2_" + flavour[i], quarkPar);
-    }
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    for (unsigned int j = i; j < flavour.size(); ++j)
-    {
-        MContraction::Meson::Par mesPar;
-        
-        mesPar.output  = "mesons/pt_" + flavour[i] + flavour[j];
-        mesPar.q1      = "Qpt_" + flavour[i];
-        mesPar.q2      = "Qpt_" + flavour[j];
-        mesPar.gammas  = "all";
-        mesPar.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_pt_"
-                                                      + flavour[i] + flavour[j],
-                                                      mesPar);
-        mesPar.output  = "mesons/Z2_" + flavour[i] + flavour[j];
-        mesPar.q1      = "QZ2_" + flavour[i];
-        mesPar.q2      = "QZ2_" + flavour[j];
-        mesPar.gammas  = "all";
-        mesPar.sink    = "sink";
-        application.createModule<MContraction::Meson>("meson_Z2_"
-                                                      + flavour[i] + flavour[j],
-                                                      mesPar);
-    }
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    for (unsigned int j = i; j < flavour.size(); ++j)
-    for (unsigned int k = j; k < flavour.size(); ++k)
-    {
-        MContraction::Baryon::Par barPar;
-        
-        barPar.output = "baryons/pt_" + flavour[i] + flavour[j] + flavour[k];
-        barPar.q1     = "Qpt_" + flavour[i];
-        barPar.q2     = "Qpt_" + flavour[j];
-        barPar.q3     = "Qpt_" + flavour[k];
-        barPar.gammas     = "(j12 j12) (j32X j32Y)";
-        barPar.quarks     = flavour_baryon[i] + flavour_baryon[j] + flavour_baryon[k];
-        barPar.prefactors     = "1.0";
-        barPar.sink    = "sink";
-        application.createModule<MContraction::Baryon>(
-            "baryon_pt_" + flavour[i] + flavour[j] + flavour[k], barPar);
-    }
-    
-    // execution
-    application.saveParameterFile("spectrum.xml");
-    application.run();
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/hadrons/Test_sigma_to_nucleon.cc b/tests/hadrons/Test_sigma_to_nucleon.cc
deleted file mode 100644
index b4e79649..00000000
--- a/tests/hadrons/Test_sigma_to_nucleon.cc
+++ /dev/null
@@ -1,154 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Tests/Hadrons/Test_hadrons_spectrum.cc
-
-Copyright (C) 2015-2018
-
- Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Application.hpp>
-#include <Hadrons/Modules.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-
-int main(int argc, char *argv[])
-{
-    // initialization //////////////////////////////////////////////////////////
-    Grid_init(&argc, &argv);
-    HadronsLogError.Active(GridLogError.isActive());
-    HadronsLogWarning.Active(GridLogWarning.isActive());
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    LOG(Message) << "Grid initialized" << std::endl;
-    
-    // run setup ///////////////////////////////////////////////////////////////
-    Application              application;
-    std::vector<std::string> flavour = {"l", "s", "c"};
-    std::vector<double>      mass    = {.01, .04, .2 };
-    
-    // global parameters
-    Application::GlobalPar globalPar;
-    globalPar.trajCounter.start = 1500;
-    globalPar.trajCounter.end   = 1520;
-    globalPar.trajCounter.step  = 20;
-    globalPar.runId             = "test";
-    application.setPar(globalPar);
-    // gauge field
-    application.createModule<MGauge::Unit>("gauge");
-    // sources
-    MSource::Point::Par ptPar;
-    ptPar.position = "0 0 0 0";
-    application.createModule<MSource::Point>("pt_0", ptPar);
-    ptPar.position = "0 0 0 4";
-    application.createModule<MSource::Point>("pt_4", ptPar);
-    // sink
-    MSink::Point::Par sinkPar;
-    sinkPar.mom = "0 0 0";
-    application.createModule<MSink::ScalarPoint>("sink", sinkPar);
-    application.createModule<MSink::Point>("sink_spec", sinkPar);
-    
-    // set fermion boundary conditions to be periodic space, antiperiodic time.
-    std::string boundary = "1 1 1 -1";
-    std::string twist = "0. 0. 0. 0.";
-
-    for (unsigned int i = 0; i < flavour.size(); ++i)
-    {
-        // actions
-        MAction::DWF::Par actionPar;
-        actionPar.gauge = "gauge";
-        actionPar.Ls    = 12;
-        actionPar.M5    = 1.8;
-        actionPar.mass  = mass[i];
-        actionPar.boundary = boundary;
-        actionPar.twist = twist;
-        application.createModule<MAction::DWF>("DWF_" + flavour[i], actionPar);
-        
-        // solvers
-        MSolver::RBPrecCG::Par solverPar;
-        solverPar.action       = "DWF_" + flavour[i];
-        solverPar.residual     = 1.0e-8;
-        solverPar.maxIteration = 10000;
-        application.createModule<MSolver::RBPrecCG>("CG_" + flavour[i],
-                                                    solverPar);
-        
-    }
-
-    // propagators
-    MFermion::GaugeProp::Par quarkPar;
-    quarkPar.solver = "CG_l";
-    quarkPar.source = "pt_0";
-    application.createModule<MFermion::GaugeProp>("Qpt_l_0", quarkPar);
-    quarkPar.source = "pt_4";
-    application.createModule<MFermion::GaugeProp>("Qpt_l_4", quarkPar);
-    quarkPar.solver = "CG_s";
-    quarkPar.source = "pt_0";
-    application.createModule<MFermion::GaugeProp>("Qpt_s_0", quarkPar);
-    //This should be a loop - how do I make this?
-    quarkPar.solver = "CG_c";
-    quarkPar.source = "pt_0";
-    application.createModule<MFermion::GaugeProp>("Qpt_c_loop", quarkPar);
-    quarkPar.solver = "CG_l";
-    quarkPar.source = "pt_0";
-    application.createModule<MFermion::GaugeProp>("Qpt_l_loop", quarkPar);
-
-    MSink::Smear::Par smearPar;
-    smearPar.q="Qpt_l_0";
-    smearPar.sink = "sink_spec";
-    application.createModule<MSink::Smear>("Qpt_u_spec",smearPar);
-   
-
-    MContraction::SigmaToNucleonEye::Par EyePar;
-    EyePar.output  = "SigmaToNucleon/Eye_u";
-    EyePar.qqLoop = "Qpt_l_loop";
-    EyePar.quSpec = "Qpt_u_spec";
-    EyePar.qdTf   = "Qpt_l_4";
-    EyePar.qsTi   = "Qpt_s_0";
-    EyePar.tf    = 4;
-    EyePar.sink    = "sink";
-    application.createModule<MContraction::SigmaToNucleonEye>("SigmaToNucleonEye_u", EyePar);
-    EyePar.output  = "SigmaToNucleon/Eye_c";
-    EyePar.qqLoop = "Qpt_c_loop";
-    application.createModule<MContraction::SigmaToNucleonEye>("SigmaToNucleonEye_c", EyePar);
-    MContraction::SigmaToNucleonNonEye::Par NonEyePar;
-    NonEyePar.output  = "SigmaToNucleon/NonEye";
-    NonEyePar.quTi = "Qpt_l_0";
-    NonEyePar.quTf = "Qpt_l_4";
-    NonEyePar.quSpec = "Qpt_u_spec";
-    NonEyePar.qdTf   = "Qpt_l_4";
-    NonEyePar.qsTi   = "Qpt_s_0";
-    NonEyePar.tf    = 4;
-    NonEyePar.sink    = "sink";
-    application.createModule<MContraction::SigmaToNucleonNonEye>("SigmaToNucleonNonEye", NonEyePar);
-
-    // execution
-    application.saveParameterFile("stn.xml");
-    application.run();
-    
-    // epilogue
-    LOG(Message) << "Grid is finalizing now" << std::endl;
-    Grid_finalize();
-    
-    return EXIT_SUCCESS;
-}
diff --git a/tests/lanczos/Test_synthetic_lanczos.cc b/tests/lanczos/Test_synthetic_lanczos.cc
index 7a3591dd..a1e0e672 100644
--- a/tests/lanczos/Test_synthetic_lanczos.cc
+++ b/tests/lanczos/Test_synthetic_lanczos.cc
@@ -73,6 +73,7 @@ public:
   }
 
   // Support for coarsening to a multigrid
+  void OpDirAll  (const Field &in, std::vector<Field> &out){};
   void OpDiag (const Field &in, Field &out) {};
   void OpDir  (const Field &in, Field &out,int dir,int disp){};
 
diff --git a/tests/solver/Test_dwf_hdcr.cc b/tests/solver/Test_dwf_hdcr.cc
index 74adc417..873530ff 100644
--- a/tests/solver/Test_dwf_hdcr.cc
+++ b/tests/solver/Test_dwf_hdcr.cc
@@ -1,4 +1,6 @@
-   /*************************************************************************************
+
+
+/*************************************************************************************
 
     Grid physics library, www.github.com/paboyle/Grid 
 
@@ -29,323 +31,174 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
     /*  END LEGAL */
 #include <Grid/Grid.h>
 #include <Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h>
-//#include <algorithms/iterative/PrecConjugateResidual.h>
 
 using namespace std;
 using namespace Grid;
- ;
+/* Params
+ * Grid: 
+ * block1(4)
+ * block2(4)
+ * 
+ * Subspace
+ * * Fine  : Subspace(nbasis,hi,lo,order,first,step) -- 32, 60,0.02,500,100,100
+ * * Coarse: Subspace(nbasis,hi,lo,order,first,step) -- 32, 18,0.02,500,100,100
 
-class myclass: Serializable {
-public:
-
-  GRID_SERIALIZABLE_CLASS_MEMBERS(myclass,
-			  int, domaindecompose,
-			  int, domainsize,
-			  int, order,
-			  int, Ls,
-			  double, mq,
-			  double, lo,
-			  double, hi,
-			  int, steps);
-
-  myclass(){};
-
-};
-myclass params;
+ * Smoother:
+ * * Fine: Cheby(hi, lo, order)            --  60,0.5,10
+ * * Coarse: Cheby(hi, lo, order)          --  12,0.1,4
 
+ * Lanczos:
+ * CoarseCoarse IRL( Nk, Nm, Nstop, poly(lo,hi,order))   24,36,24,0.002,4.0,61 
+ */
 RealD InverseApproximation(RealD x){
   return 1.0/x;
 }
 
-template<class Fobj,class CComplex,int nbasis, class Matrix>
+template<class Field,class Matrix> class ChebyshevSmoother : public LinearFunction<Field>
+{
+public:
+  typedef LinearOperatorBase<Field>                            FineOperator;
+  Matrix         & _SmootherMatrix;
+  FineOperator   & _SmootherOperator;
+  
+  Chebyshev<Field> Cheby;
+
+  ChebyshevSmoother(RealD _lo,RealD _hi,int _ord, FineOperator &SmootherOperator,Matrix &SmootherMatrix) :
+    _SmootherOperator(SmootherOperator),
+    _SmootherMatrix(SmootherMatrix),
+    Cheby(_lo,_hi,_ord,InverseApproximation)
+  {};
+
+  void operator() (const Field &in, Field &out) 
+  {
+    Field tmp(in.Grid());
+    MdagMLinearOperator<Matrix,Field>   MdagMOp(_SmootherMatrix); 
+    _SmootherOperator.AdjOp(in,tmp);
+    Cheby(MdagMOp,tmp,out);         
+  }
+};
+template<class Field,class Matrix> class MirsSmoother : public LinearFunction<Field>
+{
+public:
+  typedef LinearOperatorBase<Field>                            FineOperator;
+  Matrix         & SmootherMatrix;
+  FineOperator   & SmootherOperator;
+  RealD tol;
+  RealD shift;
+  int   maxit;
+
+  MirsSmoother(RealD _shift,RealD _tol,int _maxit,FineOperator &_SmootherOperator,Matrix &_SmootherMatrix) :
+    shift(_shift),tol(_tol),maxit(_maxit),
+    SmootherOperator(_SmootherOperator),
+    SmootherMatrix(_SmootherMatrix)
+  {};
+
+  void operator() (const Field &in, Field &out) 
+  {
+    ZeroGuesser<Field> Guess;
+    ConjugateGradient<Field>  CG(tol,maxit,false);
+ 
+    Field src(in.Grid());
+
+    ShiftedMdagMLinearOperator<SparseMatrixBase<Field>,Field> MdagMOp(SmootherMatrix,shift);
+    SmootherOperator.AdjOp(in,src);
+    Guess(src,out);
+    CG(MdagMOp,src,out); 
+  }
+};
+
+template<class Fobj,class CComplex,int nbasis, class Matrix, class Guesser, class CoarseSolver>
 class MultiGridPreconditioner : public LinearFunction< Lattice<Fobj> > {
 public:
 
   typedef Aggregation<Fobj,CComplex,nbasis> Aggregates;
   typedef CoarsenedMatrix<Fobj,CComplex,nbasis> CoarseOperator;
-
-  typedef typename Aggregation<Fobj,CComplex,nbasis>::siteVector     siteVector;
-  typedef typename Aggregation<Fobj,CComplex,nbasis>::CoarseScalar CoarseScalar;
   typedef typename Aggregation<Fobj,CComplex,nbasis>::CoarseVector CoarseVector;
   typedef typename Aggregation<Fobj,CComplex,nbasis>::CoarseMatrix CoarseMatrix;
   typedef typename Aggregation<Fobj,CComplex,nbasis>::FineField    FineField;
   typedef LinearOperatorBase<FineField>                            FineOperator;
+  typedef LinearFunction    <FineField>                            FineSmoother;
 
   Aggregates     & _Aggregates;
   CoarseOperator & _CoarseOperator;
   Matrix         & _FineMatrix;
   FineOperator   & _FineOperator;
-  Matrix         & _SmootherMatrix;
-  FineOperator   & _SmootherOperator;
+  Guesser        & _Guess;
+  FineSmoother   & _Smoother;
+  CoarseSolver   & _CoarseSolve;
+
+  int    level;  void Level(int lv) {level = lv; };
+
+#define GridLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< " Level "<<level <<" "
 
-  // Constructor
   MultiGridPreconditioner(Aggregates &Agg, CoarseOperator &Coarse, 
 			  FineOperator &Fine,Matrix &FineMatrix,
-			  FineOperator &Smooth,Matrix &SmootherMatrix) 
+			  FineSmoother &Smoother,
+			  Guesser &Guess_,
+			  CoarseSolver &CoarseSolve_)
     : _Aggregates(Agg),
       _CoarseOperator(Coarse),
       _FineOperator(Fine),
       _FineMatrix(FineMatrix),
-      _SmootherOperator(Smooth),
-      _SmootherMatrix(SmootherMatrix)
+      _Smoother(Smoother),
+      _Guess(Guess_),
+      _CoarseSolve(CoarseSolve_),
+      level(1)  {  }
+
+  virtual void operator()(const FineField &in, FineField & out) 
   {
-  }
-
-  void PowerMethod(const FineField &in) {
-
-    FineField p1(in.Grid());
-    FineField p2(in.Grid());
-
-    MdagMLinearOperator<Matrix,FineField>   fMdagMOp(_FineMatrix);
-
-    p1=in;
-    for(int i=0;i<20;i++){
-      RealD absp1=std::sqrt(norm2(p1));
-      fMdagMOp.HermOp(p1,p2);// this is the G5 herm bit      
-      //      _FineOperator.Op(p1,p2);// this is the G5 herm bit      
-      RealD absp2=std::sqrt(norm2(p2));
-      if(i%10==9)
-	std::cout<<GridLogMessage << "Power method on mdagm "<<i<<" " << absp2/absp1<<std::endl;
-      p1=p2*(1.0/std::sqrt(absp2));
-    }
-  }
-
-  void operator()(const FineField &in, FineField & out) {
-    operatorCheby(in,out);
-  }
-
-    ////////////////////////////////////////////////////////////////////////
-    // ADEF2: [PTM+Q] in = [1 - Q A] M in + Q in = Min + Q [ in -A Min]
-    // ADEF1: [MP+Q ] in =M [1 - A Q] in + Q in  
-    ////////////////////////////////////////////////////////////////////////
-#if 1
-  void operatorADEF2(const FineField &in, FineField & out) {
-
     CoarseVector Csrc(_CoarseOperator.Grid());
-    CoarseVector Ctmp(_CoarseOperator.Grid());
-    CoarseVector Csol(_CoarseOperator.Grid());
-
-    ConjugateGradient<CoarseVector>  CG(1.0e-10,100000);
-    ConjugateGradient<FineField>    fCG(3.0e-2,1000);
-
-    HermitianLinearOperator<CoarseOperator,CoarseVector>  HermOp(_CoarseOperator);
-    MdagMLinearOperator<CoarseOperator,CoarseVector>     MdagMOp(_CoarseOperator);
-    MdagMLinearOperator<Matrix,FineField>               fMdagMOp(_FineMatrix);
-
-    FineField tmp(in.Grid());
-    FineField res(in.Grid());
-    FineField Min(in.Grid());
-
-    // Monitor completeness of low mode space
-    _Aggregates.ProjectToSubspace  (Csrc,in);
-    _Aggregates.PromoteFromSubspace(Csrc,out);
-    std::cout<<GridLogMessage<<"Coarse Grid Preconditioner\nCompleteness in: "<<std::sqrt(norm2(out)/norm2(in))<<std::endl;
-
-    // [PTM+Q] in = [1 - Q A] M in + Q in = Min + Q [ in -A Min]
-    _FineOperator.Op(in,tmp);// this is the G5 herm bit
-    fCG(fMdagMOp,tmp,Min);    // solves  MdagM = g5 M g5M
-
-    // Monitor completeness of low mode space
-    _Aggregates.ProjectToSubspace  (Csrc,Min);
-    _Aggregates.PromoteFromSubspace(Csrc,out);
-    std::cout<<GridLogMessage<<"Completeness Min: "<<std::sqrt(norm2(out)/norm2(Min))<<std::endl;
-
-    _FineOperator.Op(Min,tmp);
-    tmp = in - tmp;   // in - A Min
-
-    Csol=Zero();
-    _Aggregates.ProjectToSubspace  (Csrc,tmp);
-    HermOp.AdjOp(Csrc,Ctmp);// Normal equations
-    CG(MdagMOp,Ctmp,Csol);
-
-    HermOp.Op(Csol,Ctmp);
-    Ctmp=Ctmp-Csrc;
-    std::cout<<GridLogMessage<<"coarse space true residual "<<std::sqrt(norm2(Ctmp)/norm2(Csrc))<<std::endl;
-    _Aggregates.PromoteFromSubspace(Csol,out);
-
-    _FineOperator.Op(out,res);
-    res=res-tmp;
-    std::cout<<GridLogMessage<<"promoted sol residual "<<std::sqrt(norm2(res)/norm2(tmp))<<std::endl;
-    _Aggregates.ProjectToSubspace  (Csrc,res);
-    std::cout<<GridLogMessage<<"coarse space proj of residual "<<norm2(Csrc)<<std::endl;
-
-    
-    out = out+Min; // additive coarse space correction
-    //    out = Min; // no additive coarse space correction
-
-    _FineOperator.Op(out,tmp);
-    tmp=tmp-in;         // tmp is new residual
-
-    std::cout<<GridLogMessage<< " Preconditioner in  " << norm2(in)<<std::endl; 
-    std::cout<<GridLogMessage<< " Preconditioner out " << norm2(out)<<std::endl; 
-    std::cout<<GridLogMessage<<"preconditioner thinks residual is "<<std::sqrt(norm2(tmp)/norm2(in))<<std::endl;
-
-  }
-#endif
-  // ADEF1: [MP+Q ] in =M [1 - A Q] in + Q in  
-#if 1
-  void operatorADEF1(const FineField &in, FineField & out) {
-
-    CoarseVector Csrc(_CoarseOperator.Grid());
-    CoarseVector Ctmp(_CoarseOperator.Grid());
-    CoarseVector Csol(_CoarseOperator.Grid()); Csol=Zero();
-
-    ConjugateGradient<CoarseVector>  CG(1.0e-10,100000);
-    ConjugateGradient<FineField>    fCG(3.0e-2,1000);
-
-    HermitianLinearOperator<CoarseOperator,CoarseVector>  HermOp(_CoarseOperator);
-    MdagMLinearOperator<CoarseOperator,CoarseVector>     MdagMOp(_CoarseOperator);
-    ShiftedMdagMLinearOperator<Matrix,FineField>        fMdagMOp(_FineMatrix,0.1);
-
-    FineField tmp(in.Grid());
-    FineField res(in.Grid());
-    FineField Qin(in.Grid());
-
-    // Monitor completeness of low mode space
-    //    _Aggregates.ProjectToSubspace  (Csrc,in);
-    //    _Aggregates.PromoteFromSubspace(Csrc,out);
-    //    std::cout<<GridLogMessage<<"Coarse Grid Preconditioner\nCompleteness in: "<<std::sqrt(norm2(out)/norm2(in))<<std::endl;
-    
-    _Aggregates.ProjectToSubspace  (Csrc,in);
-    HermOp.AdjOp(Csrc,Ctmp);// Normal equations
-    CG(MdagMOp,Ctmp,Csol);
-    _Aggregates.PromoteFromSubspace(Csol,Qin);
-
-    //    Qin=0;
-    _FineOperator.Op(Qin,tmp);// A Q in
-    tmp = in - tmp;            // in - A Q in
-
-    _FineOperator.Op(tmp,res);// this is the G5 herm bit
-    fCG(fMdagMOp,res,out);    // solves  MdagM = g5 M g5M
-
-    out = out + Qin;
-
-    _FineOperator.Op(out,tmp);
-    tmp=tmp-in;         // tmp is new residual
-
-    std::cout<<GridLogMessage<<"preconditioner thinks residual is "<<std::sqrt(norm2(tmp)/norm2(in))<<std::endl;
-
-  }
-#endif
-
-  void SmootherTest (const FineField & in){
-    
-    FineField vec1(in.Grid());
-    FineField vec2(in.Grid());
-    RealD lo[3] = { 0.5, 1.0, 2.0};
-
-    //    MdagMLinearOperator<Matrix,FineField>        fMdagMOp(_FineMatrix);
-    ShiftedMdagMLinearOperator<Matrix,FineField> fMdagMOp(_SmootherMatrix,0.0);
-
-    RealD Ni,r;
-
-    Ni = norm2(in);
-
-    for(int ilo=0;ilo<3;ilo++){
-      for(int ord=5;ord<50;ord*=2){
-
-	std::cout << " lo "<<lo[ilo]<<" order "<<ord<<std::endl;
-
-	_SmootherOperator.AdjOp(in,vec1);
-
-	Chebyshev<FineField> Cheby  (lo[ilo],70.0,ord,InverseApproximation);
-	Cheby(fMdagMOp,vec1,vec2);    // solves  MdagM = g5 M g5M
-
-	_FineOperator.Op(vec2,vec1);// this is the G5 herm bit
-	vec1  = in - vec1;   // tmp  = in - A Min
-	r=norm2(vec1);
-	std::cout<<GridLogMessage << "Smoother resid "<<std::sqrt(r/Ni)<<std::endl;
-
-      }
-    }
-  }
-
-  void operatorCheby(const FineField &in, FineField & out) {
-
-    CoarseVector Csrc(_CoarseOperator.Grid());
-    CoarseVector Ctmp(_CoarseOperator.Grid());
-    CoarseVector Csol(_CoarseOperator.Grid()); Csol=Zero();
-
-    ConjugateGradient<CoarseVector>  CG(3.0e-3,100000);
-
-    HermitianLinearOperator<CoarseOperator,CoarseVector>  HermOp(_CoarseOperator);
-    MdagMLinearOperator<CoarseOperator,CoarseVector>     MdagMOp(_CoarseOperator);
-    //    MdagMLinearOperator<Matrix,FineField>        fMdagMOp(_FineMatrix);
-    ShiftedMdagMLinearOperator<Matrix,FineField> fMdagMOp(_SmootherMatrix,0.0);
-
+    CoarseVector Csol(_CoarseOperator.Grid()); 
     FineField vec1(in.Grid());
     FineField vec2(in.Grid());
 
-    Chebyshev<FineField> Cheby    (params.lo,params.hi,params.order,InverseApproximation);
-    Chebyshev<FineField> ChebyAccu(params.lo,params.hi,params.order,InverseApproximation);
+    double t;
+    // Fine Smoother
+    t=-usecond();
+    _Smoother(in,out);
+    t+=usecond();
+    GridLogLevel << "Smoother took "<< t/1000.0<< "ms" <<std::endl;
 
-    _Aggregates.ProjectToSubspace  (Csrc,in);
+    // Update the residual
+    _FineOperator.Op(out,vec1);  sub(vec1, in ,vec1);   
 
-    //    _Aggregates.PromoteFromSubspace(Csrc,out);
-    //    std::cout<<GridLogMessage<<"Completeness: "<<std::sqrt(norm2(out)/norm2(in))<<std::endl;
-    
-    //    ofstream fout("smoother");
-    //    Cheby.csv(fout);
-
-    // V11 multigrid.
-    // Use a fixed chebyshev and hope hermiticity helps.
-
-    // To make a working smoother for indefinite operator
-    // must multiply by "Mdag" (ouch loses all low mode content)
-    // and apply to poly approx of (mdagm)^-1.
-    // so that we end up with an odd polynomial.
-
-    RealD Ni = norm2(in);
-
-    _SmootherOperator.AdjOp(in,vec1);// this is the G5 herm bit
-    ChebyAccu(fMdagMOp,vec1,out);    // solves  MdagM = g5 M g5M
-
-    // Update with residual for out
-    _FineOperator.Op(out,vec1);// this is the G5 herm bit
-    vec1  = in - vec1;   // tmp  = in - A Min
-
-    RealD r = norm2(vec1);
-
-    std::cout<<GridLogMessage << "Smoother resid "<<std::sqrt(r/Ni)<< " " << r << " " << Ni <<std::endl;
-    
+    // Fine to Coarse 
+    t=-usecond();
     _Aggregates.ProjectToSubspace  (Csrc,vec1);
-    
-    HermOp.AdjOp(Csrc,Ctmp);// Normal equations // This appears to be zero.
-    CG(MdagMOp,Ctmp,Csol);
-    _Aggregates.PromoteFromSubspace(Csol,vec1); // Ass^{-1} [in - A Min]_s
-                                                // Q = Q[in - A Min]  
-    out = out+vec1;
+    t+=usecond();
+    GridLogLevel << "Project to coarse took "<< t/1000.0<< "ms" <<std::endl;
 
-    // Three preconditioner smoothing -- hermitian if C3 = C1
-    // Recompute error
-    _FineOperator.Op(out,vec1);// this is the G5 herm bit
-    vec1  = in - vec1;   // tmp  = in - A Min
-    r=norm2(vec1);
+    // Coarse correction
+    t=-usecond();
+    _CoarseSolve(Csrc,Csol);
+    t+=usecond();
+    GridLogLevel << "Coarse solve took "<< t/1000.0<< "ms" <<std::endl;
 
-    std::cout<<GridLogMessage << "Coarse resid "<<std::sqrt(r/Ni)<<std::endl;
+    // Coarse to Fine
+    t=-usecond();
+    _Aggregates.PromoteFromSubspace(Csol,vec1); 
+    add(out,out,vec1);
+    t+=usecond();
+    GridLogLevel << "Promote to this level took "<< t/1000.0<< "ms" <<std::endl;
 
-    // Reapply smoother
-    _SmootherOperator.Op(vec1,vec2);  // this is the G5 herm bit
-    ChebyAccu(fMdagMOp,vec2,vec1);    // solves  MdagM = g5 M g5M
+    // Residual
+    _FineOperator.Op(out,vec1);  sub(vec1 ,in , vec1);  
 
-    out =out+vec1;
-    vec1  = in - vec1;   // tmp  = in - A Min
-    r=norm2(vec1);
-    std::cout<<GridLogMessage << "Smoother resid "<<std::sqrt(r/Ni)<<std::endl;
+    // Fine Smoother
+    t=-usecond();
+    _Smoother(vec1,vec2);
+    t+=usecond();
+    GridLogLevel << "Smoother took "<< t/1000.0<< "ms" <<std::endl;
 
+    add( out,out,vec2);
   }
-
 };
 
 int main (int argc, char ** argv)
 {
   Grid_init(&argc,&argv);
 
-  XmlReader RD("params.xml");
-  read(RD,"params",params);
-  std::cout<<"Params: Order "<<params.order<<"["<<params.lo<<","<<params.hi<<"]"<< " steps "<<params.steps<<std::endl;
-
-  const int Ls=params.Ls;
+  const int Ls=16;
 
   GridCartesian         * UGrid   = SpaceTimeGrid::makeFourDimGrid(GridDefaultLatt(), GridDefaultSimd(Nd,vComplex::Nsimd()),GridDefaultMpi());
   GridRedBlackCartesian * UrbGrid = SpaceTimeGrid::makeFourDimRedBlackGrid(UGrid);
@@ -357,14 +210,22 @@ int main (int argc, char ** argv)
   // Construct a coarsened grid; utility for this?
   ///////////////////////////////////////////////////
   std::vector<int> block ({2,2,2,2});
+  std::vector<int> blockc ({2,2,2,2});
   const int nbasis= 32;
-
+  const int nbasisc= 32;
   auto clatt = GridDefaultLatt();
   for(int d=0;d<clatt.size();d++){
     clatt[d] = clatt[d]/block[d];
   }
+  auto cclatt = clatt;
+  for(int d=0;d<clatt.size();d++){
+    cclatt[d] = clatt[d]/blockc[d];
+  }
+
   GridCartesian *Coarse4d =  SpaceTimeGrid::makeFourDimGrid(clatt, GridDefaultSimd(Nd,vComplex::Nsimd()),GridDefaultMpi());;
   GridCartesian *Coarse5d =  SpaceTimeGrid::makeFiveDimGrid(1,Coarse4d);
+  GridCartesian *CoarseCoarse4d =  SpaceTimeGrid::makeFourDimGrid(cclatt, GridDefaultSimd(Nd,vComplex::Nsimd()),GridDefaultMpi());;
+  GridCartesian *CoarseCoarse5d =  SpaceTimeGrid::makeFiveDimGrid(1,CoarseCoarse4d);
 
   std::vector<int> seeds4({1,2,3,4});
   std::vector<int> seeds5({5,6,7,8});
@@ -372,186 +233,167 @@ int main (int argc, char ** argv)
   GridParallelRNG          RNG5(FGrid);   RNG5.SeedFixedIntegers(seeds5);
   GridParallelRNG          RNG4(UGrid);   RNG4.SeedFixedIntegers(seeds4);
   GridParallelRNG          CRNG(Coarse5d);CRNG.SeedFixedIntegers(cseeds);
-
-  Gamma g5(Gamma::Algebra::Gamma5);
-
   LatticeFermion    src(FGrid); gaussian(RNG5,src);// src=src+g5*src;
-  LatticeFermion result(FGrid); result=Zero();
-  LatticeFermion    ref(FGrid); ref=Zero();
-  LatticeFermion    tmp(FGrid);
-  LatticeFermion    err(FGrid);
+  LatticeFermion result(FGrid); 
   LatticeGaugeField Umu(UGrid); 
-  LatticeGaugeField UmuDD(UGrid); 
-  LatticeColourMatrix U(UGrid);
-  LatticeColourMatrix zz(UGrid);
 
   FieldMetaData header;
   std::string file("./ckpoint_lat.4000");
   NerscIO::readConfiguration(Umu,header,file);
 
-
-  if ( params.domaindecompose ) { 
-    Lattice<iScalar<vInteger> > coor(UGrid);
-    zz=Zero();
-    for(int mu=0;mu<Nd;mu++){
-      LatticeCoordinate(coor,mu);
-      U = PeekIndex<LorentzIndex>(Umu,mu);
-      U = where(mod(coor,params.domainsize)==(Integer)0,zz,U);
-      PokeIndex<LorentzIndex>(UmuDD,U,mu);
-    }
-  } else { 
-    UmuDD = Umu;
-  }
-  //  SU3::ColdConfiguration(RNG4,Umu);
-  //  SU3::TepidConfiguration(RNG4,Umu);
-  //  SU3::HotConfiguration(RNG4,Umu);
-  //  Umu=Zero();
-
-  RealD mass=params.mq;
-  RealD M5=1.8;
-
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   std::cout<<GridLogMessage << "Building g5R5 hermitian DWF operator" <<std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
+  RealD mass=0.001;
+  RealD M5=1.8;
   DomainWallFermionR Ddwf(Umu,*FGrid,*FrbGrid,*UGrid,*UrbGrid,mass,M5);
-  DomainWallFermionR DdwfDD(UmuDD,*FGrid,*FrbGrid,*UGrid,*UrbGrid,mass,M5);
 
   typedef Aggregation<vSpinColourVector,vTComplex,nbasis>              Subspace;
   typedef CoarsenedMatrix<vSpinColourVector,vTComplex,nbasis>          CoarseOperator;
   typedef CoarseOperator::CoarseVector                                 CoarseVector;
-
+  typedef CoarseOperator::siteVector siteVector;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   std::cout<<GridLogMessage << "Calling Aggregation class to build subspace" <<std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   MdagMLinearOperator<DomainWallFermionR,LatticeFermion> HermDefOp(Ddwf);
-  Subspace Aggregates(Coarse5d,FGrid,0);
-  //  Aggregates.CreateSubspace(RNG5,HermDefOp,nbasis);
-  assert ( (nbasis & 0x1)==0);
-  int nb=nbasis/2;
-  std::cout<<GridLogMessage << " nbasis/2 = "<<nb<<std::endl;
-  //  Aggregates.CreateSubspace(RNG5,HermDefOp,nb);
-  //  Aggregates.CreateSubspaceLanczos(RNG5,HermDefOp,nb);
-  Aggregates.CreateSubspaceChebyshev(RNG5,HermDefOp,nb);
-  for(int n=0;n<nb;n++){
-    G5R5(Aggregates.subspace[n+nb],Aggregates.subspace[n]);
-    std::cout<<GridLogMessage<<n<<" subspace "<<norm2(Aggregates.subspace[n+nb])<<" "<<norm2(Aggregates.subspace[n]) <<std::endl;
-  }
-  for(int n=0;n<nbasis;n++){
-    std::cout<<GridLogMessage << "vec["<<n<<"] = "<<norm2(Aggregates.subspace[n])  <<std::endl;
-  }
 
-//  for(int i=0;i<nbasis;i++){
-//    result =     Aggregates.subspace[i];
-//    Aggregates.subspace[i]=result+g5*result;
-//  }
-  result=Zero();
+  Subspace Aggregates(Coarse5d,FGrid,0);
+
+  assert ( (nbasis & 0x1)==0);
+  {
+    int nb=nbasis/2;
+    Aggregates.CreateSubspaceChebyshev(RNG5,HermDefOp,nb,60.0,0.02,500,100,100,0.0);
+    for(int n=0;n<nb;n++){
+      G5R5(Aggregates.subspace[n+nb],Aggregates.subspace[n]);
+    }
+    LatticeFermion A(FGrid);
+    LatticeFermion B(FGrid);
+    for(int n=0;n<nb;n++){
+      A = Aggregates.subspace[n];
+      B = Aggregates.subspace[n+nb];
+      Aggregates.subspace[n]   = A+B; // 1+G5 // eigen value of G5R5 is +1
+      Aggregates.subspace[n+nb]= A-B; // 1-G5 // eigen value of G5R5 is -1
+    }
+  }
   
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   std::cout<<GridLogMessage << "Building coarse representation of Indef operator" <<std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
+  typedef CoarsenedMatrix<vSpinColourVector,vTComplex,nbasis>    Level1Op;
+  typedef CoarsenedMatrix<siteVector,iScalar<vTComplex>,nbasisc> Level2Op;
+
   Gamma5R5HermitianLinearOperator<DomainWallFermionR,LatticeFermion> HermIndefOp(Ddwf);
-  Gamma5R5HermitianLinearOperator<DomainWallFermionR,LatticeFermion> HermIndefOpDD(DdwfDD);
-  CoarsenedMatrix<vSpinColourVector,vTComplex,nbasis> LDOp(*Coarse5d,1); // Hermitian matrix
-  LDOp.CoarsenOperator(FGrid,HermIndefOp,Aggregates);
+
+  Level1Op LDOp(*Coarse5d,1); LDOp.CoarsenOperator(FGrid,HermIndefOp,Aggregates);
+
+
+  //////////////////////////////////////////////////
+  // Deflate the course space. Recursive multigrid?
+  //////////////////////////////////////////////////
+  typedef Aggregation<siteVector,iScalar<vTComplex>,nbasisc>                   CoarseSubspace;
+  CoarseSubspace CoarseAggregates(CoarseCoarse5d,Coarse5d,0);
 
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Testing some coarse space solvers  " <<std::endl;
+  std::cout<<GridLogMessage << "Build deflation space in coarse operator "<< std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  CoarseVector c_src (Coarse5d);
-  CoarseVector c_res (Coarse5d);
-  gaussian(CRNG,c_src);
-  c_res=Zero();
 
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Solving posdef-CG on coarse space "<< std::endl;
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   MdagMLinearOperator<CoarseOperator,CoarseVector> PosdefLdop(LDOp);
-  ConjugateGradient<CoarseVector> CG(1.0e-6,100000);
-  CG(PosdefLdop,c_src,c_res);
+  {
+    int nb=nbasisc/2;
+    CoarseAggregates.CreateSubspaceChebyshev(CRNG,PosdefLdop,nb,12.0,0.02,500,100,100,0.0);
+    for(int n=0;n<nb;n++){
+      auto subspace    = CoarseAggregates.subspace[n].View();
+      auto subspace_g5 = CoarseAggregates.subspace[n+nb].View();
+      for(int nn=0;nn<nb;nn++){
+	for(int site=0;site<Coarse5d->oSites();site++){
+	  subspace_g5[site](nn)   = subspace[site](nn);
+	  subspace_g5[site](nn+nb)=-subspace[site](nn+nb);
+	}
+      }
+    }
+  }
+
+  Level2Op L2Op(*CoarseCoarse5d,1); // Hermitian matrix
+  typedef Level2Op::CoarseVector CoarseCoarseVector;
+  HermitianLinearOperator<Level1Op,CoarseVector> L1LinOp(LDOp);
+  L2Op.CoarsenOperator(Coarse5d,L1LinOp,CoarseAggregates);
 
-    std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-    std::cout<<GridLogMessage << "Solving indef-MCR on coarse space "<< std::endl;
-    std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-//    HermitianLinearOperator<CoarseOperator,CoarseVector> HermIndefLdop(LDOp);
-//    ConjugateResidual<CoarseVector> MCR(1.0e-6,100000);
-//    MCR(HermIndefLdop,c_src,c_res);
 
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Building deflation preconditioner "<< std::endl;
+  std::cout<<GridLogMessage << " Running CoarseCoarse grid Lanczos "<< std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
 
-  MultiGridPreconditioner <vSpinColourVector,vTComplex,nbasis,DomainWallFermionR> Precon  (Aggregates, LDOp,
-											   HermIndefOp,Ddwf,
-											   HermIndefOp,Ddwf);
+  MdagMLinearOperator<Level2Op,CoarseCoarseVector> IRLHermOpL2(L2Op);
+  Chebyshev<CoarseCoarseVector> IRLChebyL2(0.001,4.2,71);
+  FunctionHermOp<CoarseCoarseVector> IRLOpChebyL2(IRLChebyL2,IRLHermOpL2);
+  PlainHermOp<CoarseCoarseVector> IRLOpL2    (IRLHermOpL2);
+  int cNk=24;
+  int cNm=36;
+  int cNstop=24;
+  ImplicitlyRestartedLanczos<CoarseCoarseVector> IRLL2(IRLOpChebyL2,IRLOpL2,cNstop,cNk,cNm,1.0e-3,20);
 
-  //  MultiGridPreconditioner <vSpinColourVector,vTComplex,nbasis,DomainWallFermionR> PreconDD(Aggregates, LDOp,
-  //											   HermIndefOp,Ddwf,
-  //											   HermIndefOpDD,DdwfDD);
-  //  TrivialPrecon<LatticeFermion> simple;
+  int cNconv;
+  std::vector<RealD>          eval2(cNm);
+  std::vector<CoarseCoarseVector>   evec2(cNm,CoarseCoarse5d);
+  CoarseCoarseVector cc_src(CoarseCoarse5d); cc_src=1.0;
+  IRLL2.calc(eval2,evec2,cc_src,cNconv);
+
+  ConjugateGradient<CoarseCoarseVector>  CoarseCoarseCG(0.1,1000);
+  DeflatedGuesser<CoarseCoarseVector> DeflCoarseCoarseGuesser(evec2,eval2);
+  NormalEquations<CoarseCoarseVector> DeflCoarseCoarseCGNE(L2Op,CoarseCoarseCG,DeflCoarseCoarseGuesser);
 
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Testing smoother efficacy"<< std::endl;
+  std::cout<<GridLogMessage << "Building 3 level Multigrid            "<< std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  Precon.SmootherTest(src);
+  typedef MultiGridPreconditioner<vSpinColourVector,  vTComplex,nbasis, DomainWallFermionR,DeflatedGuesser<CoarseVector> , NormalEquations<CoarseVector> >   TwoLevelMG;
+  typedef MultiGridPreconditioner<siteVector,iScalar<vTComplex>,nbasisc,Level1Op, DeflatedGuesser<CoarseCoarseVector>, NormalEquations<CoarseCoarseVector> > CoarseMG;
+  typedef MultiGridPreconditioner<vSpinColourVector,  vTComplex,nbasis, DomainWallFermionR,ZeroGuesser<CoarseVector>, LinearFunction<CoarseVector> >     ThreeLevelMG;
 
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  std::cout<<GridLogMessage << "Testing DD smoother efficacy"<< std::endl;
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  PreconDD.SmootherTest(src);
+  // MultiGrid preconditioner acting on the coarse space <-> coarsecoarse space
+  ChebyshevSmoother<CoarseVector,  Level1Op >        CoarseSmoother(0.1,12.0,3,L1LinOp,LDOp);
+  ChebyshevSmoother<LatticeFermion,DomainWallFermionR> FineSmoother(0.5,60.0,10,HermIndefOp,Ddwf);
 
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  std::cout<<GridLogMessage << "Testing SAP smoother efficacy"<< std::endl;
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  PreconDD.SAP(src,result);
+  //  MirsSmoother<CoarseVector,  Level1Op >        CoarseCGSmoother(0.1,0.1,4,L1LinOp,LDOp);
+  //  MirsSmoother<LatticeFermion,DomainWallFermionR> FineCGSmoother(0.0,0.01,8,HermIndefOp,Ddwf);
 
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  std::cout<<GridLogMessage << "Unprec CG "<< std::endl;
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-
-  //  TrivialPrecon<LatticeFermion> simple;
-  //  ConjugateGradient<LatticeFermion> fCG(1.0e-8,100000);
-  //  fCG(HermDefOp,src,result);
-
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Red Black Prec CG "<< std::endl;
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  LatticeFermion    src_o(FrbGrid);
-  LatticeFermion result_o(FrbGrid);
-  pickCheckerboard(Odd,src_o,src);
-  result_o=Zero();
-  SchurDiagMooeeOperator<DomainWallFermionR,LatticeFermion> HermOpEO(Ddwf);
-  ConjugateGradient<LatticeFermion> pCG(1.0e-8,10000);
-  //  pCG(HermOpEO,src_o,result_o);
-
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  std::cout<<GridLogMessage << "Testing GCR on indef matrix "<< std::endl;
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  PrecGeneralisedConjugateResidual<LatticeFermion> UPGCR(1.0e-8,100000,simple,8,128);
-  //  UPGCR(HermIndefOp,src,result);
+  CoarseMG Level2Precon (CoarseAggregates, L2Op,
+			 L1LinOp,LDOp,
+			 CoarseSmoother,
+			 DeflCoarseCoarseGuesser,
+			 DeflCoarseCoarseCGNE);
+  Level2Precon.Level(2);
 
+  // PGCR Applying this solver to solve the coarse space problem
+  PrecGeneralisedConjugateResidual<CoarseVector>  l2PGCR(0.1, 100, L1LinOp,Level2Precon,16,16);
+  l2PGCR.Level(2);
   
-  /// Get themax eval
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage <<" Applying power method to find spectral range      "<<std::endl;
-  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  Precon.PowerMethod(src);
+  // Wrap the 2nd level solver in a MultiGrid preconditioner acting on the fine space
+  ZeroGuesser<CoarseVector> CoarseZeroGuesser;
+  ThreeLevelMG ThreeLevelPrecon(Aggregates, LDOp,
+				HermIndefOp,Ddwf,
+				FineSmoother,
+				CoarseZeroGuesser,
+				l2PGCR);
+  ThreeLevelPrecon.Level(1);
 
-
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  std::cout<<GridLogMessage << "Building a two level DDPGCR "<< std::endl;
-  //  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  //  PrecGeneralisedConjugateResidual<LatticeFermion> PGCRDD(1.0e-8,100000,PreconDD,8,128);
-  //  result=Zero();
-  //  std::cout<<GridLogMessage<<"checking norm src "<<norm2(src)<<std::endl;
-  //  PGCRDD(HermIndefOp,src,result);
+  // Apply the fine-coarse-coarsecoarse 2 deep MG preconditioner in an outer PGCR on the fine fgrid
+  PrecGeneralisedConjugateResidual<LatticeFermion> l1PGCR(1.0e-8,1000,HermIndefOp,ThreeLevelPrecon,16,16);
+  l1PGCR.Level(1);
 
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  std::cout<<GridLogMessage << "Building a two level PGCR "<< std::endl;
+  std::cout<<GridLogMessage << "Calling 3 level Multigrid            "<< std::endl;
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
-  PrecGeneralisedConjugateResidual<LatticeFermion> PGCR(1.0e-8,100000,Precon,8,8);
-  std::cout<<GridLogMessage<<"checking norm src "<<norm2(src)<<std::endl;
   result=Zero();
-  PGCR(HermIndefOp,src,result);
+  l1PGCR(src,result);
+
+  CoarseVector c_src(Coarse5d); c_src=1.0;
+  std::cout<<GridLogMessage << "**************************************************"<< std::endl;
+  std::cout<<GridLogMessage << " Fine        PowerMethod           "<< std::endl;
+  PowerMethod<LatticeFermion>       PM;   PM(HermDefOp,src);
+  std::cout<<GridLogMessage << " Coarse       PowerMethod           "<< std::endl;
+  PowerMethod<CoarseVector>        cPM;  cPM(PosdefLdop,c_src);
+  std::cout<<GridLogMessage << " CoarseCoarse PowerMethod           "<< std::endl;
+  PowerMethod<CoarseCoarseVector> ccPM; ccPM(IRLHermOpL2,cc_src);
 
   std::cout<<GridLogMessage << "**************************************************"<< std::endl;
   std::cout<<GridLogMessage << "Done "<< std::endl;
diff --git a/tests/solver/Test_wilsonclover_bicgstab_prec.cc b/tests/solver/Test_wilsonclover_bicgstab_prec.cc
new file mode 100644
index 00000000..c1905400
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_bicgstab_prec.cc
@@ -0,0 +1,85 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_unprec.cc
+
+    Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeFermion src(&Grid); random(pRNG,src);
+  RealD nrm = norm2(src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  double volume=1;
+  for(int mu=0;mu<Nd;mu++){
+    volume=volume*latt_size[mu];
+  }  
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  LatticeFermion    src_o(&RBGrid);
+  LatticeFermion result_o(&RBGrid);
+  pickCheckerboard(Odd, src_o, src);
+  result_o = Zero();
+
+  NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
+  BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
+  CG(HermOp, src_o, result_o);
+
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_bicgstab_schur.cc b/tests/solver/Test_wilsonclover_bicgstab_schur.cc
new file mode 100644
index 00000000..af021267
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_bicgstab_schur.cc
@@ -0,0 +1,81 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_unprec.cc
+
+    Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeFermion src(&Grid); random(pRNG,src);
+  RealD nrm = norm2(src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  double volume=1;
+  for(int mu=0;mu<Nd;mu++){
+    volume=volume*latt_size[mu];
+  }  
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
+  NonHermitianSchurRedBlackDiagMooeeSolve<LatticeFermion> SchurSolver(CG);
+
+  SchurSolver(Dw, src, result);
+
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_bicgstab_unprec.cc b/tests/solver/Test_wilsonclover_bicgstab_unprec.cc
new file mode 100644
index 00000000..21b7521d
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_bicgstab_unprec.cc
@@ -0,0 +1,80 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_unprec.cc
+
+    Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeFermion src(&Grid); random(pRNG,src);
+  RealD nrm = norm2(src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  double volume=1;
+  for(int mu=0;mu<Nd;mu++){
+    volume=volume*latt_size[mu];
+  }  
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  NonHermitianLinearOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
+  BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
+  CG(HermOp,src,result);
+
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_cg_prec.cc b/tests/solver/Test_wilsonclover_cg_prec.cc
new file mode 100644
index 00000000..04202860
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_cg_prec.cc
@@ -0,0 +1,91 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_prec.cc
+
+    Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeFermion src(&Grid); random(pRNG,src);
+  RealD nrm = norm2(src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  std::vector<LatticeColourMatrix> U(4,&Grid);
+
+  for(int mu=0;mu<Nd;mu++){
+    U[mu] = PeekIndex<LorentzIndex>(Umu,mu);
+  }
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  //  HermitianOperator<WilsonFermion,LatticeFermion> HermOp(Dw);
+  //  ConjugateGradient<LatticeFermion> CG(1.0e-8,10000);
+  //  CG(HermOp,src,result);
+  
+  LatticeFermion    src_o(&RBGrid);
+  LatticeFermion result_o(&RBGrid);
+  pickCheckerboard(Odd,src_o,src);
+  result_o=Zero();
+
+  SchurDiagMooeeOperator<WilsonCloverFermionR,LatticeFermion> HermOpEO(Dw);
+  ConjugateGradient<LatticeFermion> CG(1.0e-8,10000);
+  CG(HermOpEO,src_o,result_o);
+  
+
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_cg_schur.cc b/tests/solver/Test_wilsonclover_cg_schur.cc
new file mode 100644
index 00000000..eaae24b3
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_cg_schur.cc
@@ -0,0 +1,77 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_schur.cc
+
+    Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  LatticeFermion    src(&Grid); random(pRNG,src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeFermion resid(&Grid); 
+
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  ConjugateGradient<LatticeFermion> CG(1.0e-8,10000);
+  SchurRedBlackDiagMooeeSolve<LatticeFermion> SchurSolver(CG);
+
+  SchurSolver(Dw,src,result);
+  
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_cg_unprec.cc b/tests/solver/Test_wilsonclover_cg_unprec.cc
new file mode 100644
index 00000000..49c52cdf
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_cg_unprec.cc
@@ -0,0 +1,80 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_wilson_cg_unprec.cc
+
+    Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  Coordinate latt_size   = GridDefaultLatt();
+  Coordinate simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
+  Coordinate mpi_layout  = GridDefaultMpi();
+  GridCartesian               Grid(latt_size,simd_layout,mpi_layout);
+  GridRedBlackCartesian     RBGrid(&Grid);
+
+  std::vector<int> seeds({1,2,3,4});
+  GridParallelRNG          pRNG(&Grid);  pRNG.SeedFixedIntegers(seeds);
+
+  LatticeFermion src(&Grid); random(pRNG,src);
+  RealD nrm = norm2(src);
+  LatticeFermion result(&Grid); result=Zero();
+  LatticeGaugeField Umu(&Grid); SU3::HotConfiguration(pRNG,Umu);
+
+  double volume=1;
+  for(int mu=0;mu<Nd;mu++){
+    volume=volume*latt_size[mu];
+  }  
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
+
+  MdagMLinearOperator<WilsonFermionR,LatticeFermion> HermOp(Dw);
+  ConjugateGradient<LatticeFermion> CG(1.0e-8,10000);
+  CG(HermOp,src,result);
+
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_mixedbicgstab_prec.cc b/tests/solver/Test_wilsonclover_mixedbicgstab_prec.cc
new file mode 100644
index 00000000..0af83f8b
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_mixedbicgstab_prec.cc
@@ -0,0 +1,126 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_dwf_cg_prec.cc
+
+    Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  std::cout << GridLogMessage << "::::: NB: to enable a quick bit reproducibility check use the --checksums flag. " << std::endl;
+
+  GridCartesian         *FGrid_d   = SpaceTimeGrid::makeFourDimGrid(GridDefaultLatt(), GridDefaultSimd(Nd, vComplexD::Nsimd()), GridDefaultMpi());
+  GridCartesian         *FGrid_f   = SpaceTimeGrid::makeFourDimGrid(GridDefaultLatt(), GridDefaultSimd(Nd, vComplexF::Nsimd()), GridDefaultMpi());
+  GridRedBlackCartesian *FrbGrid_d = SpaceTimeGrid::makeFourDimRedBlackGrid(FGrid_d);
+  GridRedBlackCartesian *FrbGrid_f = SpaceTimeGrid::makeFourDimRedBlackGrid(FGrid_f);
+
+  std::vector<int> fSeeds({1, 2, 3, 4});
+  GridParallelRNG  fPRNG(FGrid_d);
+  fPRNG.SeedFixedIntegers(fSeeds);
+
+  // clang-format off
+  LatticeFermionD    src(FGrid_d);    gaussian(fPRNG, src);
+  LatticeFermionD    result(FGrid_d); result = Zero();
+  LatticeGaugeFieldD Umu_d(FGrid_d);  SU3::HotConfiguration(fPRNG, Umu_d);
+  LatticeGaugeFieldF Umu_f(FGrid_f);  precisionChange(Umu_f, Umu_d);
+  // clang-format on
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionD Dw_d(Umu_d, *FGrid_d, *FrbGrid_d, mass, csw_r, csw_t);
+  WilsonCloverFermionF Dw_f(Umu_f, *FGrid_f, *FrbGrid_f, mass, csw_r, csw_t);
+
+  LatticeFermionD      src_o(FrbGrid_d);
+  LatticeFermionD   result_o(FrbGrid_d);
+  LatticeFermionD result_o_2(FrbGrid_d);
+  pickCheckerboard(Odd, src_o, src);
+  result_o.Checkerboard() = Odd;
+  result_o = Zero();
+  result_o_2.Checkerboard() = Odd;
+  result_o_2 = Zero();
+
+  NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionD, LatticeFermionD> NonHermOpEO_d(Dw_d);
+  NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionF, LatticeFermionF> NonHermOpEO_f(Dw_f);
+
+  std::cout << GridLogMessage << "::::::::::::: Starting mixed CG" << std::endl;
+  MixedPrecisionBiCGSTAB<LatticeFermionD, LatticeFermionF> mCG(1.0e-8, 10000, 50, FrbGrid_f, NonHermOpEO_f, NonHermOpEO_d);
+  mCG(src_o, result_o);
+
+  std::cout << GridLogMessage << "::::::::::::: Starting regular CG" << std::endl;
+  BiCGSTAB<LatticeFermionD> CG(1.0e-8, 10000);
+  CG(NonHermOpEO_d, src_o, result_o_2);
+
+  LatticeFermionD diff_o(FrbGrid_d);
+  RealD diff = axpy_norm(diff_o, -1.0, result_o, result_o_2);
+
+  std::cout << GridLogMessage << "::::::::::::: Diff between mixed and regular CG: " << diff << std::endl;
+
+  #ifdef HAVE_LIME
+  if( GridCmdOptionExists(argv,argv+argc,"--checksums") )
+  {
+    std::string file1("./Propagator1");
+    emptyUserRecord record;
+    uint32_t nersc_csum;
+    uint32_t scidac_csuma;
+    uint32_t scidac_csumb;
+    typedef SpinColourVectorD   FermionD;
+    typedef vSpinColourVectorD vFermionD;
+
+    BinarySimpleMunger<FermionD,FermionD> munge;
+    std::string format = getFormatString<vFermionD>();
+    
+    BinaryIO::writeLatticeObject<vFermionD,FermionD>(result_o,file1,munge, 0, format,
+                 nersc_csum,scidac_csuma,scidac_csumb);
+
+    std::cout << GridLogMessage << " Mixed checksums "<<std::hex << scidac_csuma << " "<<scidac_csumb<<std::endl;
+
+    BinaryIO::writeLatticeObject<vFermionD,FermionD>(result_o_2,file1,munge, 0, format,
+                 nersc_csum,scidac_csuma,scidac_csumb);
+
+    std::cout << GridLogMessage << " CG checksums "<<std::hex << scidac_csuma << " "<<scidac_csumb<<std::endl;
+  }
+  #endif
+  
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_wilsonclover_mixedcg_prec.cc b/tests/solver/Test_wilsonclover_mixedcg_prec.cc
new file mode 100644
index 00000000..8af9036f
--- /dev/null
+++ b/tests/solver/Test_wilsonclover_mixedcg_prec.cc
@@ -0,0 +1,126 @@
+    /*************************************************************************************
+
+    Grid physics library, www.github.com/paboyle/Grid 
+
+    Source file: ./tests/Test_dwf_cg_prec.cc
+
+    Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+    See the full license in the file "LICENSE" in the top level distribution directory
+    *************************************************************************************/
+    /*  END LEGAL */
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+ ;
+
+template<class d>
+struct scal {
+  d internal;
+};
+
+  Gamma::Algebra Gmu [] = {
+    Gamma::Algebra::GammaX,
+    Gamma::Algebra::GammaY,
+    Gamma::Algebra::GammaZ,
+    Gamma::Algebra::GammaT
+  };
+
+int main (int argc, char ** argv)
+{
+  Grid_init(&argc,&argv);
+
+  std::cout << GridLogMessage << "::::: NB: to enable a quick bit reproducibility check use the --checksums flag. " << std::endl;
+
+  GridCartesian         *FGrid_d   = SpaceTimeGrid::makeFourDimGrid(GridDefaultLatt(), GridDefaultSimd(Nd, vComplexD::Nsimd()), GridDefaultMpi());
+  GridCartesian         *FGrid_f   = SpaceTimeGrid::makeFourDimGrid(GridDefaultLatt(), GridDefaultSimd(Nd, vComplexF::Nsimd()), GridDefaultMpi());
+  GridRedBlackCartesian *FrbGrid_d = SpaceTimeGrid::makeFourDimRedBlackGrid(FGrid_d);
+  GridRedBlackCartesian *FrbGrid_f = SpaceTimeGrid::makeFourDimRedBlackGrid(FGrid_f);
+
+  std::vector<int> fSeeds({1, 2, 3, 4});
+  GridParallelRNG  fPRNG(FGrid_d);
+  fPRNG.SeedFixedIntegers(fSeeds);
+
+  // clang-format off
+  LatticeFermionD    src(FGrid_d);    gaussian(fPRNG, src);
+  LatticeFermionD    result(FGrid_d); result = Zero();
+  LatticeGaugeFieldD Umu_d(FGrid_d);  SU3::HotConfiguration(fPRNG, Umu_d);
+  LatticeGaugeFieldF Umu_f(FGrid_f);  precisionChange(Umu_f, Umu_d);
+  // clang-format on
+  
+  RealD mass = -0.1;
+  RealD csw_r = 1.0;
+  RealD csw_t = 1.0;
+  WilsonCloverFermionD Dw_d(Umu_d, *FGrid_d, *FrbGrid_d, mass, csw_r, csw_t);
+  WilsonCloverFermionF Dw_f(Umu_f, *FGrid_f, *FrbGrid_f, mass, csw_r, csw_t);
+
+  LatticeFermionD      src_o(FrbGrid_d);
+  LatticeFermionD   result_o(FrbGrid_d);
+  LatticeFermionD result_o_2(FrbGrid_d);
+  pickCheckerboard(Odd, src_o, src);
+  result_o.Checkerboard() = Odd;
+  result_o = Zero();
+  result_o_2.Checkerboard() = Odd;
+  result_o_2 = Zero();
+
+  SchurDiagMooeeOperator<WilsonCloverFermionD, LatticeFermionD> HermOpEO_d(Dw_d);
+  SchurDiagMooeeOperator<WilsonCloverFermionF, LatticeFermionF> HermOpEO_f(Dw_f);
+
+  std::cout << GridLogMessage << "::::::::::::: Starting mixed CG" << std::endl;
+  MixedPrecisionConjugateGradient<LatticeFermionD, LatticeFermionF> mCG(1.0e-8, 10000, 50, FrbGrid_f, HermOpEO_f, HermOpEO_d);
+  mCG(src_o, result_o);
+
+  std::cout << GridLogMessage << "::::::::::::: Starting regular CG" << std::endl;
+  ConjugateGradient<LatticeFermionD> CG(1.0e-8, 10000);
+  CG(HermOpEO_d, src_o, result_o_2);
+
+  LatticeFermionD diff_o(FrbGrid_d);
+  RealD diff = axpy_norm(diff_o, -1.0, result_o, result_o_2);
+
+  std::cout << GridLogMessage << "::::::::::::: Diff between mixed and regular CG: " << diff << std::endl;
+
+  #ifdef HAVE_LIME
+  if( GridCmdOptionExists(argv,argv+argc,"--checksums") )
+  {
+    std::string file1("./Propagator1");
+    emptyUserRecord record;
+    uint32_t nersc_csum;
+    uint32_t scidac_csuma;
+    uint32_t scidac_csumb;
+    typedef SpinColourVectorD   FermionD;
+    typedef vSpinColourVectorD vFermionD;
+
+    BinarySimpleMunger<FermionD,FermionD> munge;
+    std::string format = getFormatString<vFermionD>();
+    
+    BinaryIO::writeLatticeObject<vFermionD,FermionD>(result_o,file1,munge, 0, format,
+                 nersc_csum,scidac_csuma,scidac_csumb);
+
+    std::cout << GridLogMessage << " Mixed checksums "<<std::hex << scidac_csuma << " "<<scidac_csumb<<std::endl;
+
+    BinaryIO::writeLatticeObject<vFermionD,FermionD>(result_o_2,file1,munge, 0, format,
+                 nersc_csum,scidac_csuma,scidac_csumb);
+
+    std::cout << GridLogMessage << " CG checksums "<<std::hex << scidac_csuma << " "<<scidac_csumb<<std::endl;
+  }
+  #endif
+  
+  Grid_finalize();
+}
diff --git a/tests/solver/Test_zMADWF_prec.cc b/tests/solver/Test_zMADWF_prec.cc
new file mode 100644
index 00000000..cbcdd055
--- /dev/null
+++ b/tests/solver/Test_zMADWF_prec.cc
@@ -0,0 +1,303 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./tests/solver/Test_zMADWF_prec.cc
+
+Copyright (C) 2015
+
+Author: Christopher Kelly <ckelly@phys.columbia.edu>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+
+//This test computes the zMobius approximation to the Mobius action and uses it within the MADWF context to accelerate an inversion
+#include <Grid/Grid.h>
+
+using namespace std;
+using namespace Grid;
+
+struct TestParams{
+  bool load_config;
+  std::string config_file;
+
+  double mass;
+
+  std::string outer_precon;
+  std::string inner_precon;
+  
+  int Ls_outer;
+  double b_plus_c_outer;
+  double resid_outer;
+  
+  int Ls_inner;
+  double b_plus_c_inner; //irrelevant for ZMobius
+  double resid_inner;
+  bool zmobius_inner;
+  double lambda_max; //upper bound of H_T eigenvalue range required to generate zMobius approximation
+  
+  TestParams(): load_config(true), config_file("ckpoint_lat.1000"), mass(0.01),
+		Ls_outer(24), b_plus_c_outer(2.0), resid_outer(1e-8),
+		Ls_inner(12), b_plus_c_inner(1.0), resid_inner(1e-8), zmobius_inner(true), lambda_max(1.42), outer_precon("Standard"), inner_precon("Standard")
+  {}
+  
+  void write(const std::string &file) const{
+    XmlWriter wr(file);
+#define DOIT(A) wr.writeDefault(#A, A)
+    DOIT(load_config);
+    DOIT(config_file);
+    DOIT(mass);
+    DOIT(outer_precon);
+    DOIT(inner_precon);
+    DOIT(Ls_outer);
+    DOIT(b_plus_c_outer);
+    DOIT(resid_outer);
+    DOIT(Ls_inner);
+    DOIT(b_plus_c_inner);
+    DOIT(resid_inner);
+    DOIT(zmobius_inner);
+    DOIT(lambda_max);
+#undef DOIT
+  }
+  void read(const std::string &file){
+    XmlReader rd(file);
+#define DOIT(A) rd.readDefault(#A, A)
+    DOIT(load_config);
+    DOIT(config_file);
+    DOIT(mass);
+    DOIT(outer_precon);
+    DOIT(inner_precon);
+    DOIT(Ls_outer);
+    DOIT(b_plus_c_outer);
+    DOIT(resid_outer);
+    DOIT(Ls_inner);
+    DOIT(b_plus_c_inner);
+    DOIT(resid_inner);
+    DOIT(zmobius_inner);
+    DOIT(lambda_max);
+#undef DOIT
+  }
+};
+
+struct RunParamsPrecStd{
+  typedef SchurRedBlackDiagMooeeSolve<LatticeFermionD> SchurSolverType;
+
+  template<typename Action>
+  using HermOpType = SchurDiagMooeeOperator<Action, LatticeFermionD>;
+};
+
+struct RunParamsPrecDiagTwo{
+  typedef SchurRedBlackDiagTwoSolve<LatticeFermionD> SchurSolverType;
+
+  template<typename Action>
+  using HermOpType = SchurDiagTwoOperator<Action, LatticeFermionD>;
+};
+
+
+struct CGincreaseTol : public MADWFinnerIterCallbackBase{
+  ConjugateGradient<LatticeFermionD> &cg_inner;  
+  RealD outer_resid;
+
+  CGincreaseTol(ConjugateGradient<LatticeFermionD> &cg_inner,
+		RealD outer_resid): cg_inner(cg_inner), outer_resid(outer_resid){}
+  
+  void operator()(const RealD current_resid){
+    std::cout << "CGincreaseTol with current residual " << current_resid << " changing inner tolerance " << cg_inner.Tolerance << " -> ";
+    while(cg_inner.Tolerance < current_resid) cg_inner.Tolerance *= 2;    
+    //cg_inner.Tolerance = outer_resid/current_resid;
+    std::cout << cg_inner.Tolerance << std::endl;
+  }
+};
+
+template<typename RunParamsOuter, typename RunParamsInner>
+void run(const TestParams &params){
+  RealD bmc = 1.0; //use Shamir kernel
+  std::vector<ComplexD> gamma_inner;
+
+  std::cout << "Compute parameters" << std::endl;
+  if(params.zmobius_inner){
+    Approx::computeZmobiusGamma(gamma_inner, params.b_plus_c_inner, params.Ls_inner, params.b_plus_c_outer, params.Ls_outer, params.lambda_max);
+  }else{
+    Approx::zolotarev_data *zdata = Approx::higham(1.0,params.Ls_inner);
+    gamma_inner.resize(params.Ls_inner);
+    for(int s=0;s<params.Ls_inner;s++) gamma_inner[s] = zdata->gamma[s];
+    Approx::zolotarev_free(zdata);
+  }
+  std::cout << "gamma:\n";
+  for(int s=0;s<params.Ls_inner;s++) std::cout << s << " " << gamma_inner[s] << std::endl;
+
+
+  GridCartesian* UGrid = SpaceTimeGrid::makeFourDimGrid(
+      GridDefaultLatt(), GridDefaultSimd(Nd, vComplexD::Nsimd()),
+      GridDefaultMpi());
+  GridRedBlackCartesian* UrbGrid = SpaceTimeGrid::makeFourDimRedBlackGrid(UGrid);
+
+
+  GridCartesian* FGrid_outer = SpaceTimeGrid::makeFiveDimGrid(params.Ls_outer, UGrid);
+  GridCartesian* FGrid_inner = SpaceTimeGrid::makeFiveDimGrid(params.Ls_inner, UGrid);
+
+  GridRedBlackCartesian* FrbGrid_outer = SpaceTimeGrid::makeFiveDimRedBlackGrid(params.Ls_outer, UGrid);
+  GridRedBlackCartesian* FrbGrid_inner = SpaceTimeGrid::makeFiveDimRedBlackGrid(params.Ls_inner, UGrid);
+
+
+  std::vector<int> seeds4({1, 2, 3, 4});
+  std::vector<int> seeds5({5, 6, 7, 8});
+
+  GridParallelRNG RNG5_outer(FGrid_outer);
+  RNG5_outer.SeedFixedIntegers(seeds5);
+
+  GridParallelRNG RNG4(UGrid);
+  RNG4.SeedFixedIntegers(seeds4);
+
+  LatticeFermionD src4(UGrid); random(RNG4,src4);
+
+  LatticeFermionD result_outer(FGrid_outer);
+  result_outer = Zero();
+  LatticeGaugeFieldD Umu(UGrid);
+
+  if(params.load_config){
+    FieldMetaData header;
+    NerscIO::readConfiguration(Umu, header, params.config_file);
+
+    for(int i=0;i<Nd;i++){
+      assert(header.dimension[i] == GridDefaultLatt()[i]);
+    }
+  }else{    
+    SU3::HotConfiguration(RNG4, Umu);
+  }
+    
+  std::cout << GridLogMessage << "Lattice dimensions: " << GridDefaultLatt()
+            << "   Ls: " << params.Ls_outer << std::endl;
+
+  RealD M5 = 1.8;
+
+  RealD b_outer = (params.b_plus_c_outer + bmc)/2.;
+  RealD c_outer = (params.b_plus_c_outer - bmc)/2.;
+
+  RealD b_inner = (params.b_plus_c_inner + bmc)/2.;
+  RealD c_inner = (params.b_plus_c_inner - bmc)/2.;
+
+  MobiusFermionD D_outer(Umu, *FGrid_outer, *FrbGrid_outer, *UGrid, *UrbGrid, params.mass, M5, b_outer, c_outer);
+  ZMobiusFermionD D_inner(Umu, *FGrid_inner, *FrbGrid_inner, *UGrid, *UrbGrid, params.mass, M5, gamma_inner, b_inner, c_inner);
+
+  LatticeFermionD src_outer(FGrid_outer);
+  D_outer.ImportPhysicalFermionSource(src4,src_outer); //applies D_- 
+
+  //Solve using a regular even-odd preconditioned CG for the Hermitian operator
+  //M y = x
+  //Mprec y'_o = x'_o     where Mprec = Doo - Doe Dee^-1 Deo    and  x'_o = -Doe Dee^-1 x_e + x_o
+  //y_o = y'_o
+
+  //(Mprec^dag Mprec) y'_o = Mprec^dag x'_o 
+  //y'_o = (Mprec^dag Mprec)^-1 Mprec^dag x'_o 
+
+  //We can get Mprec^dag x'_o from x_o  from SchurRedBlackDiagMooeeSolve::RedBlackSource
+  ConjugateGradient<LatticeFermionD> CG_outer(params.resid_outer, 10000);
+  typename RunParamsOuter::SchurSolverType SchurSolver_outer(CG_outer);
+  
+  LatticeFermionD tmp_e_outer(FrbGrid_outer);
+  LatticeFermionD src_o_outer(FrbGrid_outer);
+  SchurSolver_outer.RedBlackSource(D_outer, src_outer, tmp_e_outer, src_o_outer);
+  
+  LatticeFermionD result_o_outer(FrbGrid_outer);
+  result_o_outer = Zero();
+
+  GridStopWatch CGTimer;
+  
+  typename RunParamsOuter::HermOpType<MobiusFermionD> HermOpEO_outer(D_outer);
+
+  CGTimer.Start();
+  CG_outer(HermOpEO_outer, src_o_outer, result_o_outer);
+  CGTimer.Stop();
+
+  std::cout << GridLogMessage << "Total outer CG time : " << CGTimer.Elapsed()
+            << std::endl;
+
+  CGTimer.Reset();
+
+  //Solve for y using MADWF with internal preconditioning
+
+  //typedef PauliVillarsSolverRBprec<LatticeFermionD, typename RunParamsOuter::SchurSolverType> PVtype;
+  //PVtype PV_outer(SchurSolver_outer);
+
+  typedef PauliVillarsSolverFourierAccel<LatticeFermionD, LatticeGaugeFieldD> PVtype;
+  PVtype PV_outer(Umu, CG_outer);
+
+  ConjugateGradient<LatticeFermionD> CG_inner(params.resid_inner, 10000, 0);
+
+  CGincreaseTol update(CG_inner, params.resid_outer);
+
+  typename RunParamsInner::SchurSolverType SchurSolver_inner(CG_inner);
+
+  ZeroGuesser<LatticeFermion> Guess;
+  MADWF<MobiusFermionD, ZMobiusFermionD, PVtype, typename RunParamsInner::SchurSolverType, ZeroGuesser<LatticeFermion> > madwf(D_outer, D_inner, PV_outer, SchurSolver_inner, Guess, params.resid_outer, 100, &update);
+  
+  LatticeFermionD result_MADWF(FGrid_outer);
+  result_MADWF = Zero();
+
+  CGTimer.Start();
+  madwf(src4, result_MADWF);
+  CGTimer.Stop();
+
+  LatticeFermionD result_o_MADWF(FrbGrid_outer);
+  pickCheckerboard(Odd, result_o_MADWF, result_MADWF);
+
+  std::cout << GridLogMessage << "Total MADWF time : " << CGTimer.Elapsed()
+            << std::endl;
+
+  LatticeFermionD diff = result_o_MADWF - result_o_outer;
+  std::cout <<GridLogMessage<< "Odd-parity MADWF result norm " << norm2(result_o_MADWF) 
+	    << " Regular result norm " << norm2(result_o_outer) 
+	    << " Norm of diff " << norm2(diff)<<std::endl;
+
+
+  //std::cout << GridLogMessage << "######## Dhop calls summary" << std::endl;
+  //D_outer.Report();
+}
+
+
+
+int main(int argc, char** argv) {
+  std::cout << "Init" << std::endl;
+  Grid_init(&argc, &argv);
+
+  TestParams params;
+  
+  if( GridCmdOptionExists(argv,argv+argc,"--params") ){
+    std::string pfile = GridCmdOptionPayload(argv,argv+argc,"--params");
+    if(pfile == "TEMPLATE"){
+      params.write("params.templ");
+      return 0;
+    }else{
+      params.read(pfile);
+    }
+  }
+
+  if(params.outer_precon == "Standard" && params.inner_precon == "Standard" ){
+    run<RunParamsPrecStd, RunParamsPrecStd>(params);
+  }else if(params.outer_precon == "DiagTwo" && params.inner_precon == "Standard"){
+    run<RunParamsPrecDiagTwo, RunParamsPrecStd>(params);
+  }else if(params.outer_precon == "Standard" && params.inner_precon == "DiagTwo"){
+    run<RunParamsPrecStd, RunParamsPrecDiagTwo>(params);
+  }else if(params.outer_precon == "DiagTwo" && params.inner_precon == "DiagTwo"){
+    run<RunParamsPrecDiagTwo, RunParamsPrecDiagTwo>(params);
+  }else assert(0);
+
+  Grid_finalize();
+}