diff --git a/lib/algorithms/CoarsenedMatrix.h b/lib/algorithms/CoarsenedMatrix.h
index 8b476603..957607b3 100644
--- a/lib/algorithms/CoarsenedMatrix.h
+++ b/lib/algorithms/CoarsenedMatrix.h
@@ -129,7 +129,7 @@ public:
       blockProject(iProj,subspace[i],subspace);
       eProj=zero; 
       parallel_for(int ss=0;ss<CoarseGrid->oSites();ss++){
-	eProj._odata[ss](i)=CComplex(1.0);
+	eProj[ss](i)=CComplex(1.0);
       }
       eProj=eProj - iProj;
       std::cout<<GridLogMessage<<"Orthog check error "<<i<<" " << norm2(eProj)<<std::endl;
@@ -140,7 +140,7 @@ public:
     blockProject(CoarseVec,FineVec,subspace);
   }
   void PromoteFromSubspace(const CoarseVector &CoarseVec,FineField &FineVec){
-    FineVec.checkerboard = subspace[0].checkerboard;
+    FineVec.Checkerboard() = subspace[0].Checkerboard();
     blockPromote(CoarseVec,FineVec,subspace);
   }
   void CreateSubspaceRandom(GridParallelRNG &RNG){
@@ -282,15 +282,15 @@ public:
 	SE=Stencil.GetEntry(ptype,point,ss);
 	  
 	if(SE->_is_local&&SE->_permute) { 
-	  permute(nbr,in._odata[SE->_offset],ptype);
+	  permute(nbr,in[SE->_offset],ptype);
 	} else if(SE->_is_local) { 
-	  nbr = in._odata[SE->_offset];
+	  nbr = in[SE->_offset];
 	} else {
 	  nbr = Stencil.CommBuf()[SE->_offset];
 	}
-	res = res + A[point]._odata[ss]*nbr;
+	res = res + A[point][ss]*nbr;
       }
-      vstream(out._odata[ss],res);
+      vstream(out[ss],res);
     }
     return norm2(out);
   };
@@ -387,9 +387,9 @@ public:
 	parallel_for(int ss=0;ss<Grid()->oSites();ss++){
 	  for(int j=0;j<nbasis;j++){
 	    if( disp!= 0 ) {
-	      A[p]._odata[ss](j,i) = oProj._odata[ss](j);
+	      A[p][ss](j,i) = oProj[ss](j);
 	    }
-	    A[self_stencil]._odata[ss](j,i) =	A[self_stencil]._odata[ss](j,i) + iProj._odata[ss](j);
+	    A[self_stencil][ss](j,i) =	A[self_stencil][ss](j,i) + iProj[ss](j);
 	  }
 	}
       }
@@ -443,7 +443,7 @@ public:
     A[8] = val*ident;
 
     //      for(int s=0;s<Grid()->oSites();s++) {
-    //	A[8]._odata[s]=val._odata[s];
+    //	A[8][s]=val[s];
     //      }
   }
   void ForceHermitian(void) {
diff --git a/lib/algorithms/FFT.h b/lib/algorithms/FFT.h
index e63ff123..959dfb2c 100644
--- a/lib/algorithms/FFT.h
+++ b/lib/algorithms/FFT.h
@@ -217,8 +217,8 @@ public:
       
     FFTW_plan p;
     {
-      FFTW_scalar *in = (FFTW_scalar *)&pgbuf._odata[0];
-      FFTW_scalar *out= (FFTW_scalar *)&pgbuf._odata[0];
+      FFTW_scalar *in = (FFTW_scalar *)&pgbuf[0];
+      FFTW_scalar *out= (FFTW_scalar *)&pgbuf[0];
       p = FFTW<scalar>::fftw_plan_many_dft(rank,n,howmany,
 					   in,inembed,
 					   istride,idist,
@@ -261,8 +261,8 @@ public:
         thread_loop_in_region( (int idx=0;idx<NN;idx++), {
 	    pencil_g.LocalIndexToLocalCoor(idx, cbuf);
 	    if ( cbuf[dim] == 0 ) {  // restricts loop to plane at lcoor[dim]==0
-	      FFTW_scalar *in = (FFTW_scalar *)&pgbuf._odata[idx];
-	      FFTW_scalar *out= (FFTW_scalar *)&pgbuf._odata[idx];
+	      FFTW_scalar *in = (FFTW_scalar *)&pgbuf[idx];
+	      FFTW_scalar *out= (FFTW_scalar *)&pgbuf[idx];
 	      FFTW<scalar>::fftw_execute_dft(p,in,out);
 	    }
 	  });
diff --git a/lib/algorithms/iterative/AdefGeneric.h b/lib/algorithms/iterative/AdefGeneric.h
index 2eff5871..30c74dde 100644
--- a/lib/algorithms/iterative/AdefGeneric.h
+++ b/lib/algorithms/iterative/AdefGeneric.h
@@ -90,7 +90,7 @@ class TwoLevelFlexiblePcg : public LinearFunction<Field>
   void operator() (const Field &src, Field &psi){
   void operator() (const Field &src, Field &psi){
 
-    psi.checkerboard = src.checkerboard;
+    psi.Checkerboard() = src.Checkerboard();
     grid             = src._grid;
 
     RealD f;
diff --git a/lib/algorithms/iterative/BlockConjugateGradient.h b/lib/algorithms/iterative/BlockConjugateGradient.h
index b2a268b1..7af65dfb 100644
--- a/lib/algorithms/iterative/BlockConjugateGradient.h
+++ b/lib/algorithms/iterative/BlockConjugateGradient.h
@@ -143,7 +143,7 @@ public:
 
     std::cout<<GridLogMessage<<" Block Conjugate Gradient : Orthog "<<Orthog<<" Nblock "<<Nblock<<std::endl;
 
-    X.checkerboard = B.checkerboard;
+    X.Checkerboard() = B.Checkerboard();
     conformable(X, B);
 
     Field tmp(B);
@@ -327,7 +327,7 @@ public:
 
     std::cout<<GridLogMessage<<" Block Conjugate Gradient : Orthog "<<Orthog<<" Nblock "<<Nblock<<std::endl;
 
-    Psi.checkerboard = Src.checkerboard;
+    Psi.Checkerboard() = Src.Checkerboard();
     conformable(Psi, Src);
 
     Field P(Src);
@@ -474,7 +474,7 @@ public:
 
     std::cout<<GridLogMessage<<"MultiRHS Conjugate Gradient : Orthog "<<Orthog<<" Nblock "<<Nblock<<std::endl;
 
-    Psi.checkerboard = Src.checkerboard;
+    Psi.Checkerboard() = Src.Checkerboard();
     conformable(Psi, Src);
 
     Field P(Src);
diff --git a/lib/algorithms/iterative/ConjugateGradient.h b/lib/algorithms/iterative/ConjugateGradient.h
index f195f735..5b9f5db7 100644
--- a/lib/algorithms/iterative/ConjugateGradient.h
+++ b/lib/algorithms/iterative/ConjugateGradient.h
@@ -54,7 +54,7 @@ public:
 
   void operator()(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi) {
 
-    psi.checkerboard = src.checkerboard;
+    psi.Checkerboard() = src.Checkerboard();
     conformable(psi, src);
 
     RealD cp, c, a, d, b, ssq, qq, b_pred;
diff --git a/lib/algorithms/iterative/ConjugateGradientMixedPrec.h b/lib/algorithms/iterative/ConjugateGradientMixedPrec.h
index e464916c..9eb83ba4 100644
--- a/lib/algorithms/iterative/ConjugateGradientMixedPrec.h
+++ b/lib/algorithms/iterative/ConjugateGradientMixedPrec.h
@@ -67,18 +67,18 @@ public:
     GridStopWatch TotalTimer;
     TotalTimer.Start();
     
-    int cb = src_d_in.checkerboard;
-    sol_d.checkerboard = cb;
+    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;
+    tmp_d.Checkerboard() = cb;
     
     FieldD tmp2_d(DoublePrecGrid);
-    tmp2_d.checkerboard = cb;
+    tmp2_d.Checkerboard() = cb;
     
     FieldD src_d(DoublePrecGrid);
     src_d = src_d_in; //source for next inner iteration, computed from residual during operation
@@ -86,10 +86,10 @@ public:
     RealD inner_tol = InnerTolerance;
     
     FieldF src_f(SinglePrecGrid);
-    src_f.checkerboard = cb;
+    src_f.Checkerboard() = cb;
     
     FieldF sol_f(SinglePrecGrid);
-    sol_f.checkerboard = cb;
+    sol_f.Checkerboard() = cb;
     
     ConjugateGradient<FieldF> CG_f(inner_tol, MaxInnerIterations);
     CG_f.ErrorOnNoConverge = false;
diff --git a/lib/algorithms/iterative/ConjugateGradientReliableUpdate.h b/lib/algorithms/iterative/ConjugateGradientReliableUpdate.h
index 9f46912e..3ce2e887 100644
--- a/lib/algorithms/iterative/ConjugateGradientReliableUpdate.h
+++ b/lib/algorithms/iterative/ConjugateGradientReliableUpdate.h
@@ -76,7 +76,7 @@ public:
     LinearOperatorBase<FieldF> *Linop_f_use = &Linop_f;
     bool using_fallback = false;
       
-    psi.checkerboard = src.checkerboard;
+    psi.Checkerboard() = src.Checkerboard();
     conformable(psi, src);
 
     RealD cp, c, a, d, b, ssq, qq, b_pred;
@@ -116,7 +116,7 @@ public:
 
     //Single prec initialization
     FieldF r_f(SinglePrecGrid);
-    r_f.checkerboard = r.checkerboard;
+    r_f.Checkerboard() = r.Checkerboard();
     precisionChange(r_f, r);
 
     FieldF psi_f(r_f);
diff --git a/lib/algorithms/iterative/ImplicitlyRestartedLanczos.h b/lib/algorithms/iterative/ImplicitlyRestartedLanczos.h
index 897eb52b..a960b634 100644
--- a/lib/algorithms/iterative/ImplicitlyRestartedLanczos.h
+++ b/lib/algorithms/iterative/ImplicitlyRestartedLanczos.h
@@ -64,11 +64,11 @@ void basisRotate(std::vector<Field> &basis,Eigen::MatrixXd& Qt,int j0, int j1, i
       
       for(int j=j0; j<j1; ++j){
 	for(int k=k0; k<k1; ++k){
-	  B[j] +=Qt(j,k) * basis[k]._odata[ss];
+	  B[j] +=Qt(j,k) * basis[k][ss];
 	}
       }
       for(int j=j0; j<j1; ++j){
-	  basis[j]._odata[ss] = B[j];
+	  basis[j][ss] = B[j];
       }
     }
   }
@@ -81,13 +81,13 @@ void basisRotateJ(Field &result,std::vector<Field> &basis,Eigen::MatrixXd& Qt,in
   typedef typename Field::vector_object vobj;
   GridBase* grid = basis[0]._grid;
 
-  result.checkerboard = basis[0].checkerboard;
+  result.Checkerboard() = basis[0].Checkerboard();
   parallel_for(int ss=0;ss < grid->oSites();ss++){
     vobj B = zero;
     for(int k=k0; k<k1; ++k){
-      B +=Qt(j,k) * basis[k]._odata[ss];
+      B +=Qt(j,k) * basis[k][ss];
     }
-    result._odata[ss] = B;
+    result[ss] = B;
   }
 }
 
@@ -487,7 +487,7 @@ until convergence
 
 	std::cout << GridLogIRL << "Test convergence: rotate subset of vectors to test convergence " << std::endl;
 
-	Field B(grid); B.checkerboard = evec[0].checkerboard;
+	Field B(grid); B.Checkerboard() = evec[0].Checkerboard();
 
 	//  power of two search pattern;  not every evalue in eval2 is assessed.
 	for(int jj = 1; jj<=Nstop; jj*=2){
@@ -525,7 +525,7 @@ until convergence
 	
   converged:
     {
-      Field B(grid); B.checkerboard = evec[0].checkerboard;
+      Field B(grid); B.Checkerboard() = evec[0].Checkerboard();
       basisRotate(evec,Qt,0,Nk,0,Nk,Nm);	    
       std::cout << GridLogIRL << " Rotated basis"<<std::endl;
       Nconv=0;
diff --git a/lib/algorithms/iterative/LocalCoherenceLanczos.h b/lib/algorithms/iterative/LocalCoherenceLanczos.h
index 0f2a524b..02904d3e 100644
--- a/lib/algorithms/iterative/LocalCoherenceLanczos.h
+++ b/lib/algorithms/iterative/LocalCoherenceLanczos.h
@@ -113,8 +113,8 @@ public:
 
     GridBase *FineGrid = _Aggregate.FineGrid;
 
-    FineField fin(FineGrid) ;fin.checkerboard  =_Aggregate.checkerboard;
-    FineField fout(FineGrid);fout.checkerboard =_Aggregate.checkerboard;
+    FineField fin(FineGrid) ;fin.Checkerboard()  =_Aggregate.Checkerboard();
+    FineField fout(FineGrid);fout.Checkerboard() =_Aggregate.Checkerboard();
     
     _Aggregate.PromoteFromSubspace(in,fin);    std::cout<<GridLogIRL<<"ProjectedFunctionHermop : Promote to fine"<<std::endl;
     _poly(_Linop,fin,fout);                    std::cout<<GridLogIRL<<"ProjectedFunctionHermop : Poly "<<std::endl;
@@ -172,10 +172,10 @@ public:
   {
     GridBase *FineGrid = _Aggregate.FineGrid;
 
-    int checkerboard   = _Aggregate.checkerboard;
+    int checkerboard   = _Aggregate.Checkerboard();
 
-    FineField fB(FineGrid);fB.checkerboard =checkerboard;
-    FineField fv(FineGrid);fv.checkerboard =checkerboard;
+    FineField fB(FineGrid);fB.Checkerboard() =checkerboard;
+    FineField fv(FineGrid);fv.Checkerboard() =checkerboard;
 
     _Aggregate.PromoteFromSubspace(B,fv);
     _smoother(_Linop,fv,fB); 
@@ -254,11 +254,11 @@ public:
     int Nk = nbasis;
     _Aggregate.subspace.resize(Nk,_FineGrid);
     _Aggregate.subspace[0]=1.0;
-    _Aggregate.subspace[0].checkerboard=_checkerboard;
+    _Aggregate.subspace[0].Checkerboard()=_checkerboard;
     normalise(_Aggregate.subspace[0]);
     PlainHermOp<FineField>    Op(_FineOp);
     for(int k=1;k<Nk;k++){
-      _Aggregate.subspace[k].checkerboard=_checkerboard;
+      _Aggregate.subspace[k].Checkerboard()=_checkerboard;
       Op(_Aggregate.subspace[k-1],_Aggregate.subspace[k]);
       normalise(_Aggregate.subspace[k]);
     }
@@ -308,7 +308,7 @@ public:
 
     ImplicitlyRestartedLanczos<FineField> IRL(ChebyOp,Op,Nstop,Nk,Nm,resid,MaxIt,betastp,MinRes);
 
-    FineField src(_FineGrid); src=1.0; src.checkerboard = _checkerboard;
+    FineField src(_FineGrid); src=1.0; src.Checkerboard() = _checkerboard;
 
     int Nconv;
     IRL.calc(evals_fine,_Aggregate.subspace,src,Nconv,false);
diff --git a/lib/algorithms/iterative/SchurRedBlack.h b/lib/algorithms/iterative/SchurRedBlack.h
index 46a03aaf..a915d8d0 100644
--- a/lib/algorithms/iterative/SchurRedBlack.h
+++ b/lib/algorithms/iterative/SchurRedBlack.h
@@ -135,30 +135,30 @@ public:
     /////////////////////////////////////////////////////
     // src_o = (source_o - Moe MeeInv source_e)
     /////////////////////////////////////////////////////
-    _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.checkerboard ==Even);
-    _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.checkerboard ==Odd);     
-    tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
+    _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
+    _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
+    tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
-    //src_o = tmp;     assert(src_o.checkerboard ==Odd);
+    //src_o = tmp;     assert(src_o.Checkerboard() ==Odd);
     _Matrix.Mooee(tmp,src_o); // Extra factor of "m" in source from dumb choice of matrix norm.
 
     //////////////////////////////////////////////////////////////
     // Call the red-black solver
     //////////////////////////////////////////////////////////////
     std::cout<<GridLogMessage << "SchurRedBlackStaggeredSolver calling the Mpc solver" <<std::endl;
-    _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.checkerboard==Odd);
+    _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
     std::cout<<GridLogMessage << "SchurRedBlackStaggeredSolver called  the Mpc solver" <<std::endl;
 
     ///////////////////////////////////////////////////
     // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
     ///////////////////////////////////////////////////
-    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.checkerboard   ==Even);
-    src_e = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.checkerboard ==Even);
+    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.Checkerboard()   ==Even);
+    src_e = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
+    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
     std::cout<<GridLogMessage << "SchurRedBlackStaggeredSolver reconstructed other CB" <<std::endl;
-    setCheckerboard(out,sol_e); assert(  sol_e.checkerboard ==Even);
-    setCheckerboard(out,sol_o); assert(  sol_o.checkerboard ==Odd );
+    setCheckerboard(out,sol_e); assert(  sol_e.Checkerboard() ==Even);
+    setCheckerboard(out,sol_o); assert(  sol_o.Checkerboard() ==Odd );
     std::cout<<GridLogMessage << "SchurRedBlackStaggeredSolver inserted solution" <<std::endl;
 
     // Verify the unprec residual
@@ -214,28 +214,28 @@ public:
     /////////////////////////////////////////////////////
     // 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);     
-    tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
+    _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
+    _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
+    tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
     // get the right MpcDag
-    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.checkerboard ==Odd);       
+    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
 
     //////////////////////////////////////////////////////////////
     // Call the red-black solver
     //////////////////////////////////////////////////////////////
     std::cout<<GridLogMessage << "SchurRedBlack solver calling the MpcDagMp solver" <<std::endl;
-    _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.checkerboard==Odd);
+    _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
 
     ///////////////////////////////////////////////////
     // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
     ///////////////////////////////////////////////////
-    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.checkerboard   ==Even);
-    src_e = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.checkerboard ==Even);
+    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.Checkerboard()   ==Even);
+    src_e = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
+    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-    setCheckerboard(out,sol_e); assert(  sol_e.checkerboard ==Even);
-    setCheckerboard(out,sol_o); assert(  sol_o.checkerboard ==Odd );
+    setCheckerboard(out,sol_e); assert(  sol_e.Checkerboard() ==Even);
+    setCheckerboard(out,sol_o); assert(  sol_o.Checkerboard() ==Odd );
 
     // Verify the unprec residual
     _Matrix.M(out,resid); 
@@ -293,30 +293,30 @@ public:
     /////////////////////////////////////////////////////
     // 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);     
-    tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
+    _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
+    _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
+    tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
     // get the right MpcDag
-    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.checkerboard ==Odd);       
+    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
 
     //////////////////////////////////////////////////////////////
     // Call the red-black solver
     //////////////////////////////////////////////////////////////
     std::cout<<GridLogMessage << "SchurRedBlack solver calling the MpcDagMp solver" <<std::endl;
-    //      _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.checkerboard==Odd);
-    _HermitianRBSolver(_HermOpEO,src_o,tmp);  assert(tmp.checkerboard==Odd);
-    _Matrix.MooeeInv(tmp,sol_o);        assert(  sol_o.checkerboard   ==Odd);
+    //      _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
+    _HermitianRBSolver(_HermOpEO,src_o,tmp);  assert(tmp.Checkerboard()==Odd);
+    _Matrix.MooeeInv(tmp,sol_o);        assert(  sol_o.Checkerboard()   ==Odd);
 
     ///////////////////////////////////////////////////
     // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
     ///////////////////////////////////////////////////
-    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.checkerboard   ==Even);
-    src_e = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.checkerboard ==Even);
+    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.Checkerboard()   ==Even);
+    src_e = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
+    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-    setCheckerboard(out,sol_e); assert(  sol_e.checkerboard ==Even);
-    setCheckerboard(out,sol_o); assert(  sol_o.checkerboard ==Odd );
+    setCheckerboard(out,sol_e); assert(  sol_e.Checkerboard() ==Even);
+    setCheckerboard(out,sol_o); assert(  sol_o.Checkerboard() ==Odd );
 
     // Verify the unprec residual
     _Matrix.M(out,resid); 
@@ -372,31 +372,31 @@ public:
     /////////////////////////////////////////////////////
     // 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);     
-    tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
+    _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.Checkerboard() ==Even);
+    _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.Checkerboard() ==Odd);     
+    tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
 
     // get the right MpcDag
-    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.checkerboard ==Odd);       
+    _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
 
     //////////////////////////////////////////////////////////////
     // Call the red-black solver
     //////////////////////////////////////////////////////////////
     std::cout<<GridLogMessage << "SchurRedBlack solver calling the MpcDagMp solver" <<std::endl;
-    //      _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.checkerboard==Odd);
-    //      _HermitianRBSolver(_HermOpEO,src_o,tmp);  assert(tmp.checkerboard==Odd);
-    _HermitianRBSolver(src_o,tmp);  assert(tmp.checkerboard==Odd);
-    _Matrix.MooeeInv(tmp,sol_o);        assert(  sol_o.checkerboard   ==Odd);
+    //      _HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.Checkerboard()==Odd);
+    //      _HermitianRBSolver(_HermOpEO,src_o,tmp);  assert(tmp.Checkerboard()==Odd);
+    _HermitianRBSolver(src_o,tmp);  assert(tmp.Checkerboard()==Odd);
+    _Matrix.MooeeInv(tmp,sol_o);        assert(  sol_o.Checkerboard()   ==Odd);
 
     ///////////////////////////////////////////////////
     // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
     ///////////////////////////////////////////////////
-    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.checkerboard   ==Even);
-    src_e = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.checkerboard ==Even);
+    _Matrix.Meooe(sol_o,tmp);        assert(  tmp.Checkerboard()   ==Even);
+    src_e = src_e-tmp;               assert(  src_e.Checkerboard() ==Even);
+    _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.Checkerboard() ==Even);
      
-    setCheckerboard(out,sol_e); assert(  sol_e.checkerboard ==Even);
-    setCheckerboard(out,sol_o); assert(  sol_o.checkerboard ==Odd );
+    setCheckerboard(out,sol_e); assert(  sol_e.Checkerboard() ==Even);
+    setCheckerboard(out,sol_o); assert(  sol_o.Checkerboard() ==Odd );
 
     // Verify the unprec residual
     _Matrix.M(out,resid);