Merge branch 'feature/ddhmc' of https://github.com/paboyle/Grid into feature/ddhmc

Several updates
Correct mass
2026-09-26 11:13:18 +01:00 · 2022-02-14 17:33:17 +01:00 · 2022-02-14 17:29:41 +01:00 · 2021-11-17 21:40:04 +00:00 · 2021-10-07 20:06:55 +01:00 · 2021-10-07 20:06:17 +01:00
972 changed files with 28286 additions and 124364 deletions
@@ -1,54 +0,0 @@
-name: Bug report
-description: Report a bug.
-title: "<insert title>"
-labels: [bug]
-
-body:
-  - type: markdown
-    attributes:
-      value: >
-        Thank you for taking the time to file a bug report.
-        Please check that the code is pointing to the HEAD of develop
-        or any commit in master which is tagged with a version number.
-
-  - type: textarea
-    attributes:
-      label: "Describe the issue:"
-      description: >
-        Describe the issue and any previous attempt to solve it.
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: "Code example:"
-      description: >
-        If relevant, show how to reproduce the issue using a minimal working
-        example.
-      placeholder: |
-        << your code here >>
-      render: shell
-    validations:
-      required: false
-
-  - type: textarea
-    attributes:
-      label: "Target platform:"
-      description: >
-        Give a description of the target platform (CPU, network, compiler).
-        Please give the full CPU part description, using for example
-        `cat /proc/cpuinfo | grep 'model name' | uniq` (Linux)
-        or `sysctl machdep.cpu.brand_string` (macOS) and the full output
-        the `--version` option of your compiler.
-    validations:
-      required: true
-
-  - type: textarea
-    attributes:
-      label: "Configure options:"
-      description: >
-        Please give the exact configure command used and attach
-        `config.log`, `grid.config.summary` and the output of `make V=1`.
-      render: shell
-    validations:
-      required: true
@@ -1,7 +1,3 @@
-# Doxygen stuff
-html/*
-latex/*
-
 # Compiled Object files #
 #########################
 *.slo
@@ -1,190 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Which rocBLAS kernel does the coarse multigrid GEMM get, and is a better
-// one available?
-//
-// The coarse operator issues a batched complex GEMM per stencil point with
-// M = K = nbasis, N = Nrhs and batch = the local coarse volume.  Traces of a
-// production run show the complex-single kernel taking as long as the
-// complex-double one while reading half the bytes, and the kernel names say
-// why: the library picks a 64x64 macro tile for single and 16x16 for double,
-// while the output block is only nbasis x Nrhs.  At nbasis 16 single
-// precision comes out absolutely slower than double.
-//
-// hipBLAS offers no way to override that choice, but rocBLAS's extended
-// entry point takes a solution index.  This walks the indices, keeps the ones
-// the library accepts for this problem, times each, and prints them against
-// the default heuristic.  No Grid, no MPI: one GPU, a few seconds.
-//
-//   hipcc -O3 -std=c++17 RocblasSolutionSweep.cc -lrocblas -lamdhip64 \
-//         -o RocblasSolutionSweep
-//   ./RocblasSolutionSweep [nbasis] [nrhs] [batch]
-//
-// If the accepted solutions include one roughly twice the double-precision
-// rate, the application can select it by index and the tuning gap is ours to
-// close.  If none does, the gap is the library's, and this output is the
-// report.
-///////////////////////////////////////////////////////////////////////////////
-#include <cstdio>
-#include <cstdlib>
-#include <vector>
-#include <string>
-#include <algorithm>
-#include <sys/time.h>
-#include <hip/hip_runtime.h>
-#include <rocblas/rocblas.h>
-
-static double usecond(void)
-{
-  struct timeval tv; gettimeofday(&tv,NULL);
-  return 1.0e6*tv.tv_sec + 1.0*tv.tv_usec;
-}
-#define HIP_CHECK(x)  do { hipError_t e=(x); if(e!=hipSuccess){ printf("HIP error %s at line %d\n",hipGetErrorString(e),__LINE__); exit(1);} } while(0)
-
-struct Result { int index; double gflops; double gbs; };
-
-// One shape, one datatype, every solution index the library accepts.
-static void sweep(rocblas_handle handle,
-		  rocblas_datatype type, const char *name, size_t elembytes,
-		  int M,int N,int K,int BATCH,int maxindex,int ncall)
-{
-  // Device data.  Contents are irrelevant to the timing; the shapes are not.
-  void *A,*B,*C;
-  HIP_CHECK(hipMalloc(&A,(size_t)M*K*BATCH*elembytes));
-  HIP_CHECK(hipMalloc(&B,(size_t)K*N*BATCH*elembytes));
-  HIP_CHECK(hipMalloc(&C,(size_t)M*N*BATCH*elembytes));
-  HIP_CHECK(hipMemset(A,0,(size_t)M*K*BATCH*elembytes));
-  HIP_CHECK(hipMemset(B,0,(size_t)K*N*BATCH*elembytes));
-  HIP_CHECK(hipMemset(C,0,(size_t)M*N*BATCH*elembytes));
-
-  // Pointer arrays, as the batched interface wants them, on the device.
-  std::vector<void *> hA(BATCH),hB(BATCH),hC(BATCH);
-  for(int b=0;b<BATCH;b++){
-    hA[b] = (char *)A + (size_t)b*M*K*elembytes;
-    hB[b] = (char *)B + (size_t)b*K*N*elembytes;
-    hC[b] = (char *)C + (size_t)b*M*N*elembytes;
-  }
-  void **dA,**dB,**dC;
-  HIP_CHECK(hipMalloc(&dA,BATCH*sizeof(void*)));
-  HIP_CHECK(hipMalloc(&dB,BATCH*sizeof(void*)));
-  HIP_CHECK(hipMalloc(&dC,BATCH*sizeof(void*)));
-  HIP_CHECK(hipMemcpy(dA,&hA[0],BATCH*sizeof(void*),hipMemcpyHostToDevice));
-  HIP_CHECK(hipMemcpy(dB,&hB[0],BATCH*sizeof(void*),hipMemcpyHostToDevice));
-  HIP_CHECK(hipMemcpy(dC,&hC[0],BATCH*sizeof(void*),hipMemcpyHostToDevice));
-
-  // alpha = beta = 1: the stencil accumulates into C, so C is read as well
-  // as written and the traffic below counts it twice.
-  double alpha_d[2] = {1.0,0.0}, beta_d[2] = {1.0,0.0};
-  float  alpha_f[2] = {1.0f,0.0f}, beta_f[2] = {1.0f,0.0f};
-  const void *alpha = (type==rocblas_datatype_f64_c) ? (const void *)alpha_d : (const void *)alpha_f;
-  const void *beta  = (type==rocblas_datatype_f64_c) ? (const void *)beta_d  : (const void *)beta_f;
-
-  double flops = 8.0*M*N*K*BATCH;                                  // complex madd
-  double bytes = (double)elembytes*((double)M*K + (double)K*N + 2.0*(double)M*N)*BATCH;
-
-  auto run = [&](rocblas_gemm_algo algo,int solution)->double
-  {
-    rocblas_status st = rocblas_gemm_batched_ex(handle,
-			   rocblas_operation_none, rocblas_operation_none,
-			   M,N,K, alpha,
-			   (const void *)dA, type, M,
-			   (const void *)dB, type, K, beta,
-			   (const void *)dC, type, M,
-			   (void *)dC,       type, M,
-			   BATCH, type, algo, solution, 0);
-    if ( st != rocblas_status_success ) return -1.0;
-    HIP_CHECK(hipDeviceSynchronize());
-    double t0=usecond();
-    for(int i=0;i<ncall;i++){
-      rocblas_gemm_batched_ex(handle,
-			   rocblas_operation_none, rocblas_operation_none,
-			   M,N,K, alpha,
-			   (const void *)dA, type, M,
-			   (const void *)dB, type, K, beta,
-			   (const void *)dC, type, M,
-			   (void *)dC,       type, M,
-			   BATCH, type, algo, solution, 0);
-    }
-    HIP_CHECK(hipDeviceSynchronize());
-    return (usecond()-t0)/ncall;
-  };
-
-  printf("\n=== %s : M=%d N=%d K=%d batch=%d ===\n",name,M,N,K,BATCH);
-
-  double tdef = run(rocblas_gemm_algo_standard,0);
-  printf("  default heuristic          : %8.1f Gflop/s  %8.1f GB/s  (%.3f ms)\n",
-	 flops/tdef/1.0e3, bytes/tdef/1.0e3, tdef/1.0e3);
-
-  // The extended call only accepts indices the library has itself listed for
-  // this problem, so ask it for the list rather than guessing.  If this does
-  // not compile, check the argument order in rocblas.h: the enumeration call
-  // has moved an argument or two between releases.
-  rocblas_int nsol = 0;
-  rocblas_status qst = rocblas_gemm_batched_ex_get_solutions(handle,
-			   rocblas_operation_none, rocblas_operation_none,
-			   M,N,K, alpha,
-			   (const void *)dA, type, M,
-			   (const void *)dB, type, K, beta,
-			   (const void *)dC, type, M,
-			   (void *)dC,       type, M,
-			   BATCH, type, rocblas_gemm_flags_none,
-			   NULL, &nsol);
-  std::vector<rocblas_int> sols;
-  if ( qst == rocblas_status_success && nsol > 0 ) {
-    sols.resize(nsol);
-    rocblas_gemm_batched_ex_get_solutions(handle,
-			   rocblas_operation_none, rocblas_operation_none,
-			   M,N,K, alpha,
-			   (const void *)dA, type, M,
-			   (const void *)dB, type, K, beta,
-			   (const void *)dC, type, M,
-			   (void *)dC,       type, M,
-			   BATCH, type, rocblas_gemm_flags_none,
-			   &sols[0], &nsol);
-  } else {
-    // Older library: fall back to probing indices.
-    for(int s=1;s<=maxindex;s++) sols.push_back(s);
-  }
-
-  std::vector<Result> ok;
-  for(size_t i=0;i<sols.size();i++){
-    double t = run(rocblas_gemm_algo_solution_index,sols[i]);
-    if ( t < 0 ) continue;                      // library rejects it for this problem
-    ok.push_back({(int)sols[i],flops/t/1.0e3,bytes/t/1.0e3});
-  }
-  printf("  library lists %d solution(s) for this problem\n",(int)sols.size());
-  std::sort(ok.begin(),ok.end(),[](const Result &a,const Result &b){ return a.gflops>b.gflops; });
-
-  printf("  %d solutions accepted of %d tried\n",(int)ok.size(),maxindex);
-  for(int i=0;i<(int)ok.size() && i<8;i++){
-    printf("    solution %5d            : %8.1f Gflop/s  %8.1f GB/s\n",
-	   ok[i].index,ok[i].gflops,ok[i].gbs);
-  }
-  if ( ok.size() ) {
-    printf("  best/default               : %.2f\n", ok[0].gflops*tdef*1.0e3/flops);
-  }
-
-  HIP_CHECK(hipFree(dA)); HIP_CHECK(hipFree(dB)); HIP_CHECK(hipFree(dC));
-  HIP_CHECK(hipFree(A));  HIP_CHECK(hipFree(B));  HIP_CHECK(hipFree(C));
-}
-
-int main(int argc,char **argv)
-{
-  int nbasis = (argc>1) ? atoi(argv[1]) : 60;
-  int nrhs   = (argc>2) ? atoi(argv[2]) : 12;
-  int batch  = (argc>3) ? atoi(argv[3]) : 1024;
-  int maxidx = (argc>4) ? atoi(argv[4]) : 400;
-
-  rocblas_handle handle;
-  rocblas_create_handle(&handle);
-  rocblas_set_pointer_mode(handle,rocblas_pointer_mode_host);
-
-  printf("rocBLAS solution sweep: the coarse stencil GEMM shape\n");
-  printf("nbasis %d, Nrhs %d, batch %d, solution indices 1..%d\n",nbasis,nrhs,batch,maxidx);
-  printf("(batch is the LOCAL coarse volume; x9 is the grouped call)\n");
-
-  sweep(handle,rocblas_datatype_f32_c,"complex single",8, nbasis,nrhs,nbasis,batch,maxidx,20);
-  sweep(handle,rocblas_datatype_f64_c,"complex double",16,nbasis,nrhs,nbasis,batch,maxidx,20);
-
-  rocblas_destroy_handle(handle);
-  return 0;
-}
@@ -1,2 +0,0 @@
-
-mpicxx -qmkl=parallel -fsycl BatchBlasBench.cc -o BatchBlasBench -DGRID_SYCL
@@ -1,5 +0,0 @@
-CXX=hipcc
-MPICXX=mpicxx 
-CXXFLAGS="-fPIC -I{$ROCM_PATH}/include/ -I${MPICH_DIR}/include -L/lib64 -I/opt/cray/pe/mpich/8.1.28/ofi/gnu/12.3/include -DGRID_HIP"
-LDFLAGS="-L/lib64 -L${MPICH_DIR}/lib -lmpi -L${CRAY_MPICH_ROOTDIR}/gtl/lib -lmpi_gtl_hsa -lamdhip64 -lhipblas -lrocblas -lmpi_gnu_123"
-hipcc $CXXFLAGS $LDFLAGS BatchBlasBench.cc -o BatchBlasBench
@@ -1,2 +0,0 @@
-
-mpicxx -qmkl=parallel -fsycl BatchBlasBench.cc -o BatchBlasBench -DGRID_SYCL
@@ -1,185 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## What This Is
-
-Grid is a data-parallel C++ library for lattice QCD. It provides SIMD-vectorised lattice containers, MPI-based domain decomposition, GPU acceleration (CUDA/HIP/SYCL), and a full suite of QCD algorithms including HMC.
-
-## Build
-
-Uses GNU Autotools. The bootstrap step only needs to run once (or after `configure.ac` changes).
-
-```bash
-./bootstrap.sh                    # downloads Eigen 3.4.0, generates configure
-mkdir build && cd build
-../configure [options]
-make -j$(nproc)
-make check                        # run root-level tests
-make install
-```
-
-Key configure options:
-
-| Option | Common values |
-|--------|---------------|
-| `--enable-simd=` | `AVX2`, `AVX512`, `KNL`, `A64FX`, `NEONv8`, `GPU` |
-| `--enable-comms=` | `mpi-auto`, `mpi3-auto`, `none` |
-| `--enable-accelerator=` | `cuda`, `hip`, `sycl` |
-| `--enable-shm=` | `shmopen`, `hugetlbfs`, `nvlink` |
-| `--enable-Nc=` | `3` (default), `2`, `4`, `5` |
-| `--with-gmp=`, `--with-mpfr=`, `--with-fftw=`, `--with-lime=` | paths to libs |
-| `--enable-hdf5`, `--enable-mkl`, `--enable-lapack` | optional features |
-
-GPU builds additionally need `--enable-gen-simd-width=64` (sets 512-bit SIMD width for GPU warp/wavefront sizing) and `--enable-unified=no --enable-shm=nvlink` for multi-GPU runs.
-
-To speed up compilation, `--disable-fermion-reps --disable-gparity` skips instantiating G-parity and higher-representation fermion operators.
-
-Platform recipes from `README.md`:
- **KNL**: `--enable-simd=KNL --enable-comms=mpi3-auto --enable-mkl`
- **Skylake/Haswell**: `--enable-simd=AVX512` or `AVX2` + `--enable-comms=mpi3-auto`
- **AMD EPYC**: `--enable-simd=AVX2 --enable-comms=mpi3`
- **A64FX (Fugaku)**: `--enable-simd=A64FX --enable-comms=mpi3 --enable-shm=shmget` (see `SVE_README.txt`)
-
-Complete, working `configure` invocations for specific HPC systems (Frontier/ROCm, Perlmutter/CUDA, Summit, SDCC-A100, etc.) live in `systems/<platform>/config-command`. These are the canonical references for production builds.
-
-Required external libs: GMP, MPFR, OpenSSL, zlib.
-
-### Use `systems/` for real machines
-
-`systems/<machine>/` holds the known-good build for each production platform (`Frontier`, `Aurora`, `Perlmutter`, `Summit`, `Tursa`, `Lumi`, `Booster`, `Crusher`, `SDCC-*`, `mac-arm`, …). Each contains a `config-command` (the exact `../../configure` invocation) and a `sourceme.sh` (module loads and env). **Prefer copying/adapting these over hand-rolling configure flags** — they encode compiler workarounds, `LDFLAGS`, and shared-memory settings that are easy to get wrong. `systems/WorkArounds.txt` records known vendor bugs.
-
-Note the GPU builds use `--enable-simd=GPU --enable-gen-simd-width=64`, so `Nsimd` is *not* 1 on device (it is `64/sizeof(scalar)`).
-
-### Regenerating `Make.inc` — required after adding or deleting source files
-
-`Make.inc` files are generated, not tracked in git (`.gitignore`d). `scripts/filelist` walks `Grid/`, `tests/*`, `benchmarks/`, `examples/`, and `HMC/` and writes the file lists and per-test `bin_PROGRAMS` rules. Every new `.cc`/`.h` in `Grid/`, and every new `Test_*.cc` / `Benchmark_*.cc` / `Example_*.cc`, is invisible to the build until you run:
-
-```bash
-./scripts/filelist    # from the source root, then re-run configure/make
-```
-
-`bootstrap.sh` runs it for you on the first setup.
-
-## Running Tests and Benchmarks
-
-```bash
-# From build directory
-make check                          # root-level tests (Test_simd, Test_cshift, etc.)
-make -C tests/<subdir> tests        # build tests in a subdirectory
-make tests                          # build all tests across all subdirectories
-./tests/core/Test_simd              # run a single test binary directly
-mpirun -n 4 ./tests/core/Test_cshift --grid 16.16.16.16 --mpi 1.1.1.4
-```
-
-`make check` is a thin smoke test — building a subdirectory with `make -C tests/<subdir> tests` and running the relevant binaries directly is the normal development loop. Test binaries take Grid's standard command-line arguments (`--grid`, `--mpi`, `--accelerator-threads`, `--threads`, `--debug-signals`, `--log`); see `Grid/util/Init.cc`.
-
-Test subdirectories and their focus: `core` (SIMD, stencil, comms), `solver` (CG, GMRES, eigensolvers), `hmc` (MD integrators), `forces` (fermion forces), `lanczos`, `IO`, `smearing`, `sp2n`, `debug`.
-
-Tests and benchmarks that need optional fermion representations are guarded by `disable_tests_without_instantiations.h` / `disable_benchmarks_without_instantiations.h`, so a `--disable-fermion-reps --disable-gparity` build silently compiles them to no-ops.
-
-## Architecture
-
-### Layer stack (bottom to top)
-
-1. **SIMD layer** (`Grid/simd/`) — platform-specific intrinsics wrapped into `vRealF`, `vComplexD`, etc. The SIMD width and layout are compile-time constants controlled by `--enable-simd`.
-
-2. **Tensor layer** (`Grid/tensors/`) — Lorentz/colour/spin tensor algebra built on top of SIMD types. `iMatrix`, `iVector`, `iScalar` templates compose into QCD types like `ColourMatrix`, `SpinColourVector`.
-
-3. **Lattice layer** (`Grid/lattice/`) — `Lattice<T>` container: a site-local tensor replicated across a distributed Cartesian grid. All arithmetic is site-parallel and expression-template-fused.
-
-4. **Cartesian/comms layer** (`Grid/cartesian/`, `Grid/communicator/`) — `GridCartesian` holds the MPI topology and local/global geometry. `Grid/cshift/` implements nearest-neighbour halo exchange; `Grid/stencil/` is the optimised multi-hop stencil used by Dirac operators.
-
-5. **Algorithm layer** (`Grid/algorithms/`) — iterative solvers (CG, GMRES, BiCGSTAB, mixed-precision), eigensolvers (Lanczos, LAPACK), FFT, smearing, and multigrid.
-
-6. **QCD layer** (`Grid/qcd/`) — gauge and fermion actions, HMC integrators, observables.
-
-### QCD subsystem (`Grid/qcd/`)
-
- `action/fermion/` — Wilson, Clover, DWF (Mobius), Staggered, twisted-mass, G-parity variants
- `action/gauge/` — Wilson gauge, Symanzik, Iwasaki, DBW2, plaquette+rect
- `representations/` — Fundamental, Adjoint, Two-index, Sp(2n)
- `hmc/` — Leapfrog, OMF2/OMF4 integrators; pseudofermion refreshment; Metropolis accept/reject
- `smearing/` — APE, Stout, HEX, gradient flow
- `observables/` — Polyakov loop, plaquette, topological charge
-
-### GPU acceleration and the view/memory-manager discipline
-### Multigrid (`Grid/algorithms/multigrid/`)
-
-Aggregation-based algebraic multigrid for Wilson-type fermions. Key files: `GeneralCoarsenedMatrixMultiRHSV2.h` (the multi-RHS coarse operator, "V2": coarsening by Fourier probing, batched-GEMM apply on a D+1 grid with rhs innermost and unvectorised), `MultiRHSBlockProject.h` (in `deflation/`; the batched-GEMM transfer operators), `PVdagMMultiGrid.h` (three-level non-Hermitian PVdagM chain with dense bottom) and `HDCGMultiGrid.h` (two-level Hermitian HDCG chain) with their `*Params.h` (XML-serialisable parameters), `MrhsMultiGrid.h` (mrhs V-cycle, preconditioner interface, fp64/fp32 seam), `Smoothers.h`, `MultiGridIO.h`, `Aggregates.h` (near-null vector construction), `Geometry.h` (coarse stencils: max-norm-1 boxes of Manhattan radius 1, 2 or 4), `CoarsenedMatrix.h` (the original nearest-neighbour Wilson multigrid). `deprecated/` holds the V1 coarse operators and the Aggregation-based single-RHS ADEF-2, kept only for the pre-2026 drivers. `MultiGrid.h` is the top-level include.
-
-### GPU acceleration
-
-GPU support is injected via macros in `Grid/threads/Accelerator.h` — `accelerator_for(i, n, nsimd, {...})`, `accelerator_forNB` (non-blocking, must be followed by `accelerator_barrier()`), `accelerator_for2dNB`, and `accelerator_inline`. On a CPU build these degrade to `thread_for` (OpenMP). Unified virtual memory is on by default (`--enable-unified=yes`); device-aware MPI (`--enable-accelerator-aware-mpi`) avoids device→host copies on transfers.
-
-Lattice data is **not** directly addressable inside a kernel. You must open a view with the correct access mode so `Grid/allocator/MemoryManager.h` can move/mark the data:
-
-```cpp
-autoView(out_v, out, AcceleratorWriteDiscard);   // RAII; closes at end of scope
-autoView(in_v,  in,  AcceleratorRead);
-accelerator_for(ss, grid->oSites(), Nsimd, {
-    coalescedWrite(out_v[ss], coalescedRead(in_v[ss]));
-});
-```
-
-Modes are `AcceleratorRead/Write/WriteDiscard` and `CpuRead/Write/WriteDiscard`. Getting the mode wrong (e.g. `AcceleratorRead` on a field you write) produces stale-data bugs that only appear on GPU builds. Inside kernels use `coalescedRead`/`coalescedWrite` rather than raw `operator[]` — they map the SIMD lane onto `threadIdx.x` so accesses stay coalesced.
-
-### Repo-local debugging skills (`skills/`)
-
-`skills/` contains hard-won, Grid-specific playbooks written as invocable skill files. Consult them before debugging in these areas rather than reasoning from first principles:
-
-| File | Covers |
-|---|---|
-| `gpu-memory-performance.md` | `acceleratorThreads()`, LambdaApply thread mapping, `coalescedRead` idiom, fused vs staged HBM access |
-| `gpu-runtime-correctness.md` | GPU runtime returning early from sync, silent wrong answers |
-| `communication-overlap.md` | 7-phase halo pipeline, per-packet events, host-staging vs GPU-direct RDMA |
-| `mpi-heterogeneous.md` | `MPI_Sendrecv` device-buffer aliasing, deterministic reductions |
-| `compiler-validation.md` | Isolating GPU compiler codegen bugs, minimal reproducers |
-| `correctness-verification.md` | Double-run fingerprinting, per-packet checksums, flight recorder |
-| `hang-diagnosis.md` | Diagnosing MPI/accelerator hangs |
-
-The key loop macros (defined in `Grid/threads/Accelerator.h`) are:
- `accelerator_for(iter, num, nsimd, {...})` — maps to CUDA/HIP kernel or OpenMP loop; `nsimd` is the innermost SIMD lane count
- `accelerator_forNB(...)` — non-blocking variant (no implicit barrier)
- `accelerator_for2dNB(iter1, num1, iter2, num2, nsimd, {...})` — 2D kernel launch
- `thread_for(iter, num, {...})` — CPU OpenMP loop (never dispatches to GPU)
-
-On CPU builds, `accelerator_for` aliases to `thread_for`.
-
-### Solver patterns
-
-`SchurRedBlack` (`Grid/algorithms/iterative/SchurRedBlack.h`) implements red-black (even/odd) preconditioning for fermion operators. Most production fermion solves use `SchurRedBlackDiagMooeeSolve` or similar wrappers that internally call a `ConjugateGradient` on the Schur complement.
-
-Mixed-precision solvers (`ConjugateGradientMixedPrec`, `BiCGSTABMixedPrec`) drive a double-precision outer loop with single-precision inner solves.
-
-### Memory and I/O
-
- `Grid/allocator/` — aligned/NUMA-aware allocators; caching allocator via `--enable-alloc-cache`
- `Grid/parallelIO/` — distributed parallel reader/writer for ILDG (via LIME), SciDAC, and native binary formats
- `Grid/serialisation/` — text, binary, HDF5, XML/JSON serialisation of arbitrary Grid objects
-
-### Executables
-
- `HMC/` — production HMC driver programmes (e.g. `Mobius2p1f.cc`, `DWF_plus_DSDR_nf2plus1_Shamir_Gparity.cc`)
- `benchmarks/` — `Benchmark_dwf`, `Benchmark_ITT`, `Benchmark_comms`, `Benchmark_memory_bandwidth`, … used to qualify a new machine
- `examples/` — small, readable programmes (`Example_plaquette.cc`, `Example_Mobius_spectrum.cc`) that are the best starting point for learning the API
-
-Each of these directories auto-builds every top-level `.cc` as its own binary via `scripts/filelist`.
-
-Every programme is wrapped in `Grid_init(&argc, &argv)` / `Grid_finalize()` (`Grid/util/Init.h`).
-
-## Key Conventions
-
- **C++17** is required throughout.
- Template structure: most classes are templated on `<_FImpl>` (fermion impl) or `<Gimpl>` (gauge impl), which encode the representation and precision. Instantiation is controlled by `--enable-fermion-instantiations`.
- **Tensor indices are positional, not labelled.** The `Grid/tensors/` arithmetic recurses structurally over the `iScalar`/`iVector`/`iMatrix` nest: each level defines only the {scalar,vector,matrix}² products at its own level, with element types resolved by automatic type deduction, so every colour/spin/lorentz combination composes from ~200 lines (versus the pre-C++11 QDP++/PETE approach of machine-generating every case). An index's meaning derives entirely from its nesting depth counted from the outside; `iScalar` is the identity/broadcast case at every level. Never insert or remove a nesting level casually — the multiplication tables contract by position.
- **Multigrid coarsening deepens the tensor nest by one level.** A coarse site vector is `iVector<CComplex,nbasis>`, and `innerProduct` on it returns `iScalar<CComplex>` — one level deeper than the fine block scalar. So the block-inner-product scalar type gains one `iScalar` wrapper per MG level (fine: `vTComplex`; level 2: `iScalar<vTComplex>`; see `examples/Example_pvdagm_3level.cc`). When calling `blockInnerProduct`/`blockZAXPY`/`blockOrthogonalise` on coarse fields, the coarse scalar type must match `decltype(innerProduct(siteVector(),siteVector()))` exactly; a wrong depth fails to compile (no viable `operator=` deep in the instantiation chain) rather than mis-contracting.
- **Grids are borrowed, never owned.** `conformable` is pointer identity, so every object that interoperates must hold the *same* `GridCartesian *`; a class that minted its own grid internally could never conform with anything else. Ownership is therefore not available, and lifetime is managed by scope discipline instead of reference counting: whoever creates a grid retains it beyond every object it handed a reference to. Anything *derived* from a grid inherits this — `~PaddedCell` dereferences its `unpadded_grid`, so a `PaddedCell` cannot even be **destroyed** after its parent grid, only used. Where a consumer must let go early, it offers an explicit hand-back (`MultiGeneralCoarsenedOperatorV2::ReleaseGrid()`) to be called *before* the grid is destroyed.
-
- The `RealD`/`RealF`/`ComplexD`/`ComplexF` typedefs are used everywhere; avoid raw `double`/`float`.
- Use `GRID_ASSERT(cond)` (defined in `Grid/GridStd.h`), not bare `assert` — it prints a Grid-formatted message and aborts cleanly under MPI.
- Logging is stream-based, not macro-based: `std::cout << GridLogMessage << ... << std::endl;`. Channels declared in `Grid/log/Log.h` include `GridLogError`, `GridLogWarning`, `GridLogDebug`, `GridLogPerformance`, `GridLogIterative`, `GridLogSolver`, `GridLogHMC`, `GridLogComms`, `GridLogMemory`, `GridLogDslash`, `GridLogIRL`, `GridLogMG`. A subset is switched on at runtime with e.g. `--log Error,Warning,Message,Performance,Iterative,Integrator,Debug,Colours` (names given without the `GridLog` prefix).
- Performance-critical paths use `GRID_TRACE(name)` from `Grid/perfmon/Tracing.h` (compiled out unless `--enable-tracing` selects a backend) and the `GridStopWatch` timers in `Grid/perfmon/Timer.h`.
- Reductions across MPI ranks go through `GridBase::GlobalSum` / `GlobalMax`; never reduce with bare MPI calls inside library code.
- Everything lives in `NAMESPACE_BEGIN(Grid)` / `NAMESPACE_END(Grid)` macros; follow the surrounding file rather than writing `namespace Grid { }`.
- British spelling is used in identifiers and comments (`colour`, `neighbour`, `serialisation`).
@@ -34,6 +34,9 @@ directory

 #if defined __GNUC__ && __GNUC__>=6
 #pragma GCC diagnostic ignored "-Wignored-attributes"
+#endif
+#if defined __GNUC__ && __GNUC__>=6
+#pragma GCC diagnostic ignored "-Wpsabi"
 #endif

 //disables and intel compiler specific warning (in json.hpp)
@@ -44,24 +47,14 @@ directory
 #ifdef __NVCC__
 //disables nvcc specific warning in json.hpp
 #pragma clang diagnostic ignored "-Wdeprecated-register"
-
-#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
- //disables nvcc specific warning in json.hpp
-#pragma nv_diag_suppress unsigned_compare_with_zero
-#pragma nv_diag_suppress cast_to_qualified_type
- //disables nvcc specific warning in many files
-#pragma nv_diag_suppress esa_on_defaulted_function_ignored
-#pragma nv_diag_suppress declared_but_not_referenced
-#pragma nv_diag_suppress extra_semicolon
-#else
- //disables nvcc specific warning in json.hpp
 #pragma diag_suppress unsigned_compare_with_zero
 #pragma diag_suppress cast_to_qualified_type
-#pragma diag_suppress declared_but_not_referenced
+
 //disables nvcc specific warning in many files
 #pragma diag_suppress esa_on_defaulted_function_ignored
 #pragma diag_suppress extra_semicolon
-#endif
+
+//Eigen only
 #endif

 // Disable vectorisation in Eigen on the Power8/9 and PowerPC
@@ -44,23 +44,20 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #include <Grid/GridStd.h>
 #include <Grid/threads/Pragmas.h>
 #include <Grid/perfmon/Timer.h>
-//#include <Grid/perfmon/PerfCount.h>
+#include <Grid/perfmon/PerfCount.h>
 #include <Grid/util/Util.h>
 #include <Grid/log/Log.h>
-#include <Grid/perfmon/Tracing.h>
 #include <Grid/allocator/Allocator.h>
 #include <Grid/simd/Simd.h>
 #include <Grid/threads/ThreadReduction.h>
 #include <Grid/serialisation/Serialisation.h>
 #include <Grid/util/Sha.h>
 #include <Grid/communicator/Communicator.h> 
-#include <Grid/communicator/RingAllReduce.h>
-#include <Grid/cartesian/Cartesian.h>
+#include <Grid/cartesian/Cartesian.h>    
 #include <Grid/tensors/Tensors.h>      
 #include <Grid/lattice/Lattice.h>      
 #include <Grid/cshift/Cshift.h>       
 #include <Grid/stencil/Stencil.h>      
-#include <Grid/stencil/GeneralLocalStencil.h>      
 #include <Grid/parallelIO/BinaryIO.h>
 #include <Grid/algorithms/Algorithms.h>   
 NAMESPACE_CHECK(GridCore)
@@ -1,17 +1,9 @@
 #ifndef GRID_STD_H
 #define GRID_STD_H

-///////////////////
-// Grid config
-///////////////////
-#include "Config.h"
-
 ///////////////////
 // Std C++ dependencies
 ///////////////////
-#define _NBACKTRACE (256)
-extern void * Grid_backtrace_buffer[_NBACKTRACE];
-
 #include <cassert>
 #include <complex>
 #include <memory>
@@ -23,46 +15,18 @@ extern void * Grid_backtrace_buffer[_NBACKTRACE];
 #include <random>
 #include <functional>
 #include <stdio.h>
-#include <string.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <strings.h>
 #include <stdio.h>
 #include <signal.h>
 #include <ctime>
 #include <sys/time.h>
 #include <chrono>
 #include <zlib.h>
-#ifdef HAVE_EXECINFO_H
-#include <execinfo.h>
-#endif
-
-void GridAbort(void);
-
-#define ASSLOG(A) ::write(STDERR_FILENO,A,::strlen(A));
-#ifdef HAVE_EXECINFO_H
-#define GRID_ASSERT(b) if(!(b)) {					\
-    fflush(stdout); \
-    ASSLOG(" GRID_ASSERT failure: ");					\
-    ASSLOG(__FILE__);							\
-    ASSLOG(" : ");							\
-    ASSLOG(#b);								\
-    ASSLOG(" : ");							\
-    int symbols = backtrace(Grid_backtrace_buffer,_NBACKTRACE);		\
-    backtrace_symbols_fd(Grid_backtrace_buffer,symbols,STDERR_FILENO);	\
-    GridAbort();							\
-  };
-#else
-#define GRID_ASSERT(b) if(!(b)) {					\
-    ASSLOG(" GRID_ASSERT failure: ");					\
-    ASSLOG(__FILE__);							\
-    ASSLOG(" : ");							\
-    ASSLOG(#b);								\
-    ASSLOG(" : ");							\
-    GridAbort();							\
-  };
-#endif

+///////////////////
+// Grid config
+///////////////////
+#include "Config.h"

 #ifdef TOFU
 #undef GRID_COMMS_THREADS
@@ -14,11 +14,7 @@
 /* NVCC save and restore compile environment*/
 #ifdef __NVCC__
 #pragma push
-#ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
-#pragma nv_diag_suppress code_is_unreachable
-#else
 #pragma diag_suppress code_is_unreachable
-#endif
 #pragma push_macro("__CUDA_ARCH__")
 #pragma push_macro("__NVCC__")
 #pragma push_macro("__CUDACC__")
@@ -34,7 +30,7 @@
 #pragma push_macro("__SYCL_DEVICE_ONLY__")
 #undef __SYCL_DEVICE_ONLY__
 #define EIGEN_DONT_VECTORIZE
-#undef EIGEN_USE_SYCL
+//#undef EIGEN_USE_SYCL
 #define __SYCL__REDEFINE__
 #endif

@@ -54,25 +54,17 @@ Version.h: version-cache
 include Make.inc
 include Eigen.inc

-if BUILD_FERMION_INSTANTIATIONS
-  extra_sources+=$(WILS_FERMION_FILES)
-  extra_sources+=$(STAG_FERMION_FILES)
+extra_sources+=$(WILS_FERMION_FILES)
+extra_sources+=$(STAG_FERMION_FILES)
 if BUILD_ZMOBIUS
-    extra_sources+=$(ZWILS_FERMION_FILES)
+  extra_sources+=$(ZWILS_FERMION_FILES)
 endif
 if BUILD_GPARITY
-    extra_sources+=$(GP_FERMION_FILES)
+  extra_sources+=$(GP_FERMION_FILES)
 endif
 if BUILD_FERMION_REPS
-    extra_sources+=$(ADJ_FERMION_FILES)
-    extra_sources+=$(TWOIND_FERMION_FILES)
-endif
-if BUILD_SP
-    extra_sources+=$(SP_FERMION_FILES)
-if BUILD_FERMION_REPS
-      extra_sources+=$(SP_TWOIND_FERMION_FILES)
-endif
-endif
+  extra_sources+=$(ADJ_FERMION_FILES)
+  extra_sources+=$(TWOIND_FERMION_FILES)
 endif

 lib_LIBRARIES = libGrid.a
@@ -29,7 +29,6 @@ directory
 #pragma once

 #include <type_traits>
-#include <exception>
 #include <cassert>

 #define NAMESPACE_BEGIN(A) namespace A {
@@ -37,7 +36,3 @@ directory
 #define GRID_NAMESPACE_BEGIN NAMESPACE_BEGIN(Grid)
 #define GRID_NAMESPACE_END   NAMESPACE_END(Grid)
 #define NAMESPACE_CHECK(x) struct namespaceTEST##x {};  static_assert(std::is_same<namespaceTEST##x, ::namespaceTEST##x>::value,"Not in :: at"  ); 
-
-#define EXCEPTION_CHECK_BEGIN(A) try {
-#define EXCEPTION_CHECK_END(A)   } catch ( std::exception e ) { BACKTRACEFP(stderr); std::cerr << __PRETTY_FUNCTION__ << " : " <<__LINE__<< " Caught exception "<<e.what()<<std::endl; throw; }
-
@@ -29,9 +29,6 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #ifndef GRID_ALGORITHMS_H
 #define GRID_ALGORITHMS_H

-NAMESPACE_CHECK(blas);
-#include <Grid/algorithms/blas/BatchedBlas.h>
-
 NAMESPACE_CHECK(algorithms);
 #include <Grid/algorithms/SparseMatrix.h>
 #include <Grid/algorithms/LinearOperator.h>
@@ -47,13 +44,7 @@ NAMESPACE_CHECK(SparseMatrix);
 #include <Grid/algorithms/approx/RemezGeneral.h>
 #include <Grid/algorithms/approx/ZMobius.h>
 NAMESPACE_CHECK(approx);
-#include <Grid/algorithms/deflation/Deflation.h>
-#include <Grid/algorithms/deflation/MultiRHSBlockProject.h>
-#include <Grid/algorithms/deflation/MultiRHSDeflation.h>
-#include <Grid/algorithms/deflation/MultiRHSBlockCGLinalg.h>
-// Not really deflation, but useful
-#include <Grid/algorithms/blas/MomentumProject.h>
-NAMESPACE_CHECK(deflation);
+#include <Grid/algorithms/iterative/Deflation.h>
 #include <Grid/algorithms/iterative/ConjugateGradient.h>
 NAMESPACE_CHECK(ConjGrad);
 #include <Grid/algorithms/iterative/BiCGSTAB.h>
@@ -64,7 +55,6 @@ NAMESPACE_CHECK(BiCGSTAB);
 #include <Grid/algorithms/iterative/ConjugateGradientMultiShift.h>
 #include <Grid/algorithms/iterative/ConjugateGradientMixedPrec.h>
 #include <Grid/algorithms/iterative/ConjugateGradientMultiShiftMixedPrec.h>
-#include <Grid/algorithms/iterative/ConjugateGradientMixedPrecBatched.h>
 #include <Grid/algorithms/iterative/BiCGSTABMixedPrec.h>
 #include <Grid/algorithms/iterative/BlockConjugateGradient.h>
 #include <Grid/algorithms/iterative/ConjugateGradientReliableUpdate.h>
@@ -76,11 +66,10 @@ NAMESPACE_CHECK(BiCGSTAB);
 #include <Grid/algorithms/iterative/MixedPrecisionFlexibleGeneralisedMinimalResidual.h>
 #include <Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h>
 #include <Grid/algorithms/iterative/PowerMethod.h>
-#include <Grid/algorithms/iterative/AdefGeneric.h>
-#include <Grid/algorithms/iterative/AdefMrhs.h>
+
 NAMESPACE_CHECK(PowerMethod);
-#include <Grid/algorithms/multigrid/MultiGrid.h>
-NAMESPACE_CHECK(multigrid);
+#include <Grid/algorithms/CoarsenedMatrix.h>
+NAMESPACE_CHECK(CoarsendMatrix);
 #include <Grid/algorithms/FFT.h>

 #endif
@@ -56,6 +56,243 @@ inline void blockMaskedInnerProduct(Lattice<CComplex> &CoarseInner,
  blockSum(CoarseInner,fine_inner_msk);
 }

+
+class Geometry {
+public:
+  int npoint;
+  int base;
+  std::vector<int> directions   ;
+  std::vector<int> displacements;
+  std::vector<int> points_dagger;
+
+  Geometry(int _d)  {
+    
+    base = (_d==5) ? 1:0;
+
+    // make coarse grid stencil for 4d , not 5d
+    if ( _d==5 ) _d=4;
+
+    npoint = 2*_d+1;
+    directions.resize(npoint);
+    displacements.resize(npoint);
+    points_dagger.resize(npoint);
+    for(int d=0;d<_d;d++){
+      directions[d   ] = d+base;
+      directions[d+_d] = d+base;
+      displacements[d  ] = +1;
+      displacements[d+_d]= -1;
+      points_dagger[d   ] = d+_d;
+      points_dagger[d+_d] = d;
+    }
+    directions   [2*_d]=0;
+    displacements[2*_d]=0;
+    points_dagger[2*_d]=2*_d;
+  }
+
+  int point(int dir, int disp) {
+    assert(disp == -1 || disp == 0 || disp == 1);
+    assert(base+0 <= dir && dir < base+4);
+
+    // directions faster index = new indexing
+    // 4d (base = 0):
+    // point 0  1  2  3  4  5  6  7  8
+    // dir   0  1  2  3  0  1  2  3  0
+    // disp +1 +1 +1 +1 -1 -1 -1 -1  0
+    // 5d (base = 1):
+    // point 0  1  2  3  4  5  6  7  8
+    // dir   1  2  3  4  1  2  3  4  0
+    // disp +1 +1 +1 +1 -1 -1 -1 -1  0
+
+    // displacements faster index = old indexing
+    // 4d (base = 0):
+    // point 0  1  2  3  4  5  6  7  8
+    // dir   0  0  1  1  2  2  3  3  0
+    // disp +1 -1 +1 -1 +1 -1 +1 -1  0
+    // 5d (base = 1):
+    // point 0  1  2  3  4  5  6  7  8
+    // dir   1  1  2  2  3  3  4  4  0
+    // disp +1 -1 +1 -1 +1 -1 +1 -1  0
+
+    if(dir == 0 and disp == 0)
+      return 8;
+    else // New indexing
+      return (1 - disp) / 2 * 4 + dir - base;
+    // else // Old indexing
+    //   return (4 * (dir - base) + 1 - disp) / 2;
+  }
+};
+  
+template<class Fobj,class CComplex,int nbasis>
+class Aggregation   {
+public:
+  typedef iVector<CComplex,nbasis >             siteVector;
+  typedef Lattice<siteVector>                 CoarseVector;
+  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
+
+  typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
+  typedef Lattice<Fobj >        FineField;
+
+  GridBase *CoarseGrid;
+  GridBase *FineGrid;
+  std::vector<Lattice<Fobj> > subspace;
+  int checkerboard;
+  int Checkerboard(void){return checkerboard;}
+  Aggregation(GridBase *_CoarseGrid,GridBase *_FineGrid,int _checkerboard) : 
+    CoarseGrid(_CoarseGrid),
+    FineGrid(_FineGrid),
+    subspace(nbasis,_FineGrid),
+    checkerboard(_checkerboard)
+  {
+  };
+  
+  void Orthogonalise(void){
+    CoarseScalar InnerProd(CoarseGrid); 
+    std::cout << GridLogMessage <<" Block Gramm-Schmidt pass 1"<<std::endl;
+    blockOrthogonalise(InnerProd,subspace);
+  } 
+  void ProjectToSubspace(CoarseVector &CoarseVec,const FineField &FineVec){
+    blockProject(CoarseVec,FineVec,subspace);
+  }
+  void PromoteFromSubspace(const CoarseVector &CoarseVec,FineField &FineVec){
+    FineVec.Checkerboard() = subspace[0].Checkerboard();
+    blockPromote(CoarseVec,FineVec,subspace);
+  }
+
+  virtual void CreateSubspace(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,int nn=nbasis) {
+
+    RealD scale;
+
+    ConjugateGradient<FineField> CG(1.0e-2,100,false);
+    FineField noise(FineGrid);
+    FineField Mn(FineGrid);
+
+    for(int b=0;b<nn;b++){
+      
+      subspace[b] = Zero();
+      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;
+
+      for(int i=0;i<1;i++){
+
+	CG(hermop,noise,subspace[b]);
+
+	noise = subspace[b];
+	scale = std::pow(norm2(noise),-0.5); 
+	noise=noise*scale;
+
+      }
+
+      hermop.Op(noise,Mn); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|MdagM|f> "<<norm2(Mn)<<std::endl;
+      subspace[b]   = noise;
+
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////////////////////
+  // World of possibilities here. But have tried quite a lot of experiments (250+ jobs run on Summit)
+  // and this is the best I found
+  ////////////////////////////////////////////////////////////////////////////////////////////////
+
+  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);
+
+    // 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);
+
+	autoView( y_v , y, AcceleratorWrite);
+	autoView( Tn_v , (*Tn), AcceleratorWrite);
+	autoView( Tnp_v , (*Tnp), AcceleratorWrite);
+	autoView( Tnm_v , (*Tnm), AcceleratorWrite);
+	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);
+  }
+
+};
+
 // Fine Object == (per site) type of fine field
 // nbasis      == number of deflation vectors
 template<class Fobj,class CComplex,int nbasis>
@@ -87,9 +324,9 @@ public:
  GridBase*        _cbgrid;
  int hermitian;

-  CartesianStencil<siteVector,siteVector,DefaultImplParams> Stencil; 
-  CartesianStencil<siteVector,siteVector,DefaultImplParams> StencilEven;
-  CartesianStencil<siteVector,siteVector,DefaultImplParams> StencilOdd;
+  CartesianStencil<siteVector,siteVector,int> Stencil; 
+  CartesianStencil<siteVector,siteVector,int> StencilEven;
+  CartesianStencil<siteVector,siteVector,int> StencilOdd;

  std::vector<CoarseMatrix> A;
  std::vector<CoarseMatrix> Aeven;
@@ -99,7 +336,7 @@ public:
  CoarseMatrix AselfInvEven;
  CoarseMatrix AselfInvOdd;

-  deviceVector<RealD> dag_factor;
+  Vector<RealD> dag_factor;

  ///////////////////////
  // Interface
@@ -121,16 +358,12 @@ public:
    autoView( in_v , in, AcceleratorRead);
    autoView( out_v , out, AcceleratorWrite);
    autoView( Stencil_v  , Stencil, AcceleratorRead);
-    int npoint = geom.npoint;
+    auto& geom_v = geom;
    typedef LatticeView<Cobj> Aview;
      
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
+    Vector<Aview> AcceleratorViewContainer;
  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
    Aview *Aview_p = & AcceleratorViewContainer[0];

    const int Nsimd = CComplex::Nsimd();
@@ -147,7 +380,7 @@ public:
      int ptype;
      StencilEntry *SE;

-      for(int point=0;point<npoint;point++){
+      for(int point=0;point<geom_v.npoint;point++){

 	SE=Stencil_v.GetEntry(ptype,point,ss);
 	  
@@ -165,7 +398,7 @@ public:
      coalescedWrite(out_v[ss](b),res);
      });

-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
  };

  void Mdag (const CoarseVector &in, CoarseVector &out)
@@ -191,17 +424,12 @@ public:
    autoView( in_v , in, AcceleratorRead);
    autoView( out_v , out, AcceleratorWrite);
    autoView( Stencil_v  , Stencil, AcceleratorRead);
-    int npoint = geom.npoint;
+    auto& geom_v = geom;
    typedef LatticeView<Cobj> Aview;

+    Vector<Aview> AcceleratorViewContainer;

-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
    Aview *Aview_p = & AcceleratorViewContainer[0];

    const int Nsimd = CComplex::Nsimd();
@@ -210,10 +438,10 @@ public:

    int osites=Grid()->oSites();

-    deviceVector<int> points(geom.npoint);
-    for(int p=0; p<geom.npoint; p++) { 
-      acceleratorPut(points[p],geom.points_dagger[p]);
-    }
+    Vector<int> points(geom.npoint, 0);
+    for(int p=0; p<geom.npoint; p++)
+      points[p] = geom.points_dagger[p];
+
    auto points_p = &points[0];

    RealD* dag_factor_p = &dag_factor[0];
@@ -226,7 +454,7 @@ public:
      int ptype;
      StencilEntry *SE;

-      for(int p=0;p<npoint;p++){
+      for(int p=0;p<geom_v.npoint;p++){
        int point = points_p[p];

 	SE=Stencil_v.GetEntry(ptype,point,ss);
@@ -245,7 +473,7 @@ public:
      coalescedWrite(out_v[ss](b),res);
      });

-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
  }

  void MdirComms(const CoarseVector &in)
@@ -260,14 +488,8 @@ public:
    out.Checkerboard() = in.Checkerboard();

    typedef LatticeView<Cobj> Aview;
-
-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = A[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
+    Vector<Aview> AcceleratorViewContainer;
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer.push_back(A[p].View(AcceleratorRead));
    Aview *Aview_p = & AcceleratorViewContainer[0];

    autoView( out_v , out, AcceleratorWrite);
@@ -300,7 +522,7 @@ public:
      }
      coalescedWrite(out_v[ss](b),res);
    });
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<geom.npoint;p++) AcceleratorViewContainer[p].ViewClose();
  }
  void MdirAll(const CoarseVector &in,std::vector<CoarseVector> &out)
  {
@@ -309,7 +531,7 @@ public:
    if ((out.size()!=ndir)&&(out.size()!=ndir+1)) { 
      std::cout <<"MdirAll out size "<< out.size()<<std::endl;
      std::cout <<"MdirAll ndir "<< ndir<<std::endl;
-      GRID_ASSERT(0);
+      assert(0);
    }
    for(int p=0;p<ndir;p++){
      MdirCalc(in,out[p],p);
@@ -373,7 +595,7 @@ public:
    conformable(in.Grid(), _cbgrid);    // verifies half grid
    conformable(in.Grid(), out.Grid()); // drops the cb check

-    GRID_ASSERT(in.Checkerboard() == Even);
+    assert(in.Checkerboard() == Even);
    out.Checkerboard() = Odd;

    DhopInternal(StencilEven, Aodd, in, out, dag);
@@ -383,7 +605,7 @@ public:
    conformable(in.Grid(), _cbgrid);    // verifies half grid
    conformable(in.Grid(), out.Grid()); // drops the cb check

-    GRID_ASSERT(in.Checkerboard() == Odd);
+    assert(in.Checkerboard() == Odd);
    out.Checkerboard() = Even;

    DhopInternal(StencilOdd, Aeven, in, out, dag);
@@ -391,7 +613,7 @@ public:

  void MooeeInternal(const CoarseVector &in, CoarseVector &out, int dag, int inv) {
    out.Checkerboard() = in.Checkerboard();
-    GRID_ASSERT(in.Checkerboard() == Odd || in.Checkerboard() == Even);
+    assert(in.Checkerboard() == Odd || in.Checkerboard() == Even);

    CoarseMatrix *Aself = nullptr;
    if(in.Grid()->_isCheckerBoarded) {
@@ -406,10 +628,10 @@ public:
      Aself = (inv) ? &AselfInv : &A[geom.npoint-1];
      DselfInternal(Stencil, *Aself, in, out, dag);
    }
-    GRID_ASSERT(Aself != nullptr);
+    assert(Aself != nullptr);
  }

-  void DselfInternal(CartesianStencil<siteVector,siteVector,DefaultImplParams> &st, CoarseMatrix &a,
+  void DselfInternal(CartesianStencil<siteVector,siteVector,int> &st, CoarseMatrix &a,
                       const CoarseVector &in, CoarseVector &out, int dag) {
    int point = geom.npoint-1;
    autoView( out_v, out, AcceleratorWrite);
@@ -472,7 +694,7 @@ public:
    }
  }

-  void DhopInternal(CartesianStencil<siteVector,siteVector,DefaultImplParams> &st, std::vector<CoarseMatrix> &a,
+  void DhopInternal(CartesianStencil<siteVector,siteVector,int> &st, std::vector<CoarseMatrix> &a,
                    const CoarseVector &in, CoarseVector &out, int dag) {
    SimpleCompressor<siteVector> compressor;

@@ -484,20 +706,14 @@ public:

    // determine in what order we need the points
    int npoint = geom.npoint-1;
-    deviceVector<int> points(npoint);
-    for(int p=0; p<npoint; p++) {
-      int val = (dag && !hermitian) ? geom.points_dagger[p] : p;
-      acceleratorPut(points[p], val);
-    }
+    Vector<int> points(npoint, 0);
+    for(int p=0; p<npoint; p++)
+      points[p] = (dag && !hermitian) ? geom.points_dagger[p] : p;
+
    auto points_p = &points[0];

-    deviceVector<Aview> AcceleratorViewContainer(geom.npoint);
-    hostVector<Aview>   hAcceleratorViewContainer(geom.npoint);
-  
-    for(int p=0;p<geom.npoint;p++) {
-      hAcceleratorViewContainer[p] = a[p].View(AcceleratorRead);
-      acceleratorPut(AcceleratorViewContainer[p],hAcceleratorViewContainer[p]);
-    }
+    Vector<Aview> AcceleratorViewContainer;
+    for(int p=0;p<npoint;p++) AcceleratorViewContainer.push_back(a[p].View(AcceleratorRead));
    Aview *Aview_p = & AcceleratorViewContainer[0];

    const int Nsimd = CComplex::Nsimd();
@@ -560,7 +776,7 @@ public:
      });
    }

-    for(int p=0;p<npoint;p++) hAcceleratorViewContainer[p].ViewClose();
+    for(int p=0;p<npoint;p++) AcceleratorViewContainer[p].ViewClose();
  }
  
  CoarsenedMatrix(GridCartesian &CoarseGrid, int hermitian_=0) 	:
@@ -568,9 +784,9 @@ public:
    _cbgrid(new GridRedBlackCartesian(&CoarseGrid)),
    geom(CoarseGrid._ndimension),
    hermitian(hermitian_),
-    Stencil(&CoarseGrid,geom.npoint,Even,geom.directions,geom.displacements),
-    StencilEven(_cbgrid,geom.npoint,Even,geom.directions,geom.displacements),
-    StencilOdd(_cbgrid,geom.npoint,Odd,geom.directions,geom.displacements),
+    Stencil(&CoarseGrid,geom.npoint,Even,geom.directions,geom.displacements,0),
+    StencilEven(_cbgrid,geom.npoint,Even,geom.directions,geom.displacements,0),
+    StencilOdd(_cbgrid,geom.npoint,Odd,geom.directions,geom.displacements,0),
    A(geom.npoint,&CoarseGrid),
    Aeven(geom.npoint,_cbgrid),
    Aodd(geom.npoint,_cbgrid),
@@ -588,9 +804,9 @@ public:
    _cbgrid(&CoarseRBGrid),
    geom(CoarseGrid._ndimension),
    hermitian(hermitian_),
-    Stencil(&CoarseGrid,geom.npoint,Even,geom.directions,geom.displacements),
-    StencilEven(&CoarseRBGrid,geom.npoint,Even,geom.directions,geom.displacements),
-    StencilOdd(&CoarseRBGrid,geom.npoint,Odd,geom.directions,geom.displacements),
+    Stencil(&CoarseGrid,geom.npoint,Even,geom.directions,geom.displacements,0),
+    StencilEven(&CoarseRBGrid,geom.npoint,Even,geom.directions,geom.displacements,0),
+    StencilOdd(&CoarseRBGrid,geom.npoint,Odd,geom.directions,geom.displacements,0),
    A(geom.npoint,&CoarseGrid),
    Aeven(geom.npoint,&CoarseRBGrid),
    Aodd(geom.npoint,&CoarseRBGrid),
@@ -611,13 +827,11 @@ public:
    }

    // GPU readable prefactor
-    std::vector<RealD> h_dag_factor(nbasis*nbasis);
    thread_for(i, nbasis*nbasis, {
      int j = i/nbasis;
      int k = i%nbasis;
-      h_dag_factor[i] = dag_factor_eigen(j, k);
+      dag_factor[i] = dag_factor_eigen(j, k);
    });
-    acceleratorCopyToDevice(&h_dag_factor[0],&dag_factor[0],dag_factor.size()*sizeof(RealD));
  }

  void CoarsenOperator(GridBase *FineGrid,LinearOperatorBase<Lattice<Fobj> > &linop,
@@ -697,7 +911,7 @@ public:
    evenmask = where(mod(bcb,2)==(Integer)0,one,zero);
    oddmask  = one-evenmask;

-    GRID_ASSERT(self_stencil!=-1);
+    assert(self_stencil!=-1);

    for(int i=0;i<nbasis;i++){

@@ -1,6 +1,6 @@
 /*************************************************************************************

-    Grid physics library, www.github.com/paboyle/Grid
+    Grid physics library, www.github.com/paboyle/Grid 

    Source file: ./lib/Cshift.h

@@ -28,680 +28,266 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 #ifndef _GRID_FFT_H_
 #define _GRID_FFT_H_

-#ifdef GRID_CUDA
-#include <cufft.h>
-#endif
-
-#ifdef GRID_HIP
-#include <hipfft/hipfft.h>
-#endif
-
-#if !defined(GRID_CUDA) && !defined(GRID_HIP)
 #ifdef HAVE_FFTW
-#if defined(USE_MKL) || defined(GRID_SYCL)
+#ifdef USE_MKL
 #include <fftw/fftw3.h>
 #else
 #include <fftw3.h>
 #endif
 #endif
-#endif

 NAMESPACE_BEGIN(Grid);

+template<class scalar> struct FFTW { };
+
+#ifdef HAVE_FFTW	
+template<> struct FFTW<ComplexD> {
+public:
+
+  typedef fftw_complex FFTW_scalar;
+  typedef fftw_plan    FFTW_plan;
+
+  static FFTW_plan fftw_plan_many_dft(int rank, const int *n,int howmany,
+				      FFTW_scalar *in, const int *inembed,		
+				      int istride, int idist,		
+				      FFTW_scalar *out, const int *onembed,		
+				      int ostride, int odist,		
+				      int sign, unsigned flags) {
+    return ::fftw_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
+  }	  
+    
+  static void fftw_flops(const FFTW_plan p,double *add, double *mul, double *fmas){
+    ::fftw_flops(p,add,mul,fmas);
+  }
+
+  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out) {
+    ::fftw_execute_dft(p,in,out);
+  }
+  inline static void fftw_destroy_plan(const FFTW_plan p) {
+    ::fftw_destroy_plan(p);
+  }
+};
+
+template<> struct FFTW<ComplexF> {
+public:
+
+  typedef fftwf_complex FFTW_scalar;
+  typedef fftwf_plan    FFTW_plan;
+
+  static FFTW_plan fftw_plan_many_dft(int rank, const int *n,int howmany,
+				      FFTW_scalar *in, const int *inembed,		
+				      int istride, int idist,		
+				      FFTW_scalar *out, const int *onembed,		
+				      int ostride, int odist,		
+				      int sign, unsigned flags) {
+    return ::fftwf_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
+  }	  
+    
+  static void fftw_flops(const FFTW_plan p,double *add, double *mul, double *fmas){
+    ::fftwf_flops(p,add,mul,fmas);
+  }
+
+  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out) {
+    ::fftwf_execute_dft(p,in,out);
+  }
+  inline static void fftw_destroy_plan(const FFTW_plan p) {
+    ::fftwf_destroy_plan(p);
+  }
+};
+
+#endif
+
 #ifndef FFTW_FORWARD
 #define FFTW_FORWARD (-1)
 #define FFTW_BACKWARD (+1)
-#define FFTW_ESTIMATE (0)
 #endif

-template<class scalar> struct FFTW {
-};
-
-#ifdef GRID_HIP
-template<> struct FFTW<ComplexD> {
+class FFT {
+private:
+    
+  GridCartesian *vgrid;
+  GridCartesian *sgrid;
+    
+  int Nd;
+  double flops;
+  double flops_call;
+  uint64_t usec;
+    
+  Coordinate dimensions;
+  Coordinate processors;
+  Coordinate processor_coor;
+    
 public:
+    
  static const int forward=FFTW_FORWARD;
  static const int backward=FFTW_BACKWARD;
-  typedef hipfftDoubleComplex FFTW_scalar;
-  typedef hipfftHandle        FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    auto rv = hipfftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,HIPFFT_Z2Z,howmany);
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    hipfftResult rv;
-    if ( sign == forward ) rv =hipfftExecZ2Z(p,in,out,HIPFFT_FORWARD);
-    else                   rv =hipfftExecZ2Z(p,in,out,HIPFFT_BACKWARD);
-    accelerator_barrier();
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { hipfftDestroy(p); }
-};
-template<> struct FFTW<ComplexF> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef hipfftComplex FFTW_scalar;
-  typedef hipfftHandle  FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    auto rv = hipfftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,HIPFFT_C2C,howmany);
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    hipfftResult rv;
-    if ( sign == forward ) rv =hipfftExecC2C(p,in,out,HIPFFT_FORWARD);
-    else                   rv =hipfftExecC2C(p,in,out,HIPFFT_BACKWARD);
-    accelerator_barrier();
-    GRID_ASSERT(rv==HIPFFT_SUCCESS);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { hipfftDestroy(p); }
-};
-#endif
+    
+  double Flops(void) {return flops;}
+  double MFlops(void) {return flops/usec;}
+  double USec(void)   {return (double)usec;}    

-#ifdef GRID_CUDA
-template<> struct FFTW<ComplexD> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef cufftDoubleComplex FFTW_scalar;
-  typedef cufftHandle        FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    cufftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,CUFFT_Z2Z,howmany);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    if ( sign == forward ) cufftExecZ2Z(p,in,out,CUFFT_FORWARD);
-    else                   cufftExecZ2Z(p,in,out,CUFFT_INVERSE);
-    accelerator_barrier();
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { cufftDestroy(p); }
-};
-template<> struct FFTW<ComplexF> {
-public:
-  static const int forward=FFTW_FORWARD;
-  static const int backward=FFTW_BACKWARD;
-  typedef cufftComplex FFTW_scalar;
-  typedef cufftHandle  FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    FFTW_plan p;
-    cufftPlanMany(&p,rank,n,n,istride,idist,n,ostride,odist,CUFFT_C2C,howmany);
-    return p;
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    if ( sign == forward ) cufftExecC2C(p,in,out,CUFFT_FORWARD);
-    else                   cufftExecC2C(p,in,out,CUFFT_INVERSE);
-    accelerator_barrier();
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { cufftDestroy(p); }
-};
-#endif
-
-#if !defined(GRID_CUDA) && !defined(GRID_HIP)
-#ifdef HAVE_FFTW
-template<> struct FFTW<ComplexD> {
-public:
-  typedef fftw_complex FFTW_scalar;
-  typedef fftw_plan    FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    return ::fftw_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    ::fftw_execute_dft(p,in,out);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { ::fftw_destroy_plan(p); }
-};
-template<> struct FFTW<ComplexF> {
-public:
-  typedef fftwf_complex FFTW_scalar;
-  typedef fftwf_plan    FFTW_plan;
-  static FFTW_plan fftw_plan_many_dft(int rank, int *n,int howmany,
-				      FFTW_scalar *in, int *inembed,
-				      int istride, int idist,
-				      FFTW_scalar *out, int *onembed,
-				      int ostride, int odist,
-				      int sign, unsigned flags) {
-    return ::fftwf_plan_many_dft(rank,n,howmany,in,inembed,istride,idist,out,onembed,ostride,odist,sign,flags);
-  }
-  inline static void fftw_execute_dft(const FFTW_plan p,FFTW_scalar *in,FFTW_scalar *out, int sign) {
-    ::fftwf_execute_dft(p,in,out);
-  }
-  inline static void fftw_destroy_plan(const FFTW_plan p) { ::fftwf_destroy_plan(p); }
-};
-#endif
-#endif
-
-struct FFTbase {
-  double        flops;
-  double        flops_call;
-  uint64_t      usec;
-  GridCartesian *_grid;
-
-  static const int forward  = FFTW_FORWARD;
-  static const int backward = FFTW_BACKWARD;
-
-  double Flops(void)  { return flops; }
-  double MFlops(void) { return flops / usec; }
-  double USec(void)   { return (double)usec; }
-
-  FFTbase(GridCartesian *grid) : _grid(grid), flops(0), flops_call(0), usec(0) {}
-};
-
-// Barrel-shift gather, FFT execute, and insert. Called by both FFT and PlannedFFT.
-// The caller is responsible for plan acquisition and destruction.
-template<class vobj>
-static void FFT_dim_execute(
-    Lattice<vobj>       &result,
-    const Lattice<vobj> &source,
-    int dim, int sign,
-    typename FFTW<typename vobj::scalar_type>::FFTW_plan p,
-    GridCartesian *grid,
-    double &flops, double &flops_call, uint64_t &usec)
-{
-  typedef typename vobj::scalar_type   scalar;
-  typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type   scalar_type;
-  typedef typename vobj::vector_type   vector_type;
-  typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
-
-#if 0
-  // ======================= ORIGINAL barrel-shift path =======================
-  // Preserved for reference.  Superseded by the transpose / all-to-all path
-  // below (the single active path for ALL P): the barrel is a P-fold redundant
-  // all-gather -- every rank assembles and transforms all Nperp lines of length
-  // G, keeping only its own L points.  The transpose partitions the Nperp
-  // perpendicular lines across the P ranks along dim, so each rank transforms
-  // only ceil(Nperp/P) lines and moves (P-1)/P of its data instead of P-1
-  // redundant copies.  See CartesianRingAllToAll in communicator/RingAllReduce.h.
-  const int Ndim = grid->Nd();
-  int L = grid->_ldimensions[dim];
-  int G = grid->_fdimensions[dim];
-  int Ncomp = sizeof(sobj) / sizeof(scalar);
-  int64_t Nlow = 1, Nhigh = 1;
-  for (int d = 0; d < dim;      d++) Nlow  *= grid->_ldimensions[d];
-  for (int d = dim+1; d < Ndim; d++) Nhigh *= grid->_ldimensions[d];
-  int64_t Nperp = Nlow * Nhigh;
-
-  deviceVector<scalar> pgbuf(Nperp * Ncomp * G);
-  scalar *pgbuf_v = &pgbuf[0];
-  int howmany = Ncomp * Nperp;
-
-  scalar div;
-  if      (sign == FFTW_BACKWARD) div = 1.0 / G;
-  else if (sign == FFTW_FORWARD)  div = 1.0;
-  else GRID_ASSERT(0);
-
-  double t_pencil = 0, t_fft = 0, t_copy = 0, t_shift = 0;
-  double t_total  = -usecond();
-
-  result = source;
-  int pc = grid->_processor_coor[dim];
-
-  const Coordinate ldims      = grid->_ldimensions;
-  const Coordinate rdims      = grid->_rdimensions;
-  const Coordinate sdims      = grid->_simd_layout;
-  const Coordinate processors = grid->_processors;
-
-  Coordinate pgdims(Ndim);
-  pgdims[0] = G;
-  for (int d = 0, dd = 1; d < Ndim; d++)
-    if (d != dim) pgdims[dd++] = ldims[d];
-  int64_t pgvol = 1;
-  for (int d = 0; d < Ndim; d++) pgvol *= pgdims[d];
-
-  const int Nsimd = vobj::Nsimd();
-  t_pencil = -usecond();
-  for (int p_idx = 0; p_idx < processors[dim]; p_idx++) {
-    t_copy -= usecond();
-    autoView(r_v, result, AcceleratorRead);
-    accelerator_for(idx, grid->oSites(), vobj::Nsimd(), {
-#ifdef GRID_SIMT
-    {
-      int lane = acceleratorSIMTlane(Nsimd);
-#else
-    for (int lane = 0; lane < Nsimd; lane++) {
-#endif
-      Coordinate icoor, ocoor, pgcoor;
-      Lexicographic::CoorFromIndex(icoor, lane, sdims);
-      Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
-      pgcoor[0] = ocoor[dim] + icoor[dim]*rdims[dim] + ((pc+p_idx)%processors[dim])*L;
-      for (int d = 0, dd = 1; d < Ndim; d++)
-        if (d != dim) { pgcoor[dd] = ocoor[d] + icoor[d]*rdims[d]; dd++; }
-      int64_t pgidx;
-      Lexicographic::IndexFromCoor(pgcoor, pgidx, pgdims);
-      vector_type *from = (vector_type *)&r_v[idx];
-      scalar_type  stmp;
-      for (int w = 0; w < Ncomp; w++) {
-        stmp = getlane(from[w], lane);
-        pgbuf_v[pgidx + w*pgvol] = stmp;
-      }
-#ifdef GRID_SIMT
-    }
-#else
-    }
-#endif
-    });
-    t_copy += usecond();
-    if (p_idx != processors[dim] - 1) {
-      Lattice<vobj> temp(grid);
-      t_shift -= usecond();
-      temp = Cshift(result, dim, L); result = temp;
-      t_shift += usecond();
-    }
-  }
-  t_pencil += usecond();
-
-  FFTW_scalar *in  = (FFTW_scalar *)pgbuf_v;
-  FFTW_scalar *out = (FFTW_scalar *)pgbuf_v;
-  t_fft = -usecond();
-  FFTW<scalar>::fftw_execute_dft(p, in, out, sign);
-  t_fft += usecond();
-
-  flops_call = 5.0 * howmany * G * log2(G);
-  usec  = t_fft;
-  flops = flops_call;
-
-  result = Zero();
-  double t_insert = -usecond();
+  FFT ( GridCartesian * grid ) :
+    vgrid(grid),
+    Nd(grid->_ndimension),
+    dimensions(grid->_fdimensions),
+    processors(grid->_processors),
+    processor_coor(grid->_processor_coor)
  {
-    autoView(r_v, result, AcceleratorWrite);
-    accelerator_for(idx, grid->oSites(), Nsimd, {
-#ifdef GRID_SIMT
-    {
-      int lane = acceleratorSIMTlane(Nsimd);
-#else
-    for (int lane = 0; lane < Nsimd; lane++) {
-#endif
-      Coordinate icoor(Ndim), ocoor(Ndim), pgcoor(Ndim);
-      Lexicographic::CoorFromIndex(icoor, lane, sdims);
-      Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
-      pgcoor[0] = ocoor[dim] + icoor[dim]*rdims[dim] + pc*L;
-      for (int d = 0, dd = 1; d < Ndim; d++)
-        if (d != dim) { pgcoor[dd] = ocoor[d] + icoor[d]*rdims[d]; dd++; }
-      int64_t pgidx;
-      Lexicographic::IndexFromCoor(pgcoor, pgidx, pgdims);
-      vector_type *to  = (vector_type *)&r_v[idx];
-      scalar_type  stmp;
-      for (int w = 0; w < Ncomp; w++) {
-        stmp = pgbuf_v[pgidx + w*pgvol];
-        putlane(to[w], stmp, lane);
-      }
-#ifdef GRID_SIMT
-    }
-#else
-    }
-#endif
-    });
+    flops=0;
+    usec =0;
+    Coordinate layout(Nd,1);
+    sgrid = new GridCartesian(dimensions,layout,processors,*grid);
+  };
+    
+  ~FFT ( void)  {
+    delete sgrid;
  }
-  result = result * div;
-  t_insert += usecond();
-  t_total  += usecond();
-
-  std::cout << GridLogPerformance << " FFT took   " << t_total/1.0e6  << " s" << std::endl;
-  std::cout << GridLogPerformance << " FFT pencil " << t_pencil/1.0e6 << " s" << std::endl;
-  std::cout << GridLogPerformance << "  of which copy " << t_copy/1.0e6  << " s" << std::endl;
-  std::cout << GridLogPerformance << "  of which shift" << t_shift/1.0e6 << " s" << std::endl;
-  std::cout << GridLogPerformance << " FFT kernels " << t_fft/1.0e6    << " s" << std::endl;
-  std::cout << GridLogPerformance << " FFT insert  " << t_insert/1.0e6 << " s" << std::endl;
-#endif
-
-  // ==================== transpose / all-to-all pencil FFT ====================
-  //
-  // P ranks lie along dim; each holds a local L-slab (L=ldim) of every global
-  // line (length G=fdim=L*P) and Nperp perpendicular lines.  We partition the
-  // Nperp lines across the P ranks: the rank at coord `own` owns the lines with
-  // olin/Oloc == own, gathers their full G points via a cartesian all-to-all,
-  // transforms only Oloc = ceil(Nperp/P) of them, then scatters the result back
-  // with the inverse all-to-all.
-  //
-  // The owned-line count is CEIL-padded to a multiple of P (Oloc*P >= Nperp) so
-  // the all-to-all stays SYMMETRIC (one uniform chunk) for ANY (P,Nperp) -- in
-  // particular a P carrying a factor absent from Nperp, e.g. P=3 on the T axis
-  // of 128^3x288 whose perpendicular volume is a pure power of two.  This keeps
-  // the transpose as total over decompositions as the barrel it replaces (no
-  // new geometry constraint), at a cost of <= (P-1) padded lines out of Nperp.
-  // Padding slots olin in [Nperp, Oloc*P) are never packed and never unpacked.
-  //
-  // The load-bearing identity: the all-to-all block index == cartesian coord
-  // along dim == which L-slab [c*L, c*L+L) of the global line -- so the block a
-  // rank receives carries the global-x tag needed to order the FFT input.
-  //
-  // Degenerate P: P=1 -> both all-to-alls are self-copies and the reorders are
-  // the identity (G=L), i.e. a pure local FFT.  P=2 -> each all-to-all moves
-  // half a field, two of them one field, equal to the barrel's single Cshift.
-  {
-    const int Ndim = grid->Nd();
-    int     L     = grid->_ldimensions[dim];
-    int     G     = grid->_fdimensions[dim];
-    int     Ncomp = sizeof(sobj) / sizeof(scalar);
-    int     P     = grid->_processors[dim];
-    int64_t Nperp = 1;
-    for (int d = 0; d < Ndim; d++)
-      if (d != dim) Nperp *= grid->_ldimensions[d];
-
-    int64_t Oloc  = (Nperp + P - 1) / P;        // ceil: owned (padded) lines/rank
-    int64_t chunk = (int64_t)L * Oloc * Ncomp;  // one all-to-all block (uniform)
-    int64_t nbuf  = (int64_t)P * chunk;         // == Ncomp*Oloc*G, one field's worth
-    int64_t howmany_local = (int64_t)Ncomp * Oloc;
-
-    scalar div;
-    if      (sign == FFTW_BACKWARD) div = 1.0 / G;
-    else if (sign == FFTW_FORWARD)  div = 1.0;
-    else GRID_ASSERT(0);
-
-    double t_total = -usecond();
-    double t_pack = 0, t_a2a = 0, t_reorder = 0, t_fft = 0, t_unpack = 0;
-
-    deviceVector<scalar> sbuf(nbuf);
-    deviceVector<scalar> rbuf(nbuf);
-    deviceVector<scalar> pgbuf(nbuf);           // FFTW pencil buffer, Ncomp*Oloc lines of G
-    scalar *sbuf_v  = &sbuf[0];
-    scalar *rbuf_v  = &rbuf[0];
-    scalar *pgbuf_v = &pgbuf[0];
-
-    // Pad slots (olin in [Nperp, Oloc*P)) are never packed, so they would carry
-    // garbage device memory into the FFT.  Zero them so the padded lines stay
-    // finite -- but ONLY when padding is actually present.  In the common
-    // Nperp % P == 0 case pack writes every sbuf entry bijectively, so skip the
-    // whole-buffer memset and its device sync entirely.
-    if ( (int64_t)Oloc*P != Nperp )
-      acceleratorMemSet(sbuf_v, 0, nbuf*sizeof(scalar));
-
-    const Coordinate ldims = grid->_ldimensions;
-    const Coordinate rdims = grid->_rdimensions;
-    const Coordinate sdims = grid->_simd_layout;
-    const int Nsimd = vobj::Nsimd();
-
-    // ---- 1. pack: source -> sbuf.  block = owner coord; payload xloc + L*(slot + Oloc*w)
-    t_pack -= usecond();
-    {
-      autoView(s_v, source, AcceleratorRead);
-      accelerator_for(idx, grid->oSites(), Nsimd, {
-#ifdef GRID_SIMT
-      {
-        int lane = acceleratorSIMTlane(Nsimd);
-#else
-      for (int lane = 0; lane < Nsimd; lane++) {
-#endif
-        Coordinate icoor(Ndim), ocoor(Ndim);
-        Lexicographic::CoorFromIndex(icoor, lane, sdims);
-        Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
-        int64_t xloc = ocoor[dim] + icoor[dim]*rdims[dim];
-        int64_t olin = 0, str = 1;
-        for (int d = 0; d < Ndim; d++) {
-          if (d == dim) continue;
-          int64_t c = ocoor[d] + icoor[d]*rdims[d];
-          olin += str * c;
-          str  *= ldims[d];
-        }
-        int64_t own  = olin / Oloc;
-        int64_t slot = olin - own*Oloc;
-        vector_type *from = (vector_type *)&s_v[idx];
-        for (int w = 0; w < Ncomp; w++) {
-          scalar_type stmp = getlane(from[w], lane);
-          sbuf_v[ own*chunk + xloc + L*(slot + Oloc*w) ] = stmp;
-        }
-#ifdef GRID_SIMT
-      }
-#else
-      }
-#endif
-      });
-    }
-    t_pack += usecond();
-
-    // ---- 2. forward all-to-all: gather my owned lines' L-slabs from every rank
-    t_a2a -= usecond();
-    CartesianRingAllToAll(grid, sbuf_v, rbuf_v, (uint64_t)chunk, dim);
-    t_a2a += usecond();
-
-    // ---- 3. reorder rbuf -> pgbuf: contiguous G-lines (w,slot), xpos = src*L + xloc
-    t_reorder -= usecond();
-    accelerator_for(q, nbuf, 1, {
-      int64_t xpos = q % G;
-      int64_t t    = q / G;           // = w*Oloc + slot
-      int64_t slot = t % Oloc;
-      int64_t w    = t / Oloc;
-      int64_t src  = xpos / L;
-      int64_t xloc = xpos % L;
-      pgbuf_v[q] = rbuf_v[ src*chunk + xloc + L*(slot + Oloc*w) ];
-    });
-    t_reorder += usecond();
-
-    // ---- 4. FFT: Ncomp*Oloc contiguous lines of length G (istride 1, idist G)
-    {
-      FFTW_scalar *in  = (FFTW_scalar *)pgbuf_v;
-      FFTW_scalar *out = (FFTW_scalar *)pgbuf_v;
-      t_fft -= usecond();
-      FFTW<scalar>::fftw_execute_dft(p, in, out, sign);
-      t_fft += usecond();
-    }
-    flops_call = 5.0 * (double)howmany_local * G * log2(G);
-    usec  = (uint64_t)t_fft;
-    flops = flops_call;
-
-    // ---- 5a. reorder pgbuf -> sbuf: block = destination coord; xpos = dst*L + xloc
-    t_reorder -= usecond();
-    accelerator_for(j, nbuf, 1, {
-      int64_t dst  = j / chunk;
-      int64_t r    = j % chunk;
-      int64_t xloc = r % L;
-      int64_t u    = r / L;           // = slot + Oloc*w
-      int64_t slot = u % Oloc;
-      int64_t w    = u / Oloc;
-      int64_t xpos = dst*L + xloc;
-      sbuf_v[j] = pgbuf_v[ w*Oloc*G + slot*G + xpos ];
-    });
-    t_reorder += usecond();
-
-    // ---- 5b. inverse all-to-all: scatter transformed L-slabs back
-    t_a2a -= usecond();
-    CartesianRingAllToAll(grid, sbuf_v, rbuf_v, (uint64_t)chunk, dim);
-    t_a2a += usecond();
-
-    // ---- 5c. unpack rbuf -> result (x div); block = owner coord of each line
-    t_unpack -= usecond();
-    {
-      autoView(r_v, result, AcceleratorWrite);
-      accelerator_for(idx, grid->oSites(), Nsimd, {
-#ifdef GRID_SIMT
-      {
-        int lane = acceleratorSIMTlane(Nsimd);
-#else
-      for (int lane = 0; lane < Nsimd; lane++) {
-#endif
-        Coordinate icoor(Ndim), ocoor(Ndim);
-        Lexicographic::CoorFromIndex(icoor, lane, sdims);
-        Lexicographic::CoorFromIndex(ocoor, idx,  rdims);
-        int64_t xloc = ocoor[dim] + icoor[dim]*rdims[dim];
-        int64_t olin = 0, str = 1;
-        for (int d = 0; d < Ndim; d++) {
-          if (d == dim) continue;
-          int64_t c = ocoor[d] + icoor[d]*rdims[d];
-          olin += str * c;
-          str  *= ldims[d];
-        }
-        int64_t own  = olin / Oloc;
-        int64_t slot = olin - own*Oloc;
-        vector_type *to = (vector_type *)&r_v[idx];
-        for (int w = 0; w < Ncomp; w++) {
-          scalar_type stmp = div * rbuf_v[ own*chunk + xloc + L*(slot + Oloc*w) ];
-          putlane(to[w], stmp, lane);
-        }
-#ifdef GRID_SIMT
-      }
-#else
-      }
-#endif
-      });
-    }
-    t_unpack += usecond();
-    t_total  += usecond();
-
-    std::cout << GridLogPerformance << " FFT took     " << t_total/1.0e6   << " s (transpose P=" << P << ")" << std::endl;
-    std::cout << GridLogPerformance << " FFT pack     " << t_pack/1.0e6    << " s" << std::endl;
-    std::cout << GridLogPerformance << " FFT alltoall " << t_a2a/1.0e6     << " s" << std::endl;
-    std::cout << GridLogPerformance << " FFT reorder  " << t_reorder/1.0e6 << " s" << std::endl;
-    std::cout << GridLogPerformance << " FFT kernels  " << t_fft/1.0e6     << " s" << std::endl;
-    std::cout << GridLogPerformance << " FFT unpack   " << t_unpack/1.0e6  << " s" << std::endl;
-  }
-}
-
-class FFT : public FFTbase {
-public:
-  FFT(GridCartesian *grid) : FFTbase(grid) {}
-  ~FFT() {}
-
+    
  template<class vobj>
-  void FFT_dim_mask(Lattice<vobj> &result, const Lattice<vobj> &source, Coordinate mask, int sign) {
-    const int Ndim = _grid->Nd();
-    Lattice<vobj> tmp = source;
-    for (int d = 0; d < Ndim; d++) {
-      if (mask[d]) {
-        FFT_dim(result, tmp, d, sign);
-        tmp = result;
+  void FFT_dim_mask(Lattice<vobj> &result,const Lattice<vobj> &source,Coordinate mask,int sign){
+
+    conformable(result.Grid(),vgrid);
+    conformable(source.Grid(),vgrid);
+    Lattice<vobj> tmp(vgrid);
+    tmp = source;
+    for(int d=0;d<Nd;d++){
+      if( mask[d] ) {
+	FFT_dim(result,tmp,d,sign);
+	tmp=result;
      }
    }
  }

  template<class vobj>
-  void FFT_all_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int sign) {
-    Coordinate mask(_grid->Nd(), 1);
-    FFT_dim_mask(result, source, mask, sign);
+  void FFT_all_dim(Lattice<vobj> &result,const Lattice<vobj> &source,int sign){
+    Coordinate mask(Nd,1);
+    FFT_dim_mask(result,source,mask,sign);
  }

-  template<class vobj>
-  void FFT_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int dim, int sign) {
-    GRID_ASSERT(source.Grid() == _grid);
-    GRID_ASSERT(result.Grid() == _grid);
-    conformable(result.Grid(), source.Grid());

-    typedef typename vobj::scalar_type   scalar;
+  template<class vobj>
+  void FFT_dim(Lattice<vobj> &result,const Lattice<vobj> &source,int dim, int sign){
+#ifndef HAVE_FFTW
+    assert(0);
+#else
+    conformable(result.Grid(),vgrid);
+    conformable(source.Grid(),vgrid);
+
+    int L = vgrid->_ldimensions[dim];
+    int G = vgrid->_fdimensions[dim];
+      
+    Coordinate layout(Nd,1);
+    Coordinate pencil_gd(vgrid->_fdimensions);
+      
+    pencil_gd[dim] = G*processors[dim];
+      
+    // Pencil global vol LxLxGxLxL per node
+    GridCartesian pencil_g(pencil_gd,layout,processors,*vgrid);
+      
+    // Construct pencils
    typedef typename vobj::scalar_object sobj;
+    typedef typename sobj::scalar_type   scalar;
+      
+    Lattice<sobj> pgbuf(&pencil_g);
+    autoView(pgbuf_v , pgbuf, CpuWrite);
+
    typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
    typedef typename FFTW<scalar>::FFTW_plan   FFTW_plan;
-
-    const int Ndim = _grid->Nd();
-    int G     = _grid->_fdimensions[dim];
-    int Ncomp = sizeof(sobj) / sizeof(scalar);
-    int64_t Nperp = 1;
-    for (int d = 0; d < Ndim; d++)
-      if (d != dim) Nperp *= _grid->_ldimensions[d];
-    int     P     = _grid->_processors[dim];
-    int64_t Oloc  = (Nperp + P - 1) / P;   // ceil-padded owned lines/rank (see FFT_dim_execute)
-    int n[]     = {G};
-    int howmany = Ncomp * (int)Oloc;
-
-    deviceVector<scalar> dummy(2);
-    FFTW_scalar *buf = (FFTW_scalar *)&dummy[0];
-    FFTW_plan p = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany,
-                                                    buf, n, 1, G,
-                                                    buf, n, 1, G,
-                                                    sign, FFTW_ESTIMATE);
-    FFT_dim_execute(result, source, dim, sign, p, _grid, flops, flops_call, usec);
-    FFTW<scalar>::fftw_destroy_plan(p);
-  }
-};
-
-template<class vobj>
-class PlannedFFT : public FFTbase {
-private:
-  typedef typename vobj::scalar_type   scalar;
-  typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::vector_type   vector_type;
-  typedef typename FFTW<scalar>::FFTW_scalar FFTW_scalar;
-  typedef typename FFTW<scalar>::FFTW_plan   FFTW_plan;
-
-  std::vector<FFTW_plan> forward_plans;
-  std::vector<FFTW_plan> backward_plans;
-
-  void PlanCreate() {
-    const int Ndim = _grid->Nd();
-    forward_plans.resize(Ndim);
-    backward_plans.resize(Ndim);
-
-    for (int d = 0; d < Ndim; d++) {
-      int G       = _grid->_fdimensions[d];
-      int Ncomp   = sizeof(sobj) / sizeof(scalar);
-      int64_t Nperp = 1;
-      for (int dd = 0; dd < Ndim; dd++)
-        if (dd != d) Nperp *= _grid->_ldimensions[dd];
-      int     P     = _grid->_processors[d];
-      int64_t Oloc  = (Nperp + P - 1) / P;   // ceil-padded owned lines/rank (see FFT_dim_execute)
-      int howmany = Ncomp * (int)Oloc;
-      int n[]     = {G};
-
-      deviceVector<scalar> dummy(2);
-      FFTW_scalar *buf = (FFTW_scalar *)&dummy[0];
-
-      forward_plans[d]  = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany, buf, n, 1, G, buf, n, 1, G, FFTW_FORWARD,  FFTW_ESTIMATE);
-      backward_plans[d] = FFTW<scalar>::fftw_plan_many_dft(1, n, howmany, buf, n, 1, G, buf, n, 1, G, FFTW_BACKWARD, FFTW_ESTIMATE);
+      
+    int Ncomp = sizeof(sobj)/sizeof(scalar);
+    int Nlow  = 1;
+    for(int d=0;d<dim;d++){
+      Nlow*=vgrid->_ldimensions[d];
    }
-  }
-
-  void PlanDestroy() {
-    for (auto p : forward_plans)  FFTW<scalar>::fftw_destroy_plan(p);
-    for (auto p : backward_plans) FFTW<scalar>::fftw_destroy_plan(p);
-    forward_plans.clear();
-    backward_plans.clear();
-  }
-
-public:
-  PlannedFFT(GridCartesian *grid) : FFTbase(grid) { PlanCreate(); }
-  ~PlannedFFT() { PlanDestroy(); }
-
-  void FFT_dim_mask(Lattice<vobj> &result, const Lattice<vobj> &source, Coordinate mask, int sign) {
-    const int Ndim = _grid->Nd();
-    Lattice<vobj> tmp = source;
-    for (int d = 0; d < Ndim; d++) {
-      if (mask[d]) {
-        FFT_dim(result, tmp, d, sign);
-        tmp = result;
+      
+    int rank = 1;  /* 1d transforms */
+    int n[] = {G}; /* 1d transforms of length G */
+    int howmany = Ncomp;
+    int odist,idist,istride,ostride;
+    idist   = odist   = 1;          /* Distance between consecutive FT's */
+    istride = ostride = Ncomp*Nlow; /* distance between two elements in the same FT */
+    int *inembed = n, *onembed = n;
+      
+    scalar div;
+    if ( sign == backward ) div = 1.0/G;
+    else if ( sign == forward ) div = 1.0;
+    else assert(0);
+      
+    FFTW_plan p;
+    {
+      FFTW_scalar *in = (FFTW_scalar *)&pgbuf_v[0];
+      FFTW_scalar *out= (FFTW_scalar *)&pgbuf_v[0];
+      p = FFTW<scalar>::fftw_plan_many_dft(rank,n,howmany,
+					   in,inembed,
+					   istride,idist,
+					   out,onembed,
+					   ostride, odist,
+					   sign,FFTW_ESTIMATE);
+    }
+      
+    // Barrel shift and collect global pencil
+    Coordinate lcoor(Nd), gcoor(Nd);
+    result = source;
+    int pc = processor_coor[dim];
+    for(int p=0;p<processors[dim];p++) {
+      {
+	autoView(r_v,result,CpuRead);
+	autoView(p_v,pgbuf,CpuWrite);
+	thread_for(idx, sgrid->lSites(),{
+          Coordinate cbuf(Nd);
+          sobj s;
+	  sgrid->LocalIndexToLocalCoor(idx,cbuf);
+	  peekLocalSite(s,r_v,cbuf);
+	  cbuf[dim]+=((pc+p) % processors[dim])*L;
+	  pokeLocalSite(s,p_v,cbuf);
+        });
+      }
+      if (p != processors[dim] - 1) {
+	result = Cshift(result,dim,L);
      }
    }
-  }
-
-  void FFT_all_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int sign) {
-    Coordinate mask(_grid->Nd(), 1);
-    FFT_dim_mask(result, source, mask, sign);
-  }
-
-  void FFT_dim(Lattice<vobj> &result, const Lattice<vobj> &source, int dim, int sign) {
-    GRID_ASSERT(source.Grid() == _grid);
-    GRID_ASSERT(result.Grid() == _grid);
-    GRID_ASSERT((int)forward_plans.size() == _grid->Nd());
-    conformable(result.Grid(), source.Grid());
-    FFTW_plan p = (sign == forward ? forward_plans : backward_plans)[dim];
-    FFT_dim_execute(result, source, dim, sign, p, _grid, flops, flops_call, usec);
+      
+    // Loop over orthog coords
+    int NN=pencil_g.lSites();
+    GridStopWatch timer;
+    timer.Start();
+    thread_for( idx,NN,{
+        Coordinate cbuf(Nd);
+	pencil_g.LocalIndexToLocalCoor(idx, cbuf);
+	if ( cbuf[dim] == 0 ) {  // restricts loop to plane at lcoor[dim]==0
+	  FFTW_scalar *in = (FFTW_scalar *)&pgbuf_v[idx];
+	  FFTW_scalar *out= (FFTW_scalar *)&pgbuf_v[idx];
+	  FFTW<scalar>::fftw_execute_dft(p,in,out);
+	}
+    });
+    timer.Stop();
+      
+    // performance counting
+    double add,mul,fma;
+    FFTW<scalar>::fftw_flops(p,&add,&mul,&fma);
+    flops_call = add+mul+2.0*fma;
+    usec += timer.useconds();
+    flops+= flops_call*NN;
+      
+    // writing out result
+    {
+      autoView(pgbuf_v,pgbuf,CpuRead);
+      autoView(result_v,result,CpuWrite);
+      thread_for(idx,sgrid->lSites(),{
+	Coordinate clbuf(Nd), cgbuf(Nd);
+	sobj s;
+	sgrid->LocalIndexToLocalCoor(idx,clbuf);
+	cgbuf = clbuf;
+	cgbuf[dim] = clbuf[dim]+L*pc;
+	peekLocalSite(s,pgbuf_v,cgbuf);
+	pokeLocalSite(s,result_v,clbuf);
+      });
+    }
+    result = result*div;
+      
+    // destroying plan
+    FFTW<scalar>::fftw_destroy_plan(p);
+#endif
  }
 };

@@ -52,7 +52,6 @@ public:
  virtual void AdjOp  (const Field &in, Field &out) = 0; // Abstract base
  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2)=0;
  virtual void HermOp(const Field &in, Field &out)=0;
-  virtual ~LinearOperatorBase(){};
 };


@@ -64,7 +63,7 @@ public:
 //
 // I'm not entirely happy with implementation; to share the Schur code between herm and non-herm
 // while still having a "OpAndNorm" in the abstract base I had to implement it in both cases
-// with an GRID_ASSERT trap in the non-herm. This isn't right; there must be a better C++ way to
+// with an assert trap in the non-herm. This isn't right; there must be a better C++ way to
 // do it, but I fear it required multiple inheritance and mixed in abstract base classes
 /////////////////////////////////////////////////////////////////////////////////////////////

@@ -103,38 +102,6 @@ public:
    _Mat.MdagM(in,out);
  }
 };
-template<class Matrix,class Field>
-class MMdagLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-public:
-  MMdagLinearOperator(Matrix &Mat): _Mat(Mat){};
-
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    _Mat.Mdiag(in,out);
-  }
-  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);
-  }
-  void AdjOp     (const Field &in, Field &out){
-    _Mat.Mdag(in,out);
-  }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    _Mat.MMdag(in,out);
-    ComplexD dot = innerProduct(in,out);
-    n1=real(dot);
-    n2=norm2(out);
-  }
-  void HermOp(const Field &in, Field &out){
-    _Mat.MMdag(in,out);
-  }
-};

 ////////////////////////////////////////////////////////////////////
 // Construct herm op and shift it for mgrid smoother
@@ -148,22 +115,22 @@ public:
  // Support for coarsening to a multigrid
  void OpDiag (const Field &in, Field &out) {
    _Mat.Mdiag(in,out);
-    GRID_ASSERT(0);
+    assert(0);
  }
  void OpDir  (const Field &in, Field &out,int dir,int disp) {
    _Mat.Mdir(in,out,dir,disp);
-    GRID_ASSERT(0);
+    assert(0);
  }
  void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
+    assert(0);
  };
  void Op     (const Field &in, Field &out){
    _Mat.M(in,out);
-    GRID_ASSERT(0);
+    assert(0);
  }
  void AdjOp     (const Field &in, Field &out){
    _Mat.Mdag(in,out);
-    GRID_ASSERT(0);
+    assert(0);
  }
  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
    HermOp(in,out);
@@ -177,67 +144,6 @@ public:
  }
 };

-////////////////////////////////////////////////////////////////////
-// Create a shifted HermOp
-////////////////////////////////////////////////////////////////////
-template<class Field>
-class ShiftedHermOpLinearOperator : public LinearOperatorBase<Field> {
-  LinearOperatorBase<Field> &_Mat;
-  RealD _shift;
-public:
-  ShiftedHermOpLinearOperator(LinearOperatorBase<Field> &Mat,RealD shift): _Mat(Mat), _shift(shift){};
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    GRID_ASSERT(0);
-  }
-  void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    GRID_ASSERT(0);
-  }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
-  };
-  void Op     (const Field &in, Field &out){
-    HermOp(in,out);
-  }
-  void AdjOp     (const Field &in, Field &out){
-    HermOp(in,out);
-  }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    HermOp(in,out);
-    ComplexD dot = innerProduct(in,out);
-    n1=real(dot);
-    n2=norm2(out);
-  }
-  void HermOp(const Field &in, Field &out){
-    _Mat.HermOp(in,out);
-    out = out + _shift*in;
-  }
-};
-
-////////////////////////////////////////////////////////////////////
-// Present any LinearOperatorBase as Hermitian: Op = AdjOp = HermOp.
-// For coarsening (CoarsenOperator applies Op) an HPD operator whose
-// Op is a factor and HermOp the product, e.g. SchurDiagMooee or MdagM.
-////////////////////////////////////////////////////////////////////
-template<class Field>
-class HermOpAdaptor : public LinearOperatorBase<Field> {
-  LinearOperatorBase<Field> &_Mat;
-public:
-  HermOpAdaptor(LinearOperatorBase<Field> &Mat): _Mat(Mat){};
-  void OpDiag (const Field &in, Field &out)                   { GRID_ASSERT(0); }
-  void OpDir  (const Field &in, Field &out,int dir,int disp)  { GRID_ASSERT(0); }
-  void OpDirAll(const Field &in, std::vector<Field> &out)     { GRID_ASSERT(0); }
-  void Op     (const Field &in, Field &out){ _Mat.HermOp(in,out); }
-  void AdjOp  (const Field &in, Field &out){ _Mat.HermOp(in,out); }
-  void HermOp (const Field &in, Field &out){ _Mat.HermOp(in,out); }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    HermOp(in,out);
-    ComplexD dot = innerProduct(in,out);
-    n1=real(dot);
-    n2=norm2(out);
-  }
-};
-
 ////////////////////////////////////////////////////////////////////
 // Wrap an already herm matrix
 ////////////////////////////////////////////////////////////////////
@@ -294,42 +200,10 @@ public:
    _Mat.Mdag(in,out);
  }
  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    GRID_ASSERT(0);
+    assert(0);
  }
  void HermOp(const Field &in, Field &out){
-    GRID_ASSERT(0);
-  }
-};
-template<class Matrix,class Field>
-class ShiftedNonHermitianLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-  RealD shift;
-public:
-  ShiftedNonHermitianLinearOperator(Matrix &Mat,RealD shft): _Mat(Mat),shift(shft){};
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    _Mat.Mdiag(in,out);
-    out = out + shift*in;
-  }
-  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);
-    out = out + shift * in;
-  }
-  void AdjOp     (const Field &in, Field &out){
-    _Mat.Mdag(in,out);
-    out = out + shift * in;
-  }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    GRID_ASSERT(0);
-  }
-  void HermOp(const Field &in, Field &out){
-    GRID_ASSERT(0);
+    assert(0);
  }
 };

@@ -349,9 +223,14 @@ class SchurOperatorBase :  public LinearOperatorBase<Field> {
    Mpc(in,tmp);
    MpcDag(tmp,out);
  }
+  virtual  void MpcMpcDag(const Field &in, Field &out) {
+    Field tmp(in.Grid());
+    tmp.Checkerboard() = in.Checkerboard();
+    MpcDag(in,tmp);
+    Mpc(tmp,out);
+  }
  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    out.Checkerboard() = in.Checkerboard();
-    MpcDagMpc(in,out);
+    HermOp(in,out);
    ComplexD dot= innerProduct(in,out); 
    n1=real(dot);
    n2=norm2(out);
@@ -368,13 +247,13 @@ class SchurOperatorBase :  public LinearOperatorBase<Field> {
  }
  // Support for coarsening to a multigrid
  void OpDiag (const Field &in, Field &out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
+    assert(0); // must coarsen the unpreconditioned system
  }
  void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    GRID_ASSERT(0);
+    assert(0);
  }
  void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
+    assert(0);
  };
 };
 template<class Matrix,class Field>
@@ -402,6 +281,16 @@ template<class Matrix,class Field>
      axpy(out,-1.0,tmp,out);
    }
 };
+// Mpc MpcDag system presented as the HermOp
+template<class Matrix,class Field>
+class SchurDiagMooeeDagOperator :  public SchurDiagMooeeOperator<Matrix,Field> {
+ public:
+  virtual void HermOp(const Field &in, Field &out){
+    out.Checkerboard() = in.Checkerboard();
+    this->MpcMpcDag(in,out);
+  }
+  SchurDiagMooeeDagOperator (Matrix &Mat): SchurDiagMooeeOperator<Matrix,Field>(Mat){};
+};
 template<class Matrix,class Field>
  class SchurDiagOneOperator :  public SchurOperatorBase<Field> {
 protected:
@@ -470,10 +359,10 @@ class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field>
    MpcDag(tmp,out);
  }
  virtual void HermOpAndNorm(const Field& in, Field& out, RealD& n1, RealD& n2) {
-    GRID_ASSERT(0);
+    assert(0);
  }
  virtual void HermOp(const Field& in, Field& out) {
-    GRID_ASSERT(0);
+    assert(0);
  }
  void Op(const Field& in, Field& out) {
    Mpc(in, out);
@@ -483,13 +372,13 @@ class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field>
  }
  // Support for coarsening to a multigrid
  void OpDiag(const Field& in, Field& out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
+    assert(0); // must coarsen the unpreconditioned system
  }
  void OpDir(const Field& in, Field& out, int dir, int disp) {
-    GRID_ASSERT(0);
+    assert(0);
  }
  void OpDirAll(const Field& in, std::vector<Field>& out){
-    GRID_ASSERT(0);
+    assert(0);
  };
 };

@@ -603,7 +492,7 @@ class SchurStaggeredOperator :  public SchurOperatorBase<Field> {
 public:
  SchurStaggeredOperator (Matrix &Mat): _Mat(Mat), tmp(_Mat.RedBlackGrid()) 
  { 
-    GRID_ASSERT( _Mat.isTrivialEE() );
+    assert( _Mat.isTrivialEE() );
    mass = _Mat.Mass();
  }
  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
@@ -633,8 +522,8 @@ class SchurStaggeredOperator :  public SchurOperatorBase<Field> {
  virtual  void MpcDag   (const Field &in, Field &out){
    Mpc(in,out);
  }
-  virtual void MpcDagMpc(const Field &in, Field &out) {
-    GRID_ASSERT(0);// Never need with staggered
+  virtual void MpcDagMpc(const Field &in, Field &out,RealD &ni,RealD &no) {
+    assert(0);// Never need with staggered
  }
 };
 template<class Matrix,class Field> using SchurStagOperator = SchurStaggeredOperator<Matrix,Field>;
@@ -646,12 +535,11 @@ template<class Field> class OperatorFunction {
 public:
  virtual void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) = 0;
  virtual void operator() (LinearOperatorBase<Field> &Linop, const std::vector<Field> &in,std::vector<Field> &out) {
-    GRID_ASSERT(in.size()==out.size());
+    assert(in.size()==out.size());
    for(int k=0;k<in.size();k++){
      (*this)(Linop,in[k],out[k]);
    }
  };
-  virtual ~OperatorFunction(){};
 };

 template<class Field> class LinearFunction {
@@ -660,14 +548,13 @@ public:

  virtual void operator() (const std::vector<Field> &in, std::vector<Field> &out)
  {
-    GRID_ASSERT(in.size() == out.size());
+    assert(in.size() == out.size());

    for (unsigned int i = 0; i < in.size(); ++i)
    {
      (*this)(in[i], out[i]);
    }
  }
-  virtual ~LinearFunction(){};
 };

 template<class Field> class IdentityLinearFunction : public LinearFunction<Field> {
@@ -713,7 +600,6 @@ class HermOpOperatorFunction : public OperatorFunction<Field> {
 template<typename Field>
 class PlainHermOp : public LinearFunction<Field> {
 public:
-  using LinearFunction<Field>::operator();
  LinearOperatorBase<Field> &_Linop;
      
  PlainHermOp(LinearOperatorBase<Field>& linop) : _Linop(linop) 
@@ -727,7 +613,6 @@ public:
 template<typename Field>
 class FunctionHermOp : public LinearFunction<Field> {
 public:
-  using LinearFunction<Field>::operator(); 
  OperatorFunction<Field>   & _poly;
  LinearOperatorBase<Field> &_Linop;
      
@@ -30,19 +30,13 @@ Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>

 NAMESPACE_BEGIN(Grid);

-template<class Field> using Preconditioner =  LinearFunction<Field> ;
-
-/*
-template<class Field> class Preconditioner :  public LinearFunction<Field> {
-  using LinearFunction<Field>::operator();
+template<class Field> class Preconditioner :  public LinearFunction<Field> { 
  virtual void operator()(const Field &src, Field & psi)=0;
 };
-*/

 template<class Field> class TrivialPrecon :  public Preconditioner<Field> { 
 public:
-  using Preconditioner<Field>::operator();
-  virtual void operator()(const Field &src, Field & psi){
+  void operator()(const Field &src, Field & psi){
    psi = src;
  }
  TrivialPrecon(void){};
@@ -45,15 +45,9 @@ public:
    M(in,tmp);
    Mdag(tmp,out);
  }
-  virtual void  MMdag(const Field &in, Field &out) {
-    Field tmp (in.Grid());
-    Mdag(in,tmp);
-    M(tmp,out);
-  }
  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;
-  virtual ~SparseMatrixBase() {};
 };

 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -78,7 +72,7 @@ public:
  virtual  void MeooeDag    (const Field &in, Field &out)=0;
  virtual  void MooeeDag    (const Field &in, Field &out)=0;
  virtual  void MooeeInvDag (const Field &in, Field &out)=0;
-  virtual ~CheckerBoardedSparseMatrixBase() {};
+
 };

 NAMESPACE_END(Grid);
@@ -59,7 +59,7 @@ public:
    RealD diff = hi-lo;
    RealD delta = diff*1.0e-9;
    for (RealD x=lo; x<hi; x+=delta) {
-      delta*=1.02;
+      delta*=1.1;
      RealD f = approx(x);
      out<< x<<" "<<f<<std::endl;
    }
@@ -90,8 +90,9 @@ public:
    order=_order;
      
    if(order < 2) exit(-1);
-    Coeffs.resize(order,0.0);
-    Coeffs[order-1] = 1.0;
+    Coeffs.resize(order);
+    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.
@@ -131,26 +132,6 @@ public:
      Coeffs[j] = s * 2.0/order;
    }
  };
-  template<class functor>
-  void Init(RealD _lo,RealD _hi,int _order, functor & func)
-  {
-    lo=_lo;
-    hi=_hi;
-    order=_order;
-      
-    if(order < 2) exit(-1);
-    Coeffs.resize(order);
-    for(int j=0;j<order;j++){
-      RealD s=0;
-      for(int k=0;k<order;k++){
-	RealD y=std::cos(M_PI*(k+0.5)/order);
-	RealD x=0.5*(y*(hi-lo)+(hi+lo));
-	RealD f=func(x);
-	s=s+f*std::cos( j*M_PI*(k+0.5)/order );
-      }
-      Coeffs[j] = s * 2.0/order;
-    }
-  };

    
  void JacksonSmooth(void){
@@ -269,9 +250,7 @@ public:
    RealD xscale = 2.0/(hi-lo);
    RealD mscale = -(hi+lo)/(hi-lo);
    Linop.HermOp(T0,y);
-    grid->Barrier();
    axpby(T1,xscale,mscale,y,in);
-    grid->Barrier();

    // sum = .5 c[0] T0 + c[1] T1
    //    out = ()*T0 + Coeffs[1]*T1;
@@ -279,12 +258,26 @@ public:
    for(int n=2;n<order;n++){

      Linop.HermOp(*Tn,y);
+#if 0
+      auto y_v = y.View();
+      auto Tn_v = Tn->View();
+      auto Tnp_v = Tnp->View();
+      auto Tnm_v = Tnm->View();
+      constexpr int Nsimd = vector_type::Nsimd();
+      accelerator_forNB(ss, in.Grid()->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));
+      });
+      if ( Coeffs[n] != 0.0) {
+	axpy(out,Coeffs[n],*Tnp,out);
+      }
+#else
      axpby(y,xscale,mscale,y,(*Tn));
      axpby(*Tnp,2.0,-1.0,y,(*Tnm));
      if ( Coeffs[n] != 0.0) {
 	axpy(out,Coeffs[n],*Tnp,out);
      }
-
+#endif
      // Cycle pointers to avoid copies
      Field *swizzle = Tnm;
      Tnm    =Tn;
@@ -299,6 +292,7 @@ public:
 template<class Field>
 class ChebyshevLanczos : public Chebyshev<Field> {
 private:
+
  std::vector<RealD> Coeffs;
  int order;
  RealD alpha;
@@ -40,7 +40,7 @@ public:
  RealD norm;
  RealD lo,hi;

-  MultiShiftFunction(int n,RealD _lo,RealD _hi): poles(n), residues(n), tolerances(n), lo(_lo), hi(_hi) {;};
+  MultiShiftFunction(int n,RealD _lo,RealD _hi): poles(n), residues(n), lo(_lo), hi(_hi) {;};
  RealD approx(RealD x);
  void csv(std::ostream &out);
  void gnuplot(std::ostream &out);
@@ -121,7 +121,7 @@ double AlgRemez::generateApprox(int num_degree, int den_degree,
  // Reallocate arrays, since degree has changed
  if (num_degree != n || den_degree != d) allocate(num_degree,den_degree);

-  GRID_ASSERT(a_len<=SUM_MAX);
+  assert(a_len<=SUM_MAX);

  step = new bigfloat[num_degree+den_degree+2];

@@ -151,9 +151,9 @@ double AlgRemez::generateApprox(int num_degree, int den_degree,
    equations();
    if (delta < tolerance) {
      std::cout<<"Delta too small, try increasing precision\n";
-      GRID_ASSERT(0);
+      assert(0);
    };    
-    GRID_ASSERT( delta>= tolerance);
+    assert( delta>= tolerance);

    search(step);
  }
@@ -134,7 +134,7 @@ class AlgRemez
  virtual ~AlgRemez();

  int getDegree(void){ 
-    GRID_ASSERT(n==d);
+    assert(n==d);
    return n;
  }
  // Reset the bounds of the approximation
@@ -28,11 +28,11 @@ void AlgRemezGeneral::setupPolyProperties(int num_degree, int den_degree, PolyTy
  pow_n = num_degree;
  pow_d = den_degree;

-  if(pow_n % 2 == 0 && num_type_in == PolyType::Odd) GRID_ASSERT(0);
-  if(pow_n % 2 == 1 && num_type_in == PolyType::Even) GRID_ASSERT(0);
+  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) GRID_ASSERT(0);
-  if(pow_d % 2 == 1 && den_type_in == PolyType::Even) GRID_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;
@@ -112,9 +112,9 @@ double AlgRemezGeneral::generateApprox(const int num_degree, const int den_degre
    equations();
    if (delta < tolerance) {
      std::cout<<"Iteration " << iter-1 << " delta too small (" << delta << "<" << tolerance << "), try increasing precision\n";
-      GRID_ASSERT(0);
+      assert(0);
    };    
-    GRID_ASSERT( delta>= tolerance );
+    assert( delta>= tolerance );

    search();
  }
@@ -278,7 +278,7 @@ void AlgRemezGeneral::equations(){
      if(num_pows[j] != -1){ *aa++ = z; t++; }
      z *= x;
    }
-    GRID_ASSERT(t == n+1);
+    assert(t == n+1);

    z = (bigfloat)1l;
    t = 0;
@@ -286,7 +286,7 @@ void AlgRemezGeneral::equations(){
      if(den_pows[j] != -1){ *aa++ = -y * z; t++; }
      z *= x;
    }
-    GRID_ASSERT(t == d);
+    assert(t == d);

    B[i] = y * z;		// Right hand side vector
  }
@@ -106,7 +106,7 @@ class AlgRemezGeneral{
 		  bigfloat (*f)(bigfloat x, void *data), void *data);

  inline int getDegree(void) const{ 
-    GRID_ASSERT(n==d);
+    assert(n==d);
    return n;
  }
  // Reset the bounds of the approximation
@@ -74,7 +74,7 @@ bigfloat epsilonMobius(bigfloat x, void* data){
 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){
-  GRID_ASSERT(omega_in.size() == Ls_in);
+  assert(omega_in.size() == Ls_in);
  omega_out.resize(Ls_out);

  //Use the Remez algorithm to generate the appropriate rational polynomial
@@ -293,7 +293,7 @@ static void sncndnFK(INTERNAL_PRECISION u, INTERNAL_PRECISION k,
 * Set type = 0 for the Zolotarev approximation, which is zero at x = 0, and
 * type = 1 for the approximation which is infinite at x = 0. */

-zolotarev_data* zolotarev(ZOLO_PRECISION epsilon, int n, int type) {
+zolotarev_data* zolotarev(PRECISION epsilon, int n, int type) {
  INTERNAL_PRECISION A, c, cp, kp, ksq, sn, cn, dn, Kp, Kj, z, z0, t, M, F,
    l, invlambda, xi, xisq, *tv, s, opl;
  int m, czero, ts;
@@ -375,12 +375,12 @@ zolotarev_data* zolotarev(ZOLO_PRECISION epsilon, int n, int type) {
  construct_partfrac(d);
  construct_contfrac(d);

-  /* Converting everything to ZOLO_PRECISION for external use only */
+  /* Converting everything to PRECISION for external use only */

  zd = (zolotarev_data*) malloc(sizeof(zolotarev_data));
-  zd -> A = (ZOLO_PRECISION) d -> A;
-  zd -> Delta = (ZOLO_PRECISION) d -> Delta;
-  zd -> epsilon = (ZOLO_PRECISION) d -> epsilon;
+  zd -> A = (PRECISION) d -> A;
+  zd -> Delta = (PRECISION) d -> Delta;
+  zd -> epsilon = (PRECISION) d -> epsilon;
  zd -> n = d -> n;
  zd -> type = d -> type;
  zd -> dn = d -> dn;
@@ -390,24 +390,24 @@ zolotarev_data* zolotarev(ZOLO_PRECISION epsilon, int n, int type) {
  zd -> deg_num = d -> deg_num;
  zd -> deg_denom = d -> deg_denom;

-  zd -> a = (ZOLO_PRECISION*) malloc(zd -> dn * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> dn; m++) zd -> a[m] = (ZOLO_PRECISION) d -> a[m];
+  zd -> a = (PRECISION*) malloc(zd -> dn * sizeof(PRECISION));
+  for (m = 0; m < zd -> dn; m++) zd -> a[m] = (PRECISION) d -> a[m];
  free(d -> a);

-  zd -> ap = (ZOLO_PRECISION*) malloc(zd -> dd * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> dd; m++) zd -> ap[m] = (ZOLO_PRECISION) d -> ap[m];
+  zd -> ap = (PRECISION*) malloc(zd -> dd * sizeof(PRECISION));
+  for (m = 0; m < zd -> dd; m++) zd -> ap[m] = (PRECISION) d -> ap[m];
  free(d -> ap);

-  zd -> alpha = (ZOLO_PRECISION*) malloc(zd -> da * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> da; m++) zd -> alpha[m] = (ZOLO_PRECISION) d -> alpha[m];
+  zd -> alpha = (PRECISION*) malloc(zd -> da * sizeof(PRECISION));
+  for (m = 0; m < zd -> da; m++) zd -> alpha[m] = (PRECISION) d -> alpha[m];
  free(d -> alpha);

-  zd -> beta = (ZOLO_PRECISION*) malloc(zd -> db * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> db; m++) zd -> beta[m] = (ZOLO_PRECISION) d -> beta[m];
+  zd -> beta = (PRECISION*) malloc(zd -> db * sizeof(PRECISION));
+  for (m = 0; m < zd -> db; m++) zd -> beta[m] = (PRECISION) d -> beta[m];
  free(d -> beta);

-  zd -> gamma = (ZOLO_PRECISION*) malloc(zd -> n * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> n; m++) zd -> gamma[m] = (ZOLO_PRECISION) d -> gamma[m];
+  zd -> gamma = (PRECISION*) malloc(zd -> n * sizeof(PRECISION));
+  for (m = 0; m < zd -> n; m++) zd -> gamma[m] = (PRECISION) d -> gamma[m];
  free(d -> gamma);

  free(d);
@@ -426,7 +426,7 @@ void zolotarev_free(zolotarev_data *zdata)
 }


-zolotarev_data* higham(ZOLO_PRECISION epsilon, int n) {
+zolotarev_data* higham(PRECISION epsilon, int n) {
  INTERNAL_PRECISION A, M, c, cp, z, z0, t, epssq;
  int m, czero;
  zolotarev_data *zd;
@@ -481,9 +481,9 @@ zolotarev_data* higham(ZOLO_PRECISION epsilon, int n) {
  /* Converting everything to PRECISION for external use only */

  zd = (zolotarev_data*) malloc(sizeof(zolotarev_data));
-  zd -> A = (ZOLO_PRECISION) d -> A;
-  zd -> Delta = (ZOLO_PRECISION) d -> Delta;
-  zd -> epsilon = (ZOLO_PRECISION) d -> epsilon;
+  zd -> A = (PRECISION) d -> A;
+  zd -> Delta = (PRECISION) d -> Delta;
+  zd -> epsilon = (PRECISION) d -> epsilon;
  zd -> n = d -> n;
  zd -> type = d -> type;
  zd -> dn = d -> dn;
@@ -493,24 +493,24 @@ zolotarev_data* higham(ZOLO_PRECISION epsilon, int n) {
  zd -> deg_num = d -> deg_num;
  zd -> deg_denom = d -> deg_denom;

-  zd -> a = (ZOLO_PRECISION*) malloc(zd -> dn * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> dn; m++) zd -> a[m] = (ZOLO_PRECISION) d -> a[m];
+  zd -> a = (PRECISION*) malloc(zd -> dn * sizeof(PRECISION));
+  for (m = 0; m < zd -> dn; m++) zd -> a[m] = (PRECISION) d -> a[m];
  free(d -> a);

-  zd -> ap = (ZOLO_PRECISION*) malloc(zd -> dd * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> dd; m++) zd -> ap[m] = (ZOLO_PRECISION) d -> ap[m];
+  zd -> ap = (PRECISION*) malloc(zd -> dd * sizeof(PRECISION));
+  for (m = 0; m < zd -> dd; m++) zd -> ap[m] = (PRECISION) d -> ap[m];
  free(d -> ap);

-  zd -> alpha = (ZOLO_PRECISION*) malloc(zd -> da * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> da; m++) zd -> alpha[m] = (ZOLO_PRECISION) d -> alpha[m];
+  zd -> alpha = (PRECISION*) malloc(zd -> da * sizeof(PRECISION));
+  for (m = 0; m < zd -> da; m++) zd -> alpha[m] = (PRECISION) d -> alpha[m];
  free(d -> alpha);

-  zd -> beta = (ZOLO_PRECISION*) malloc(zd -> db * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> db; m++) zd -> beta[m] = (ZOLO_PRECISION) d -> beta[m];
+  zd -> beta = (PRECISION*) malloc(zd -> db * sizeof(PRECISION));
+  for (m = 0; m < zd -> db; m++) zd -> beta[m] = (PRECISION) d -> beta[m];
  free(d -> beta);

-  zd -> gamma = (ZOLO_PRECISION*) malloc(zd -> n * sizeof(ZOLO_PRECISION));
-  for (m = 0; m < zd -> n; m++) zd -> gamma[m] = (ZOLO_PRECISION) d -> gamma[m];
+  zd -> gamma = (PRECISION*) malloc(zd -> n * sizeof(PRECISION));
+  for (m = 0; m < zd -> n; m++) zd -> gamma[m] = (PRECISION) d -> gamma[m];
  free(d -> gamma);

  free(d);
@@ -523,17 +523,17 @@ NAMESPACE_END(Grid);
 #ifdef TEST

 #undef ZERO
-#define ZERO ((ZOLO_PRECISION) 0)
+#define ZERO ((PRECISION) 0)
 #undef ONE
-#define ONE ((ZOLO_PRECISION) 1)
+#define ONE ((PRECISION) 1)
 #undef TWO
-#define TWO ((ZOLO_PRECISION) 2)
+#define TWO ((PRECISION) 2)

 /* Evaluate the rational approximation R(x) using the factored form */

-static ZOLO_PRECISION zolotarev_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
+static PRECISION zolotarev_eval(PRECISION x, zolotarev_data* rdata) {
  int m;
-  ZOLO_PRECISION R;
+  PRECISION R;

  if (rdata -> type == 0) {
    R = rdata -> A * x;
@@ -551,9 +551,9 @@ static ZOLO_PRECISION zolotarev_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {

 /* Evaluate the rational approximation R(x) using the partial fraction form */

-static ZOLO_PRECISION zolotarev_partfrac_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
+static PRECISION zolotarev_partfrac_eval(PRECISION x, zolotarev_data* rdata) {
  int m;
-  ZOLO_PRECISION R = rdata -> alpha[rdata -> da - 1];
+  PRECISION R = rdata -> alpha[rdata -> da - 1];
  for (m = 0; m < rdata -> dd; m++)
    R += rdata -> alpha[m] / (x * x - rdata -> ap[m]);
  if (rdata -> type == 1) R += rdata -> alpha[rdata -> dd] / (x * x);
@@ -568,18 +568,18 @@ static ZOLO_PRECISION zolotarev_partfrac_eval(ZOLO_PRECISION x, zolotarev_data*
 * non-signalling overflow this will work correctly since 1/(1/0) = 1/INF = 0,
 * but with signalling overflow you will get an error message. */

-static ZOLO_PRECISION zolotarev_contfrac_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
+static PRECISION zolotarev_contfrac_eval(PRECISION x, zolotarev_data* rdata) {
  int m;
-  ZOLO_PRECISION R = rdata -> beta[0] * x;
+  PRECISION R = rdata -> beta[0] * x;
  for (m = 1; m < rdata -> db; m++) R = rdata -> beta[m] * x + ONE / R;
  return R;
 }    

 /* Evaluate the rational approximation R(x) using Cayley form */

-static ZOLO_PRECISION zolotarev_cayley_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
+static PRECISION zolotarev_cayley_eval(PRECISION x, zolotarev_data* rdata) {
  int m;
-  ZOLO_PRECISION T;
+  PRECISION T;

  T = rdata -> type == 0 ? ONE : -ONE;
  for (m = 0; m < rdata -> n; m++)
@@ -607,7 +607,7 @@ int main(int argc, char** argv) {
  int m, n, plotpts = 5000, type = 0;
  float eps, x, ypferr, ycferr, ycaylerr, maxypferr, maxycferr, maxycaylerr;
  zolotarev_data *rdata;
-  ZOLO_PRECISION y;
+  PRECISION y;
  FILE *plot_function, *plot_error, 
    *plot_partfrac, *plot_contfrac, *plot_cayley;

@@ -626,13 +626,13 @@ int main(int argc, char** argv) {
  }

  rdata = type == 2 
-    ? higham((ZOLO_PRECISION) eps, n) 
-    : zolotarev((ZOLO_PRECISION) eps, n, type);
+    ? higham((PRECISION) eps, n) 
+    : zolotarev((PRECISION) eps, n, type);

  printf("Zolotarev Test: R(epsilon = %g, n = %d, type = %d)\n\t" 
 	 STRINGIFY(VERSION) "\n\t" STRINGIFY(HVERSION)
 	 "\n\tINTERNAL_PRECISION = " STRINGIFY(INTERNAL_PRECISION)
-	 "\tZOLO_PRECISION = " STRINGIFY(ZOLO_PRECISION)
+	 "\tPRECISION = " STRINGIFY(PRECISION)
 	 "\n\n\tRational approximation of degree (%d,%d), %s at x = 0\n"
 	 "\tDelta = %g (maximum error)\n\n"
 	 "\tA = %g (overall factor)\n",
@@ -681,15 +681,15 @@ int main(int argc, char** argv) {
    x = 2.4 * (float) m / plotpts - 1.2;
    if (rdata -> type == 0 || fabs(x) * (float) plotpts > 1.0) {
      /* skip x = 0 for type 1, as R(0) is singular */
-      y = zolotarev_eval((ZOLO_PRECISION) x, rdata);
+      y = zolotarev_eval((PRECISION) x, rdata);
      fprintf(plot_function, "%g %g\n", x, (float) y);
      fprintf(plot_error, "%g %g\n",
 	      x, (float)((y - ((x > 0.0 ? ONE : -ONE))) / rdata -> Delta));
-      ypferr = (float)((zolotarev_partfrac_eval((ZOLO_PRECISION) x, rdata) - y)
+      ypferr = (float)((zolotarev_partfrac_eval((PRECISION) x, rdata) - y)
 		       / rdata -> Delta);
-      ycferr = (float)((zolotarev_contfrac_eval((ZOLO_PRECISION) x, rdata) - y)
+      ycferr = (float)((zolotarev_contfrac_eval((PRECISION) x, rdata) - y)
 		       / rdata -> Delta);
-      ycaylerr = (float)((zolotarev_cayley_eval((ZOLO_PRECISION) x, rdata) - y)
+      ycaylerr = (float)((zolotarev_cayley_eval((PRECISION) x, rdata) - y)
 		       / rdata -> Delta);
      if (fabs(x) < 1.0 && fabs(x) > rdata -> epsilon) {
 	maxypferr = MAX(maxypferr, fabs(ypferr));
@@ -9,10 +9,10 @@ NAMESPACE_BEGIN(Approx);
 #define HVERSION Header Time-stamp: <14-OCT-2004 09:26:51.00 adk@MISSCONTRARY>

 #ifndef ZOLOTAREV_INTERNAL
-#ifndef ZOLO_PRECISION
-#define ZOLO_PRECISION double
+#ifndef PRECISION
+#define PRECISION double
 #endif
-#define ZPRECISION ZOLO_PRECISION
+#define ZPRECISION PRECISION
 #define ZOLOTAREV_DATA zolotarev_data
 #endif

@@ -77,8 +77,8 @@ typedef struct {
 * zolotarev_data structure. The arguments must satisfy the constraints that
 * epsilon > 0, n > 0, and type = 0 or 1. */

-ZOLOTAREV_DATA* higham(ZOLO_PRECISION epsilon, int n) ;
-ZOLOTAREV_DATA* zolotarev(ZOLO_PRECISION epsilon, int n, int type);
+ZOLOTAREV_DATA* higham(PRECISION epsilon, int n) ;
+ZOLOTAREV_DATA* zolotarev(PRECISION epsilon, int n, int type);
 void zolotarev_free(zolotarev_data *zdata);
 #endif

@@ -86,4 +86,3 @@ void zolotarev_free(zolotarev_data *zdata);
 NAMESPACE_END(Approx);
 NAMESPACE_END(Grid);
 #endif
-
@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: BatchedBlas.h
-
-    Copyright (C) 2023
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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/GridCore.h>
-#include <Grid/algorithms/blas/BatchedBlas.h>
-NAMESPACE_BEGIN(Grid);
-gridblasHandle_t GridBLAS::gridblasHandle;
-int              GridBLAS::gridblasInit;
-NAMESPACE_END(Grid);
-
@@ -1,362 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: BatchedInverse.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-#include <Grid/algorithms/blas/BatchedBlas.h>
-
-#ifdef GRID_HIP
-#include <rocsolver/rocsolver.h>
-#endif
-// GRID_CUDA: batched LU inversion lives in cuBLAS (getrfBatched/getriBatched);
-//            cublas_v2.h already included via BatchedBlas.h.
-// GRID_SYCL: oneapi/mkl.hpp already included via BatchedBlas.h (lapack::getrf/getri).
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// GridBLASInverse: cross-platform batched dense matrix inversion.
-//
-// HIGH LEVEL contract (deliberately NOT a getrf/getrs interface): invert a
-// batch of dense N x N matrices IN PLACE,
-//
-//     A[i] <- A[i]^{-1}       i = 0 .. batchCount-1
-//
-// Layout: column major, lda = N, contiguous per batch element; pointer list
-// exactly as GridBLAS::gemmBatched (deviceVector<T*> of device pointers).
-// Each backend chooses HOW:
-//   HIP  : rocSOLVER getrf_batched + getri_batched
-//   CUDA : cuBLAS getrfBatched + getriBatched (out-of-place getri; workspace
-//          hidden here, result copied back so the surface stays in-place)
-//   SYCL : oneMKL LAPACK getrf + getri per batch element (USM, in-order queue)
-//   CPU  : Eigen PartialPivLU (the correctness oracle for all of the above)
-//
-// The int32 vendor-batched entry points bound N < 2^31 (asserted); the huge
-// single-matrix ILP64 path (getrf_64 + blocked identity-getrs harvest, proven
-// in the dense coarse-coarse setup at N=69120) migrates here as a batch==1
-// large-N dispatch in a follow-up -- the recursive Schur leaves are the
-// batched consumers this surface is shaped for.
-//
-// NB GPU-backend call signatures are written to vendor documentation but the
-// air-gapped development loop compiles only the CPU/Eigen path; verify the
-// rocSOLVER/cuBLAS/oneMKL calls against headers on first device compile.
-// Semantics are locked by the CPU unit test (Test_batched_blas).
-///////////////////////////////////////////////////////////////////////////////
-class GridBLASInverse {
-public:
-
-#ifdef GRID_HIP
-  // rocSOLVER runs on a rocblas_handle (distinct type from hipblasHandle_t)
-  static rocblas_handle & Handle(void) {
-    static rocblas_handle h;
-    static int init = 0;
-    if ( !init ) {
-      auto st = rocblas_create_handle(&h);
-      GRID_ASSERT(st == rocblas_status_success);
-      init = 1;
-    }
-    return h;
-  }
-#endif
-#ifdef GRID_CUDA
-  // cuBLAS batched LU shares the GridBLAS handle
-  static cublasHandle_t & Handle(void) {
-    GridBLAS::Init();
-    return GridBLAS::gridblasHandle;
-  }
-#endif
-#ifdef GRID_SYCL
-  static sycl::queue * & Handle(void) {
-    GridBLAS::Init();
-    return GridBLAS::gridblasHandle;
-  }
-#endif
-
-  GridBLASInverse() {};
-  ~GridBLASInverse() {};
-
-  ///////////////////////////////////////////////////////////////////////////
-  // SINGLE large matrix, in place: blocked LU + identity solve.
-  //   HIP : rocsolver_zgetrf_64 (blocked, GEMM-based) then ONE zgetrs_64 with
-  //         the N x N identity as RHS (trsm-based) into a scratch N x N, copied
-  //         back.  Extra device memory: N*N*16 B (1.2 GB at N=8640).
-  //   other backends: falls through to inverseBatched(batch 1).
-  // Why: rocSOLVER getri_batched is a small-matrix routine -- measured 0.35 s
-  // at N=1920, 0.53 s at 4320, 1.84 s at 8640 (n^1.2-1.8, i.e. overhead
-  // bound) as the big-leaf inverse of the 2D Schur recursion, where 287
-  // ranks wait on it.  The _64 getrf/getrs pair is the path proven in the
-  // 1-rank dense coarse-coarse setup at N=69120 (DenseCoarseMatrix.h).
-  // Same in-place, column-major, lda=N contract as inverseBatched.
-  // ComplexD and ComplexF overloads (z*_64 / c*_64), so the distributed
-  // dense inverse can run in either precision (DenseInverseScalar).
-  // NB: written to rocSOLVER's documented *_64 signatures; not compiled on
-  // HIP in the air-gapped loop -- verify on first hipcc build.
-  ///////////////////////////////////////////////////////////////////////////
-  double lastGetrfUs = 0.0, lastGetrsUs = 0.0;   // split timing of the last inverseLU (HIP path)
-  void inverseLU(int64_t N, ComplexD *A)
-  {
-#ifdef GRID_HIP
-    rocblas_handle handle = Handle();
-    deviceVector<int64_t>  ipiv((uint64_t)N);
-    deviceVector<int64_t>  info(1);
-    double t0 = usecond();
-    auto st1 = rocsolver_zgetrf_64(handle, N, N, (rocblas_double_complex *)A, N, &ipiv[0], &info[0]);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    accelerator_barrier();
-    lastGetrfUs = usecond()-t0;
-    int64_t info_h = -1; acceleratorCopyFromDevice(&info[0], &info_h, sizeof(int64_t));
-    GRID_ASSERT(info_h == 0);
-    deviceVector<ComplexD> X((uint64_t)N*N);
-    { ComplexD *x = &X[0]; const int64_t NN = N;
-      accelerator_for(idx, (uint64_t)N*N, 1, { int64_t j = idx/NN, i = idx - j*NN; x[idx] = (i==j) ? ComplexD(1.0,0.0) : ComplexD(0.0,0.0); });
-      accelerator_barrier(); }
-    auto st2 = rocsolver_zgetrs_64(handle, rocblas_operation_none, N, N,
-                                   (rocblas_double_complex *)A, N, &ipiv[0],
-                                   (rocblas_double_complex *)&X[0], N);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    lastGetrsUs = usecond()-t0-lastGetrfUs;
-    acceleratorCopyDeviceToDevice((void *)&X[0], (void *)A, (uint64_t)N*N*sizeof(ComplexD));
-#else
-    deviceVector<ComplexD*> bp(1); std::vector<ComplexD*> ptr(1); ptr[0] = A;
-    acceleratorCopyToDevice(&ptr[0], &bp[0], sizeof(ComplexD*));
-    inverseBatched(N, bp);
-#endif
-  }
-  // fp32 overload: the Schur-recursion leaf under --enable-dense-inverse-precision=single
-  void inverseLU(int64_t N, ComplexF *A)
-  {
-#ifdef GRID_HIP
-    rocblas_handle handle = Handle();
-    deviceVector<int64_t>  ipiv((uint64_t)N);
-    deviceVector<int64_t>  info(1);
-    double t0 = usecond();
-    auto st1 = rocsolver_cgetrf_64(handle, N, N, (rocblas_float_complex *)A, N, &ipiv[0], &info[0]);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    accelerator_barrier();
-    lastGetrfUs = usecond()-t0;
-    int64_t info_h = -1; acceleratorCopyFromDevice(&info[0], &info_h, sizeof(int64_t));
-    GRID_ASSERT(info_h == 0);
-    deviceVector<ComplexF> X((uint64_t)N*N);
-    { ComplexF *x = &X[0]; const int64_t NN = N;
-      accelerator_for(idx, (uint64_t)N*N, 1, { int64_t j = idx/NN, i = idx - j*NN; x[idx] = (i==j) ? ComplexF(1.0,0.0) : ComplexF(0.0,0.0); });
-      accelerator_barrier(); }
-    auto st2 = rocsolver_cgetrs_64(handle, rocblas_operation_none, N, N,
-                                   (rocblas_float_complex *)A, N, &ipiv[0],
-                                   (rocblas_float_complex *)&X[0], N);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    lastGetrsUs = usecond()-t0-lastGetrfUs;
-    acceleratorCopyDeviceToDevice((void *)&X[0], (void *)A, (uint64_t)N*N*sizeof(ComplexF));
-#else
-    deviceVector<ComplexF*> bp(1); std::vector<ComplexF*> ptr(1); ptr[0] = A;
-    acceleratorCopyToDevice(&ptr[0], &bp[0], sizeof(ComplexF*));
-    inverseBatched(N, bp);
-#endif
-  }
-
-  void inverseBatched(int64_t N, deviceVector<ComplexF*> &Amat)
-  {
-    int32_t batchCount = Amat.size();
-    GRID_ASSERT(batchCount > 0);
-
-#ifdef GRID_HIP
-    GRID_ASSERT( N < 2147483647L );
-    rocblas_int n   = (rocblas_int)N;
-    rocblas_int lda = (rocblas_int)N;
-
-    deviceVector<rocblas_int> ipiv((uint64_t)batchCount*N);
-    deviceVector<rocblas_int> info(batchCount);
-
-    auto st1 = rocsolver_cgetrf_batched(Handle(), n, n,
-					(rocblas_float_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    auto st2 = rocsolver_cgetri_batched(Handle(), n,
-					(rocblas_float_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    std::vector<rocblas_int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(rocblas_int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0); // singular pivot => abort loudly
-#endif
-#ifdef GRID_CUDA
-    GRID_ASSERT( N < 2147483647L );
-    int n = (int)N;
-
-    deviceVector<int> ipiv((uint64_t)batchCount*N);
-    deviceVector<int> info(batchCount);
-
-    auto st1 = cublasCgetrfBatched(Handle(), n,
-				   (cuComplex **)&Amat[0], n,
-				   &ipiv[0], &info[0], batchCount);
-    GRID_ASSERT(st1 == CUBLAS_STATUS_SUCCESS);
-
-    // getri is OUT of place: hidden workspace keeps the surface in-place
-    deviceVector<ComplexF>  work((uint64_t)batchCount*N*N);
-    deviceVector<ComplexF*> Cptr(batchCount);
-    std::vector<ComplexF*>  Cptr_h(batchCount);
-    std::vector<ComplexF*>  Aptr_h(batchCount);
-    for(int i=0;i<batchCount;i++) Cptr_h[i] = &work[(uint64_t)i*N*N];
-    acceleratorCopyToDevice(&Cptr_h[0],&Cptr[0],batchCount*sizeof(ComplexF*));
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexF*));
-
-    auto st2 = cublasCgetriBatched(Handle(), n,
-				   (const cuComplex *const *)&Amat[0], n,
-				   &ipiv[0],
-				   (cuComplex **)&Cptr[0], n,
-				   &info[0], batchCount);
-    GRID_ASSERT(st2 == CUBLAS_STATUS_SUCCESS);
-    accelerator_barrier();
-    std::vector<int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-    for(int i=0;i<batchCount;i++)
-      acceleratorCopyDeviceToDevice(Cptr_h[i],Aptr_h[i],(uint64_t)N*N*sizeof(ComplexF));
-#endif
-#ifdef GRID_SYCL
-    // Per-element oneMKL LAPACK on the in-order queue; group API optimisation later.
-    sycl::queue *q = Handle();
-    std::vector<ComplexF*> Aptr_h(batchCount);
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexF*));
-
-    int64_t lwf = oneapi::mkl::lapack::getrf_scratchpad_size<std::complex<float> >(*q,N,N,N);
-    int64_t lwi = oneapi::mkl::lapack::getri_scratchpad_size<std::complex<float> >(*q,N,N);
-    deviceVector<ComplexF> scratchf(lwf);
-    deviceVector<ComplexF> scratchi(lwi);
-    deviceVector<int64_t>  ipiv(N);
-    for(int i=0;i<batchCount;i++){
-      oneapi::mkl::lapack::getrf(*q,N,N,(std::complex<float>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<float>*)&scratchf[0],lwf);
-      oneapi::mkl::lapack::getri(*q,N,  (std::complex<float>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<float>*)&scratchi[0],lwi);
-    }
-    q->wait();
-#endif
-#if !defined(GRID_SYCL) && !defined(GRID_CUDA) && !defined(GRID_HIP)
-    // Reference implementation; the oracle the unit test locks semantics with.
-    thread_for (p, batchCount, {
-      Eigen::Map<Eigen::MatrixXcf> eA(Amat[p],N,N);
-      Eigen::PartialPivLU<Eigen::MatrixXcf> lu(eA);
-      eA = lu.inverse();
-      });
-#endif
-  }
-
-  void inverseBatched(int64_t N, deviceVector<ComplexD*> &Amat)
-  {
-    int32_t batchCount = Amat.size();
-    GRID_ASSERT(batchCount > 0);
-
-#ifdef GRID_HIP
-    GRID_ASSERT( N < 2147483647L );
-    rocblas_int n   = (rocblas_int)N;
-    rocblas_int lda = (rocblas_int)N;
-
-    deviceVector<rocblas_int> ipiv((uint64_t)batchCount*N);
-    deviceVector<rocblas_int> info(batchCount);
-
-    auto st1 = rocsolver_zgetrf_batched(Handle(), n, n,
-					(rocblas_double_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st1 == rocblas_status_success);
-    auto st2 = rocsolver_zgetri_batched(Handle(), n,
-					(rocblas_double_complex *const *)&Amat[0], lda,
-					&ipiv[0], (rocblas_stride)N,
-					&info[0], batchCount);
-    GRID_ASSERT(st2 == rocblas_status_success);
-    accelerator_barrier();
-    std::vector<rocblas_int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(rocblas_int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-#endif
-#ifdef GRID_CUDA
-    GRID_ASSERT( N < 2147483647L );
-    int n = (int)N;
-
-    deviceVector<int> ipiv((uint64_t)batchCount*N);
-    deviceVector<int> info(batchCount);
-
-    auto st1 = cublasZgetrfBatched(Handle(), n,
-				   (cuDoubleComplex **)&Amat[0], n,
-				   &ipiv[0], &info[0], batchCount);
-    GRID_ASSERT(st1 == CUBLAS_STATUS_SUCCESS);
-
-    deviceVector<ComplexD>  work((uint64_t)batchCount*N*N);
-    deviceVector<ComplexD*> Cptr(batchCount);
-    std::vector<ComplexD*>  Cptr_h(batchCount);
-    std::vector<ComplexD*>  Aptr_h(batchCount);
-    for(int i=0;i<batchCount;i++) Cptr_h[i] = &work[(uint64_t)i*N*N];
-    acceleratorCopyToDevice(&Cptr_h[0],&Cptr[0],batchCount*sizeof(ComplexD*));
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexD*));
-
-    auto st2 = cublasZgetriBatched(Handle(), n,
-				   (const cuDoubleComplex *const *)&Amat[0], n,
-				   &ipiv[0],
-				   (cuDoubleComplex **)&Cptr[0], n,
-				   &info[0], batchCount);
-    GRID_ASSERT(st2 == CUBLAS_STATUS_SUCCESS);
-    accelerator_barrier();
-    std::vector<int> info_h(batchCount);
-    acceleratorCopyFromDevice(&info[0],&info_h[0],batchCount*sizeof(int));
-    for(int i=0;i<batchCount;i++) GRID_ASSERT(info_h[i]==0);
-    for(int i=0;i<batchCount;i++)
-      acceleratorCopyDeviceToDevice(Cptr_h[i],Aptr_h[i],(uint64_t)N*N*sizeof(ComplexD));
-#endif
-#ifdef GRID_SYCL
-    sycl::queue *q = Handle();
-    std::vector<ComplexD*> Aptr_h(batchCount);
-    acceleratorCopyFromDevice(&Amat[0],&Aptr_h[0],batchCount*sizeof(ComplexD*));
-
-    int64_t lwf = oneapi::mkl::lapack::getrf_scratchpad_size<std::complex<double> >(*q,N,N,N);
-    int64_t lwi = oneapi::mkl::lapack::getri_scratchpad_size<std::complex<double> >(*q,N,N);
-    deviceVector<ComplexD> scratchf(lwf);
-    deviceVector<ComplexD> scratchi(lwi);
-    deviceVector<int64_t>  ipiv(N);
-    for(int i=0;i<batchCount;i++){
-      oneapi::mkl::lapack::getrf(*q,N,N,(std::complex<double>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<double>*)&scratchf[0],lwf);
-      oneapi::mkl::lapack::getri(*q,N,  (std::complex<double>*)Aptr_h[i],N,&ipiv[0],
-				 (std::complex<double>*)&scratchi[0],lwi);
-    }
-    q->wait();
-#endif
-#if !defined(GRID_SYCL) && !defined(GRID_CUDA) && !defined(GRID_HIP)
-    thread_for (p, batchCount, {
-      Eigen::Map<Eigen::MatrixXcd> eA(Amat[p],N,N);
-      Eigen::PartialPivLU<Eigen::MatrixXcd> lu(eA);
-      eA = lu.inverse();
-      });
-#endif
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,300 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: MomentumProject.h
-
-    Copyright (C) 2025
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-/* 
-   MultiMomProject
-
-   Import vectors -> nxyz x (ncomponent x nt)
-   Import complex phases -> nmom x nxy
-
-   apply = via (possibly batched) GEMM
-*/
-template<class Field, class ComplexField>
-class MomentumProject
-{
-public:
-
-  typedef typename Field::scalar_type   scalar;
-  typedef typename Field::scalar_object scalar_object;
-
-  GridBase *grid;
-  uint64_t nmom;
-  uint64_t nxyz;
-  uint64_t nt;
-  uint64_t nbtw;
-  uint64_t words;
-
-  deviceVector<scalar> BLAS_V;      // 
-  deviceVector<scalar> BLAS_M;      // 
-  deviceVector<scalar> BLAS_P;      // 
-  
-  MomentumProject(){};
- ~MomentumProject(){ Deallocate(); };
-  
-  void Deallocate(void)
-  {
-    grid=nullptr;
-    nmom=0;
-    nxyz=0;
-    nt=0;
-    nbtw=0;
-    words=0;
-    BLAS_V.resize(0);
-    BLAS_M.resize(0);
-    BLAS_P.resize(0);
-  }
-  void Allocate(int _nmom,GridBase *_grid)
-  {
-    grid=_grid;
-    Coordinate ldims = grid->LocalDimensions();
-
-    nmom=_nmom;
-    nt   = ldims[grid->Nd()-1];
-    nxyz = grid->lSites()/nt;
-    words = sizeof(scalar_object)/sizeof(scalar);
-    nbtw = nt * words;
-
-    BLAS_V.resize (nxyz * nt * words );
-    BLAS_M.resize (nmom * nxyz       );
-    BLAS_P.resize (nmom * nt * words );
-  }
-  void ImportMomenta(const std::vector <ComplexField> &momenta)
-  {
-    GRID_ASSERT(momenta.size()==nmom);
-    //    might as well just make the momenta here
-    typedef typename Field::vector_object vobj;
-
-    int nd = grid->_ndimension;
-
-    uint64_t sz = BLAS_M.size();
-
-    GRID_ASSERT(momenta.size()==nmom)
-    GRID_ASSERT(momenta[0].Grid()==grid);
-    GRID_ASSERT(sz = nxyz * nmom);
-    
-    Coordinate rdimensions = grid->_rdimensions;
-    Coordinate ldims       = grid->LocalDimensions();
-    int64_t osites         = grid->oSites();
-    Coordinate simd        = grid->_simd_layout;
-    const int Nsimd        = vobj::Nsimd();
-    uint64_t lwords        = words; // local variable for copy in to GPU
-    int64_t Nxyz = nxyz;
-    auto blasData_p  = &BLAS_M[0];
-    for(int m=0;m<momenta.size();m++){
-
-      autoView( Data   , momenta[m], AcceleratorRead);
-      auto Data_p  = &Data[0];
-
-      accelerator_for(xyz,nxyz,1,{
-	  //////////////////////////////////////////
-	  // isite -- map lane within buffer to lane within lattice
-	  ////////////////////////////////////////////
-	    Coordinate lcoor(nd,0);
-	    Lexicographic::CoorFromIndex(lcoor,xyz,ldims);
-	    
-	    Coordinate icoor(nd);
-	    Coordinate ocoor(nd);
-	    for (int d = 0; d < nd; d++) {
-	      icoor[d] = lcoor[d]/rdimensions[d];
-	      ocoor[d] = lcoor[d]%rdimensions[d];
-	    }
-	    int64_t osite;
-	    int64_t isite;
-	    Lexicographic::IndexFromCoor(ocoor,osite,rdimensions);
-	    Lexicographic::IndexFromCoor(icoor,isite,simd);
-	    
-	    // BLAS_M[nmom][slice_vol]
-	    // Fortran Column major BLAS layout is M_xyz,mom
-	    scalar data = extractLane(isite,Data[osite]);
-	    uint64_t idx = xyz+m*Nxyz;
-	    blasData_p[idx] = data;
-	});
-    }
-  }
-  void ImportVector(Field &vec)
-  {
-    typedef typename Field::vector_object vobj;
-
-    int nd = grid->_ndimension;
-
-    uint64_t sz = BLAS_V.size();
-
-    GRID_ASSERT(sz = nxyz * words * nt);
-    
-    Coordinate rdimensions = grid->_rdimensions;
-    Coordinate ldims= grid->LocalDimensions();
-    int64_t osites = grid->oSites();
-    Coordinate simd = grid->_simd_layout;
-    const int Nsimd = vobj::Nsimd();
-    uint64_t lwords= words; // local variable for copy in to GPU
-
-    auto blasData_p  = &BLAS_V[0];
-    autoView( Data   , vec, AcceleratorRead);
-    auto Data_p  = &Data[0];
-
-    int64_t nwords = words;// for capture
-    int64_t Nt     = nt;// for capture
-    
-    accelerator_for(sf,osites,Nsimd,{
-#ifdef GRID_SIMT
-        {
-	  int lane=acceleratorSIMTlane(Nsimd); // buffer lane
-#else
-	  for(int lane=0;lane<Nsimd;lane++) {
-#endif
-	  //////////////////////////////////////////
-	  // isite -- map lane within buffer to lane within lattice
-	  ////////////////////////////////////////////
-	    Coordinate lcoor(nd,0);
-	    Coordinate icoor(nd);
-	    Coordinate ocoor(nd);
-	    
-	    Lexicographic::CoorFromIndex(icoor,lane,simd);
-	    Lexicographic::CoorFromIndex(ocoor,sf,rdimensions);
-
-	  
-	    int64_t l_xyz = 0;
-	    for (int d = 0; d < nd; d++) {
-	      lcoor[d] = rdimensions[d]*icoor[d] + ocoor[d];
-	    }
-	    uint64_t l_t   = lcoor[nd-1];
-
-	    Coordinate xyz_coor = lcoor;
-	    xyz_coor[nd-1] =0;
-	    Lexicographic::IndexFromCoor(xyz_coor,l_xyz,ldims);
-
-	    
-	    scalar_object data = extractLane(lane,Data[sf]);
-	    scalar *data_words = (scalar *) &data;
-	    for(int w = 0 ; w < nwords; w++) {
-	      // BLAS_V[slice_vol][nt][words]
-	      // Fortran Column major BLAS layout is V_(t,w)_xyz
-	      uint64_t idx = w+l_t*nwords + l_xyz * nwords * Nt;
-	      blasData_p[idx] = data_words[w];
-	    }
-#ifdef GRID_SIMT
-	}
-#else
-	}
-#endif
-	});
-  }
-  void ExportMomentumProjection(std::vector<typename Field::scalar_object> &projection)
-  {
-    projection.resize(nmom*nt);
-    acceleratorCopyFromDevice(&BLAS_P[0],(scalar *)&projection[0],BLAS_P.size()*sizeof(scalar));
-    // Could decide on a layout late?
-  }
-
-  // Row major layout "C" order:
-  // BLAS_V[slice_vol][nt][words]
-  // BLAS_M[nmom][slice_vol]
-  // BLAS_P[nmom][nt][words]
-  //
-  // Fortran Column major BLAS layout is V_(w,t)_xyz
-  // Fortran Column major BLAS layout is M_xyz,mom
-  // Fortran Column major BLAS layout is P_(w,t),mom
-  //
-  // Projected
-  //
-  // P = (V * M)_(w,t),mom
-  //
-  void Project(Field &data,std::vector< typename Field::scalar_object > & projected_gdata)
-  {
-    double t_import=0;
-    double t_export=0;
-    double t_gemm  =0;
-    double t_allreduce=0;
-    t_import-=usecond();
-    this->ImportVector(data);
-
-    std::vector< typename Field::scalar_object > projected_planes;
-
-    deviceVector<scalar *> Vd(1);
-    deviceVector<scalar *> Md(1);
-    deviceVector<scalar *> Pd(1);
-
-    scalar * Vh = & BLAS_V[0];
-    scalar * Mh = & BLAS_M[0];
-    scalar * Ph = & BLAS_P[0];
-
-    acceleratorPut(Vd[0],Vh);
-    acceleratorPut(Md[0],Mh);
-    acceleratorPut(Pd[0],Ph);
-    t_import+=usecond();
-
-    GridBLAS BLAS;
-
-    /////////////////////////////////////////
-    // P_im = VMmx . Vxi
-    /////////////////////////////////////////
-    t_gemm-=usecond();
-    BLAS.gemmBatched(GridBLAS_OP_N,GridBLAS_OP_N, 
-    		     words*nt,nmom,nxyz,
-		     scalar(1.0),
-		     Vd,
-		     Md,
-		     scalar(0.0),  // wipe out result
-		     Pd);
-    BLAS.synchronise();
-    t_gemm+=usecond();
-
-    t_export-=usecond();
-    ExportMomentumProjection(projected_planes); // resizes
-    t_export+=usecond();
-
-    /////////////////////////////////
-    // Reduce across MPI ranks
-    /////////////////////////////////
-    int nd = grid->Nd();
-    int gt = grid->GlobalDimensions()[nd-1];
-    int lt = grid->LocalDimensions()[nd-1];
-    projected_gdata.resize(gt*nmom);
-    for(int t=0;t<gt*nmom;t++){ // global Nt array with zeroes for stuff not on this node
-      projected_gdata[t]=Zero();
-    }
-    for(int t=0;t<lt;t++){
-    for(int m=0;m<nmom;m++){
-      int st = grid->LocalStarts()[nd-1];
-      projected_gdata[t+st + gt*m] = projected_planes[t+lt*m];
-    }}
-    t_allreduce-=usecond();
-    grid->GlobalSumVector((scalar *)&projected_gdata[0],gt*nmom*words);
-    t_allreduce+=usecond();
-
-    std::cout << GridLogPerformance<<" MomentumProject t_import  "<<t_import<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_export  "<<t_export<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_gemm    "<<t_gemm<<"us"<<std::endl;
-    std::cout << GridLogPerformance<<" MomentumProject t_reduce  "<<t_allreduce<<"us"<<std::endl;
-
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,376 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: MultiRHSBlockCGLinalg.h
-
-    Copyright (C) 2024
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-
-/* Need helper object for BLAS accelerated mrhs blockCG */
-template<class Field>
-class MultiRHSBlockCGLinalg
-{
-public:
-
-  typedef typename Field::scalar_type   scalar;
-  typedef typename Field::scalar_object scalar_object;
-  typedef typename Field::vector_object vector_object;
-
-  deviceVector<scalar> BLAS_X;      // nrhs x vol -- the sources
-  deviceVector<scalar> BLAS_Y;      // nrhs x vol -- the result
-  deviceVector<scalar> BLAS_C;      // nrhs x nrhs -- the coefficients 
-  deviceVector<scalar> BLAS_Cred;   // nrhs x nrhs x oSites -- reduction buffer
-  deviceVector<scalar *> Xdip;
-  deviceVector<scalar *> Ydip;
-  deviceVector<scalar *> Cdip;
-  
-  MultiRHSBlockCGLinalg() {};
-  ~MultiRHSBlockCGLinalg(){ Deallocate(); };
-  
-  void Deallocate(void)
-  {
-    Xdip.resize(0);
-    Ydip.resize(0);
-    Cdip.resize(0);
-    BLAS_Cred.resize(0);
-    BLAS_C.resize(0);
-    BLAS_X.resize(0);
-    BLAS_Y.resize(0);
-  }
-  void MaddMatrix(std::vector<Field> &AP, Eigen::MatrixXcd &m , const std::vector<Field> &X,const std::vector<Field> &Y,RealD scale=1.0)
-  {
-    std::vector<Field> Y_copy(AP.size(),AP[0].Grid());
-    for(int r=0;r<AP.size();r++){
-      Y_copy[r] = Y[r];
-    }
-    MulMatrix(AP,m,X);
-    for(int r=0;r<AP.size();r++){
-      AP[r] = scale*AP[r]+Y_copy[r];
-    }
-  }
-  void MulMatrix(std::vector<Field> &Y, Eigen::MatrixXcd &m , const std::vector<Field> &X)
-  {
-    typedef typename Field::scalar_type scomplex;
-    GridBase *grid;
-    uint64_t vol;
-    uint64_t words;
-
-    int nrhs = Y.size();
-    grid  = X[0].Grid();
-    vol   = grid->lSites();
-    words = sizeof(scalar_object)/sizeof(scalar);
-    int64_t vw = vol * words;
-
-    RealD t0 = usecond();
-    BLAS_X.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_Y.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_C.resize(nrhs * nrhs);// cost free if size doesn't change
-    RealD t1 = usecond();
-
-    /////////////////////////////////////////////
-    // Copy in the multi-rhs sources
-    /////////////////////////////////////////////
-    for(int r=0;r<nrhs;r++){
-      int64_t offset = r*vw;
-      autoView(x_v,X[r],AcceleratorRead);
-      acceleratorCopyDeviceToDevice(&x_v[0],&BLAS_X[offset],sizeof(scalar_object)*vol);
-    }
-
-    // Assumes Eigen storage contiguous
-    acceleratorCopyToDevice(&m(0,0),&BLAS_C[0],BLAS_C.size()*sizeof(scalar));
-    
-  /*
-   * in Fortran column major notation (cuBlas order)
-   *
-   * Xxr = [X1(x)][..][Xn(x)]
-   * Yxr = [Y1(x)][..][Ym(x)]
-   * Y = X . C
-   */
-    deviceVector<scalar *> Xd(1);
-    deviceVector<scalar *> Yd(1);
-    deviceVector<scalar *> Cd(1);
-
-    scalar * Xh = & BLAS_X[0];
-    scalar * Yh = & BLAS_Y[0];
-    scalar * Ch = & BLAS_C[0];
-
-    acceleratorPut(Xd[0],Xh);
-    acceleratorPut(Yd[0],Yh);
-    acceleratorPut(Cd[0],Ch);
-
-    RealD t2 = usecond();
-    GridBLAS BLAS;
-    /////////////////////////////////////////
-    // Y = X*C (transpose?)
-    /////////////////////////////////////////
-    BLAS.gemmBatched(GridBLAS_OP_N,GridBLAS_OP_N, 
-    		     vw,nrhs,nrhs,
-		     scalar(1.0),
-		     Xd,
-		     Cd,
-		     scalar(0.0),  // wipe out Y
-		     Yd);
-    BLAS.synchronise();
-    RealD t3 = usecond();
-
-    // Copy back Y = m X 
-    for(int r=0;r<nrhs;r++){
-      int64_t offset = r*vw;
-      autoView(y_v,Y[r],AcceleratorWrite);
-      acceleratorCopyDeviceToDevice(&BLAS_Y[offset],&y_v[0],sizeof(scalar_object)*vol);
-    }    
-    RealD t4 = usecond();
-    std::cout <<GridLogPerformance << "MulMatrix alloc    took "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix preamble took "<< t2-t1<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix blas     took "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix copy     took "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "MulMatrix total "<< t4-t0<<" us"<<std::endl;
-  }
-  
-  void InnerProductMatrix(Eigen::MatrixXcd &m , const std::vector<Field> &X, const std::vector<Field> &Y)
-  {
-#if 0    
-    int nrhs;
-    GridBase *grid;
-    uint64_t vol;
-    uint64_t words;
-
-    nrhs = X.size();
-    GRID_ASSERT(X.size()==Y.size());
-    conformable(X[0],Y[0]);
-
-    grid  = X[0].Grid();
-    vol   = grid->lSites();
-    words = sizeof(scalar_object)/sizeof(scalar);
-    int64_t vw = vol * words;
-
-    RealD t0 = usecond();
-    BLAS_X.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_Y.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_C.resize(nrhs * nrhs);// cost free if size doesn't change
-    RealD t1 = usecond();
-
-    /////////////////////////////////////////////
-    // Copy in the multi-rhs sources
-    /////////////////////////////////////////////
-    for(int r=0;r<nrhs;r++){
-      int64_t offset = r*vw;
-      autoView(x_v,X[r],AcceleratorRead);
-      acceleratorCopyDeviceToDevice(&x_v[0],&BLAS_X[offset],sizeof(scalar_object)*vol);
-      autoView(y_v,Y[r],AcceleratorRead);
-      acceleratorCopyDeviceToDevice(&y_v[0],&BLAS_Y[offset],sizeof(scalar_object)*vol);
-    }
-    RealD t2 = usecond();
-
-  /*
-   * in Fortran column major notation (cuBlas order)
-   *
-   * Xxr = [X1(x)][..][Xn(x)]
-   *
-   * Yxr = [Y1(x)][..][Ym(x)]
-   *
-   * C_rs = X^dag Y
-   */
-    deviceVector<scalar *> Xd(1);
-    deviceVector<scalar *> Yd(1);
-    deviceVector<scalar *> Cd(1);
-
-    scalar * Xh = & BLAS_X[0];
-    scalar * Yh = & BLAS_Y[0];
-    scalar * Ch = & BLAS_C[0];
-
-    acceleratorPut(Xd[0],Xh);
-    acceleratorPut(Yd[0],Yh);
-    acceleratorPut(Cd[0],Ch);
-
-    GridBLAS BLAS;
-
-    RealD t3 = usecond();
-    /////////////////////////////////////////
-    // C_rs = X^dag Y
-    /////////////////////////////////////////
-    BLAS.gemmBatched(GridBLAS_OP_C,GridBLAS_OP_N, 
-    		     nrhs,nrhs,vw,
-		     ComplexD(1.0),
-		     Xd,
-		     Yd,
-		     ComplexD(0.0),  // wipe out C
-		     Cd);
-    BLAS.synchronise();
-    RealD t4 = usecond();
-
-    std::vector<scalar> HOST_C(BLAS_C.size());      // nrhs . nrhs -- the coefficients 
-    acceleratorCopyFromDevice(&BLAS_C[0],&HOST_C[0],BLAS_C.size()*sizeof(scalar));
-    grid->GlobalSumVector(&HOST_C[0],nrhs*nrhs);
-
-    RealD t5 = usecond();
-    for(int rr=0;rr<nrhs;rr++){
-      for(int r=0;r<nrhs;r++){
-	int off = r+nrhs*rr;
-	m(r,rr)=HOST_C[off];
-      }
-    }
-    RealD t6 = usecond();
-    uint64_t M=nrhs;
-    uint64_t N=nrhs;
-    uint64_t K=vw;
-    RealD bytes = 1.0*sizeof(ComplexD)*(M*N*2+N*K+M*K);
-    RealD flops = 8.0*M*N*K;
-    flops = flops/(t4-t3)/1.e3;
-    bytes = bytes/(t4-t3)/1.e3;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp    t2 "<< t2-t1<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix gsum t5 "<< t5-t4<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp   t6 "<< t6-t5<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
-#else
-    int nrhs;
-    GridBase *grid;
-    uint64_t vol;
-    uint64_t words;
-
-    nrhs = X.size();
-    GRID_ASSERT(X.size()==Y.size());
-    conformable(X[0],Y[0]);
-
-    grid  = X[0].Grid();
-    int rd0 =  grid->_rdimensions[0] * grid->_rdimensions[1];
-    vol   = grid->oSites()/rd0;
-    words = rd0*sizeof(vector_object)/sizeof(scalar);
-    int64_t vw = vol * words;
-    GRID_ASSERT(vw == grid->lSites()*sizeof(scalar_object)/sizeof(scalar));
-
-    RealD t0 = usecond();
-    BLAS_X.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_Y.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_Cred.resize(nrhs * nrhs * vol);// cost free if size doesn't change
-    RealD t1 = usecond();
-
-    /////////////////////////////////////////////
-    // Copy in the multi-rhs sources -- layout batched BLAS ready
-    /////////////////////////////////////////////
-    for(int r=0;r<nrhs;r++){
-      autoView(x_v,X[r],AcceleratorRead);
-      autoView(y_v,Y[r],AcceleratorRead);
-      scalar *from_x=(scalar *)&x_v[0];
-      scalar *from_y=(scalar *)&y_v[0];
-      scalar *BX = &BLAS_X[0];
-      scalar *BY = &BLAS_Y[0];
-      accelerator_for(ssw,vw,1,{
-	  uint64_t ss=ssw/words;
-	  uint64_t  w=ssw%words;
-	  uint64_t offset = w+r*words+ss*nrhs*words; // [ss][rhs][words]
-	  BX[offset] = from_x[ssw];
-	  BY[offset] = from_y[ssw];
-	});
-    }
-    RealD t2 = usecond();
-
-  /*
-   * in Fortran column major notation (cuBlas order)
-   *
-   * Xxr = [X1(x)][..][Xn(x)]
-   *
-   * Yxr = [Y1(x)][..][Ym(x)]
-   *
-   * C_rs = X^dag Y
-   */
-    Xdip.resize(vol);
-    Ydip.resize(vol);
-    Cdip.resize(vol);
-    std::vector<scalar *> Xh(vol);
-    std::vector<scalar *> Yh(vol);
-    std::vector<scalar *> Ch(vol);
-    for(uint64_t ss=0;ss<vol;ss++){
-
-      Xh[ss] = & BLAS_X[ss*nrhs*words];
-      Yh[ss] = & BLAS_Y[ss*nrhs*words];
-      Ch[ss] = & BLAS_Cred[ss*nrhs*nrhs];
-
-    }
-    acceleratorCopyToDevice(&Xh[0],&Xdip[0],vol*sizeof(scalar *));
-    acceleratorCopyToDevice(&Yh[0],&Ydip[0],vol*sizeof(scalar *));
-    acceleratorCopyToDevice(&Ch[0],&Cdip[0],vol*sizeof(scalar *));
-    
-    GridBLAS BLAS;
-
-    RealD t3 = usecond();
-    /////////////////////////////////////////
-    // C_rs = X^dag Y
-    /////////////////////////////////////////
-    BLAS.gemmBatched(GridBLAS_OP_C,GridBLAS_OP_N, 
-    		     nrhs,nrhs,words,
-		     ComplexD(1.0),
-		     Xdip,
-		     Ydip,
-		     ComplexD(0.0),  // wipe out C
-		     Cdip);
-    BLAS.synchronise();
-    RealD t4 = usecond();
-
-    std::vector<scalar> HOST_C(BLAS_Cred.size());      // nrhs . nrhs -- the coefficients 
-    acceleratorCopyFromDevice(&BLAS_Cred[0],&HOST_C[0],BLAS_Cred.size()*sizeof(scalar));
-
-    RealD t5 = usecond();
-    m = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    for(int ss=0;ss<vol;ss++){
-      Eigen::Map<Eigen::MatrixXcd> eC((std::complex<double> *)&HOST_C[ss*nrhs*nrhs],nrhs,nrhs);
-      m = m + eC;
-    }
-    RealD t6l = usecond();
-    grid->GlobalSumVector((scalar *) &m(0,0),nrhs*nrhs);
-    RealD t6 = usecond();
-    uint64_t M=nrhs;
-    uint64_t N=nrhs;
-    uint64_t K=vw;
-    RealD xybytes = grid->lSites()*sizeof(scalar_object);
-    RealD bytes = 1.0*sizeof(ComplexD)*(M*N*2+N*K+M*K);
-    RealD flops = 8.0*M*N*K;
-    flops = flops/(t4-t3)/1.e3;
-    bytes = bytes/(t4-t3)/1.e3;
-    xybytes = 4*xybytes/(t2-t1)/1.e3;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix m,n,k "<< M<<","<<N<<","<<K<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix alloc t1 "<< t1-t0<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp    t2 "<< t2-t1<<" us "<<xybytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix setup t3 "<< t3-t2<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas t4 "<< t4-t3<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< flops<<" GF/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix blas    "<< bytes<<" GB/s"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix cp     t5 "<< t5-t4<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix lsum   t6l "<< t6l-t5<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix gsum   t6 "<< t6-t6l<<" us"<<std::endl;
-    std::cout <<GridLogPerformance<< "InnerProductMatrix took "<< t6-t0<<" us"<<std::endl;
-#endif
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,300 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: MultiRHSDeflation.h
-
-    Copyright (C) 2023
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-
-/* Need helper object for BLAS accelerated mrhs projection
-
-   i) MultiRHS Deflation
-
-   Import Evecs -> nev x vol x internal 
-   Import vector of Lattice objects -> nrhs x vol x internal
-   => Cij (nrhs x Nev) via GEMM.
-   => Guess  (nrhs x vol x internal)  = C x evecs (via GEMM)
-   Export
-
-   
-   ii) MultiRHS block projection
-
-   Import basis -> nblock x nbasis x  (block x internal) 
-   Import vector of fine lattice objects -> nblock x nrhs x (block x internal) 
-
-   => coarse_(nrhs x nbasis )^block = via batched GEMM
-
-   iii)   Alternate interface: 
-   Import higher dim Lattice object-> vol x nrhs layout
-   
-*/
-template<class Field>
-class MultiRHSDeflation
-{
-public:
-
-  typedef typename Field::scalar_type   scalar;
-  typedef typename Field::scalar_object scalar_object;
-  typedef typename Field::vector_object vobj;
-
-  int nev;
-  std::vector<RealD> eval;
-  GridBase *grid;
-  uint64_t vol;
-  uint64_t words;
-  
-  deviceVector<scalar> BLAS_E;      //  nev x vol -- the eigenbasis   (up to a 1/sqrt(lambda))
-  deviceVector<scalar> BLAS_R;      // nrhs x vol -- the sources
-  deviceVector<scalar> BLAS_G;      // nrhs x vol -- the guess
-  deviceVector<scalar> BLAS_C;      // nrhs x nev -- the coefficients 
-  
-  MultiRHSDeflation(){};
-  ~MultiRHSDeflation(){ Deallocate(); };
-  
-  void Deallocate(void)
-  {
-    nev=0;
-    grid=nullptr;
-    vol=0;
-    words=0;
-    // deviceVector is a std::vector with a device allocator: resize(0) drops
-    // the size and keeps the capacity, returning no device memory.  Swapping
-    // with an empty vector destroys the buffer.
-    deviceVector<scalar>().swap(BLAS_E);
-    deviceVector<scalar>().swap(BLAS_R);
-    deviceVector<scalar>().swap(BLAS_C);
-    deviceVector<scalar>().swap(BLAS_G);
-  }
-  // Resident (non-evictable) device memory held by this deflator.
-  uint64_t DeviceBytes(void)
-  {
-    return (BLAS_E.capacity()+BLAS_R.capacity()+BLAS_C.capacity()+BLAS_G.capacity())*sizeof(scalar);
-  }
-  void Allocate(int _nev,GridBase *_grid)
-  {
-    nev=_nev;
-    grid=_grid;
-    vol   = grid->lSites();
-    words = sizeof(scalar_object)/sizeof(scalar);
-    eval.resize(nev);
-    BLAS_E.resize (vol * words * nev );
-    std::cout << GridLogMessage << " Allocate for "<<nev<<" eigenvectors and volume "<<vol<<std::endl;
-  }
-  void ImportEigenVector(Field &evec,RealD &_eval, int ev)
-  {
-    //    std::cout << " ev " <<ev<<" eval "<<_eval<< std::endl;
-    GRID_ASSERT(ev<eval.size());
-    eval[ev] = _eval;
-
-    int64_t offset = ev*vol*words;
-    autoView(v,evec,AcceleratorRead);
-    acceleratorCopyDeviceToDevice(&v[0],&BLAS_E[offset],sizeof(scalar_object)*vol);
-
-  }
-  void ImportEigenBasis(std::vector<Field> &evec,std::vector<RealD> &_eval)
-  {
-    ImportEigenBasis(evec,_eval,0,evec.size());
-  }
-  // Could use to import a batch of eigenvectors
-  void ImportEigenBasis(std::vector<Field> &evec,std::vector<RealD> &_eval, int _ev0, int _nev)
-  {
-    GRID_ASSERT(_ev0+_nev<=evec.size());
-
-    Allocate(_nev,evec[0].Grid());
-    
-    // Imports a sub-batch of eigenvectors, _ev0, ..., _ev0+_nev-1
-    for(int e=0;e<nev;e++){
-      std::cout << "Importing eigenvector "<<e<<" evalue "<<_eval[_ev0+e]<<std::endl;
-      ImportEigenVector(evec[_ev0+e],_eval[_ev0+e],e);
-    }
-  }
-  /////////////////////////////////////////////////////////////////////////
-  // Sources as a vector of D-dimensional fields: each is one contiguous
-  // column of BLAS_R already, so import/export are straight copies.
-  // The eigenvectors may live on a D grid or on the Nrhs=1 D+1 grid of the
-  // same local volume; the two are the same bytes, so only the site count
-  // is checked, not grid identity.
-  /////////////////////////////////////////////////////////////////////////
-  void DeflateSources(std::vector<Field> &source,std::vector<Field> & guess)
-  {
-    int nrhs = source.size();
-    GRID_ASSERT(source.size()==guess.size());
-    GRID_ASSERT(grid->lSites() == guess[0].Grid()->lSites());
-    conformable(guess[0],source[0]);
-
-    int64_t vw = vol * words;
-    BLAS_R.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_G.resize(nrhs * vw); // cost free if size doesn't change
-    BLAS_C.resize(nev * nrhs);// cost free if size doesn't change
-
-    for(int r=0;r<nrhs;r++){
-      int64_t offset = r*vw;
-      autoView(v,source[r],AcceleratorRead);
-      acceleratorCopyDeviceToDevice(&v[0],&BLAS_R[offset],sizeof(scalar_object)*vol);
-    }
-    DeflateBLAS(nrhs);
-    for(int r=0;r<nrhs;r++){
-      int64_t offset = r*vw;
-      autoView(v,guess[r],AcceleratorWrite);
-      acceleratorCopyDeviceToDevice(&BLAS_G[offset],&v[0],sizeof(scalar_object)*vol);
-    }
-  }
-  /////////////////////////////////////////////////////////////////////////
-  // Sources as ONE D+1 dimensional multiRHS field, rhs innermost
-  // (dimension 0, undistributed) on an UNVECTORISED coarse space, so the
-  // site index is rhs + nrhs*x with x the D-dimensional site.  The GEMM
-  // wants x contiguous per rhs, so the import is a permutation, one fused
-  // pass over the field; likewise the export.  No slices.
-  /////////////////////////////////////////////////////////////////////////
-  void DeflateSources(const Field &source_mrhs, Field &guess_mrhs)
-  {
-    conformable(source_mrhs,guess_mrhs);
-    GridBase *hi = source_mrhs.Grid();
-    GRID_ASSERT(hi->_ndimension    == grid->_ndimension+1);
-    GRID_ASSERT(hi->_processors[0] == 1);
-    GRID_ASSERT(hi->_simd_layout[0]== 1);
-    GRID_ASSERT(vobj::Nsimd()      == 1);
-    int nrhs = hi->_fdimensions[0];
-    GRID_ASSERT(hi->lSites() == nrhs*vol);
-
-    int64_t vw = vol * words;
-    BLAS_R.resize(nrhs * vw);
-    BLAS_G.resize(nrhs * vw);
-    BLAS_C.resize(nev * nrhs);
-
-    ImportSourcesMrhs(source_mrhs,nrhs);
-    DeflateBLAS(nrhs);
-    ExportGuessMrhs(guess_mrhs,nrhs);
-  }
-  void ImportSourcesMrhs(const Field &source_mrhs,int nrhs)
-  {
-    const int64_t lwords = words, lnrhs = nrhs, vw = vol*words;
-    autoView(v,source_mrhs,AcceleratorRead);
-    auto vp = &v[0];
-    scalar *R = &BLAS_R[0];
-    accelerator_for(scr, lnrhs*vol, 1, {
-      int64_t r = scr % lnrhs;
-      int64_t x = scr / lnrhs;
-      const scalar *s = (const scalar *)&vp[scr];
-      for(int64_t w=0;w<lwords;w++) R[r*vw + x*lwords + w] = s[w];
-    });
-  }
-  void ExportGuessMrhs(Field &guess_mrhs,int nrhs)
-  {
-    const int64_t lwords = words, lnrhs = nrhs, vw = vol*words;
-    autoView(v,guess_mrhs,AcceleratorWrite);
-    auto vp = &v[0];
-    scalar *G = &BLAS_G[0];
-    accelerator_for(scr, lnrhs*vol, 1, {
-      int64_t r = scr % lnrhs;
-      int64_t x = scr / lnrhs;
-      scalar *g = (scalar *)&vp[scr];
-      for(int64_t w=0;w<lwords;w++) g[w] = G[r*vw + x*lwords + w];
-    });
-  }
-  /////////////////////////////////////////////////////////////////////////
-  // BLAS_R (nrhs columns of vol*words) -> BLAS_G, through the imported
-  // eigenbasis: C = E^dag R / lambda, G = E C.
-  /////////////////////////////////////////////////////////////////////////
-  void DeflateBLAS(int nrhs)
-  {
-    int64_t vw = vol * words;
-    RealD t0 = usecond();
-
-  /*
-   * in Fortran column major notation (cuBlas order)
-   *
-   * Exe = [e1(x)][..][en(x)]
-   *
-   * Rxr = [r1(x)][..][rm(x)]
-   *
-   * C_er = E^dag R
-   * C_er = C_er / lambda_e 
-   * G_xr = Exe Cer
-   */
-    deviceVector<scalar *> Ed(1);
-    deviceVector<scalar *> Rd(1);
-    deviceVector<scalar *> Cd(1);
-    deviceVector<scalar *> Gd(1);
-
-    scalar * Eh = & BLAS_E[0];
-    scalar * Rh = & BLAS_R[0];
-    scalar * Ch = & BLAS_C[0];
-    scalar * Gh = & BLAS_G[0];
-
-    acceleratorPut(Ed[0],Eh);
-    acceleratorPut(Rd[0],Rh);
-    acceleratorPut(Cd[0],Ch);
-    acceleratorPut(Gd[0],Gh);
-
-    GridBLAS BLAS;
-
-    /////////////////////////////////////////
-    // C_er = E^dag R
-    /////////////////////////////////////////
-    BLAS.gemmBatched(GridBLAS_OP_C,GridBLAS_OP_N, 
-    		     nev,nrhs,vw,
-		     scalar(1.0),
-		     Ed,
-		     Rd,
-		     scalar(0.0),  // wipe out C
-		     Cd);
-    BLAS.synchronise();
-
-    GRID_ASSERT(BLAS_C.size()==nev*nrhs);
-
-    std::vector<scalar> HOST_C(BLAS_C.size());      // nrhs . nev -- the coefficients 
-    acceleratorCopyFromDevice(&BLAS_C[0],&HOST_C[0],BLAS_C.size()*sizeof(scalar));
-    grid->GlobalSumVector(&HOST_C[0],nev*nrhs);
-    for(int e=0;e<nev;e++){
-      scalar lam(1.0/eval[e]);          // in the coarse scalar: fp32 coarse spaces too
-      for(int r=0;r<nrhs;r++){
-	int off = e+nev*r;
-	HOST_C[off]=HOST_C[off] * lam;
-	//	std::cout << "C["<<e<<"]["<<r<<"] ="<<HOST_C[off]<< " eval[e] "<<eval[e] <<std::endl;
-      }
-    }
-    acceleratorCopyToDevice(&HOST_C[0],&BLAS_C[0],BLAS_C.size()*sizeof(scalar));
-
-    
-    /////////////////////////////////////////
-    // Guess G_xr = Exe Cer
-    /////////////////////////////////////////
-    BLAS.gemmBatched(GridBLAS_OP_N,GridBLAS_OP_N, 
-		     vw,nrhs,nev,
-		     scalar(1.0),
-		     Ed, // x . nev
-		     Cd, // nev . nrhs
-		     scalar(0.0),
-		     Gd);
-    BLAS.synchronise();
-    RealD t1 = usecond();
-    std::cout << GridLogMessage << "MultiRHSDeflation for "<<nrhs<<" sources with "<<nev<<" eigenvectors took " << (t1-t0)/1e3 <<" ms"<<std::endl;
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -33,134 +33,109 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
   * Script A = SolverMatrix 
   * Script P = Preconditioner
   *
+   * Deflation methods considered
+   *      -- Solve P A x = P b        [ like Luscher ]
+   * DEF-1        M P A x = M P b     [i.e. left precon]
+   * DEF-2        P^T M A x = P^T M b
+   * ADEF-1       Preconditioner = M P + Q      [ Q + M + M A Q]
+   * ADEF-2       Preconditioner = P^T M + Q
+   * BNN          Preconditioner = P^T M P + Q
+   * BNN2         Preconditioner = M P + P^TM +Q - M P A M 
+   * 
   * Implement ADEF-2
   *
   * Vstart = P^Tx + Qb
   * M1 = P^TM + Q
   * M2=M3=1
+   * Vout = x
   */
-NAMESPACE_BEGIN(Grid);

-
-template<class Field>
-class TwoLevelCG : public LinearFunction<Field>
+// abstract base
+template<class Field, class CoarseField>
+class TwoLevelFlexiblePcg : public LinearFunction<Field>
 {
 public:
+  int verbose;
  RealD   Tolerance;
  Integer MaxIterations;
+  const int mmax = 5;
  GridBase *grid;
+  GridBase *coarsegrid;

-  // Fine operator, Smoother, CoarseSolver
-  LinearOperatorBase<Field>   &_FineLinop;
-  LinearFunction<Field>   &_Smoother;
-
-  GridStopWatch ProjectTimer;
-  GridStopWatch PromoteTimer;
-  GridStopWatch CoarseTimer;
-  GridStopWatch SmoothTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch M3Timer;
-  GridStopWatch LinalgTimer;
-
-  int64_t M3Calls;
-  int64_t SmoothCalls;
-  int64_t MatrixCalls;
-  int64_t ProjectCalls;
-  int64_t CoarseCalls;
-  int64_t PromoteCalls;
+  LinearOperatorBase<Field>   *_Linop
+  OperatorFunction<Field>     *_Smoother,
+  LinearFunction<CoarseField> *_CoarseSolver;

+  // Need somthing that knows how to get from Coarse to fine and back again
+  
  // more most opertor functions
-  TwoLevelCG(RealD tol,
-	     Integer maxit,
-	     LinearOperatorBase<Field>   &FineLinop,
-	     LinearFunction<Field>       &Smoother,
-	     GridBase *fine) : 
+  TwoLevelFlexiblePcg(RealD tol,
+		     Integer maxit,
+		     LinearOperatorBase<Field> *Linop,
+		     LinearOperatorBase<Field> *SmootherLinop,
+		     OperatorFunction<Field>   *Smoother,
+		     OperatorFunction<CoarseField>  CoarseLinop
+		     ) : 
      Tolerance(tol), 
      MaxIterations(maxit),
-      _FineLinop(FineLinop),
-      _Smoother(Smoother)
-  {
-    grid       = fine;
+      _Linop(Linop),
+      _PreconditionerLinop(PrecLinop),
+      _Preconditioner(Preconditioner)
+  { 
+    verbose=0;
  };
-  
-  virtual void operator() (const Field &src, Field &x)
-  {
-    std::cout << GridLogMessage<<"HDCG: fPcg starting single RHS"<<std::endl;
+
+  // The Pcg routine is common to all, but the various matrices differ from derived 
+  // implementation to derived implmentation
+  void operator() (const Field &src, Field &psi){
+  void operator() (const Field &src, Field &psi){
+
+    psi.Checkerboard() = src.Checkerboard();
+    grid             = src.Grid();
+
    RealD f;
    RealD rtzp,rtz,a,d,b;
    RealD rptzp;
-
+    RealD tn;
+    RealD guess = norm2(psi);
+    RealD ssq   = norm2(src);
+    RealD rsq   = ssq*Tolerance*Tolerance;
+    
    /////////////////////////////
    // Set up history vectors
    /////////////////////////////
-    int mmax = 5;
-    std::cout << GridLogMessage<<"HDCG: fPcg allocating"<<std::endl;
-    std::vector<Field> p(mmax,grid);
+    std::vector<Field> p  (mmax,grid);
    std::vector<Field> mmp(mmax,grid);
    std::vector<RealD> pAp(mmax);
-    Field z(grid);
+
+    Field x  (grid); x = psi;
+    Field z  (grid);
    Field tmp(grid);
-    Field  mp (grid);
-    Field  r  (grid);
-    Field  mu (grid);
-    
-    std::cout << GridLogMessage<<"HDCG: fPcg allocated"<<std::endl;
-    //Initial residual computation & set up
-    RealD guess   = norm2(x);
-    std::cout << GridLogMessage<<"HDCG: fPcg guess nrm "<<guess<<std::endl;
-    RealD src_nrm = norm2(src);
-    std::cout << GridLogMessage<<"HDCG: fPcg src nrm "<<src_nrm<<std::endl;
-    
-    if ( src_nrm == 0.0 ) {
-      std::cout << GridLogMessage<<"HDCG: fPcg given trivial source norm "<<src_nrm<<std::endl;
-      x=Zero();
-    }
-    RealD tn;
-    
-    GridStopWatch HDCGTimer;
-    ProjectTimer.Reset();
-    PromoteTimer.Reset();
-    CoarseTimer.Reset();
-    SmoothTimer.Reset();
-    MatrixTimer.Reset();
-    M3Timer.Reset();
-    LinalgTimer.Reset();
-    M3Calls = SmoothCalls = MatrixCalls = ProjectCalls = CoarseCalls = PromoteCalls = 0;
-    HDCGTimer.Start();
+    Field r  (grid);
+    Field mu (grid);
+  
    //////////////////////////
    // x0 = Vstart -- possibly modify guess
    //////////////////////////
+    x=src;
    Vstart(x,src);

    // r0 = b -A x0
-    _FineLinop.HermOp(x,mmp[0]);
+    HermOp(x,mmp); // Shouldn't this be something else?
    axpy (r, -1.0,mmp[0], src);    // Recomputes r=src-Ax0
-    {
-      double n1 = norm2(x);
-      double n2 = norm2(mmp[0]);
-      double n3 = norm2(r);
-      std::cout<<GridLogMessage<<"x,vstart,r = "<<n1<<" "<<n2<<" "<<n3<<std::endl;
-    }

    //////////////////////////////////
    // Compute z = M1 x
    //////////////////////////////////
-    PcgM1(r,z);
+    M1(r,z,tmp,mp,SmootherMirs);
    rtzp =real(innerProduct(r,z));
-    
+
    ///////////////////////////////////////
    // Solve for Mss mu = P A z and set p = z-mu
-    // Def2 p = 1 - Q Az = Pright z
+    // Def2: p = 1 - Q Az = Pright z 
    // Other algos M2 is trivial
    ///////////////////////////////////////
-    PcgM2(z,p[0]);
-
-    RealD ssq =  norm2(src);
-    RealD rsq =  ssq*Tolerance*Tolerance;
-
-    std::cout << GridLogMessage<<"HDCG: k=0 residual "<<rtzp<<" rsq "<<rsq<<"\n";
-
-    Field pp(grid);
+    M2(z,p[0]);

    for (int k=0;k<=MaxIterations;k++){
    
@@ -168,53 +143,31 @@ class TwoLevelCG : public LinearFunction<Field>
      int peri_kp = (k+1) % mmax;

      rtz=rtzp;
-      M3Timer.Start();
-      d= PcgM3(p[peri_k],mmp[peri_k]);
-      M3Timer.Stop();
-      M3Calls++;
+      d= M3(p[peri_k],mp,mmp[peri_k],tmp);
      a = rtz/d;
-
+    
      // Memorise this
      pAp[peri_k] = d;

-      LinalgTimer.Start();
      axpy(x,a,p[peri_k],x);
      RealD rn = axpy_norm(r,-a,mmp[peri_k],r);
-      LinalgTimer.Stop();

      // Compute z = M x
-      PcgM1(r,z);
+      M1(r,z,tmp,mp);

-      {
-	RealD n1,n2;
-	n1=norm2(r);
-	n2=norm2(z);
-	std::cout << GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : vector r,z "<<n1<<" "<<n2<<"\n";
-      }
-      LinalgTimer.Start();
      rtzp =real(innerProduct(r,z));
-      LinalgTimer.Stop();
-      std::cout << GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : inner rtzp "<<rtzp<<"\n";

-      //    PcgM2(z,p[0]);
-      PcgM2(z,mu); // ADEF-2 this is identity. Axpy possible to eliminate
+      M2(z,mu); // ADEF-2 this is identity. Axpy possible to eliminate

-      p[peri_kp]=mu;
+      p[peri_kp]=p[peri_k];

-      // Standard search direction  p -> z + b p
+      // Standard search direction  p -> z + b p    ; b = 
      b = (rtzp)/rtz;
-      
-      int northog;
-      // k=zero  <=> peri_kp=1;        northog = 1
-      // k=1     <=> peri_kp=2;        northog = 2
-      // ...               ...                  ...
-      // k=mmax-2<=> peri_kp=mmax-1;   northog = mmax-1
-      // k=mmax-1<=> peri_kp=0;        northog = 1

+      int northog;
      //    northog     = (peri_kp==0)?1:peri_kp; // This is the fCG(mmax) algorithm
      northog     = (k>mmax-1)?(mmax-1):k;        // This is the fCG-Tr(mmax-1) algorithm
    
-      std::cout<<GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : orthogonalising to last "<<northog<<" vectors\n";
      for(int back=0; back < northog; back++){
 	int peri_back = (k-back)%mmax;
 	RealD pbApk= real(innerProduct(mmp[peri_back],p[peri_kp]));
@@ -223,320 +176,222 @@ class TwoLevelCG : public LinearFunction<Field>
      }

      RealD rrn=sqrt(rn/ssq);
-      RealD rtn=sqrt(rtz/ssq);
-      RealD rtnp=sqrt(rtzp/ssq);
-
-      std::cout<<GridLogMessage<<"HDCG: fPcg k= "<<k<<" residual = "<<rrn<<"\n";
+      std::cout<<GridLogMessage<<"TwoLevelfPcg: k= "<<k<<" residual = "<<rrn<<std::endl;

      // Stopping condition
      if ( rn <= rsq ) { 

-	HDCGTimer.Stop();
-	std::cout<<GridLogMessage<<"HDCG: fPcg converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg breakdown"<<std::endl;
-	auto mspc = [](GridStopWatch &sw, int64_t n) -> double {
-	  return (n > 0) ? sw.useconds() * 1e-3 / n : 0.0;
-	};
-	std::cout<<GridLogMessage<<"HDCG: fPcg M3 (fine MVM)  "<<M3Timer.Elapsed()
-		 <<"  "<<M3Calls<<" calls  "<<mspc(M3Timer,M3Calls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg linalg         "<<LinalgTimer.Elapsed()<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg smoother       "<<SmoothTimer.Elapsed()
-		 <<"  "<<SmoothCalls<<" calls  "<<mspc(SmoothTimer,SmoothCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg matrix (in M1) "<<MatrixTimer.Elapsed()
-		 <<"  "<<MatrixCalls<<" calls  "<<mspc(MatrixTimer,MatrixCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg project        "<<ProjectTimer.Elapsed()
-		 <<"  "<<ProjectCalls<<" calls  "<<mspc(ProjectTimer,ProjectCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg coarse         "<<CoarseTimer.Elapsed()
-		 <<"  "<<CoarseCalls<<" calls  "<<mspc(CoarseTimer,CoarseCalls)<<" ms/call"<<std::endl;
-	std::cout<<GridLogMessage<<"HDCG: fPcg promote        "<<PromoteTimer.Elapsed()
-		 <<"  "<<PromoteCalls<<" calls  "<<mspc(PromoteTimer,PromoteCalls)<<" ms/call"<<std::endl;
-
-	_FineLinop.HermOp(x,mmp[0]);			  
+	HermOp(x,mmp); // Shouldn't this be something else?
 	axpy(tmp,-1.0,src,mmp[0]);
 	
-	RealD  mmpnorm = sqrt(norm2(mmp[0]));
-	RealD  xnorm   = sqrt(norm2(x));
-	RealD  srcnorm = sqrt(norm2(src));
-	RealD  tmpnorm = sqrt(norm2(tmp));
-	RealD  true_residual = tmpnorm/srcnorm;
-	std::cout<<GridLogMessage
-	       <<"HDCG: true residual is "<<true_residual
-	       <<" solution "<<xnorm
-	       <<" source "<<srcnorm
-	       <<" mmp "<<mmpnorm	  
-	       <<std::endl;
-      
-	return;
+	RealD psinorm = sqrt(norm2(x));
+	RealD srcnorm = sqrt(norm2(src));
+	RealD tmpnorm = sqrt(norm2(tmp));
+	RealD true_residual = tmpnorm/srcnorm;
+	std::cout<<GridLogMessage<<"TwoLevelfPcg:   true residual is "<<true_residual<<std::endl;
+	std::cout<<GridLogMessage<<"TwoLevelfPcg: target residual was"<<Tolerance<<std::endl;
+	return k;
      }
-
    }
-    HDCGTimer.Stop();
-    std::cout<<GridLogMessage<<"HDCG: not converged "<<HDCGTimer.Elapsed()<<std::endl;
-    RealD  xnorm   = sqrt(norm2(x));
-    RealD  srcnorm = sqrt(norm2(src));
-    std::cout<<GridLogMessage<<"HDCG: non-converged solution "<<xnorm<<" source "<<srcnorm<<std::endl;
+    // Non-convergence
+    assert(0);
  }

-
-
-  virtual void operator() (std::vector<Field> &src, std::vector<Field> &x)
-  {
-    std::cout << GridLogMessage<<"HDCG: mrhs fPcg starting"<<std::endl;
-    src[0].Grid()->Barrier();
-    int nrhs = src.size();
-    std::vector<RealD> f(nrhs);
-    std::vector<RealD> rtzp(nrhs);
-    std::vector<RealD> rtz(nrhs);
-    std::vector<RealD> a(nrhs);
-    std::vector<RealD> d(nrhs);
-    std::vector<RealD> b(nrhs);
-    std::vector<RealD> rptzp(nrhs);
-    /////////////////////////////
-    // Set up history vectors
-    /////////////////////////////
-    int mmax = 3;
-    std::cout << GridLogMessage<<"HDCG: fPcg allocating"<<std::endl;
-    src[0].Grid()->Barrier();
-    std::vector<std::vector<Field> > p(nrhs);   for(int r=0;r<nrhs;r++)  p[r].resize(mmax,grid);
-    std::cout << GridLogMessage<<"HDCG: fPcg allocated p"<<std::endl;
-    src[0].Grid()->Barrier();
-    std::vector<std::vector<Field> > mmp(nrhs); for(int r=0;r<nrhs;r++) mmp[r].resize(mmax,grid);
-    std::cout << GridLogMessage<<"HDCG: fPcg allocated mmp"<<std::endl;
-    src[0].Grid()->Barrier();
-    std::vector<std::vector<RealD> > pAp(nrhs); for(int r=0;r<nrhs;r++) pAp[r].resize(mmax);
-    std::cout << GridLogMessage<<"HDCG: fPcg allocated pAp"<<std::endl;
-    src[0].Grid()->Barrier();
-    std::vector<Field> z(nrhs,grid);
-    std::vector<Field>  mp (nrhs,grid);
-    std::vector<Field>  r  (nrhs,grid);
-    std::vector<Field>  mu (nrhs,grid);
-    std::cout << GridLogMessage<<"HDCG: fPcg allocated z,mp,r,mu"<<std::endl;
-    src[0].Grid()->Barrier();
-
-    //Initial residual computation & set up
-    std::vector<RealD> src_nrm(nrhs);
-    for(int rhs=0;rhs<nrhs;rhs++) {
-      src_nrm[rhs]=norm2(src[rhs]);
-      GRID_ASSERT(src_nrm[rhs]!=0.0);
-    }
-    std::vector<RealD> tn(nrhs);
-
-    GridStopWatch HDCGTimer;
-    HDCGTimer.Start();
-    //////////////////////////
-    // x0 = Vstart -- possibly modify guess
-    //////////////////////////
-    Vstart(x,src);
-
-    for(int rhs=0;rhs<nrhs;rhs++){
-      // r0 = b -A x0
-      _FineLinop.HermOp(x[rhs],mmp[rhs][0]);
-      axpy (r[rhs], -1.0,mmp[rhs][0], src[rhs]);    // Recomputes r=src-Ax0
-    }
-
-    //////////////////////////////////
-    // Compute z = M1 x
-    //////////////////////////////////
-    // This needs a multiRHS version for acceleration
-    PcgM1(r,z);
-
-    std::vector<RealD> ssq(nrhs);
-    std::vector<RealD> rsq(nrhs);
-    std::vector<Field> pp(nrhs,grid);
-
-    for(int rhs=0;rhs<nrhs;rhs++){
-      rtzp[rhs] =real(innerProduct(r[rhs],z[rhs]));
-      p[rhs][0]=z[rhs];
-      ssq[rhs]=norm2(src[rhs]);
-      rsq[rhs]=  ssq[rhs]*Tolerance*Tolerance;
-      std::cout << GridLogMessage<<"mrhs HDCG: "<<rhs<<" k=0 residual "<<rtzp[rhs]<<" rsq "<<rsq[rhs]<<"\n";
-    }
-
-    std::vector<RealD> rn(nrhs);
-    for (int k=0;k<=MaxIterations;k++){
-    
-      int peri_k  = k % mmax;
-      int peri_kp = (k+1) % mmax;
-
-      for(int rhs=0;rhs<nrhs;rhs++){
-	rtz[rhs]=rtzp[rhs];
-	d[rhs]= PcgM3(p[rhs][peri_k],mmp[rhs][peri_k]);
-	a[rhs] = rtz[rhs]/d[rhs];
-    
-	// Memorise this
-	pAp[rhs][peri_k] = d[rhs];
-
-	axpy(x[rhs],a[rhs],p[rhs][peri_k],x[rhs]);
-	rn[rhs] = axpy_norm(r[rhs],-a[rhs],mmp[rhs][peri_k],r[rhs]);
-      }
-
-      // Compute z = M x (for *all* RHS)
-      PcgM1(r,z);
-      std::cout << GridLogMessage<<"HDCG::fPcg M1 complete"<<std::endl;
-      grid->Barrier();
-      
-      RealD max_rn=0.0;
-      for(int rhs=0;rhs<nrhs;rhs++){
-
-	rtzp[rhs] =real(innerProduct(r[rhs],z[rhs]));
-
-	std::cout << GridLogMessage<<"HDCG::fPcg rhs"<<rhs<<" iteration "<<k<<" : inner rtzp "<<rtzp[rhs]<<"\n";
-	
-	mu[rhs]=z[rhs];
-
-	p[rhs][peri_kp]=mu[rhs];
-
-	// Standard search direction p == z + b p 
-	b[rhs] = (rtzp[rhs])/rtz[rhs];
-
-	int northog = (k>mmax-1)?(mmax-1):k;        // This is the fCG-Tr(mmax-1) algorithm
-	std::cout<<GridLogMessage<<"HDCG::fPcg iteration "<<k<<" : orthogonalising to last "<<northog<<" vectors\n";
-	for(int back=0; back < northog; back++){
-	  int peri_back = (k-back)%mmax;
-	  RealD pbApk= real(innerProduct(mmp[rhs][peri_back],p[rhs][peri_kp]));
-	  RealD beta = -pbApk/pAp[rhs][peri_back];
-	  axpy(p[rhs][peri_kp],beta,p[rhs][peri_back],p[rhs][peri_kp]);
-	}
-
-	RealD rrn=sqrt(rn[rhs]/ssq[rhs]);
-	RealD rtn=sqrt(rtz[rhs]/ssq[rhs]);
-	RealD rtnp=sqrt(rtzp[rhs]/ssq[rhs]);
-	
-	std::cout<<GridLogMessage<<"HDCG: rhs "<<rhs<<"fPcg k= "<<k<<" residual = "<<rrn<<"\n";
-	if ( rrn > max_rn ) max_rn = rrn;
-      }
-
-      // Stopping condition based on worst case
-      if ( max_rn <= Tolerance ) { 
-
-	HDCGTimer.Stop();
-	std::cout<<GridLogMessage<<"HDCG: mrhs fPcg converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;;
-
-	for(int rhs=0;rhs<nrhs;rhs++){
-	  _FineLinop.HermOp(x[rhs],mmp[rhs][0]);			  
-	  Field tmp(grid);
-	  axpy(tmp,-1.0,src[rhs],mmp[rhs][0]);
-      
-	  RealD  mmpnorm = sqrt(norm2(mmp[rhs][0]));
-	  RealD  xnorm   = sqrt(norm2(x[rhs]));
-	  RealD  srcnorm = sqrt(norm2(src[rhs]));
-	  RealD  tmpnorm = sqrt(norm2(tmp));
-	  RealD  true_residual = tmpnorm/srcnorm;
-	  std::cout<<GridLogMessage
-		   <<"HDCG: true residual ["<<rhs<<"] is "<<true_residual
-		   <<" solution "<<xnorm
-		   <<" source "<<srcnorm
-		   <<" mmp "<<mmpnorm	  
-		   <<std::endl;
-	}
-	return;
-      }
-      
-    }
-    HDCGTimer.Stop();
-    std::cout<<GridLogMessage<<"HDCG: not converged "<<HDCGTimer.Elapsed()<<std::endl;
-    for(int rhs=0;rhs<nrhs;rhs++){
-      RealD  xnorm   = sqrt(norm2(x[rhs]));
-      RealD  srcnorm = sqrt(norm2(src[rhs]));
-      std::cout<<GridLogMessage<<"HDCG: non-converged solution "<<xnorm<<" source "<<srcnorm<<std::endl;
-    }
-  }
-  
-
 public:

-  virtual void PcgM1(std::vector<Field> & in,std::vector<Field> & out)
-  {
-    std::cout << "PcgM1 default (cheat) mrhs version"<<std::endl;
-    for(int rhs=0;rhs<in.size();rhs++){
-      this->PcgM1(in[rhs],out[rhs]);
-    }
-  }
-  virtual void PcgM1(Field & in, Field & out)     =0;
-  virtual void Vstart(std::vector<Field> & x,std::vector<Field> & src)
-  {
-    std::cout << "Vstart default (cheat) mrhs version"<<std::endl;
-    for(int rhs=0;rhs<x.size();rhs++){
-      this->Vstart(x[rhs],src[rhs]);
-    }
-  }
-  virtual void Vstart(Field & x,const Field & src)=0;
+  virtual void M(Field & in,Field & out,Field & tmp) {

-  virtual void PcgM2(const Field & in, Field & out) {
+  }
+
+  virtual void M1(Field & in, Field & out) {// the smoother
+
+    // [PTM+Q] in = [1 - Q A] M in + Q in = Min + Q [ in -A Min]
+    Field tmp(grid);
+    Field Min(grid);
+
+    PcgM(in,Min); // Smoother call
+
+    HermOp(Min,out);
+    axpy(tmp,-1.0,out,in);          // tmp  = in - A Min
+
+    ProjectToSubspace(tmp,PleftProj);     
+    ApplyInverse(PleftProj,PleftMss_proj); // Ass^{-1} [in - A Min]_s
+    PromoteFromSubspace(PleftMss_proj,tmp);// tmp = Q[in - A Min]  
+    axpy(out,1.0,Min,tmp); // Min+tmp
+  }
+
+  virtual void M2(const Field & in, Field & out) {
    out=in;
+    // Must override for Def2 only
+    //  case PcgDef2:
+    //    Pright(in,out);
+    //    break;
  }

-  virtual RealD PcgM3(const Field & p, Field & mmp){
-    RealD dd;
-    _FineLinop.HermOp(p,mmp);
-    ComplexD dot = innerProduct(p,mmp);
-    dd=real(dot);
+  virtual RealD M3(const Field & p, Field & mmp){
+    double d,dd;
+    HermOpAndNorm(p,mmp,d,dd);
    return dd;
+    // Must override for Def1 only
+    //  case PcgDef1:
+    //    d=linop_d->Mprec(p,mmp,tmp,0,1);// Dag no
+    //      linop_d->Mprec(mmp,mp,tmp,1);// Dag yes
+    //    Pleft(mp,mmp);
+    //    d=real(linop_d->inner(p,mmp));
  }

-  /////////////////////////////////////////////////////////////////////
-  // Only Def1 has non-trivial Vout.
-  /////////////////////////////////////////////////////////////////////
+  virtual void VstartDef2(Field & xconst Field & src){
+    //case PcgDef2:
+    //case PcgAdef2: 
+    //case PcgAdef2f:
+    //case PcgV11f:
+    ///////////////////////////////////
+    // Choose x_0 such that 
+    // x_0 = guess +  (A_ss^inv) r_s = guess + Ass_inv [src -Aguess]
+    //                               = [1 - Ass_inv A] Guess + Assinv src
+    //                               = P^T guess + Assinv src 
+    //                               = Vstart  [Tang notation]
+    // This gives:
+    // W^T (src - A x_0) = src_s - A guess_s - r_s
+    //                   = src_s - (A guess)_s - src_s  + (A guess)_s 
+    //                   = 0 
+    ///////////////////////////////////
+    Field r(grid);
+    Field mmp(grid);
+    
+    HermOp(x,mmp);
+    axpy (r, -1.0, mmp, src);        // r_{-1} = src - A x
+    ProjectToSubspace(r,PleftProj);     
+    ApplyInverseCG(PleftProj,PleftMss_proj); // Ass^{-1} r_s
+    PromoteFromSubspace(PleftMss_proj,mmp);  
+    x=x+mmp;

-};
-  
+  }

-  
-template<class Field>
-class TwoLevelADEF1defl : public TwoLevelCG<Field>
-{
-public:
-  const std::vector<Field> &evec;
-  const std::vector<RealD> &eval;
-  
-  TwoLevelADEF1defl(RealD tol,
-		   Integer maxit,
-		   LinearOperatorBase<Field>   &FineLinop,
-		   LinearFunction<Field>   &Smoother,
-		   std::vector<Field> &_evec,
-		   std::vector<RealD> &_eval) : 
-    TwoLevelCG<Field>(tol,maxit,FineLinop,Smoother,_evec[0].Grid()),
-    evec(_evec),
-    eval(_eval)
-  {};
-
-  // Can just inherit existing M2
-  // Can just inherit existing M3
-
-  // Simple vstart - do nothing
  virtual void Vstart(Field & x,const Field & src){
-    x=src; // Could apply Q
-  };
-
-  // Override PcgM1
-  virtual void PcgM1(Field & in, Field & out)
-  {
-    GRID_TRACE("EvecPreconditioner ");
-    int N=evec.size();
-    Field Pin(this->grid);
-    Field Qin(this->grid);
-
-    //MP  + Q = M(1-AQ) + Q = M
-    // // If we are eigenvector deflating in coarse space
-    // // Q   = Sum_i |phi_i> 1/lambda_i <phi_i|
-    // // A Q = Sum_i |phi_i> <phi_i|
-    // // M(1-AQ) = M(1-proj) + Q
-    Qin.Checkerboard()=in.Checkerboard();
-    Qin = Zero();
-    Pin = in;
-    for (int i=0;i<N;i++) {
-      const Field& tmp = evec[i];
-      auto ip = TensorRemove(innerProduct(tmp,in));
-      axpy(Qin, ip / eval[i],tmp,Qin);
-      axpy(Pin, -ip ,tmp,Pin);
-    }
-
-    this->_Smoother(Pin,out);
-
-    out = out + Qin;
+    return;
  }
-};

-NAMESPACE_END(Grid);
+  /////////////////////////////////////////////////////////////////////
+  // Only Def1 has non-trivial Vout. Override in Def1
+  /////////////////////////////////////////////////////////////////////
+  virtual void   Vout  (Field & in, Field & out,Field & src){
+    out = in;
+    //case PcgDef1:
+    //    //Qb + PT x
+    //    ProjectToSubspace(src,PleftProj);     
+    //    ApplyInverse(PleftProj,PleftMss_proj); // Ass^{-1} r_s
+    //    PromoteFromSubspace(PleftMss_proj,tmp);  
+    //    
+    //    Pright(in,out);
+    //    
+    //    linop_d->axpy(out,tmp,out,1.0);
+    //    break;
+  }

+  ////////////////////////////////////////////////////////////////////////////////////////////////
+  // Pright and Pleft are common to all implementations
+  ////////////////////////////////////////////////////////////////////////////////////////////////
+  virtual void Pright(Field & in,Field & out){
+    // P_R  = [ 1              0 ] 
+    //        [ -Mss^-1 Msb    0 ] 
+    Field in_sbar(grid);
+
+    ProjectToSubspace(in,PleftProj);     
+    PromoteFromSubspace(PleftProj,out);  
+    axpy(in_sbar,-1.0,out,in);       // in_sbar = in - in_s 
+
+    HermOp(in_sbar,out);
+    ProjectToSubspace(out,PleftProj);           // Mssbar in_sbar  (project)
+
+    ApplyInverse     (PleftProj,PleftMss_proj); // Mss^{-1} Mssbar 
+    PromoteFromSubspace(PleftMss_proj,out);     // 
+
+    axpy(out,-1.0,out,in_sbar);     // in_sbar - Mss^{-1} Mssbar in_sbar
+  }
+  virtual void Pleft (Field & in,Field & out){
+    // P_L  = [ 1  -Mbs Mss^-1] 
+    //        [ 0   0         ] 
+    Field in_sbar(grid);
+    Field    tmp2(grid);
+    Field    Mtmp(grid);
+
+    ProjectToSubspace(in,PleftProj);     
+    PromoteFromSubspace(PleftProj,out);  
+    axpy(in_sbar,-1.0,out,in);      // in_sbar = in - in_s
+
+    ApplyInverse(PleftProj,PleftMss_proj); // Mss^{-1} in_s
+    PromoteFromSubspace(PleftMss_proj,out);
+
+    HermOp(out,Mtmp);
+
+    ProjectToSubspace(Mtmp,PleftProj);      // Msbar s Mss^{-1}
+    PromoteFromSubspace(PleftProj,tmp2);
+
+    axpy(out,-1.0,tmp2,Mtmp);
+    axpy(out,-1.0,out,in_sbar);     // in_sbar - Msbars Mss^{-1} in_s
+  }
+}
+
+template<class Field>
+class TwoLevelFlexiblePcgADef2 : public TwoLevelFlexiblePcg<Field> {
+ public:
+  virtual void M(Field & in,Field & out,Field & tmp){
+
+  } 
+  virtual void M1(Field & in, Field & out,Field & tmp,Field & mp){
+
+  }
+  virtual void M2(Field & in, Field & out){
+
+  }
+  virtual RealD M3(Field & p, Field & mp,Field & mmp, Field & tmp){
+
+  }
+  virtual void Vstart(Field & in, Field & src, Field & r, Field & mp, Field & mmp, Field & tmp){
+
+  }
+}
+/*
+template<class Field>
+class TwoLevelFlexiblePcgAD : public TwoLevelFlexiblePcg<Field> {
+ public:
+  virtual void M(Field & in,Field & out,Field & tmp); 
+  virtual void M1(Field & in, Field & out,Field & tmp,Field & mp);
+  virtual void M2(Field & in, Field & out);
+  virtual RealD M3(Field & p, Field & mp,Field & mmp, Field & tmp);
+  virtual void Vstart(Field & in, Field & src, Field & r, Field & mp, Field & mmp, Field & tmp);
+}
+
+template<class Field>
+class TwoLevelFlexiblePcgDef1 : public TwoLevelFlexiblePcg<Field> {
+ public:
+  virtual void M(Field & in,Field & out,Field & tmp); 
+  virtual void M1(Field & in, Field & out,Field & tmp,Field & mp);
+  virtual void M2(Field & in, Field & out);
+  virtual RealD M3(Field & p, Field & mp,Field & mmp, Field & tmp);
+  virtual void Vstart(Field & in, Field & src, Field & r, Field & mp, Field & mmp, Field & tmp);
+  virtual void   Vout  (Field & in, Field & out,Field & src,Field & tmp);
+}
+
+template<class Field>
+class TwoLevelFlexiblePcgDef2 : public TwoLevelFlexiblePcg<Field> {
+ public:
+  virtual void M(Field & in,Field & out,Field & tmp); 
+  virtual void M1(Field & in, Field & out,Field & tmp,Field & mp);
+  virtual void M2(Field & in, Field & out);
+  virtual RealD M3(Field & p, Field & mp,Field & mmp, Field & tmp);
+  virtual void Vstart(Field & in, Field & src, Field & r, Field & mp, Field & mmp, Field & tmp);
+}
+
+template<class Field>
+class TwoLevelFlexiblePcgV11: public TwoLevelFlexiblePcg<Field> {
+ public:
+  virtual void M(Field & in,Field & out,Field & tmp); 
+  virtual void M1(Field & in, Field & out,Field & tmp,Field & mp);
+  virtual void M2(Field & in, Field & out);
+  virtual RealD M3(Field & p, Field & mp,Field & mmp, Field & tmp);
+  virtual void Vstart(Field & in, Field & src, Field & r, Field & mp, Field & mmp, Field & tmp);
+}
+*/
 #endif
@@ -1,660 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/AdefGeneric.h
-
-    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 */
-#pragma once
-
-#include <Grid/algorithms/multigrid/MrhsPreconditioner.h>
-
-  /*
-   * Compared to Tang-2009:  P=Pleft. P^T = PRight Q=MssInv.
-   * Script A = SolverMatrix 
-   * Script P = Preconditioner
-   *
-   * Implement ADEF-2
-   *
-   * Vstart = P^Tx + Qb
-   * M1 = P^TM + Q
-   * M2=M3=1
-   */
-NAMESPACE_BEGIN(Grid);
-
-
-//////////////////////////////////////////////////////////////////////
-// Two-level CG family on a vector of right-hand sides, with the
-// preconditioner (M1 and Vstart) as an MrhsPreconditioner object:
-//   fPcg           flexible PCG, one Krylov per rhs, shared M1 call
-//   PrecBlockCGrQ  preconditioned BlockCGrQ (arXiv:2409.03904 s2.2);
-//                  assumes a stationary preconditioner; not the
-//                  production choice (its linalg grows as nrhs^2)
-// Also a LinearFunction<Field>: one rhs is the nrhs=1 case.
-//////////////////////////////////////////////////////////////////////
-enum class MrhsCGAlgorithm { fPcg, PrecBlockCGrQ };
-
-template<class Field>
-class TwoLevelCGmrhs : public LinearFunction<Field>
-{
- public:
-  using LinearFunction<Field>::operator();
-  RealD   Tolerance;
-  Integer MaxIterations;
-  GridBase *grid;
-  MrhsCGAlgorithm Algorithm;
-
-  LinearOperatorBase<Field>    &_FineLinop;
-  MrhsPreconditioner<Field>    &_Precon;
-  MultiRHSBlockCGLinalg<Field>  _BlockCGLinalg;
-
-  TwoLevelCGmrhs(RealD tol,
-		 Integer maxit,
-		 LinearOperatorBase<Field> &FineLinop,
-		 MrhsPreconditioner<Field> &Precon,
-		 GridBase *fine,
-		 MrhsCGAlgorithm alg = MrhsCGAlgorithm::fPcg) :
-    Tolerance(tol),
-    MaxIterations(maxit),
-    Algorithm(alg),
-    _FineLinop(FineLinop),
-    _Precon(Precon)
-  {
-    grid = fine;
-  };
-
-  // mrhs entry point
-  virtual void operator() (std::vector<Field> &src, std::vector<Field> &x)
-  {
-    if ( Algorithm == MrhsCGAlgorithm::PrecBlockCGrQ ) SolvePrecBlockCG(src,x);
-    else                                              SolveSingleSystem(src,x);
-  }
-  // LinearFunction entry points
-  virtual void operator() (const Field &src, Field &x)
-  {
-    std::vector<Field> S(1,src);
-    std::vector<Field> X(1,x);
-    (*this)(S,X);
-    x = X[0];
-  }
-  virtual void operator() (const std::vector<Field> &src, std::vector<Field> &x)
-  {
-    std::vector<Field> S(src);
-    (*this)(S,x);
-  }
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Thin QR factorisation (google it)
-////////////////////////////////////////////////////////////////////////////////////////////////////
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  //Dimensions
-  // R_{ferm x Nblock} =  Q_{ferm x Nblock} x  C_{Nblock x Nblock} -> ferm x Nblock
-  //
-  // Rdag R = m_rr = Herm = L L^dag        <-- Cholesky decomposition (LLT routine in Eigen)
-  //
-  //   Q  C = R => Q = R C^{-1}
-  //
-  // Want  Ident = Q^dag Q = C^{-dag} R^dag R C^{-1} = C^{-dag} L L^dag C^{-1} = 1_{Nblock x Nblock} 
-  //
-  // Set C = L^{dag}, and then Q^dag Q = ident 
-  //
-  // Checks:
-  // Cdag C = Rdag R ; passes.
-  // QdagQ  = 1      ; passes
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  void ThinQRfact (Eigen::MatrixXcd &m_zz,
-		   Eigen::MatrixXcd &C,
-		   Eigen::MatrixXcd &Cinv,
-		   std::vector<Field> &  Q,
-		   std::vector<Field> & MQ,
-		   const std::vector<Field> & Z,
-		   const std::vector<Field> & MZ)
-  {
-    RealD t0=usecond();
-    _BlockCGLinalg.InnerProductMatrix(m_zz,MZ,Z);
-    RealD t1=usecond();
-
-    m_zz = 0.5*(m_zz+m_zz.adjoint());
-    
-    Eigen::MatrixXcd L    = m_zz.llt().matrixL(); 
-    
-    C    = L.adjoint();
-    Cinv = C.inverse();
-    
-    RealD t3=usecond();
-    _BlockCGLinalg.MulMatrix( Q,Cinv,Z);
-    _BlockCGLinalg.MulMatrix(MQ,Cinv,MZ);
-    RealD t4=usecond();
-    std::cout << " ThinQRfact IP    :"<< t1-t0<<" us"<<std::endl;
-    std::cout << " ThinQRfact Eigen :"<< t3-t1<<" us"<<std::endl;
-    std::cout << " ThinQRfact MulMat:"<< t4-t3<<" us"<<std::endl;
-  }
-
-  virtual void SolvePrecBlockCG (std::vector<Field> &src, std::vector<Field> &X)
-  {
-    std::cout << GridLogMessage<<"HDCG: mrhs fPrecBlockcg starting"<<std::endl;
-    src[0].Grid()->Barrier();
-    int nrhs = src.size();
-    //    std::vector<RealD> f(nrhs);
-    //    std::vector<RealD> rtzp(nrhs);
-    //    std::vector<RealD> rtz(nrhs);
-    //    std::vector<RealD> a(nrhs);
-    //    std::vector<RealD> d(nrhs);
-    //    std::vector<RealD> b(nrhs);
-    //    std::vector<RealD> rptzp(nrhs);
-
-    ////////////////////////////////////////////
-    //Initial residual computation & set up
-    ////////////////////////////////////////////
-    std::vector<RealD> ssq(nrhs);
-    for(int rhs=0;rhs<nrhs;rhs++){
-      ssq[rhs]=norm2(src[rhs]); GRID_ASSERT(ssq[rhs]!=0.0);
-    }      
-
-    ///////////////////////////
-    // Fields -- eliminate duplicates between fPcg and block cg
-    ///////////////////////////
-    std::vector<Field> Mtmp(nrhs,grid);
-    std::vector<Field> tmp(nrhs,grid);
-    std::vector<Field>   Z(nrhs,grid); // Rename Z to R
-    std::vector<Field>  MZ(nrhs,grid); // Rename MZ to Z
-    std::vector<Field>   Q(nrhs,grid); // 
-    std::vector<Field>  MQ(nrhs,grid); // Rename to P
-    std::vector<Field>   D(nrhs,grid);
-    std::vector<Field>  AD(nrhs,grid);
-    
-    /************************************************************************
-     * Preconditioned Block conjugate gradient rQ
-     * Generalise Sebastien Birk Thesis, after Dubrulle 2001.
-     * Introduce preconditioning following Saad Ch9
-     ************************************************************************
-     * Dimensions:
-     *
-     *   X,B etc... ==(Nferm x nrhs)
-     *  Matrix A==(Nferm x Nferm)
-     *  
-     * Nferm = Nspin x Ncolour x Ncomplex x Nlattice_site
-     * QC => Thin QR factorisation (google it)
-     *
-     * R = B-AX
-     * Z = Mi R
-     * QC = Z
-     * D = Q 
-     * for k: 
-     *   R  = AD
-     *   Z  = Mi R
-     *   M  = [D^dag R]^{-1}
-     *   X  = X + D M C
-     *   QS = Q - Z.M
-     *   D  = Q + D S^dag
-     *   C  = S C
-     */
-    Eigen::MatrixXcd m_DZ     = Eigen::MatrixXcd::Identity(nrhs,nrhs);
-    Eigen::MatrixXcd m_M      = Eigen::MatrixXcd::Identity(nrhs,nrhs);
-    Eigen::MatrixXcd m_zz     = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    Eigen::MatrixXcd m_rr     = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    
-    Eigen::MatrixXcd m_C      = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    Eigen::MatrixXcd m_Cinv   = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    Eigen::MatrixXcd m_S      = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    Eigen::MatrixXcd m_Sinv   = Eigen::MatrixXcd::Zero(nrhs,nrhs);
-    
-    Eigen::MatrixXcd m_tmp    = Eigen::MatrixXcd::Identity(nrhs,nrhs);
-    Eigen::MatrixXcd m_tmp1   = Eigen::MatrixXcd::Identity(nrhs,nrhs);
-
-    GridStopWatch HDCGTimer;
-
-    //////////////////////////
-    // x0 = Vstart -- possibly modify guess
-    //////////////////////////
-    _Precon.Vstart(X,src);
-
-    //////////////////////////
-    // R = B-AX
-    //////////////////////////
-    for(int rhs=0;rhs<nrhs;rhs++){
-      // r0 = b -A x0
-      _FineLinop.HermOp(X[rhs],tmp[rhs]);
-      axpy (Z[rhs], -1.0,tmp[rhs], src[rhs]);    // Computes R=Z=src - A X0
-    }
-
-    //////////////////////////////////
-    // Compute MZ = M1 Z = M1 B - M1 A x0
-    //////////////////////////////////
-    _Precon(Z,MZ);  
-
-    //////////////////////////////////
-    // QC = Z
-    //////////////////////////////////
-    ThinQRfact (m_zz, m_C, m_Cinv, Q, MQ, Z, MZ);
-
-    //////////////////////////////////
-    // D=MQ
-    //////////////////////////////////
-    for(int b=0;b<nrhs;b++) D[b]=MQ[b]; // LLT rotation of the MZ basis of search dirs
-
-    std::cout << GridLogMessage<<"PrecBlockCGrQ vec computed initial residual and QR fact " <<std::endl;
-
-    _Precon.ResetTimers();
-
-    GridStopWatch M1Timer;
-    GridStopWatch M2Timer;
-    GridStopWatch M3Timer;
-    GridStopWatch LinalgTimer;
-    GridStopWatch InnerProdTimer;
-
-    HDCGTimer.Start();
-
-    std::vector<RealD> rn(nrhs);
-    for (int k=0;k<=MaxIterations;k++){
-
-      ////////////////////
-      // Z  = AD
-      ////////////////////
-      M3Timer.Start();
-      for(int b=0;b<nrhs;b++) _FineLinop.HermOp(D[b], Z[b]);      
-      M3Timer.Stop();
-
-      ////////////////////
-      // MZ  = M1 Z <==== the Multigrid preconditioner
-      ////////////////////
-      M1Timer.Start();
-      _Precon(Z,MZ);
-      M1Timer.Stop();
-
-      ////////////////////
-      // M  = [D^dag Z]^{-1} = (<Ddag MZ>_M)^{-1} inner prod, generalising Saad derivation of Precon CG
-      ////////////////////
-      InnerProdTimer.Start();
-      _BlockCGLinalg.InnerProductMatrix(m_DZ,D,Z);
-      InnerProdTimer.Stop();
-      m_M       = m_DZ.inverse();
-
-      ///////////////////////////
-      // X  = X + D MC
-      ///////////////////////////
-      m_tmp     = m_M * m_C;
-      LinalgTimer.Start();
-      _BlockCGLinalg.MaddMatrix(X,m_tmp, D,X);     // D are the search directions and X takes the updates 
-      LinalgTimer.Stop();
-
-      ///////////////////////////
-      // QS = Q - M Z
-      // (MQ) S = MQ - M (M1Z)
-      ///////////////////////////
-      LinalgTimer.Start();
-      _BlockCGLinalg.MaddMatrix(tmp ,m_M, Z, Q,-1.0);
-      _BlockCGLinalg.MaddMatrix(Mtmp,m_M,MZ,MQ,-1.0);
-      ThinQRfact (m_zz, m_S, m_Sinv, Q, MQ, tmp, Mtmp);
-      LinalgTimer.Stop();
-
-      ////////////////////////////
-      // D  = MQ + D S^dag
-      ////////////////////////////
-      m_tmp = m_S.adjoint();
-      LinalgTimer.Start();
-      _BlockCGLinalg.MaddMatrix(D,m_tmp,D,MQ);
-      LinalgTimer.Stop();
-
-      ////////////////////////////
-      // C  = S C
-      ////////////////////////////
-      m_C = m_S*m_C;
-      
-      ////////////////////////////
-      // convergence monitor
-      ////////////////////////////
-      m_rr = m_C.adjoint() * m_C;
-      
-
-      RealD max_resid=0;
-      RealD rrsum=0;
-      RealD sssum=0;
-      RealD rr;
-
-      for(int b=0;b<nrhs;b++) {
-	rrsum+=real(m_rr(b,b));
-	sssum+=ssq[b];
-	rr = real(m_rr(b,b))/ssq[b];
-	if ( rr > max_resid ) max_resid = rr;
-      }
-      std::cout << GridLogMessage <<
-	  "\t Prec BlockCGrQ Iteration "<<k<<" ave resid "<< std::sqrt(rrsum/sssum) << " max "<< std::sqrt(max_resid) <<std::endl;
-
-
-      if ( max_resid < Tolerance*Tolerance ) { 
-
-	HDCGTimer.Stop();
-	std::cout<<GridLogMessage<<"HDCG: mrhs PrecBlockCGrQ converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs PrecBlockCGrQ : Linalg  "<<LinalgTimer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs PrecBlockCGrQ : fine H  "<<M3Timer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs PrecBlockCGrQ : prec M1 "<<M1Timer.Elapsed()<<std::endl;;
-	_Precon.ReportTimers("HDCG: mrhs PrecBlockCGrQ : ");
-
-	for(int rhs=0;rhs<nrhs;rhs++){
-
-	  _FineLinop.HermOp(X[rhs],tmp[rhs]);			  
-
-	  Field mytmp(grid);
-	  axpy(mytmp,-1.0,src[rhs],tmp[rhs]);
-      
-	  RealD  xnorm   = sqrt(norm2(X[rhs]));
-	  RealD  srcnorm = sqrt(norm2(src[rhs]));
-	  RealD  tmpnorm = sqrt(norm2(mytmp));
-	  RealD  true_residual = tmpnorm/srcnorm;
-	  std::cout<<GridLogMessage
-		   <<"HDCG: true residual ["<<rhs<<"] is "<<true_residual
-		   <<" solution "<<xnorm
-		   <<" source "<<srcnorm
-		   <<std::endl;
-	}
-	return;
-      }
-      
-    }
-    HDCGTimer.Stop();
-    std::cout<<GridLogMessage<<"HDCG: PrecBlockCGrQ not converged "<<HDCGTimer.Elapsed()<<std::endl;
-    GRID_ASSERT(0);
-  }
-
-  virtual void SolveSingleSystem (std::vector<Field> &src, std::vector<Field> &x)
-  {
-    std::cout << GridLogMessage<<"HDCG: mrhs fPcg starting"<<std::endl;
-    src[0].Grid()->Barrier();
-    int nrhs = src.size();
-    std::vector<RealD> f(nrhs);
-    std::vector<RealD> rtzp(nrhs);
-    std::vector<RealD> rtz(nrhs);
-    std::vector<RealD> a(nrhs);
-    std::vector<RealD> d(nrhs);
-    std::vector<RealD> b(nrhs);
-    std::vector<RealD> rptzp(nrhs);
-    /////////////////////////////
-    // Set up history vectors
-    /////////////////////////////
-    int mmax = 3;
-
-    std::vector<std::vector<Field> > p(nrhs);   for(int r=0;r<nrhs;r++)  p[r].resize(mmax,grid);
-    std::vector<std::vector<Field> > mmp(nrhs); for(int r=0;r<nrhs;r++) mmp[r].resize(mmax,grid);
-    std::vector<std::vector<RealD> > pAp(nrhs); for(int r=0;r<nrhs;r++) pAp[r].resize(mmax);
-
-    std::vector<Field> z(nrhs,grid);
-    std::vector<Field>  mp (nrhs,grid);
-    std::vector<Field>  r  (nrhs,grid);
-    std::vector<Field>  mu (nrhs,grid);
-
-    //Initial residual computation & set up
-    std::vector<RealD> src_nrm(nrhs);
-    for(int rhs=0;rhs<nrhs;rhs++) {
-      src_nrm[rhs]=norm2(src[rhs]);
-      GRID_ASSERT(src_nrm[rhs]!=0.0);
-    }
-    std::vector<RealD> tn(nrhs);
-
-    GridStopWatch HDCGTimer;
-    //////////////////////////
-    // x0 = Vstart -- possibly modify guess
-    //////////////////////////
-    _Precon.Vstart(x,src);
-
-    for(int rhs=0;rhs<nrhs;rhs++){
-      // r0 = b -A x0
-      _FineLinop.HermOp(x[rhs],mmp[rhs][0]);
-      axpy (r[rhs], -1.0,mmp[rhs][0], src[rhs]);    // Recomputes r=src-Ax0
-    }
-
-    //////////////////////////////////
-    // Compute z = M1 x
-    //////////////////////////////////
-    // This needs a multiRHS version for acceleration
-    _Precon(r,z);
-
-    std::vector<RealD> ssq(nrhs);
-    std::vector<RealD> rsq(nrhs);
-    std::vector<Field> pp(nrhs,grid);
-
-    for(int rhs=0;rhs<nrhs;rhs++){
-      rtzp[rhs] =real(innerProduct(r[rhs],z[rhs]));
-      p[rhs][0]=z[rhs];
-      ssq[rhs]=norm2(src[rhs]);
-      rsq[rhs]=  ssq[rhs]*Tolerance*Tolerance;
-      //      std::cout << GridLogMessage<<"mrhs HDCG: "<<rhs<<" k=0 residual "<<rtzp[rhs]<<" rsq "<<rsq[rhs]<<"\n";
-    }
-
-    _Precon.ResetTimers();
-
-    GridStopWatch M1Timer;
-    GridStopWatch M2Timer;
-    GridStopWatch M3Timer;
-    GridStopWatch LinalgTimer;
-
-    HDCGTimer.Start();
-
-    std::vector<RealD> rn(nrhs);
-    for (int k=0;k<=MaxIterations;k++){
-    
-      int peri_k  = k % mmax;
-      int peri_kp = (k+1) % mmax;
-
-      for(int rhs=0;rhs<nrhs;rhs++){
-	rtz[rhs]=rtzp[rhs];
-	M3Timer.Start();
-	d[rhs]= PcgM3(p[rhs][peri_k],mmp[rhs][peri_k]);
-	M3Timer.Stop();
-	a[rhs] = rtz[rhs]/d[rhs];
-
-	LinalgTimer.Start();
-	// Memorise this
-	pAp[rhs][peri_k] = d[rhs];
-
-	axpy(x[rhs],a[rhs],p[rhs][peri_k],x[rhs]);
-	rn[rhs] = axpy_norm(r[rhs],-a[rhs],mmp[rhs][peri_k],r[rhs]);
-	LinalgTimer.Stop();
-      }
-
-      // Compute z = M x (for *all* RHS)
-      M1Timer.Start();
-      _Precon(r,z);
-      M1Timer.Stop();
-      
-      RealD max_rn=0.0;
-      LinalgTimer.Start();
-      for(int rhs=0;rhs<nrhs;rhs++){
-
-	rtzp[rhs] =real(innerProduct(r[rhs],z[rhs]));
-
-	//	std::cout << GridLogMessage<<"HDCG::fPcg rhs"<<rhs<<" iteration "<<k<<" : inner rtzp "<<rtzp[rhs]<<"\n";
-	mu[rhs]=z[rhs];
-
-	p[rhs][peri_kp]=mu[rhs];
-
-	// Standard search direction p == z + b p 
-	b[rhs] = (rtzp[rhs])/rtz[rhs];
-
-	int northog = (k>mmax-1)?(mmax-1):k;        // This is the fCG-Tr(mmax-1) algorithm
-	for(int back=0; back < northog; back++){
-	  int peri_back = (k-back)%mmax;
-	  RealD pbApk= real(innerProduct(mmp[rhs][peri_back],p[rhs][peri_kp]));
-	  RealD beta = -pbApk/pAp[rhs][peri_back];
-	  axpy(p[rhs][peri_kp],beta,p[rhs][peri_back],p[rhs][peri_kp]);
-	}
-
-	RealD rrn=sqrt(rn[rhs]/ssq[rhs]);
-	RealD rtn=sqrt(rtz[rhs]/ssq[rhs]);
-	RealD rtnp=sqrt(rtzp[rhs]/ssq[rhs]);
-	
-	std::cout<<GridLogMessage<<"HDCG:fPcg rhs "<<rhs<<" k= "<<k<<" residual = "<<rrn<<"\n";
-	if ( rrn > max_rn ) max_rn = rrn;
-      }
-      LinalgTimer.Stop();
-
-      // Stopping condition based on worst case
-      if ( max_rn <= Tolerance ) { 
-
-	HDCGTimer.Stop();
-	std::cout<<GridLogMessage<<"HDCG: mrhs fPcg converged in "<<k<<" iterations and "<<HDCGTimer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs fPcg : Linalg  "<<LinalgTimer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs fPcg : fine M3 "<<M3Timer.Elapsed()<<std::endl;;
-	std::cout<<GridLogMessage<<"HDCG: mrhs fPcg : prec M1 "<<M1Timer.Elapsed()<<std::endl;;
-	_Precon.ReportTimers("HDCG: mrhs fPcg : ");
-
-	for(int rhs=0;rhs<nrhs;rhs++){
-	  _FineLinop.HermOp(x[rhs],mmp[rhs][0]);			  
-	  Field tmp(grid);
-	  axpy(tmp,-1.0,src[rhs],mmp[rhs][0]);
-      
-	  RealD  mmpnorm = sqrt(norm2(mmp[rhs][0]));
-	  RealD  xnorm   = sqrt(norm2(x[rhs]));
-	  RealD  srcnorm = sqrt(norm2(src[rhs]));
-	  RealD  tmpnorm = sqrt(norm2(tmp));
-	  RealD  true_residual = tmpnorm/srcnorm;
-	  std::cout<<GridLogMessage
-		   <<"HDCG: true residual ["<<rhs<<"] is "<<true_residual
-		   <<" solution "<<xnorm
-		   <<" source "<<srcnorm
-		   <<" mmp "<<mmpnorm	  
-		   <<std::endl;
-	}
-	return;
-      }
-      
-    }
-    HDCGTimer.Stop();
-    std::cout<<GridLogMessage<<"HDCG: not converged "<<HDCGTimer.Elapsed()<<std::endl;
-    for(int rhs=0;rhs<nrhs;rhs++){
-      RealD  xnorm   = sqrt(norm2(x[rhs]));
-      RealD  srcnorm = sqrt(norm2(src[rhs]));
-      std::cout<<GridLogMessage<<"HDCG: non-converged solution "<<xnorm<<" source "<<srcnorm<<std::endl;
-    }
-  }
-
-  RealD PcgM3(const Field & p, Field & mmp){
-    RealD dd;
-    _FineLinop.HermOp(p,mmp);
-    ComplexD dot = innerProduct(p,mmp);
-    dd=real(dot);
-    return dd;
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// ADEF-2 as an mrhs preconditioner object (Tang, Nabben, Vuik, Erlangga):
-//   M1     = [1 - Q A] M + Q   with  Q = P A_c^{-1} P^dag  (deflated coarse solve)
-//   Vstart = Q b               the coarse-corrected start (precise coarse solve)
-// The coarse space is the D+1 multiRHS field throughout: the projector's
-// mixed overloads take the vector of fine fields straight to it, and the
-// deflator and coarse solver act on it.  No per-rhs slices anywhere.
-// The D+1 grid follows the solver's Nrhs through SetCoarseGridMrhs.
-//////////////////////////////////////////////////////////////////////
-// Projector_t defaults to a transfer operator whose STORE matches Field.
-template<class Field, class CoarseField, class Projector_t = MultiRHSBlockProject<Field> >
-class MrhsADEF2Preconditioner : public MrhsPreconditioner<Field>
-{
-public:
-  GridBase                       *grid;             // fine
-  GridBase                       *coarsegridmrhs;   // D+1, rhs innermost
-  LinearOperatorBase<Field>      &_FineLinop;
-  LinearFunction<Field>          &_Smoother;
-  LinearFunction<CoarseField>    &_CoarseSolver;        // in M1
-  LinearFunction<CoarseField>    &_CoarseSolverPrecise; // in Vstart
-  Projector_t                    &_Projector;   // store precision need not match Field
-  MultiRHSDeflation<CoarseField> &_Deflator;            // nev==0: no deflation, zero coarse guess
-
-  MrhsADEF2Preconditioner(LinearOperatorBase<Field>      &FineLinop,
-			  LinearFunction<Field>          &Smoother,
-			  LinearFunction<CoarseField>    &CoarseSolver,
-			  LinearFunction<CoarseField>    &CoarseSolverPrecise,
-			  Projector_t                    &Projector,
-			  MultiRHSDeflation<CoarseField> &Deflator,
-			  GridBase *CoarseGridMrhs,
-			  GridBase *FineGrid) :
-    _FineLinop(FineLinop), _Smoother(Smoother),
-    _CoarseSolver(CoarseSolver), _CoarseSolverPrecise(CoarseSolverPrecise),
-    _Projector(Projector), _Deflator(Deflator)
-  {
-    // The fine grid is given, NOT taken from the projector: the projector's
-    // grid carries its STORE's layout, which need not be this Field's (an
-    // fp32 preconditioner may project through an fp64 store, or the reverse).
-    grid           = FineGrid;
-    coarsegridmrhs = CoarseGridMrhs;
-  };
-  // Store matches Field: the projector's grid IS this Field's grid.
-  MrhsADEF2Preconditioner(LinearOperatorBase<Field>      &FineLinop,
-			  LinearFunction<Field>          &Smoother,
-			  LinearFunction<CoarseField>    &CoarseSolver,
-			  LinearFunction<CoarseField>    &CoarseSolverPrecise,
-			  Projector_t                    &Projector,
-			  MultiRHSDeflation<CoarseField> &Deflator,
-			  GridBase *CoarseGridMrhs) :
-    MrhsADEF2Preconditioner(FineLinop,Smoother,CoarseSolver,CoarseSolverPrecise,
-			    Projector,Deflator,CoarseGridMrhs,Projector.fine_grid) {};
-
-  void SetCoarseGridMrhs(GridBase *CoarseGridMrhs) { coarsegridmrhs = CoarseGridMrhs; }
-
-  // The coarse solver's starting guess: deflated, or zero
-  void CoarseGuess(CoarseField &src,CoarseField &guess)
-  {
-    this->DeflateTimer.Start();
-    if ( _Deflator.nev > 0 ) _Deflator.DeflateSources(src,guess);
-    else                     guess = Zero();
-    this->DeflateTimer.Stop();
-  }
-  // x_0 = Q b
-  virtual void Vstart(std::vector<Field> &x,std::vector<Field> &src)
-  {
-    CoarseField Csrc(coarsegridmrhs), Csol(coarsegridmrhs);
-    this->ProjectTimer.Start();  _Projector.blockProject(src,Csrc);  this->ProjectTimer.Stop();
-    CoarseGuess(Csrc,Csol);
-    this->CoarseTimer.Start();   _CoarseSolverPrecise(Csrc,Csol);    this->CoarseTimer.Stop();
-    this->PromoteTimer.Start();  _Projector.blockPromote(x,Csol);    this->PromoteTimer.Stop();
-  }
-  // [1 - Q A] M in + Q in = Min + Q [in - A Min]
-  virtual void operator()(std::vector<Field> &in,std::vector<Field> &out)
-  {
-    int nrhs=in.size();
-    std::vector<Field> tmp(nrhs,grid), Min(nrhs,grid);
-    CoarseField Csrc(coarsegridmrhs), Csol(coarsegridmrhs);
-
-    this->SmoothTimer.Start();
-    for(int r=0;r<nrhs;r++) _Smoother(in[r],Min[r]);
-    this->SmoothTimer.Stop();
-
-    this->FineTimer.Start();
-    for(int r=0;r<nrhs;r++){
-      _FineLinop.HermOp(Min[r],out[r]);
-      axpy(tmp[r],-1.0,out[r],in[r]);          // in - A Min
-    }
-    this->FineTimer.Stop();
-
-    this->ProjectTimer.Start();  _Projector.blockProject(tmp,Csrc);  this->ProjectTimer.Stop();
-    CoarseGuess(Csrc,Csol);
-    this->CoarseTimer.Start();   _CoarseSolver(Csrc,Csol);           this->CoarseTimer.Stop();
-    this->PromoteTimer.Start();  _Projector.blockPromote(tmp,Csol);  this->PromoteTimer.Stop();
-
-    this->FineTimer.Start();
-    for(int r=0;r<nrhs;r++) axpy(out[r],1.0,Min[r],tmp[r]);       // Min + Q[in - A Min]
-    this->FineTimer.Stop();
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -47,7 +47,7 @@ class BiCGSTAB : public OperatorFunction<Field>
  public:
    using OperatorFunction<Field>::operator();
    
-    bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+    bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                             // Defaults true.
    RealD Tolerance;
    Integer MaxIterations;
@@ -77,7 +77,7 @@ class BiCGSTAB : public OperatorFunction<Field>

      // Initial residual computation & set up
      RealD guess = norm2(psi);
-      GRID_ASSERT(std::isnan(guess) == 0);
+      assert(std::isnan(guess) == 0);
    
      Linop.Op(psi, v);
      b = norm2(v);
@@ -214,7 +214,7 @@ class BiCGSTAB : public OperatorFunction<Field>
          std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() << std::endl;
          std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() << std::endl;

-          if(ErrorOnNoConverge){ GRID_ASSERT(true_residual / Tolerance < 10000.0); }
+          if(ErrorOnNoConverge){ assert(true_residual / Tolerance < 10000.0); }

          IterationsToComplete = k;	

@@ -224,7 +224,7 @@ class BiCGSTAB : public OperatorFunction<Field>
      
      std::cout << GridLogMessage << "BiCGSTAB did NOT converge" << std::endl;

-      if(ErrorOnNoConverge){ GRID_ASSERT(0); }
+      if(ErrorOnNoConverge){ assert(0); }
      IterationsToComplete = k;
    }
 };
@@ -36,8 +36,7 @@ NAMESPACE_BEGIN(Grid);
 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:
-    using LinearFunction<FieldD>::operator();
+  public:                                                
    RealD   Tolerance;
    RealD   InnerTolerance; // Initial tolerance for inner CG. Defaults to Tolerance but can be changed
    Integer MaxInnerIterations;
@@ -31,58 +31,6 @@ directory

 NAMESPACE_BEGIN(Grid);

-template<class Field>
-void InnerProductMatrix(Eigen::MatrixXcd &m , const std::vector<Field> &X, const std::vector<Field> &Y){
-  typedef typename Field::scalar_type scomplex;
-  int Nblock = X.size();
-  for(int b=0;b<Nblock;b++){
-  for(int bp=0;bp<Nblock;bp++) {
-    m(b,bp) = innerProduct(X[b],Y[bp]);  
-  }}
-}
-template<class Field>
-void MaddMatrix(std::vector<Field> &AP, Eigen::MatrixXcd &m , const std::vector<Field> &X,const std::vector<Field> &Y,RealD scale=1.0){
-  // Should make this cache friendly with site outermost, parallel_for
-  // Deal with case AP aliases with either Y or X
-  //
-  //Could pack "X" and "AP" into a Nblock x Volume dense array.
-  // AP(Nrhs x vol) = Y(Nrhs x vol) + scale * m(nrhs x nrhs) * X(nrhs*vol)
-  typedef typename Field::scalar_type scomplex;
-  int Nblock = AP.size();
-  std::vector<Field> tmp(Nblock,X[0]);
-  for(int b=0;b<Nblock;b++){
-    tmp[b]   = Y[b];
-    for(int bp=0;bp<Nblock;bp++) {
-      tmp[b] = tmp[b] +scomplex(scale*m(bp,b))*X[bp]; 
-    }
-  }
-  for(int b=0;b<Nblock;b++){
-    AP[b] = tmp[b];
-  }
-}
-template<class Field>
-void MulMatrix(std::vector<Field> &AP, Eigen::MatrixXcd &m , const std::vector<Field> &X){
-  // Should make this cache friendly with site outermost, parallel_for
-  typedef typename Field::scalar_type scomplex;
-  int Nblock = AP.size();
-  for(int b=0;b<Nblock;b++){
-    AP[b] = Zero();
-    for(int bp=0;bp<Nblock;bp++) {
-      AP[b] += scomplex(m(bp,b))*X[bp]; 
-    }
-  }
-}
-template<class Field>
-double normv(const std::vector<Field> &P){
-  int Nblock = P.size();
-  double nn = 0.0;
-  for(int b=0;b<Nblock;b++) {
-    nn+=norm2(P[b]);
-  }
-  return nn;
-}
-
-
 enum BlockCGtype { BlockCG, BlockCGrQ, CGmultiRHS, BlockCGVec, BlockCGrQVec };

 //////////////////////////////////////////////////////////////////////////
@@ -98,7 +46,7 @@ class BlockConjugateGradient : public OperatorFunction<Field> {
  int Nblock;

  BlockCGtype CGtype;
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                           // Defaults true.
  RealD Tolerance;
  Integer MaxIterations;
@@ -139,19 +87,10 @@ void ThinQRfact (Eigen::MatrixXcd &m_rr,
  sliceInnerProductMatrix(m_rr,R,R,Orthog);

  // Force manifest hermitian to avoid rounding related
-  /*
-  int rank=m_rr.rows();
-  for(int r=0;r<rank;r++){
-  for(int s=0;s<rank;s++){
-    std::cout << "QR m_rr["<<r<<","<<s<<"] "<<m_rr(r,s)<<std::endl;
-  }}
-  */
  m_rr = 0.5*(m_rr+m_rr.adjoint());

  Eigen::MatrixXcd L    = m_rr.llt().matrixL(); 

-//  ComplexD det = L.determinant();
-//  std::cout << " Det m_rr "<<det<<std::endl;
  C    = L.adjoint();
  Cinv = C.inverse();
  ////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -171,20 +110,11 @@ void ThinQRfact (Eigen::MatrixXcd &m_rr,
 		 const std::vector<Field> & R)
 {
  InnerProductMatrix(m_rr,R,R);
-  /*
-  int rank=m_rr.rows();
-  for(int r=0;r<rank;r++){
-  for(int s=0;s<rank;s++){
-    std::cout << "QRvec m_rr["<<r<<","<<s<<"] "<<m_rr(r,s)<<std::endl;
-  }}
-  */
+
  m_rr = 0.5*(m_rr+m_rr.adjoint());

  Eigen::MatrixXcd L    = m_rr.llt().matrixL(); 

-  //  ComplexD det = L.determinant();
-  //  std::cout << " Det m_rr "<<det<<std::endl;
-
  C    = L.adjoint();
  Cinv = C.inverse();

@@ -201,7 +131,7 @@ void operator()(LinearOperatorBase<Field> &Linop, const Field &Src, Field &Psi)
  } else if (CGtype == CGmultiRHS ) {
    CGmultiRHSsolve(Linop,Src,Psi);
  } else {
-    GRID_ASSERT(0);
+    assert(0);
  }
 }
 virtual void operator()(LinearOperatorBase<Field> &Linop, const std::vector<Field> &Src, std::vector<Field> &Psi) 
@@ -209,7 +139,7 @@ virtual void operator()(LinearOperatorBase<Field> &Linop, const std::vector<Fiel
  if ( CGtype == BlockCGrQVec ) {
    BlockCGrQsolveVec(Linop,Src,Psi);
  } else {
-    GRID_ASSERT(0);
+    assert(0);
  }
 }

@@ -256,13 +186,12 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
  sliceNorm(ssq,B,Orthog);
  RealD sssum=0;
  for(int b=0;b<Nblock;b++) sssum+=ssq[b];
-  for(int b=0;b<Nblock;b++) std::cout << "src["<<b<<"]" << ssq[b] <<std::endl;

  sliceNorm(residuals,B,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  sliceNorm(residuals,X,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  /************************************************************************
   * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
@@ -292,9 +221,6 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
  Linop.HermOp(X, AD);
  tmp = B - AD;  

-  sliceNorm(residuals,tmp,Orthog);
-  for(int b=0;b<Nblock;b++) std::cout << "res["<<b<<"]" << residuals[b] <<std::endl;
-  
  ThinQRfact (m_rr, m_C, m_Cinv, Q, tmp);
  D=Q;

@@ -310,8 +236,6 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
  GridStopWatch SolverTimer;
  SolverTimer.Start();

-  RealD max_resid=0;
-
  int k;
  for (k = 1; k <= MaxIterations; k++) {

@@ -356,7 +280,7 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
     */
    m_rr = m_C.adjoint() * m_C;

-    max_resid=0;
+    RealD max_resid=0;
    RealD rrsum=0;
    RealD rr;

@@ -398,11 +322,9 @@ void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X)
    }

  }
+  std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge" << std::endl;

-  std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge "<<k<<" / "<<MaxIterations
-	    <<" residual "<< std::sqrt(max_resid)<< std::endl;
-
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
  IterationsToComplete = k;
 }
 //////////////////////////////////////////////////////////////////////////
@@ -438,10 +360,10 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
  for(int b=0;b<Nblock;b++) sssum+=ssq[b];

  sliceNorm(residuals,Src,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  sliceNorm(residuals,Psi,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  // Initial search dir is guess
  Linop.HermOp(Psi, AP);
@@ -540,10 +462,47 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
  }
  std::cout << GridLogMessage << "MultiRHSConjugateGradient did NOT converge" << std::endl;

-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
  IterationsToComplete = k;
 }

+void InnerProductMatrix(Eigen::MatrixXcd &m , const std::vector<Field> &X, const std::vector<Field> &Y){
+  for(int b=0;b<Nblock;b++){
+  for(int bp=0;bp<Nblock;bp++) {
+    m(b,bp) = innerProduct(X[b],Y[bp]);  
+  }}
+}
+void MaddMatrix(std::vector<Field> &AP, Eigen::MatrixXcd &m , const std::vector<Field> &X,const std::vector<Field> &Y,RealD scale=1.0){
+  // Should make this cache friendly with site outermost, parallel_for
+  // Deal with case AP aliases with either Y or X
+  std::vector<Field> tmp(Nblock,X[0]);
+  for(int b=0;b<Nblock;b++){
+    tmp[b]   = Y[b];
+    for(int bp=0;bp<Nblock;bp++) {
+      tmp[b] = tmp[b] + scomplex(scale*m(bp,b))*X[bp]; 
+    }
+  }
+  for(int b=0;b<Nblock;b++){
+    AP[b] = tmp[b];
+  }
+}
+void MulMatrix(std::vector<Field> &AP, Eigen::MatrixXcd &m , const std::vector<Field> &X){
+  // Should make this cache friendly with site outermost, parallel_for
+  for(int b=0;b<Nblock;b++){
+    AP[b] = Zero();
+    for(int bp=0;bp<Nblock;bp++) {
+      AP[b] += scomplex(m(bp,b))*X[bp]; 
+    }
+  }
+}
+double normv(const std::vector<Field> &P){
+  double nn = 0.0;
+  for(int b=0;b<Nblock;b++) {
+    nn+=norm2(P[b]);
+  }
+  return nn;
+}
+
 ////////////////////////////////////////////////////////////////////////////
 // BlockCGrQvec implementation:
 //--------------------------
@@ -554,7 +513,7 @@ void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &
 void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field> &B, std::vector<Field> &X) 
 {
  Nblock = B.size();
-  GRID_ASSERT(Nblock == X.size());
+  assert(Nblock == X.size());

  std::cout<<GridLogMessage<<" Block Conjugate Gradient Vec rQ : Nblock "<<Nblock<<std::endl;

@@ -590,14 +549,13 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field

  RealD sssum=0;
  for(int b=0;b<Nblock;b++){ ssq[b] = norm2(B[b]);}
-  for(int b=0;b<Nblock;b++){ std::cout << "ssq["<<b<<"] "<<ssq[b]<<std::endl;}
  for(int b=0;b<Nblock;b++) sssum+=ssq[b];

  for(int b=0;b<Nblock;b++){ residuals[b] = norm2(B[b]);}
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  for(int b=0;b<Nblock;b++){ residuals[b] = norm2(X[b]);}
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
+  for(int b=0;b<Nblock;b++){ assert(std::isnan(residuals[b])==0); }

  /************************************************************************
   * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
@@ -627,7 +585,6 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
  for(int b=0;b<Nblock;b++) {
    Linop.HermOp(X[b], AD[b]);
    tmp[b] = B[b] - AD[b];  
-    std::cout << "r0["<<b<<"] "<<norm2(tmp[b])<<std::endl;
  }

  ThinQRfact (m_rr, m_C, m_Cinv, Q, tmp);
@@ -731,7 +688,7 @@ void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field
  }
  std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge" << std::endl;

-  if (ErrorOnNoConverge) GRID_ASSERT(0);
+  if (ErrorOnNoConverge) assert(0);
  IterationsToComplete = k;
 }

@@ -36,7 +36,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
 public:
  using OperatorFunction<Field>::operator();

-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when CAGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when CAGMRES fails to converge,
                          // defaults to true

  RealD   Tolerance;
@@ -82,7 +82,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
    conformable(psi, src);

    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD cp;
    RealD ssq = norm2(src);
@@ -137,7 +137,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
    std::cout << GridLogMessage << "CommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
  }

  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -185,7 +185,7 @@ class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<
      }
    }

-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
    return cp;
  }

@@ -38,14 +38,13 @@ NAMESPACE_BEGIN(Grid);
 // single input vec, single output vec.
 /////////////////////////////////////////////////////////////

-
 template <class Field>
 class ConjugateGradient : public OperatorFunction<Field> {
 public:

  using OperatorFunction<Field>::operator();
-  
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
                           // Defaults true.
  RealD Tolerance;
  Integer MaxIterations;
@@ -55,26 +54,10 @@ public:
  ConjugateGradient(RealD tol, Integer maxit, bool err_on_no_conv = true)
    : Tolerance(tol),
      MaxIterations(maxit),
-      ErrorOnNoConverge(err_on_no_conv)
-  {};
+      ErrorOnNoConverge(err_on_no_conv){};

-  virtual void LogIteration(int k,RealD a,RealD b){
-    //    std::cout << "ConjugageGradient::LogIteration() "<<std::endl;
-  };
-  virtual void LogBegin(void){
-    std::cout << "ConjugageGradient::LogBegin() "<<std::endl;
-  };
+  void operator()(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi) {

-    void operator()(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi) {
-
-      this->LogBegin();
-
-      GRID_TRACE("ConjugateGradient");
-    GridStopWatch PreambleTimer;
-    GridStopWatch ConstructTimer;
-    GridStopWatch NormTimer;
-    GridStopWatch AssignTimer;
-    PreambleTimer.Start();
    psi.Checkerboard() = src.Checkerboard();

    conformable(psi, src);
@@ -82,32 +65,22 @@ public:
    RealD cp, c, a, d, b, ssq, qq;
    //RealD b_pred;

-    // Was doing copies
-    ConstructTimer.Start();
-    Field p  (src.Grid());
-    Field mmp(src.Grid());
-    Field r  (src.Grid());
-    ConstructTimer.Stop();
+    Field p(src);
+    Field mmp(src);
+    Field r(src);

    // Initial residual computation & set up
-    NormTimer.Start();
-    ssq = norm2(src);
    RealD guess = norm2(psi);
-    NormTimer.Stop();
-    GRID_ASSERT(std::isnan(guess) == 0);
-    AssignTimer.Start();
-    if ( guess == 0.0 ) {
-      r = src;
-      p = r;
-      a = ssq;
-    } else { 
-      Linop.HermOpAndNorm(psi, mmp, d, b);
-      r = src - mmp;
-      p = r;
-      a = norm2(p);
-    }
+    assert(std::isnan(guess) == 0);
+    
+    Linop.HermOpAndNorm(psi, mmp, d, b);
+    
+    r = src - mmp;
+    p = r;
+
+    a = norm2(p);
    cp = a;
-    AssignTimer.Stop();
+    ssq = norm2(src);

    // Handle trivial case of zero src
    if (ssq == 0.){
@@ -129,7 +102,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;
+      std::cout << GridLogMessage << "ConjugateGradient guess is converged already "<<TrueResidual<< " tol "<< Tolerance<< std::endl;
      IterationsToComplete = 0;	
      return;
    }
@@ -137,7 +110,6 @@ public:
    std::cout << GridLogIterative << std::setprecision(8)
              << "ConjugateGradient: k=0 residual " << cp << " target " << rsq << std::endl;

-    PreambleTimer.Stop();
    GridStopWatch LinalgTimer;
    GridStopWatch InnerTimer;
    GridStopWatch AxpyNormTimer;
@@ -145,13 +117,9 @@ public:
    GridStopWatch MatrixTimer;
    GridStopWatch SolverTimer;

-    RealD usecs = -usecond();
    SolverTimer.Start();
    int k;
    for (k = 1; k <= MaxIterations; k++) {
-
-      GridStopWatch IterationTimer;
-      IterationTimer.Start();
      c = cp;

      MatrixTimer.Start();
@@ -183,50 +151,34 @@ public:
      }
      LinearCombTimer.Stop();
      LinalgTimer.Stop();
-      LogIteration(k,a,b);

-      IterationTimer.Stop();
-      if ( (k % 500) == 0 ) {
-	std::cout << GridLogMessage << "ConjugateGradient: Iteration " << k
+      std::cout << GridLogIterative << "ConjugateGradient: Iteration " << k
                << " residual " << sqrt(cp/ssq) << " target " << Tolerance << std::endl;
-      } else { 
-	std::cout << GridLogIterative << "ConjugateGradient: Iteration " << k
-		  << " residual " << sqrt(cp/ssq) << " target " << Tolerance << " took " << IterationTimer.Elapsed() << std::endl;
-      }

      // Stopping condition
      if (cp <= rsq) {
-	usecs +=usecond();
        SolverTimer.Stop();
        Linop.HermOpAndNorm(psi, mmp, d, qq);
        p = mmp - src;
-	GridBase *grid = src.Grid();
-	RealD DwfFlops = (1452. )*grid->gSites()*4*k
-   	               + (8+4+8+4+4)*12*grid->gSites()*k; // CG linear algebra
+
        RealD srcnorm = std::sqrt(norm2(src));
        RealD resnorm = std::sqrt(norm2(p));
        RealD true_residual = resnorm / srcnorm;
+
        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 << "\tPreamble   " << PreambleTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tPreamble   " << PreambleTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tConstruct  " << ConstructTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tNorm       " << NormTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tAssign     " << AssignTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tSolver     " << SolverTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "Solver breakdown "<<std::endl;
-	std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\tInner      " << InnerTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\t\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;

-	std::cout << GridLogDebug << "\tMobius flop rate " << DwfFlops/ usecs<< " Gflops " <<std::endl;
-
-        if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
+        if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);

 	IterationsToComplete = k;	
 	TrueResidual = true_residual;
@@ -235,143 +187,17 @@ public:
      }
    }
    // Failed. Calculate true residual before giving up                                                         
-    // Linop.HermOpAndNorm(psi, mmp, d, qq);
-    //    p = mmp - src;
-    //TrueResidual = sqrt(norm2(p)/ssq);
-    //    TrueResidual = 1;
+    Linop.HermOpAndNorm(psi, mmp, d, qq);
+    p = mmp - src;

-    std::cout << GridLogMessage << "ConjugateGradient did NOT converge "<<k<<" / "<< MaxIterations
-    	      <<" residual "<< std::sqrt(cp / ssq)<< std::endl;
-    SolverTimer.Stop();
-    std::cout << GridLogMessage << "\tPreamble   " << PreambleTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage << "\tConstruct  " << ConstructTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage << "\tNorm       " << NormTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage << "\tAssign     " << AssignTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage << "\tSolver     " << SolverTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage << "Solver breakdown "<<std::endl;
-    std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
-    std::cout << GridLogMessage<< "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-    std::cout << GridLogPerformance << "\t\tInner      " << InnerTimer.Elapsed() <<std::endl;
-    std::cout << GridLogPerformance << "\t\tAxpyNorm   " << AxpyNormTimer.Elapsed() <<std::endl;
-    std::cout << GridLogPerformance << "\t\tLinearComb " << LinearCombTimer.Elapsed() <<std::endl;
+    TrueResidual = sqrt(norm2(p)/ssq);

-    if (ErrorOnNoConverge) GRID_ASSERT(0);
+    std::cout << GridLogMessage << "ConjugateGradient did NOT converge "<<k<<" / "<< MaxIterations<< std::endl;
+
+    if (ErrorOnNoConverge) assert(0);
    IterationsToComplete = k;

  }
 };
-
-
-template <class Field>
-class ConjugateGradientPolynomial : public ConjugateGradient<Field> {
-public:
-  // Optionally record the CG polynomial
-  std::vector<double> ak;
-  std::vector<double> bk;
-  std::vector<double> poly_p;
-  std::vector<double> poly_r;
-  std::vector<double> poly_Ap;
-  std::vector<double> polynomial;
-
-public:
-  ConjugateGradientPolynomial(RealD tol, Integer maxit, bool err_on_no_conv = true)
-    : ConjugateGradient<Field>(tol,maxit,err_on_no_conv)
-  { };
-  void PolyHermOp(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi)
-  {
-    Field tmp(src.Grid());
-    Field AtoN(src.Grid());
-    AtoN = src;
-    psi=AtoN*polynomial[0];
-    for(int n=1;n<polynomial.size();n++){
-      tmp = AtoN;
-      Linop.HermOp(tmp,AtoN);
-      psi = psi + polynomial[n]*AtoN;
-    }
-  }
-  void CGsequenceHermOp(LinearOperatorBase<Field> &Linop, const Field &src, Field &x)
-  {
-    Field Ap(src.Grid());
-    Field r(src.Grid());
-    Field p(src.Grid());
-    p=src;
-    r=src;
-    x=Zero();
-    x.Checkerboard()=src.Checkerboard();
-    for(int k=0;k<ak.size();k++){
-      x = x + ak[k]*p;
-      Linop.HermOp(p,Ap);
-      r = r - ak[k] * Ap;
-      p = r + bk[k] * p;
-    }
-  }
-  void Solve(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi)
-  {
-    psi=Zero();
-    this->operator ()(Linop,src,psi);
-  }
-  virtual void LogBegin(void)
-  {
-    std::cout << "ConjugageGradientPolynomial::LogBegin() "<<std::endl;
-    ak.resize(0);
-    bk.resize(0);
-    polynomial.resize(0);
-    poly_Ap.resize(0);
-    poly_Ap.resize(0);
-    poly_p.resize(1);
-    poly_r.resize(1);
-    poly_p[0]=1.0;
-    poly_r[0]=1.0;
-  };
-  virtual void LogIteration(int k,RealD a,RealD b)
-  {
-    // With zero guess,
-    // p = r = src
-    //
-    // iterate:
-    //   x =  x + a p
-    //   r =  r - a A p
-    //   p =  r + b p
-    //
-    // [0]
-    // r = x
-    // p = x
-    // Ap=0
-    //
-    // [1]
-    // Ap = A x + 0  ==> shift poly P right by 1 and add 0.
-    // x  = x + a p  ==> add polynomials term by term 
-    // r  = r - a A p  ==> add polynomials term by term
-    // p  = r + b p  ==> add polynomials term by term
-    //
-    std::cout << "ConjugageGradientPolynomial::LogIteration() "<<k<<std::endl;
-    ak.push_back(a);
-    bk.push_back(b);
-    //  Ap= right_shift(p)
-    poly_Ap.resize(k+1);
-    poly_Ap[0]=0.0;
-    for(int i=0;i<k;i++){
-      poly_Ap[i+1]=poly_p[i];
-    }
-
-    //  x = x + a p
-    polynomial.resize(k);
-    polynomial[k-1]=0.0;
-    for(int i=0;i<k;i++){
-      polynomial[i] = polynomial[i] + a * poly_p[i];
-    }
-    
-    //  r = r - a Ap
-    //  p = r + b p
-    poly_r.resize(k+1);
-    poly_p.resize(k+1);
-    poly_r[k] = poly_p[k] = 0.0;
-    for(int i=0;i<k+1;i++){
-      poly_r[i] = poly_r[i] - a * poly_Ap[i];
-      poly_p[i] = poly_r[i] + b * poly_p[i];
-    }
-  }
-};
-
 NAMESPACE_END(Grid);
 #endif
@@ -35,8 +35,7 @@ NAMESPACE_BEGIN(Grid);
    typename std::enable_if< getPrecision<FieldD>::value == 2, int>::type = 0,
    typename std::enable_if< getPrecision<FieldF>::value == 1, int>::type = 0> 
  class MixedPrecisionConjugateGradient : public LinearFunction<FieldD> {
-  public:
-    using LinearFunction<FieldD>::operator();
+  public:                                                
    RealD   Tolerance;
    RealD   InnerTolerance; //Initial tolerance for inner CG. Defaults to Tolerance but can be changed
    Integer MaxInnerIterations;
@@ -53,23 +52,31 @@ NAMESPACE_BEGIN(Grid);

    //Option to speed up *inner single precision* solves using a LinearFunction that produces a guess
    LinearFunction<FieldF> *guesser;
-    
-    MixedPrecisionConjugateGradient(RealD tol, 
+
+    MixedPrecisionConjugateGradient(RealD Tol,
+				    Integer maxinnerit, 
+				    Integer maxouterit, 
+				    GridBase* _sp_grid, 
+				    LinearOperatorBase<FieldF> &_Linop_f, 
+				    LinearOperatorBase<FieldD> &_Linop_d) :
+      MixedPrecisionConjugateGradient(Tol, Tol, maxinnerit, maxouterit, _sp_grid, _Linop_f, _Linop_d) {};
+
+    MixedPrecisionConjugateGradient(RealD Tol,
+				    RealD InnerTol,
 				    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){ };
+      Tolerance(Tol), InnerTolerance(InnerTol), MaxInnerIterations(maxinnerit), MaxOuterIterations(maxouterit), SinglePrecGrid(_sp_grid),
+      OuterLoopNormMult(100.), guesser(NULL){ assert(InnerTol < 1.0e-1);};

    void useGuesser(LinearFunction<FieldF> &g){
      guesser = &g;
    }
  
  void operator() (const FieldD &src_d_in, FieldD &sol_d){
-    std::cout << GridLogMessage << "MixedPrecisionConjugateGradient: Starting mixed precision CG with outer tolerance " << Tolerance << " and inner tolerance " << InnerTolerance << std::endl;
    TotalInnerIterations = 0;
 	
    GridStopWatch TotalTimer;
@@ -82,6 +89,11 @@ NAMESPACE_BEGIN(Grid);
    RealD stop = src_norm * Tolerance*Tolerance;

    GridBase* DoublePrecGrid = src_d_in.Grid();
+
+    //Generate precision change workspaces
+    precisionChangeWorkspace wk_dp_from_sp(DoublePrecGrid, SinglePrecGrid);
+    precisionChangeWorkspace wk_sp_from_dp(SinglePrecGrid, DoublePrecGrid);
+
    FieldD tmp_d(DoublePrecGrid);
    tmp_d.Checkerboard() = cb;
    
@@ -99,7 +111,6 @@ NAMESPACE_BEGIN(Grid);
    FieldF sol_f(SinglePrecGrid);
    sol_f.Checkerboard() = cb;
    
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Starting initial inner CG with tolerance " << inner_tol << std::endl;
    ConjugateGradient<FieldF> CG_f(inner_tol, MaxInnerIterations);
    CG_f.ErrorOnNoConverge = false;

@@ -108,25 +119,22 @@ NAMESPACE_BEGIN(Grid);
    GridStopWatch PrecChangeTimer;
    
    Integer &outer_iter = TotalOuterIterations; //so it will be equal to the final iteration count
-
-    precisionChangeWorkspace pc_wk_sp_to_dp(DoublePrecGrid, SinglePrecGrid);
-    precisionChangeWorkspace pc_wk_dp_to_sp(SinglePrecGrid, DoublePrecGrid);
-    
+      
    for(outer_iter = 0; outer_iter < MaxOuterIterations; outer_iter++){
      //Compute double precision rsd and also new RHS vector.
      Linop_d.HermOp(sol_d, tmp_d);
      RealD norm = axpy_norm(src_d, -1., tmp_d, src_d_in); //src_d is residual vector
-      std::cout<<GridLogMessage<<" rsd norm "<<norm<<std::endl;
+      
      std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Outer iteration " <<outer_iter<<" residual "<< norm<< " target "<< stop<<std::endl;

      if(norm < OuterLoopNormMult * stop){
 	std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Outer iteration converged on iteration " <<outer_iter <<std::endl;
 	break;
      }
-      while(norm * inner_tol * inner_tol < stop*1.01) inner_tol *= 2;  // inner_tol = sqrt(stop/norm) ??
+      while(norm * inner_tol * inner_tol < stop) inner_tol *= 2;  // inner_tol = sqrt(stop/norm) ??

      PrecChangeTimer.Start();
-      precisionChange(src_f, src_d, pc_wk_dp_to_sp);
+      precisionChange(src_f, src_d, wk_sp_from_dp);
      PrecChangeTimer.Stop();
      
      sol_f = Zero();
@@ -136,7 +144,6 @@ NAMESPACE_BEGIN(Grid);
 	(*guesser)(src_f, sol_f);

      //Inner CG
-      std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Outer iteration " << outer_iter << " starting inner CG with tolerance " << inner_tol << std::endl;
      CG_f.Tolerance = inner_tol;
      InnerCGtimer.Start();
      CG_f(Linop_f, src_f, sol_f);
@@ -145,7 +152,7 @@ NAMESPACE_BEGIN(Grid);
      
      //Convert sol back to double and add to double prec solution
      PrecChangeTimer.Start();
-      precisionChange(tmp_d, sol_f, pc_wk_sp_to_dp);
+      precisionChange(tmp_d, sol_f, wk_dp_from_sp);
      PrecChangeTimer.Stop();
      
      axpy(sol_d, 1.0, tmp_d, sol_d);
@@ -1,213 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ConjugateGradientMixedPrecBatched.h
-
-    Copyright (C) 2015
-
-    Author: Raoul Hodgson <raoul.hodgson@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 GRID_CONJUGATE_GRADIENT_MIXED_PREC_BATCHED_H
-#define GRID_CONJUGATE_GRADIENT_MIXED_PREC_BATCHED_H
-
-NAMESPACE_BEGIN(Grid);
-
-//Mixed precision restarted defect correction CG
-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 MixedPrecisionConjugateGradientBatched : public LinearFunction<FieldD> {
-public:
-  using LinearFunction<FieldD>::operator();
-  RealD   Tolerance;
-  RealD   InnerTolerance; //Initial tolerance for inner CG. Defaults to Tolerance but can be changed
-  Integer MaxInnerIterations;
-  Integer MaxOuterIterations;
-  Integer MaxPatchupIterations;
-  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;
-
-  //Option to speed up *inner single precision* solves using a LinearFunction that produces a guess
-  LinearFunction<FieldF> *guesser;
-  bool updateResidual;
-  
-  MixedPrecisionConjugateGradientBatched(RealD tol, 
-          Integer maxinnerit, 
-          Integer maxouterit, 
-          Integer maxpatchit,
-          GridBase* _sp_grid, 
-          LinearOperatorBase<FieldF> &_Linop_f, 
-          LinearOperatorBase<FieldD> &_Linop_d,
-          bool _updateResidual=true) :
-    Linop_f(_Linop_f), Linop_d(_Linop_d),
-    Tolerance(tol), InnerTolerance(tol), MaxInnerIterations(maxinnerit), MaxOuterIterations(maxouterit), MaxPatchupIterations(maxpatchit), SinglePrecGrid(_sp_grid),
-    OuterLoopNormMult(100.), guesser(NULL), updateResidual(_updateResidual) { };
-
-  void useGuesser(LinearFunction<FieldF> &g){
-    guesser = &g;
-  }
-  
-  void operator() (const FieldD &src_d_in, FieldD &sol_d){
-    std::vector<FieldD> srcs_d_in{src_d_in};
-    std::vector<FieldD> sols_d{sol_d};
-
-    (*this)(srcs_d_in,sols_d);
-
-    sol_d = sols_d[0];
-  }
-
-  void operator() (const std::vector<FieldD> &src_d_in, std::vector<FieldD> &sol_d){
-    GRID_ASSERT(src_d_in.size() == sol_d.size());
-    int NBatch = src_d_in.size();
-
-    std::cout << GridLogMessage << "NBatch = " << NBatch << std::endl;
-
-    Integer TotalOuterIterations = 0; //Number of restarts
-    std::vector<Integer> TotalInnerIterations(NBatch,0);     //Number of inner CG iterations
-    std::vector<Integer> TotalFinalStepIterations(NBatch,0); //Number of CG iterations in final patch-up step
-  
-    GridStopWatch TotalTimer;
-    TotalTimer.Start();
-
-    GridStopWatch InnerCGtimer;
-    GridStopWatch PrecChangeTimer;
-    
-    int cb = src_d_in[0].Checkerboard();
-    
-    std::vector<RealD> src_norm;
-    std::vector<RealD> norm;
-    std::vector<RealD> stop;
-    
-    GridBase* DoublePrecGrid = src_d_in[0].Grid();
-    FieldD tmp_d(DoublePrecGrid);
-    tmp_d.Checkerboard() = cb;
-    
-    FieldD tmp2_d(DoublePrecGrid);
-    tmp2_d.Checkerboard() = cb;
-
-    std::vector<FieldD> src_d;
-    std::vector<FieldF> src_f;
-    std::vector<FieldF> sol_f;
-
-    for (int i=0; i<NBatch; i++) {
-      sol_d[i].Checkerboard() = cb;
-
-      src_norm.push_back(norm2(src_d_in[i]));
-      norm.push_back(0.);
-      stop.push_back(src_norm[i] * Tolerance*Tolerance);
-
-      src_d.push_back(src_d_in[i]); //source for next inner iteration, computed from residual during operation
-
-      src_f.push_back(SinglePrecGrid);
-      src_f[i].Checkerboard() = cb;
-
-      sol_f.push_back(SinglePrecGrid);
-      sol_f[i].Checkerboard() = cb;
-    }
-    
-    RealD inner_tol = InnerTolerance;
-    
-    ConjugateGradient<FieldF> CG_f(inner_tol, MaxInnerIterations);
-    CG_f.ErrorOnNoConverge = false;
-    
-    Integer &outer_iter = TotalOuterIterations; //so it will be equal to the final iteration count
-      
-    for(outer_iter = 0; outer_iter < MaxOuterIterations; outer_iter++){
-      std::cout << GridLogMessage << std::endl;
-      std::cout << GridLogMessage << "Outer iteration " << outer_iter << std::endl;
-      
-      bool allConverged = true;
-      
-      for (int i=0; i<NBatch; i++) {
-        //Compute double precision rsd and also new RHS vector.
-        Linop_d.HermOp(sol_d[i], tmp_d);
-        norm[i] = axpy_norm(src_d[i], -1., tmp_d, src_d_in[i]); //src_d is residual vector
-        
-        std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradientBatched: Outer iteration " << outer_iter <<" solve " << i << " residual "<< norm[i] << " target "<< stop[i] <<std::endl;
-
-        PrecChangeTimer.Start();
-        precisionChange(src_f[i], src_d[i]);
-        PrecChangeTimer.Stop();
-        
-        sol_f[i] = Zero();
-      
-        if(norm[i] > OuterLoopNormMult * stop[i]) {
-          allConverged = false;
-        }
-      }
-      if (allConverged) break;
-
-      if (updateResidual) {
-        RealD normMax = *std::max_element(std::begin(norm), std::end(norm));
-        RealD stopMax = *std::max_element(std::begin(stop), std::end(stop));
-        while( normMax * inner_tol * inner_tol < stopMax) inner_tol *= 2;  // inner_tol = sqrt(stop/norm) ??
-        CG_f.Tolerance = inner_tol;
-      }
-
-      //Optionally improve inner solver guess (eg using known eigenvectors)
-      if(guesser != NULL) {
-        (*guesser)(src_f, sol_f);
-      }
-
-      for (int i=0; i<NBatch; i++) {
-        //Inner CG
-        InnerCGtimer.Start();
-        CG_f(Linop_f, src_f[i], sol_f[i]);
-        InnerCGtimer.Stop();
-        TotalInnerIterations[i] += CG_f.IterationsToComplete;
-        
-        //Convert sol back to double and add to double prec solution
-        PrecChangeTimer.Start();
-        precisionChange(tmp_d, sol_f[i]);
-        PrecChangeTimer.Stop();
-        
-        axpy(sol_d[i], 1.0, tmp_d, sol_d[i]);
-      }
-
-    }
-    
-    //Final trial CG
-    std::cout << GridLogMessage << std::endl;
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradientBatched: Starting final patch-up double-precision solve"<<std::endl;
-    
-    for (int i=0; i<NBatch; i++) {
-      ConjugateGradient<FieldD> CG_d(Tolerance, MaxPatchupIterations);
-      CG_d(Linop_d, src_d_in[i], sol_d[i]);
-      TotalFinalStepIterations[i] += CG_d.IterationsToComplete;
-    }
-
-    TotalTimer.Stop();
-
-    std::cout << GridLogMessage << std::endl;
-    for (int i=0; i<NBatch; i++) {
-      std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradientBatched: solve " << i << " Inner CG iterations " << TotalInnerIterations[i] << " Restarts " << TotalOuterIterations << " Final CG iterations " << TotalFinalStepIterations[i] << std::endl;
-    }
-    std::cout << GridLogMessage << std::endl;
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradientBatched: Total time " << TotalTimer.Elapsed() << " Precision change " << PrecChangeTimer.Elapsed() << " Inner CG total " << InnerCGtimer.Elapsed() << std::endl;
-    
-  }
-};
-
-NAMESPACE_END(Grid);
-
-#endif
@@ -44,7 +44,7 @@ public:

  using OperatorFunction<Field>::operator();

-  //  RealD   Tolerance;
+  RealD   Tolerance;
  Integer MaxIterations;
  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
  std::vector<int> IterationsToCompleteShift;  // Iterations for this shift
@@ -84,7 +84,6 @@ public:

  void operator() (LinearOperatorBase<Field> &Linop, const Field &src, std::vector<Field> &psi)
  {
-    GRID_TRACE("ConjugateGradientMultiShift");
  
    GridBase *grid = src.Grid();
  
@@ -98,15 +97,15 @@ public:
    std::vector<RealD> alpha(nshift,1.0);
    std::vector<Field>   ps(nshift,grid);// Search directions

-    GRID_ASSERT(psi.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
+    assert(psi.size()==nshift);
+    assert(mass.size()==nshift);
+    assert(mresidual.size()==nshift);
  
-    // remove dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
-    std::vector<RealD>  rsq(nshift);
-    std::vector<std::array<RealD,2> >  z(nshift);
-    std::vector<int>     converged(nshift);
+    // dynamic sized arrays on stack; 2d is a pain with vector
+    RealD  bs[nshift];
+    RealD  rsq[nshift];
+    RealD  z[nshift][2];
+    int     converged[nshift];
  
    const int       primary =0;
  
@@ -122,7 +121,7 @@ public:
  
    // Check lightest mass
    for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
+      assert( mass[s]>= mass[primary] );
      converged[s]=0;
    }
  
@@ -144,7 +143,7 @@ public:
    for(int s=0;s<nshift;s++){
      rsq[s] = cp * mresidual[s] * mresidual[s];
      std::cout<<GridLogMessage<<"ConjugateGradientMultiShift: shift "<<s
-	       <<" target resid^2 "<<rsq[s]<<std::endl;
+	       <<" target resid "<<rsq[s]<<std::endl;
      ps[s] = src;
    }
    // r and p for primary
@@ -325,8 +324,8 @@ public:

      std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
      std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tAXPY     " << AXPYTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tMatrix   " << MatrixTimer.Elapsed()     <<std::endl;
+      std::cout << GridLogMessage << "\tAXPY    " << AXPYTimer.Elapsed()     <<std::endl;
+      std::cout << GridLogMessage << "\tMarix    " << MatrixTimer.Elapsed()     <<std::endl;
      std::cout << GridLogMessage << "\tShift    " << ShiftTimer.Elapsed()     <<std::endl;

      IterationsToComplete = k;	
@@ -338,7 +337,7 @@ public:
    }
    // ugly hack
    std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    //  GRID_ASSERT(0);
+    //  assert(0);
  }

 };
@@ -1,373 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ConjugateGradientMultiShift.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: Christopher Kelly <ckelly@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//CK 2020: A variant of the multi-shift conjugate gradient with the matrix multiplication in single precision. 
-//The residual is stored in single precision, but the search directions and solution are stored in double precision. 
-//Every update_freq iterations the residual is corrected in double precision. 
-//For safety the a final regular CG is applied to clean up if necessary
-
-//PB Pure single, then double fixup
-
-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 ConjugateGradientMultiShiftMixedPrecCleanup : public OperatorMultiFunction<FieldD>,
-					     public OperatorFunction<FieldD>
-{
-public:                                                
-
-  using OperatorFunction<FieldD>::operator();
-
-  RealD   Tolerance;
-  Integer MaxIterationsMshift;
-  Integer MaxIterations;
-  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;
-
-  int ReliableUpdateFreq; //number of iterations between reliable updates
-
-  GridBase* SinglePrecGrid; //Grid for single-precision fields
-  LinearOperatorBase<FieldF> &Linop_f; //single precision
-
-  ConjugateGradientMultiShiftMixedPrecCleanup(Integer maxit, const MultiShiftFunction &_shifts,
-				       GridBase* _SinglePrecGrid, LinearOperatorBase<FieldF> &_Linop_f,
-				       int _ReliableUpdateFreq) : 
-    MaxIterationsMshift(maxit),  shifts(_shifts), SinglePrecGrid(_SinglePrecGrid), Linop_f(_Linop_f), ReliableUpdateFreq(_ReliableUpdateFreq),
-    MaxIterations(20000)
-  { 
-    verbose=1;
-    IterationsToCompleteShift.resize(_shifts.order);
-    TrueResidualShift.resize(_shifts.order);
-  }
-
-  void operator() (LinearOperatorBase<FieldD> &Linop, const FieldD &src, FieldD &psi)
-  {
-    GridBase *grid = src.Grid();
-    int nshift = shifts.order;
-    std::vector<FieldD> results(nshift,grid);
-    (*this)(Linop,src,results,psi);
-  }
-  void operator() (LinearOperatorBase<FieldD> &Linop, const FieldD &src, std::vector<FieldD> &results, FieldD &psi)
-  {
-    int nshift = shifts.order;
-
-    (*this)(Linop,src,results);
-  
-    psi = shifts.norm*src;
-    for(int i=0;i<nshift;i++){
-      psi = psi + shifts.residues[i]*results[i];
-    }
-
-    return;
-  }
-
-  void operator() (LinearOperatorBase<FieldD> &Linop_d, const FieldD &src_d, std::vector<FieldD> &psi_d)
-  { 
-    GRID_TRACE("ConjugateGradientMultiShiftMixedPrecCleanup");
-    GridBase *DoublePrecGrid = src_d.Grid();
-
-    ////////////////////////////////////////////////////////////////////////
-    // Convenience references to the info stored in "MultiShiftFunction"
-    ////////////////////////////////////////////////////////////////////////
-    int nshift = shifts.order;
-
-    std::vector<RealD> &mass(shifts.poles); // Make references to array in "shifts"
-    std::vector<RealD> &mresidual(shifts.tolerances);
-    std::vector<RealD> alpha(nshift,1.0);
-
-    //Double precision search directions
-    FieldD p_d(DoublePrecGrid);
-    std::vector<FieldF> ps_f (nshift, SinglePrecGrid);// Search directions (single precision)
-    std::vector<FieldF> psi_f(nshift, SinglePrecGrid);// solutions (single precision)
-
-    FieldD tmp_d(DoublePrecGrid);
-    FieldD r_d(DoublePrecGrid);
-    FieldF r_f(SinglePrecGrid);
-    FieldD mmp_d(DoublePrecGrid);
-
-    GRID_ASSERT(psi_d.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
-  
-    // dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
-    std::vector<RealD>  rsq(nshift);
-    std::vector<RealD>  rsqf(nshift);
-    std::vector<std::array<RealD,2> >  z(nshift);
-    std::vector<int>     converged(nshift);
-  
-    const int       primary =0;
-  
-    //Primary shift fields CG iteration
-    RealD a,b,c,d;
-    RealD cp,bp,qq; //prev
-  
-    // Matrix mult fields
-    FieldF p_f(SinglePrecGrid);
-    FieldF mmp_f(SinglePrecGrid);
-
-    // Check lightest mass
-    for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
-      converged[s]=0;
-    }
-  
-    // Wire guess to zero
-    // Residuals "r" are src
-    // First search direction "p" is also src
-    cp = norm2(src_d);
-
-    // Handle trivial case of zero src.
-    if( cp == 0. ){
-      for(int s=0;s<nshift;s++){
-	psi_d[s] = Zero();
-	psi_f[s] = Zero();
-	IterationsToCompleteShift[s] = 1;
-	TrueResidualShift[s] = 0.;
-      }
-      return;
-    }
-
-    for(int s=0;s<nshift;s++){
-      rsq[s] = cp * mresidual[s] * mresidual[s];
-      rsqf[s] =rsq[s];
-      std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrecCleanup: shift "<< s <<" target resid "<<rsq[s]<<std::endl;
-      //      ps_d[s] = src_d;
-      precisionChange(ps_f[s],src_d);
-    }
-    // r and p for primary
-    p_d = src_d; //primary copy --- make this a reference to ps_d to save axpys
-    r_d = p_d;
-    
-    //MdagM+m[0]
-    precisionChange(p_f,p_d);
-    Linop_f.HermOpAndNorm(p_f,mmp_f,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
-    precisionChange(tmp_d,mmp_f);
-    Linop_d.HermOpAndNorm(p_d,mmp_d,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
-    tmp_d = tmp_d - mmp_d;
-    std::cout << " Testing operators match "<<norm2(mmp_d)<<" f "<<norm2(mmp_f)<<" diff "<< norm2(tmp_d)<<std::endl;
-    //    GRID_ASSERT(norm2(tmp_d)< 1.0e-4);
-
-    axpy(mmp_d,mass[0],p_d,mmp_d);
-    RealD rn = norm2(p_d);
-    d += rn*mass[0];
-
-    b = -cp /d;
-  
-    // Set up the various shift variables
-    int       iz=0;
-    z[0][1-iz] = 1.0;
-    z[0][iz]   = 1.0;
-    bs[0]      = b;
-    for(int s=1;s<nshift;s++){
-      z[s][1-iz] = 1.0;
-      z[s][iz]   = 1.0/( 1.0 - b*(mass[s]-mass[0]));
-      bs[s]      = b*z[s][iz]; 
-    }
-  
-    // r += b[0] A.p[0]
-    // c= norm(r)
-    c=axpy_norm(r_d,b,mmp_d,r_d);
-  
-    for(int s=0;s<nshift;s++) {
-      axpby(psi_d[s],0.,-bs[s]*alpha[s],src_d,src_d);
-      precisionChange(psi_f[s],psi_d[s]);
-    }
-  
-    ///////////////////////////////////////
-    // Timers
-    ///////////////////////////////////////
-    GridStopWatch AXPYTimer, ShiftTimer, QRTimer, MatrixTimer, SolverTimer, PrecChangeTimer, CleanupTimer;
-
-    SolverTimer.Start();
-  
-    // Iteration loop
-    int k;
-  
-    for (k=1;k<=MaxIterationsMshift;k++){    
-
-      a = c /cp;
-      AXPYTimer.Start();
-      axpy(p_d,a,p_d,r_d); 
-      AXPYTimer.Stop();
-
-      PrecChangeTimer.Start();
-      precisionChange(r_f, r_d);
-      PrecChangeTimer.Stop();
-
-      AXPYTimer.Start();
-      for(int s=0;s<nshift;s++){
-	if ( ! converged[s] ) { 
-	  if (s==0){
-	    axpy(ps_f[s],a,ps_f[s],r_f);
-	  } else{
-	    RealD as =a *z[s][iz]*bs[s] /(z[s][1-iz]*b);
-	    axpby(ps_f[s],z[s][iz],as,r_f,ps_f[s]);
-	  }
-	}
-      }
-      AXPYTimer.Stop();
-
-      cp=c;
-      PrecChangeTimer.Start();
-      precisionChange(p_f, p_d); //get back single prec search direction for linop
-      PrecChangeTimer.Stop();
-      MatrixTimer.Start();  
-      Linop_f.HermOp(p_f,mmp_f);
-      MatrixTimer.Stop();  
-      PrecChangeTimer.Start();
-      precisionChange(mmp_d, mmp_f); // From Float to Double
-      PrecChangeTimer.Stop();
-
-      d=real(innerProduct(p_d,mmp_d));    
-      axpy(mmp_d,mass[0],p_d,mmp_d);
-      RealD rn = norm2(p_d);
-      d += rn*mass[0];
-    
-      bp=b;
-      b=-cp/d;
-
-      // Toggle the recurrence history
-      bs[0] = b;
-      iz = 1-iz;
-      ShiftTimer.Start();
-      for(int s=1;s<nshift;s++){
-	if((!converged[s])){
-	  RealD z0 = z[s][1-iz];
-	  RealD z1 = z[s][iz];
-	  z[s][iz] = z0*z1*bp
-	    / (b*a*(z1-z0) + z1*bp*(1- (mass[s]-mass[0])*b)); 
-	  bs[s] = b*z[s][iz]/z0; // NB sign  rel to Mike
-	}
-      }
-      ShiftTimer.Stop();
-
-      //Update single precision solutions
-      AXPYTimer.Start();
-      for(int s=0;s<nshift;s++){
-	int ss = s;
-	if( (!converged[s]) ) { 
-	  axpy(psi_f[ss],-bs[s]*alpha[s],ps_f[s],psi_f[ss]);
-	}
-      }
-      c = axpy_norm(r_d,b,mmp_d,r_d);
-      AXPYTimer.Stop();
-    
-      // Convergence checks
-      int all_converged = 1;
-      for(int s=0;s<nshift;s++){
-      
-	if ( (!converged[s]) ){
-	  IterationsToCompleteShift[s] = k;
-	
-	  RealD css  = c * z[s][iz]* z[s][iz];
-	
-	  if(css<rsqf[s]){
-	    if ( ! converged[s] )
-	      std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrecCleanup k="<<k<<" Shift "<<s<<" has converged"<<std::endl;
-	    converged[s]=1;
-	  } else {
-	    all_converged=0;
-	  }
-
-	}
-      }
-
-      if ( all_converged || k == MaxIterationsMshift-1){
-
-	SolverTimer.Stop();
-
-	for(int s=0;s<nshift;s++){
-	  precisionChange(psi_d[s],psi_f[s]);
-	}
-
-	
-	if ( all_converged ){
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrecCleanup: All shifts have converged iteration "<<k<<std::endl;
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrecCleanup: Checking solutions"<<std::endl;
-	} else {
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrecCleanup: Not all shifts have converged iteration "<<k<<std::endl;
-	}
-	
-	// Check answers 
-	for(int s=0; s < nshift; s++) { 
-	  Linop_d.HermOpAndNorm(psi_d[s],mmp_d,d,qq);
-	  axpy(tmp_d,mass[s],psi_d[s],mmp_d);
-	  axpy(r_d,-alpha[s],src_d,tmp_d);
-	  RealD rn = norm2(r_d);
-	  RealD cn = norm2(src_d);
-	  TrueResidualShift[s] = std::sqrt(rn/cn);
-	  std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrecCleanup: shift["<<s<<"] true residual "<< TrueResidualShift[s] << " target " << mresidual[s] << std::endl;
-
-	  //If we have not reached the desired tolerance, do a (mixed precision) CG cleanup
-	  if(rn >= rsq[s]){
-	    CleanupTimer.Start();
-	    std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrecCleanup: performing cleanup step for shift " << s << std::endl;
-
-	    //Setup linear operators for final cleanup
-	    ConjugateGradientMultiShiftMixedPrecSupport::ShiftedLinop<FieldD> Linop_shift_d(Linop_d, mass[s]);
-	    ConjugateGradientMultiShiftMixedPrecSupport::ShiftedLinop<FieldF> Linop_shift_f(Linop_f, mass[s]);
-					       
-	    MixedPrecisionConjugateGradient<FieldD,FieldF> cg(mresidual[s], MaxIterations, MaxIterations, SinglePrecGrid, Linop_shift_f, Linop_shift_d); 
-	    cg(src_d, psi_d[s]);
-	    
-	    TrueResidualShift[s] = cg.TrueResidual;
-	    CleanupTimer.Stop();
-	  }
-	}
-
-	std::cout << GridLogMessage << "ConjugateGradientMultiShiftMixedPrecCleanup: Time Breakdown for body"<<std::endl;
-	std::cout << GridLogMessage << "\tSolver    " << SolverTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\t\tAXPY    " << AXPYTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\t\tMatrix    " << MatrixTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\t\tShift    " << ShiftTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\t\tPrecision Change " << PrecChangeTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\tFinal Cleanup " << CleanupTimer.Elapsed()     <<std::endl;
-	std::cout << GridLogMessage << "\tSolver+Cleanup " << SolverTimer.Elapsed() + CleanupTimer.Elapsed() << std::endl;
-
-	IterationsToComplete = k;	
-
-	return;
-      }
-   
-    }
-    std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    GRID_ASSERT(0);
-  }
-
-};
-NAMESPACE_END(Grid);
-
@@ -48,12 +48,12 @@ public:

  ShiftedLinop(LinearOperatorBase<Field> &_linop_base, RealD _shift): linop_base(_linop_base), shift(_shift){}

-  void OpDiag (const Field &in, Field &out){ GRID_ASSERT(0); }
-  void OpDir  (const Field &in, Field &out,int dir,int disp){ GRID_ASSERT(0); }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){ GRID_ASSERT(0); }
+  void OpDiag (const Field &in, Field &out){ assert(0); }
+  void OpDir  (const Field &in, Field &out,int dir,int disp){ assert(0); }
+  void OpDirAll  (const Field &in, std::vector<Field> &out){ assert(0); }
  
-  void Op     (const Field &in, Field &out){ GRID_ASSERT(0); }
-  void AdjOp  (const Field &in, Field &out){ GRID_ASSERT(0); }
+  void Op     (const Field &in, Field &out){ assert(0); }
+  void AdjOp  (const Field &in, Field &out){ assert(0); }

  void HermOp(const Field &in, Field &out){
    linop_base.HermOp(in, out);
@@ -81,7 +81,6 @@ public:
  using OperatorFunction<FieldD>::operator();

  RealD   Tolerance;
-  Integer MaxIterationsMshift;
  Integer MaxIterations;
  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
  std::vector<int> IterationsToCompleteShift;  // Iterations for this shift
@@ -96,9 +95,9 @@ public:

  ConjugateGradientMultiShiftMixedPrec(Integer maxit, const MultiShiftFunction &_shifts,
 				       GridBase* _SinglePrecGrid, LinearOperatorBase<FieldF> &_Linop_f,
-				       int _ReliableUpdateFreq) : 
-    MaxIterationsMshift(maxit),  shifts(_shifts), SinglePrecGrid(_SinglePrecGrid), Linop_f(_Linop_f), ReliableUpdateFreq(_ReliableUpdateFreq),
-    MaxIterations(20000)
+				       int _ReliableUpdateFreq
+				       ) : 
+    MaxIterations(maxit),  shifts(_shifts), SinglePrecGrid(_SinglePrecGrid), Linop_f(_Linop_f), ReliableUpdateFreq(_ReliableUpdateFreq)
  { 
    verbose=1;
    IterationsToCompleteShift.resize(_shifts.order);
@@ -128,12 +127,10 @@ public:

  void operator() (LinearOperatorBase<FieldD> &Linop_d, const FieldD &src_d, std::vector<FieldD> &psi_d)
  { 
-    GRID_TRACE("ConjugateGradientMultiShiftMixedPrec");
    GridBase *DoublePrecGrid = src_d.Grid();
+    precisionChangeWorkspace wk_f_from_d(SinglePrecGrid, DoublePrecGrid);
+    precisionChangeWorkspace wk_d_from_f(DoublePrecGrid, SinglePrecGrid);

-    precisionChangeWorkspace pc_wk_s_to_d(DoublePrecGrid,SinglePrecGrid);
-    precisionChangeWorkspace pc_wk_d_to_s(SinglePrecGrid,DoublePrecGrid);
-    
    ////////////////////////////////////////////////////////////////////////
    // Convenience references to the info stored in "MultiShiftFunction"
    ////////////////////////////////////////////////////////////////////////
@@ -151,16 +148,15 @@ public:
    FieldD r_d(DoublePrecGrid);
    FieldD mmp_d(DoublePrecGrid);

-    GRID_ASSERT(psi_d.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
-    GRID_ASSERT(mresidual.size()==nshift);
+    assert(psi_d.size()==nshift);
+    assert(mass.size()==nshift);
+    assert(mresidual.size()==nshift);
  
    // dynamic sized arrays on stack; 2d is a pain with vector
-    std::vector<RealD>  bs(nshift);
-    std::vector<RealD>  rsq(nshift);
-    std::vector<RealD>  rsqf(nshift);
-    std::vector<std::array<RealD,2> >  z(nshift);
-    std::vector<int>     converged(nshift);
+    RealD  bs[nshift];
+    RealD  rsq[nshift];
+    RealD  z[nshift][2];
+    int     converged[nshift];
  
    const int       primary =0;
  
@@ -169,12 +165,16 @@ public:
    RealD cp,bp,qq; //prev
  
    // Matrix mult fields
+    FieldF r_f(SinglePrecGrid);
    FieldF p_f(SinglePrecGrid);
+    FieldF tmp_f(SinglePrecGrid);
    FieldF mmp_f(SinglePrecGrid);
+    FieldF src_f(SinglePrecGrid);
+    precisionChange(src_f, src_d, wk_f_from_d);

    // Check lightest mass
    for(int s=0;s<nshift;s++){
-      GRID_ASSERT( mass[s]>= mass[primary] );
+      assert( mass[s]>= mass[primary] );
      converged[s]=0;
    }
  
@@ -195,26 +195,18 @@ public:

    for(int s=0;s<nshift;s++){
      rsq[s] = cp * mresidual[s] * mresidual[s];
-      rsqf[s] =rsq[s];
      std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec: shift "<< s <<" target resid "<<rsq[s]<<std::endl;
      ps_d[s] = src_d;
    }
    // r and p for primary
+    r_f=src_f; //residual maintained in single
+    p_f=src_f;
    p_d = src_d; //primary copy --- make this a reference to ps_d to save axpys
-    r_d = p_d;
-    
+  
    //MdagM+m[0]
-    precisionChange(p_f, p_d, pc_wk_d_to_s);
-
    Linop_f.HermOpAndNorm(p_f,mmp_f,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
-    precisionChange(tmp_d, mmp_f, pc_wk_s_to_d);
-    Linop_d.HermOpAndNorm(p_d,mmp_d,d,qq); // mmp = MdagM p        d=real(dot(p, mmp)),  qq=norm2(mmp)
-    tmp_d = tmp_d - mmp_d;
-    std::cout << " Testing operators match "<<norm2(mmp_d)<<" f "<<norm2(mmp_f)<<" diff "<< norm2(tmp_d)<<std::endl;
-    GRID_ASSERT(norm2(tmp_d)< 1.0);
-
-    axpy(mmp_d,mass[0],p_d,mmp_d);
-    RealD rn = norm2(p_d);
+    axpy(mmp_f,mass[0],p_f,mmp_f);
+    RealD rn = norm2(p_f);
    d += rn*mass[0];

    b = -cp /d;
@@ -232,7 +224,7 @@ public:
  
    // r += b[0] A.p[0]
    // c= norm(r)
-    c=axpy_norm(r_d,b,mmp_d,r_d);
+    c=axpy_norm(r_f,b,mmp_f,r_f);
  
    for(int s=0;s<nshift;s++) {
      axpby(psi_d[s],0.,-bs[s]*alpha[s],src_d,src_d);
@@ -248,9 +240,14 @@ public:
    // Iteration loop
    int k;
  
-    for (k=1;k<=MaxIterationsMshift;k++){    
-
+    for (k=1;k<=MaxIterations;k++){    
      a = c /cp;
+
+      //Update double precision search direction by residual
+      PrecChangeTimer.Start();
+      precisionChange(r_d, r_f, wk_d_from_f);
+      PrecChangeTimer.Stop();
+
      AXPYTimer.Start();
      axpy(p_d,a,p_d,r_d); 

@@ -267,28 +264,24 @@ public:
      AXPYTimer.Stop();

      PrecChangeTimer.Start();
-      precisionChange(p_f, p_d, pc_wk_d_to_s); //get back single prec search direction for linop
+      precisionChange(p_f, p_d, wk_f_from_d); //get back single prec search direction for linop
      PrecChangeTimer.Stop();

      cp=c;
      MatrixTimer.Start();  
-      Linop_f.HermOp(p_f,mmp_f);
+      Linop_f.HermOp(p_f,mmp_f); 
+      d=real(innerProduct(p_f,mmp_f));    
      MatrixTimer.Stop();  

-      PrecChangeTimer.Start();
-      precisionChange(mmp_d, mmp_f, pc_wk_s_to_d); // From Float to Double
-      PrecChangeTimer.Stop();
-
      AXPYTimer.Start();
-      d=real(innerProduct(p_d,mmp_d));    
-      axpy(mmp_d,mass[0],p_d,mmp_d);
+      axpy(mmp_f,mass[0],p_f,mmp_f);
      AXPYTimer.Stop();
-      RealD rn = norm2(p_d);
+      RealD rn = norm2(p_f);
      d += rn*mass[0];
    
      bp=b;
      b=-cp/d;
-
+    
      // Toggle the recurrence history
      bs[0] = b;
      iz = 1-iz;
@@ -314,12 +307,12 @@ public:
      }

      //Perform reliable update if necessary; otherwise update residual from single-prec mmp
-      c = axpy_norm(r_d,b,mmp_d,r_d);
-
+      RealD c_f = axpy_norm(r_f,b,mmp_f,r_f);
      AXPYTimer.Stop();

+      c = c_f;
+
      if(k % ReliableUpdateFreq == 0){
-	RealD c_old = c;
 	//Replace r with true residual
 	MatrixTimer.Start();  
 	Linop_d.HermOp(psi_d[0],mmp_d); 
@@ -328,10 +321,15 @@ public:
 	AXPYTimer.Start();
 	axpy(mmp_d,mass[0],psi_d[0],mmp_d);

-	c = axpy_norm(r_d, -1.0, mmp_d, src_d);
+	RealD c_d = axpy_norm(r_d, -1.0, mmp_d, src_d);
 	AXPYTimer.Stop();

-	std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<< ", replaced |r|^2 = "<<c_old <<" with |r|^2 = "<<c<<std::endl;
+	std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<< ", replaced |r|^2 = "<<c_f <<" with |r|^2 = "<<c_d<<std::endl;
+	
+	PrecChangeTimer.Start();
+	precisionChange(r_f, r_d, wk_f_from_d);
+	PrecChangeTimer.Stop();
+	c = c_d;
      }
    
      // Convergence checks
@@ -343,7 +341,7 @@ public:
 	
 	  RealD css  = c * z[s][iz]* z[s][iz];
 	
-	  if(css<rsqf[s]){
+	  if(css<rsq[s]){
 	    if ( ! converged[s] )
 	      std::cout<<GridLogMessage<<"ConjugateGradientMultiShiftMixedPrec k="<<k<<" Shift "<<s<<" has converged"<<std::endl;
 	    converged[s]=1;
@@ -354,17 +352,12 @@ public:
 	}
      }

-      if ( all_converged || k == MaxIterationsMshift-1){
+      if ( all_converged ){

 	SolverTimer.Stop();
-
-	if ( all_converged ){
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrec: All shifts have converged iteration "<<k<<std::endl;
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrec: Checking solutions"<<std::endl;
-	} else {
-	  std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrec: Not all shifts have converged iteration "<<k<<std::endl;
-	}
-	
+	std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrec: All shifts have converged iteration "<<k<<std::endl;
+	std::cout<<GridLogMessage<< "ConjugateGradientMultiShiftMixedPrec: Checking solutions"<<std::endl;
+      
 	// Check answers 
 	for(int s=0; s < nshift; s++) { 
 	  Linop_d.HermOpAndNorm(psi_d[s],mmp_d,d,qq);
@@ -405,10 +398,12 @@ public:

 	return;
      }
+
   
    }
+    // ugly hack
    std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    GRID_ASSERT(0);
+    //  assert(0);
  }

 };
@@ -35,7 +35,7 @@ template<class FieldD,class FieldF,
 	 typename std::enable_if< getPrecision<FieldF>::value == 1, int>::type = 0> 
 class ConjugateGradientReliableUpdate : public LinearFunction<FieldD> {
 public:
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
+  bool ErrorOnNoConverge;  // throw an assert when the CG fails to converge.
  // Defaults true.
  RealD Tolerance;
  Integer MaxIterations;
@@ -48,7 +48,7 @@ public:
  LinearOperatorBase<FieldF> &Linop_f;
  LinearOperatorBase<FieldD> &Linop_d;
  GridBase* SinglePrecGrid;
-  RealD Delta; //reliable update parameter. A reliable update is performed when the residual drops by a factor of Delta relative to its value at the last update
+  RealD Delta; //reliable update parameter

  //Optional ability to switch to a different linear operator once the tolerance reaches a certain point. Useful for single/half -> single/single
  LinearOperatorBase<FieldF> *Linop_fallback;
@@ -65,9 +65,7 @@ public:
      ErrorOnNoConverge(err_on_no_conv),
      DoFinalCleanup(true),
      Linop_fallback(NULL)
-  {
-    GRID_ASSERT(Delta > 0. && Delta < 1. && "Expect  0 < Delta < 1");
-  };
+  {};

  void setFallbackLinop(LinearOperatorBase<FieldF> &_Linop_fallback, const RealD _fallback_transition_tol){
    Linop_fallback = &_Linop_fallback;
@@ -75,7 +73,6 @@ public:
  }
    
  void operator()(const FieldD &src, FieldD &psi) {
-    GRID_TRACE("ConjugateGradientReliableUpdate");
    LinearOperatorBase<FieldF> *Linop_f_use = &Linop_f;
    bool using_fallback = false;
      
@@ -90,7 +87,7 @@ public:

    // Initial residual computation & set up
    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);
    
    Linop_d.HermOpAndNorm(psi, mmp, d, b);
    
@@ -118,12 +115,9 @@ public:
    }

    //Single prec initialization
-    precisionChangeWorkspace pc_wk_sp_to_dp(src.Grid(), SinglePrecGrid);
-    precisionChangeWorkspace pc_wk_dp_to_sp(SinglePrecGrid, src.Grid());
-    
    FieldF r_f(SinglePrecGrid);
    r_f.Checkerboard() = r.Checkerboard();
-    precisionChange(r_f, r, pc_wk_dp_to_sp);
+    precisionChange(r_f, r);

    FieldF psi_f(r_f);
    psi_f = Zero();
@@ -139,8 +133,7 @@ public:
    GridStopWatch LinalgTimer;
    GridStopWatch MatrixTimer;
    GridStopWatch SolverTimer;
-    GridStopWatch PrecChangeTimer;
-    
+
    SolverTimer.Start();
    int k = 0;
    int l = 0;
@@ -179,9 +172,7 @@ public:
      // Stopping condition
      if (cp <= rsq) {
 	//Although not written in the paper, I assume that I have to add on the final solution
-	PrecChangeTimer.Start();
-	precisionChange(mmp, psi_f, pc_wk_sp_to_dp);
-	PrecChangeTimer.Stop();
+	precisionChange(mmp, psi_f);
 	psi = psi + mmp;
 	
 	
@@ -202,10 +193,7 @@ public:
 	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 << "\tPrecChange " << PrecChangeTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tPrecChange avg time " << PrecChangeTimer.Elapsed()/(2*l+1) <<std::endl;

-	
 	IterationsToComplete = k;	
 	ReliableUpdatesPerformed = l;
 	  
@@ -217,7 +205,7 @@ public:
 	  CG(Linop_d,src,psi);
 	  IterationsToCleanup = CG.IterationsToComplete;
 	}
-	else if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
+	else if (ErrorOnNoConverge) assert(true_residual / Tolerance < 10000.0);

 	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate complete.\n";
 	return;
@@ -225,21 +213,14 @@ public:
      else if(cp < Delta * MaxResidSinceLastRelUp) { //reliable update
 	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate "
 		  << cp << "(residual) < " << Delta << "(Delta) * " << MaxResidSinceLastRelUp << "(MaxResidSinceLastRelUp) on iteration " << k << " : performing reliable update\n";
-	PrecChangeTimer.Start();
-	precisionChange(mmp, psi_f, pc_wk_sp_to_dp);
-	PrecChangeTimer.Stop();
+	precisionChange(mmp, psi_f);
 	psi = psi + mmp;

-	MatrixTimer.Start();
 	Linop_d.HermOpAndNorm(psi, mmp, d, qq);
-	MatrixTimer.Stop();
-	
 	r = src - mmp;

 	psi_f = Zero();
-	PrecChangeTimer.Start();
-	precisionChange(r_f, r, pc_wk_dp_to_sp);
-	PrecChangeTimer.Stop();
+	precisionChange(r_f, r);
 	cp = norm2(r);
 	MaxResidSinceLastRelUp = cp;

@@ -263,7 +244,7 @@ public:
    std::cout << GridLogMessage << "ConjugateGradientReliableUpdate did NOT converge"
 	      << std::endl;
      
-    if (ErrorOnNoConverge) GRID_ASSERT(0);
+    if (ErrorOnNoConverge) assert(0);
    IterationsToComplete = k;
    ReliableUpdatesPerformed = l;      
  }    
@@ -106,7 +106,7 @@ public:
    }

    std::cout<<GridLogMessage<<"ConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
  }
 };
 NAMESPACE_END(Grid);
@@ -33,19 +33,16 @@ namespace Grid {
 template<class Field>
 class ZeroGuesser: public LinearFunction<Field> {
 public:
-  using LinearFunction<Field>::operator();
    virtual void operator()(const Field &src, Field &guess) { guess = Zero(); };
 };
 template<class Field>
 class DoNothingGuesser: public LinearFunction<Field> {
 public:
-  using LinearFunction<Field>::operator();
  virtual void operator()(const Field &src, Field &guess) {  };
 };
 template<class Field>
 class SourceGuesser: public LinearFunction<Field> {
 public:
-  using LinearFunction<Field>::operator();
  virtual void operator()(const Field &src, Field &guess) { guess = src; };
 };

@@ -60,7 +57,6 @@ private:
  const unsigned int       N;

 public:
-  using LinearFunction<Field>::operator();

  DeflatedGuesser(const std::vector<Field> & _evec,const std::vector<RealD> & _eval)
  : DeflatedGuesser(_evec, _eval, _evec.size())
@@ -69,8 +65,8 @@ public:
  DeflatedGuesser(const std::vector<Field> & _evec, const std::vector<RealD> & _eval, const unsigned int _N)
  : evec(_evec), eval(_eval), N(_N)
  {
-    GRID_ASSERT(evec.size()==eval.size());
-    GRID_ASSERT(N <= evec.size());
+    assert(evec.size()==eval.size());
+    assert(N <= evec.size());
  } 

  virtual void operator()(const Field &src,Field &guess) {
@@ -91,7 +87,6 @@ private:
  const std::vector<RealD>       &eval_coarse;
 public:
  
-  using LinearFunction<FineField>::operator();
  LocalCoherenceDeflatedGuesser(const std::vector<FineField>   &_subspace,
 				const std::vector<CoarseField> &_evec_coarse,
 				const std::vector<RealD>       &_eval_coarse)
@@ -113,42 +108,7 @@ public:
    blockPromote(guess_coarse,guess,subspace);
    guess.Checkerboard() = src.Checkerboard();
  };
-
-  void operator()(const std::vector<FineField> &src,std::vector<FineField> &guess) {
-    int Nevec = (int)evec_coarse.size();
-    int Nsrc = (int)src.size();
-    // make temp variables
-    std::vector<CoarseField> src_coarse(Nsrc,evec_coarse[0].Grid());
-    std::vector<CoarseField> guess_coarse(Nsrc,evec_coarse[0].Grid());    
-    //Preporcessing
-    std::cout << GridLogMessage << "Start BlockProject for loop" << std::endl;
-    for (int j=0;j<Nsrc;j++)
-    {
-    guess_coarse[j] = Zero();
-    std::cout << GridLogMessage << "BlockProject iter: " << j << std::endl;
-    blockProject(src_coarse[j],src[j],subspace);
-    }
-    //deflation set up for eigen vector batchsize 1 and source batch size equal number of sources
-    std::cout << GridLogMessage << "Start ProjectAccum for loop" << std::endl;
-    for (int i=0;i<Nevec;i++)
-    {
-      std::cout << GridLogMessage << "ProjectAccum Nvec: " << i << std::endl;
-      const CoarseField & tmp = evec_coarse[i];
-      for (int j=0;j<Nsrc;j++)
-      {
-        axpy(guess_coarse[j],TensorRemove(innerProduct(tmp,src_coarse[j])) / eval_coarse[i],tmp,guess_coarse[j]);
-      }
-    }
-    //postprocessing
-    std::cout << GridLogMessage << "Start BlockPromote for loop" << std::endl;
-    for (int j=0;j<Nsrc;j++) {
-      std::cout << GridLogMessage << "BlockProject iter: " << j << std::endl;
-      blockPromote(guess_coarse[j],guess[j],subspace);
-      guess[j].Checkerboard() = src[j].Checkerboard();
-    }
-  };
-
-  };
+};



@@ -36,7 +36,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
 public:
  using OperatorFunction<Field>::operator();

-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FCAGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when FCAGMRES fails to converge,
                          // defaults to true

  RealD   Tolerance;
@@ -87,7 +87,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
    conformable(psi, src);

    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD cp;
    RealD ssq = norm2(src);
@@ -144,7 +144,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
    std::cout << GridLogMessage << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
  }

  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -191,7 +191,7 @@ class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorF
      }
    }

-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
    return cp;
  }

@@ -36,7 +36,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
 public:
  using OperatorFunction<Field>::operator();

-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when FGMRES fails to converge,
                          // defaults to true

  RealD   Tolerance;
@@ -85,7 +85,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
    conformable(psi, src);

    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD cp;
    RealD ssq = norm2(src);
@@ -142,7 +142,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
    std::cout << GridLogMessage << "FlexibleGeneralisedMinimalResidual did NOT converge" << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
  }

  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -189,7 +189,7 @@ class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
      }
    }

-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
    return cp;
  }

@@ -1,87 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/iterative/GCRCoefficients.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////
-// Recorded GCR coefficients: per-step means over calls of the step length
-// a_k and the orthogonalisation coefficients b_kj (already scaled and
-// signed as applied: p_{k+1} = r + sum_j b_kj p_{k-j}).
-//////////////////////////////////////////////////////////////////////////////
-struct GCRCoefficients {
-  int mmax = 0;
-  // Every recorded call is kept: calls[c] = list of (a_k, [b_kj]) per step.
-  // A(k)/B(k,j) return the coefficients of the SELECTED call: by default the
-  // last complete one.  Selection "mean" averages coefficients over calls --
-  // kept for comparison only: the mean of the coefficients of a nonlinear
-  // recurrence is not the mean of the polynomials, and in practice (Frontier
-  // M3, 2026-08-26) it was worse than every individual call.
-  enum Select { Last=0, First=1, Index=2, Mean=3 };
-  Select select = Last;
-  int    index  = 0;
-  typedef std::vector<std::pair<ComplexD,std::vector<ComplexD> > > Call;
-  std::vector<Call> calls;
-  Call current;
-  void RecordA(int k, ComplexD a){
-    if ( k==0 && current.size() ) { calls.push_back(current); current.clear(); }
-    if ( (int)current.size() <= k ) current.resize(k+1);
-    current[k].first = a;
-  }
-  void RecordB(int k, const std::vector<ComplexD> &b){
-    if ( (int)current.size() <= k ) current.resize(k+1);
-    current[k].second = b;
-  }
-  void Flush(void){ if ( current.size() ) { calls.push_back(current); current.clear(); } }
-  int  Calls(void) const { return calls.size() + (current.size() ? 1 : 0); }
-  const Call & Chosen(void) const {
-    GRID_ASSERT( calls.size() || current.size() );
-    if ( calls.empty() ) return current;
-    if ( select==First ) return calls.front();
-    if ( select==Index ) { GRID_ASSERT(index>=0 && index<(int)calls.size()); return calls[index]; }
-    return calls.back();
-  }
-  int  Steps(void) const { return select==Mean ? MeanSteps() : Chosen().size(); }
-  int  NB(int k) const   { return select==Mean ? MeanNB(k)   : Chosen()[k].second.size(); }
-  ComplexD A(int k) const    { return select==Mean ? MeanA(k)   : Chosen()[k].first; }
-  ComplexD B(int k,int j) const { return select==Mean ? MeanB(k,j) : Chosen()[k].second[j]; }
-  // mean over calls (comparison only)
-  int MeanSteps(void) const { int m=0; for(auto &c:calls) m = std::max(m,(int)c.size()); return m; }
-  int MeanNB(int k) const { int m=0; for(auto &c:calls) if(k<(int)c.size()) m = std::max(m,(int)c[k].second.size()); return m; }
-  ComplexD MeanA(int k) const { ComplexD s(0.0); int n=0; for(auto &c:calls) if(k<(int)c.size()){ s+=c[k].first; n++; } return s/(double)n; }
-  ComplexD MeanB(int k,int j) const { ComplexD s(0.0); int n=0; for(auto &c:calls) if(k<(int)c.size() && j<(int)c[k].second.size()){ s+=c[k].second[j]; n++; } return s/(double)n; }
-  void Report(const std::string &name) const {
-    const char *sel[4]={"last","first","index","mean"};
-    std::cout << GridLogMessage << "GCRCoefficients " << name << ": " << Calls() << " calls, " << Steps() << " steps, mmax " << mmax
-              << ", selection " << sel[select] << std::endl;
-    for(int k=0;k<Steps();k++){
-      std::cout << GridLogMessage << "  step " << k << " a=(" << real(A(k)) << "," << imag(A(k)) << ")";
-      for(int j=0;j<NB(k);j++) std::cout << " b[" << j << "]=(" << real(B(k,j)) << "," << imag(B(k,j)) << ")";
-      // spread of a_k across calls: how different the individual polynomials are
-      if ( calls.size()>1 ) {
-        RealD lo=1e300, hi=0; for(auto &c:calls) if(k<(int)c.size()){ RealD x=real(c[k].first), y=imag(c[k].first); RealD m=std::sqrt(x*x+y*y); lo=std::min(lo,m); hi=std::max(hi,m); }
-        std::cout << "   |a| over calls [" << lo << "," << hi << "]";
-      }
-      std::cout << std::endl;
-    }
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -36,7 +36,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
 public:
  using OperatorFunction<Field>::operator();

-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when GMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when GMRES fails to converge,
                          // defaults to true

  RealD   Tolerance;
@@ -80,7 +80,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
    conformable(psi, src);

    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD cp;
    RealD ssq = norm2(src);
@@ -135,7 +135,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
    std::cout << GridLogMessage << "GeneralisedMinimalResidual did NOT converge" << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
  }

  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
@@ -181,7 +181,7 @@ class GeneralisedMinimalResidual : public OperatorFunction<Field> {
      }
    }

-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
    return cp;
  }

@@ -79,16 +79,14 @@ template<class Field> class ImplicitlyRestartedLanczosHermOpTester  : public Imp
    RealD vv = norm2(v) / ::pow(evalMaxApprox,2.0);

    std::cout.precision(13);
-
-    int conv=0;
-    if( (vv<eresid*eresid) ) conv = 1;
-
    std::cout<<GridLogIRL  << "[" << std::setw(3)<<j<<"] "
 	     <<"eval = "<<std::setw(25)<< eval << " (" << eval_poly << ")"
 	     <<" |H B[i] - eval[i]B[i]|^2 / evalMaxApprox^2 " << std::setw(25) << vv
-	     <<" target " << eresid*eresid << " conv " <<conv
 	     <<std::endl;

+    int conv=0;
+    if( (vv<eresid*eresid) ) conv = 1;
+
    return conv;
  }
 };
@@ -211,7 +209,7 @@ until convergence
  void calc(std::vector<RealD>& eval, std::vector<Field>& evec,  const Field& src, int& Nconv, bool reverse=false)
  {
    GridBase *grid = src.Grid();
-    GRID_ASSERT(grid == evec[0].Grid());
+    assert(grid == evec[0].Grid());
    
    //    GridLogIRL.TimingMode(1);
    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
@@ -231,7 +229,7 @@ until convergence
    }
    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
 	
-    GRID_ASSERT(Nm <= evec.size() && Nm <= eval.size());
+    assert(Nm <= evec.size() && Nm <= eval.size());
    
    // quickly get an idea of the largest eigenvalue to more properly normalize the residuum
    RealD evalMaxApprox = 0.0;
@@ -245,10 +243,9 @@ until convergence
 	_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 vnum = real(innerProduct(tmp,tmp)); // HermOp^2.
+	RealD vnum = real(innerProduct(src_n,tmp)); // HermOp.
 	RealD vden = norm2(src_n);
-	RealD na = std::sqrt(vnum/vden);
+	RealD na = vnum/vden;
 	if (fabs(evalMaxApprox/na - 1.0) < 0.0001)
 	  i=_MAX_ITER_IRL_MEVAPP_;
 	evalMaxApprox = na;
@@ -256,7 +253,6 @@ until convergence
 	src_n = tmp;
      }
    }
-    std::cout << GridLogIRL << " Final evalMaxApprox  " << evalMaxApprox << std::endl;
 	
    std::vector<RealD> lme(Nm);  
    std::vector<RealD> lme2(Nm);
@@ -337,7 +333,7 @@ until convergence
      }
      std::cout<<GridLogIRL <<"QR decomposed "<<std::endl;

-      GRID_ASSERT(k2<Nm);      GRID_ASSERT(k2<Nm);      GRID_ASSERT(k1>0);
+      assert(k2<Nm);      assert(k2<Nm);      assert(k1>0);

      basisRotate(evec,Qt,k1-1,k2+1,0,Nm,Nm); /// big constraint on the basis
      std::cout<<GridLogIRL <<"basisRotated  by Qt *"<<k1-1<<","<<k2+1<<")"<<std::endl;
@@ -423,15 +419,14 @@ until convergence
 	}
      }

-      if ( Nconv < Nstop ) {
+      if ( Nconv < Nstop )
 	std::cout << GridLogIRL << "Nconv ("<<Nconv<<") < Nstop ("<<Nstop<<")"<<std::endl;
-	std::cout << GridLogIRL << "returning Nstop vectors, the last "<< Nstop-Nconv << "of which might meet convergence criterion only approximately" <<std::endl;
-      }
+
      eval=eval2;
      
      //Keep only converged
-      eval.resize(Nstop);// was Nconv
-      evec.resize(Nstop,grid);// was Nconv
+      eval.resize(Nconv);// Nstop?
+      evec.resize(Nconv,grid);// Nstop?
      basisSortInPlace(evec,eval,reverse);
      
    }
@@ -461,15 +456,15 @@ until convergence
 	    std::vector<Field>& evec,
 	    Field& w,int Nm,int k)
  {
-    std::cout<<GridLogDebug << "Lanczos step " <<k<<std::endl;
+    std::cout<<GridLogIRL << "Lanczos step " <<k<<std::endl;
    const RealD tiny = 1.0e-20;
-    GRID_ASSERT( k< Nm );
+    assert( k< Nm );

    GridStopWatch gsw_op,gsw_o;

    Field& evec_k = evec[k];

-    _PolyOp(evec_k,w);    std::cout<<GridLogDebug << "PolyOp" <<std::endl;
+    _PolyOp(evec_k,w);    std::cout<<GridLogIRL << "PolyOp" <<std::endl;

    if(k>0) w -= lme[k-1] * evec[k-1];

@@ -484,18 +479,18 @@ until convergence
    lme[k] = beta;

    if ( (k>0) && ( (k % orth_period) == 0 )) {
-      std::cout<<GridLogDebug << "Orthogonalising " <<k<<std::endl;
+      std::cout<<GridLogIRL << "Orthogonalising " <<k<<std::endl;
      orthogonalize(w,evec,k); // orthonormalise
-      std::cout<<GridLogDebug << "Orthogonalised " <<k<<std::endl;
+      std::cout<<GridLogIRL << "Orthogonalised " <<k<<std::endl;
    }

    if(k < Nm-1) evec[k+1] = w;

-    std::cout<<GridLogIRL << "Lanczos step alpha[" << k << "] = " << zalph << " beta[" << k << "] = "<<beta<<std::endl;
+    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<<GridLogDebug << "Lanczos step complete " <<k<<std::endl;
+    std::cout<<GridLogIRL << "Lanczos step complete " <<k<<std::endl;
  }

  void diagonalize_Eigen(std::vector<RealD>& lmd, std::vector<RealD>& lme, 
@@ -597,7 +592,7 @@ until convergence
    }  else if ( diagonalisation == IRLdiagonaliseWithEigen ) { 
      diagonalize_Eigen(lmd,lme,Nk,Nm,Qt,grid);
    } else { 
-      GRID_ASSERT(0);
+      assert(0);
    }
  }

@@ -687,7 +682,7 @@ void diagonalize_lapack(std::vector<RealD>& lmd,
    }
  }
 #else 
-  GRID_ASSERT(0);
+  assert(0);
 #endif
 }

@@ -44,7 +44,6 @@ public:
 				  int, MinRes);    // Must restart
 };

-//This class is the input parameter class for some testing programs
 struct LocalCoherenceLanczosParams : Serializable {
 public:
  GRID_SERIALIZABLE_CLASS_MEMBERS(LocalCoherenceLanczosParams,
@@ -68,7 +67,6 @@ public:
 template<class Fobj,class CComplex,int nbasis>
 class ProjectedHermOp : public LinearFunction<Lattice<iVector<CComplex,nbasis > > > {
 public:
-  using LinearFunction<Lattice<iVector<CComplex,nbasis > > >::operator();
  typedef iVector<CComplex,nbasis >           CoarseSiteVector;
  typedef Lattice<CoarseSiteVector>           CoarseField;
  typedef Lattice<CComplex>   CoarseScalar; // used for inner products on fine field
@@ -80,7 +78,7 @@ public:
  ProjectedHermOp(LinearOperatorBase<FineField>& linop, std::vector<FineField> & _subspace) : 
    _Linop(linop), subspace(_subspace)
  {  
-    GRID_ASSERT(subspace.size() >0);
+    assert(subspace.size() >0);
  };

  void operator()(const CoarseField& in, CoarseField& out) {
@@ -99,7 +97,6 @@ public:
 template<class Fobj,class CComplex,int nbasis>
 class ProjectedFunctionHermOp : public LinearFunction<Lattice<iVector<CComplex,nbasis > > > {
 public:
-  using LinearFunction<Lattice<iVector<CComplex,nbasis > > >::operator();
  typedef iVector<CComplex,nbasis >           CoarseSiteVector;
  typedef Lattice<CoarseSiteVector>           CoarseField;
  typedef Lattice<CComplex>   CoarseScalar; // used for inner products on fine field
@@ -146,24 +143,16 @@ public:
  LinearOperatorBase<FineField> &_Linop;
  RealD                             _coarse_relax_tol;
  std::vector<FineField>        &_subspace;
-
-  int _largestEvalIdxForReport; //The convergence of the LCL is based on the evals of the coarse grid operator, not those of the underlying fine grid operator
-                                //As a result we do not know what the eval range of the fine operator is until the very end, making tuning the Cheby bounds very difficult
-                                //To work around this issue, every restart we separately reconstruct the fine operator eval for the lowest and highest evec and print these
-                                //out alongside the evals of the coarse operator. To do so we need to know the index of the largest eval (i.e. Nstop-1)
-                                //NOTE: If largestEvalIdxForReport=-1 (default) then this is not performed
  
  ImplicitlyRestartedLanczosSmoothedTester(LinearFunction<CoarseField>   &Poly,
 					   OperatorFunction<FineField>   &smoother,
 					   LinearOperatorBase<FineField> &Linop,
 					   std::vector<FineField>        &subspace,
-					   RealD coarse_relax_tol=5.0e3,
-					   int largestEvalIdxForReport=-1) 
+					   RealD coarse_relax_tol=5.0e3) 
    : _smoother(smoother), _Linop(Linop), _Poly(Poly), _subspace(subspace),
-      _coarse_relax_tol(coarse_relax_tol), _largestEvalIdxForReport(largestEvalIdxForReport)
+      _coarse_relax_tol(coarse_relax_tol)  
  {    };

-  //evalMaxApprox: approximation of largest eval of the fine Chebyshev operator (suitably wrapped by block projection)
  int TestConvergence(int j,RealD eresid,CoarseField &B, RealD &eval,RealD evalMaxApprox)
  {
    CoarseField v(B);
@@ -186,26 +175,12 @@ public:
 	     <<" |H B[i] - eval[i]B[i]|^2 / evalMaxApprox^2 " << std::setw(25) << vv
 	     <<std::endl;

-    if(_largestEvalIdxForReport != -1 && (j==0 || j==_largestEvalIdxForReport)){
-      std::cout<<GridLogIRL << "Estimating true eval of fine grid operator for eval idx " << j << std::endl;
-      RealD tmp_eval;
-      ReconstructEval(j,eresid,B,tmp_eval,1.0); //don't use evalMaxApprox of coarse operator! (cf below)
-    }
-    
    int conv=0;
    if( (vv<eresid*eresid) ) conv = 1;
    return conv;
  }
-
-  //This function is called at the end of the coarse grid Lanczos. It promotes the coarse eigenvector 'B' to the fine grid,
-  //applies a smoother to the result then computes the computes the *fine grid* eigenvalue (output as 'eval').
-
-  //evalMaxApprox should be the approximation of the largest eval of the fine Hermop. However when this function is called by IRL it actually passes the largest eval of the *Chebyshev* operator (as this is the max approx used for the TestConvergence above)
-  //As the largest eval of the Chebyshev is typically several orders of magnitude larger this makes the convergence test pass even when it should not.
-  //We therefore ignore evalMaxApprox here and use a value of 1.0 (note this value is already used by TestCoarse)
-  int ReconstructEval(int j,RealD eresid,CoarseField &B, RealD &eval,RealD evalMaxApprox)  
+  int ReconstructEval(int j,RealD eresid,CoarseField &B, RealD &eval,RealD evalMaxApprox)
  {
-    evalMaxApprox = 1.0; //cf above
    GridBase *FineGrid = _subspace[0].Grid();    
    int checkerboard   = _subspace[0].Checkerboard();
    FineField fB(FineGrid);fB.Checkerboard() =checkerboard;
@@ -224,13 +199,13 @@ public:
    eval   = vnum/vden;
    fv -= eval*fB;
    RealD vv = norm2(fv) / ::pow(evalMaxApprox,2.0);
-    if ( j > nbasis ) eresid = eresid*_coarse_relax_tol;
-    
+
    std::cout.precision(13);
    std::cout<<GridLogIRL  << "[" << std::setw(3)<<j<<"] "
 	     <<"eval = "<<std::setw(25)<< eval << " (" << eval_poly << ")"
-	     <<" |H B[i] - eval[i]B[i]|^2 / evalMaxApprox^2 " << std::setw(25) << vv << " target " << eresid*eresid
+	     <<" |H B[i] - eval[i]B[i]|^2 / evalMaxApprox^2 " << std::setw(25) << vv
 	     <<std::endl;
+    if ( j > nbasis ) eresid = eresid*_coarse_relax_tol;
    if( (vv<eresid*eresid) ) return 1;
    return 0;
  }
@@ -308,10 +283,6 @@ public:
    evals_coarse.resize(0);
  };

-  //The block inner product is the inner product on the fine grid locally summed over the blocks
-  //to give a Lattice<Scalar> on the coarse grid. This function orthnormalizes the fine-grid subspace
-  //vectors under the block inner product. This step must be performed after computing the fine grid
-  //eigenvectors and before computing the coarse grid eigenvectors.    
  void Orthogonalise(void ) {
    CoarseScalar InnerProd(_CoarseGrid);
    std::cout << GridLogMessage <<" Gramm-Schmidt pass 1"<<std::endl;
@@ -346,21 +317,19 @@ public:

  void testFine(RealD resid) 
  {
-    GRID_ASSERT(evals_fine.size() == nbasis);
-    GRID_ASSERT(subspace.size() == nbasis);
+    assert(evals_fine.size() == nbasis);
+    assert(subspace.size() == nbasis);
    PlainHermOp<FineField>    Op(_FineOp);
    ImplicitlyRestartedLanczosHermOpTester<FineField> SimpleTester(Op);
    for(int k=0;k<nbasis;k++){
-      GRID_ASSERT(SimpleTester.ReconstructEval(k,resid,subspace[k],evals_fine[k],1.0)==1);
+      assert(SimpleTester.ReconstructEval(k,resid,subspace[k],evals_fine[k],1.0)==1);
    }
  }

-  //While this method serves to check the coarse eigenvectors, it also recomputes the eigenvalues from the smoothed reconstructed eigenvectors
-  //hence the smoother can be tuned after running the coarse Lanczos by using a different smoother here
  void testCoarse(RealD resid,ChebyParams cheby_smooth,RealD relax) 
  {
-    GRID_ASSERT(evals_fine.size() == nbasis);
-    GRID_ASSERT(subspace.size() == nbasis);
+    assert(evals_fine.size() == nbasis);
+    assert(subspace.size() == nbasis);
    //////////////////////////////////////////////////////////////////////////////////////////////////
    // create a smoother and see if we can get a cheap convergence test and smooth inside the IRL
    //////////////////////////////////////////////////////////////////////////////////////////////////
@@ -380,7 +349,7 @@ public:
  void calcFine(ChebyParams cheby_parms,int Nstop,int Nk,int Nm,RealD resid, 
 		RealD MaxIt, RealD betastp, int MinRes)
  {
-    GRID_ASSERT(nbasis<=Nm);
+    assert(nbasis<=Nm);
    Chebyshev<FineField>      Cheby(cheby_parms);
    FunctionHermOp<FineField> ChebyOp(Cheby,_FineOp);
    PlainHermOp<FineField>    Op(_FineOp);
@@ -400,54 +369,40 @@ public:
    IRL.calc(evals_fine,subspace,src,Nconv,false);
    
    // Shrink down to number saved
-    GRID_ASSERT(Nstop>=nbasis);
-    GRID_ASSERT(Nconv>=nbasis);
+    assert(Nstop>=nbasis);
+    assert(Nconv>=nbasis);
    evals_fine.resize(nbasis);
    subspace.resize(nbasis,_FineGrid);
  }
-
-
-  //cheby_op: Parameters of the fine grid Chebyshev polynomial used for the Lanczos acceleration
-  //cheby_smooth: Parameters of a separate Chebyshev polynomial used after the Lanczos has completed to smooth out high frequency noise in the reconstructed fine grid eigenvectors prior to computing the eigenvalue
-  //relax: Reconstructed eigenvectors (post smoothing) are naturally not as precise as true eigenvectors. This factor acts as a multiplier on the stopping condition when determining whether the results satisfy the user provided stopping condition
  void calcCoarse(ChebyParams cheby_op,ChebyParams cheby_smooth,RealD relax,
 		  int Nstop, int Nk, int Nm,RealD resid, 
 		  RealD MaxIt, RealD betastp, int MinRes)
  {
-    Chebyshev<FineField>                          Cheby(cheby_op); //Chebyshev of fine operator on fine grid
-    ProjectedHermOp<Fobj,CComplex,nbasis>         Op(_FineOp,subspace); //Fine operator on coarse grid with intermediate fine grid conversion
-    ProjectedFunctionHermOp<Fobj,CComplex,nbasis> ChebyOp (Cheby,_FineOp,subspace); //Chebyshev of fine operator on coarse grid with intermediate fine grid conversion
+    Chebyshev<FineField>                          Cheby(cheby_op);
+    ProjectedHermOp<Fobj,CComplex,nbasis>         Op(_FineOp,subspace);
+    ProjectedFunctionHermOp<Fobj,CComplex,nbasis> ChebyOp (Cheby,_FineOp,subspace);
    //////////////////////////////////////////////////////////////////////////////////////////////////
    // create a smoother and see if we can get a cheap convergence test and smooth inside the IRL
    //////////////////////////////////////////////////////////////////////////////////////////////////

-    Chebyshev<FineField>                                           ChebySmooth(cheby_smooth); //lower order Chebyshev of fine operator on fine grid used to smooth regenerated eigenvectors
-    ImplicitlyRestartedLanczosSmoothedTester<Fobj,CComplex,nbasis> ChebySmoothTester(ChebyOp,ChebySmooth,_FineOp,subspace,relax,Nstop-1); 
+    Chebyshev<FineField>                                           ChebySmooth(cheby_smooth);
+    ImplicitlyRestartedLanczosSmoothedTester<Fobj,CComplex,nbasis> ChebySmoothTester(ChebyOp,ChebySmooth,_FineOp,subspace,relax);

    evals_coarse.resize(Nm);
    evec_coarse.resize(Nm,_CoarseGrid);

    CoarseField src(_CoarseGrid);     src=1.0; 

-    //Note the "tester" here is also responsible for generating the fine grid eigenvalues which are output into the "evals_coarse" array
    ImplicitlyRestartedLanczos<CoarseField> IRL(ChebyOp,ChebyOp,ChebySmoothTester,Nstop,Nk,Nm,resid,MaxIt,betastp,MinRes);
    int Nconv=0;
    IRL.calc(evals_coarse,evec_coarse,src,Nconv,false);
-    GRID_ASSERT(Nconv>=Nstop);
+    assert(Nconv>=Nstop);
    evals_coarse.resize(Nstop);
    evec_coarse.resize (Nstop,_CoarseGrid);
    for (int i=0;i<Nstop;i++){
      std::cout << i << " Coarse eval = " << evals_coarse[i]  << std::endl;
    }
  }
-
-  //Get the fine eigenvector 'i' by reconstruction
-  void getFineEvecEval(FineField &evec, RealD &eval, const int i) const{
-    blockPromote(evec_coarse[i],evec,subspace);  
-    eval = evals_coarse[i];
-  }
-    
-    
 };

 NAMESPACE_END(Grid);
@@ -35,7 +35,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
 public:
  using OperatorFunction<Field>::operator();

-  bool ErrorOnNoConverge; // throw an GRID_ASSERT when the MR fails to converge.
+  bool ErrorOnNoConverge; // throw an assert when the MR fails to converge.
                          // Defaults true.
  RealD   Tolerance;
  Integer MaxIterations;
@@ -59,7 +59,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {

    // Initial residual computation & set up
    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD ssq = norm2(src);
    RealD rsq = Tolerance * Tolerance * ssq;
@@ -136,7 +136,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
        std::cout << GridLogMessage << "MR Time elapsed: Linalg  " << LinalgTimer.Elapsed() << std::endl;

        if (ErrorOnNoConverge)
-          GRID_ASSERT(true_residual / Tolerance < 10000.0);
+          assert(true_residual / Tolerance < 10000.0);

        IterationsToComplete = k;

@@ -148,7 +148,7 @@ template<class Field> class MinimalResidual : public OperatorFunction<Field> {
              << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);

    IterationsToComplete = k;
  }
@@ -37,7 +37,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction

  using OperatorFunction<FieldD>::operator();

-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when MPFGMRES fails to converge,
+  bool ErrorOnNoConverge; // Throw an assert when MPFGMRES fails to converge,
                          // defaults to true

  RealD   Tolerance;
@@ -91,7 +91,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
    conformable(psi, src);

    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
+    assert(std::isnan(guess) == 0);

    RealD cp;
    RealD ssq = norm2(src);
@@ -150,7 +150,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
    std::cout << GridLogMessage << "MPFGMRES did NOT converge" << std::endl;

    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
+      assert(0);
  }

  RealD outerLoopBody(LinearOperatorBase<FieldD> &LinOp, const FieldD &src, FieldD &psi, RealD rsq) {
@@ -197,7 +197,7 @@ class MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction
      }
    }

-    GRID_ASSERT(0); // Never reached
+    assert(0); // Never reached
    return cp;
  }

@@ -33,7 +33,7 @@ NAMESPACE_BEGIN(Grid);
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 // Take a matrix and form an NE solver calling a Herm solver
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class NormalEquations : public LinearFunction<Field>{
+template<class Field> class NormalEquations {
 private:
  SparseMatrixBase<Field> & _Matrix;
  OperatorFunction<Field> & _HermitianSolver;
@@ -60,33 +60,7 @@ public:
  }     
 };

-template<class Field> class NormalResidual : public LinearFunction<Field>{
-private:
-  SparseMatrixBase<Field> & _Matrix;
-  OperatorFunction<Field> & _HermitianSolver;
-  LinearFunction<Field>   & _Guess;
-public:
-
-  /////////////////////////////////////////////////////
-  // Wrap the usual normal equations trick
-  /////////////////////////////////////////////////////
- NormalResidual(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver,
-		 LinearFunction<Field> &Guess) 
-   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
-
-  void operator() (const Field &in, Field &out){
- 
-    Field res(in.Grid());
-    Field tmp(in.Grid());
-
-    MMdagLinearOperator<SparseMatrixBase<Field>,Field> MMdagOp(_Matrix);
-    _Guess(in,res);
-    _HermitianSolver(MMdagOp,in,res);  // M Mdag res = in ;
-    _Matrix.Mdag(res,out);             // out = Mdag res
-  }     
-};
-
-template<class Field> class HPDSolver : public LinearFunction<Field> {
+template<class Field> class HPDSolver {
 private:
  LinearOperatorBase<Field> & _Matrix;
  OperatorFunction<Field> & _HermitianSolver;
@@ -104,13 +78,13 @@ public:
  void operator() (const Field &in, Field &out){
 
    _Guess(in,out);
-    _HermitianSolver(_Matrix,in,out);  //M out = in
+    _HermitianSolver(_Matrix,in,out);  // Mdag M out = Mdag in

  }     
 };


-template<class Field> class MdagMSolver : public LinearFunction<Field> {
+template<class Field> class MdagMSolver {
 private:
  SparseMatrixBase<Field> & _Matrix;
  OperatorFunction<Field> & _HermitianSolver;
@@ -20,7 +20,7 @@ template<class Field> class PowerMethod
    RealD evalMaxApprox = 0.0; 
    auto src_n = src; 
    auto tmp = src; 
-    const int _MAX_ITER_EST_ = 200; 
+    const int _MAX_ITER_EST_ = 50; 

    for (int i=0;i<_MAX_ITER_EST_;i++) { 
      
@@ -29,83 +29,17 @@ template<class Field> class PowerMethod
      RealD vnum = real(innerProduct(src_n,tmp)); // HermOp. 
      RealD vden = norm2(src_n); 
      RealD na = vnum/vden; 
-
-      std::cout << GridLogMessage << "PowerMethod: Current approximation of largest eigenvalue " << na << std::endl;
      
-      //      if ( (fabs(evalMaxApprox/na - 1.0) < 0.0001) || (i==_MAX_ITER_EST_-1) ) { 
-	// 	evalMaxApprox = na; 
-	// 	return evalMaxApprox; 
-      //      } 
+      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; 
      src_n = tmp;
    }
-    std::cout << GridLogMessage << " Approximation of largest eigenvalue: " << evalMaxApprox << std::endl;
-    return evalMaxApprox;
-  }
-};
-
-// Non-Hermitian sibling of PowerMethod.  Drives Op() -- the operator the
-// caller actually applies -- rather than HermOp(), so it returns |lambda_max|
-// of a NON-Hermitian operator and reports the spectral-edge diagnostics the
-// Hermitian PowerMethod cannot:
-//   step 0 : |A v|/|v| on the (random) start src -- a one-sample lower bound
-//            on sigma_max(A).
-//   step k : |A v_k| -> |lambda_max| as v_k -> the dominant eigenvector; the
-//            complex Rayleigh quotient <v,Av> gives its phase (real => on the
-//            axis, a non-converging oscillation => a conjugate pair of equal
-//            modulus at the top).
-//   return : |lambda_max|, with a SUMMARY line flagging non-normality when the
-//            step-0 sigma_max lower bound sits well above the converged
-//            |lambda_max| -- the case where the numerical range extends beyond
-//            the spectrum and a spectrum-based smoother/Chebyshev bound is
-//            unsafe (the field of values must be used instead).
-template<class Field> class PowerMethodNonHermitian
-{
- public:
-
-  template<typename T> static RealD normalise(T& v)
-  {
-    RealD nn = sqrt(norm2(v));
-    v = v * (1.0/nn);
-    return nn;
-  }
-
-  RealD operator()(LinearOperatorBase<Field> &Op, const Field &src)
-  {
-    GridBase *grid = src.Grid();
-    Field v(grid), Av(grid);
-    v = src;
-
-    RealD ratio = 0.0, ratio0 = 0.0;
-    ComplexD rq(0.0);
-    const int _MAX_ITER_EST_ = 200;
-
-    for (int i=0;i<_MAX_ITER_EST_;i++) {
-      normalise(v);                       // v is now unit
-      Op.Op(v,Av);
-      ratio = sqrt(norm2(Av));            // |A v| = |lambda_max| in the limit
-      rq    = innerProduct(v,Av);         // complex Rayleigh quotient
-
-      if ( i==0 ) {
-        ratio0 = ratio;
-        std::cout << GridLogMessage << "PowerMethodNonHermitian: step 0 (random v): |Av|/|v| = "
-                  << ratio << "   [lower bound on sigma_max]" << std::endl;
-      }
-      if ( (i%10==0) || (i==_MAX_ITER_EST_-1) )
-        std::cout << GridLogMessage << "PowerMethodNonHermitian: step " << i << " |Av|/|v| = " << ratio
-                  << "  Rayleigh (" << real(rq) << "," << imag(rq) << ")" << std::endl;
-
-      v = Av;
-    }
-
-    std::cout << GridLogMessage << "PowerMethodNonHermitian: |lambda_max| ~ " << ratio
-              << "  Rayleigh (" << real(rq) << "," << imag(rq) << ")"
-              << "  phase " << atan2(imag(rq),real(rq)) << " rad"
-              << "  step-0/converged = " << ratio0/ratio
-              << (ratio0/ratio > 1.2 ? "   ** non-normal: sigma_max well above |lambda_max| **"
-                                     : "   (near-normal)")
-              << std::endl;
-    return ratio;
+    assert(0);
+    return 0;
  }
 };
 }
@@ -1,76 +0,0 @@
-#pragma once
-namespace Grid {
-
-class Band
-{
-  RealD lo, hi;
-public:
-  Band(RealD _lo,RealD _hi)
-  {
-    lo=_lo;
-    hi=_hi;
-  }
-  RealD operator() (RealD x){
-    if ( x>lo && x<hi ){
-      return 1.0;
-    } else {
-      return 0.0;
-    }
-  }
-};
-
-class PowerSpectrum
-{ 
- public: 
-
-  template<typename T>  static RealD normalise(T& v) 
-  {
-    RealD nn = norm2(v);
-    nn = sqrt(nn);
-    v = v * (1.0/nn);
-    return nn;
-  }
-
-  std::vector<RealD> ranges;
-  std::vector<int> order;
-  
-  PowerSpectrum(  std::vector<RealD> &bins, std::vector<int> &_order ) : ranges(bins), order(_order)  { };
-
-  template<class Field>
-  RealD operator()(LinearOperatorBase<Field> &HermOp, const Field &src) 
-  { 
-    GridBase *grid = src.Grid(); 
-    int N=ranges.size();
-    RealD hi = ranges[N-1];
-
-    RealD lo_band = 0.0;
-    RealD hi_band;
-    RealD nn=norm2(src);
-    RealD ss=0.0;
-
-    Field tmp = src;
-
-    for(int b=0;b<N;b++){
-      hi_band = ranges[b];
-      Band Notch(lo_band,hi_band);
-      
-      Chebyshev<Field> polynomial;
-      polynomial.Init(0.0,hi,order[b],Notch);
-      polynomial.JacksonSmooth();
-
-      polynomial(HermOp,src,tmp) ;
-
-      RealD p=norm2(tmp);
-      ss=ss+p;
-      std::cout << GridLogMessage << " PowerSpectrum Band["<<lo_band<<","<<hi_band<<"] power "<<norm2(tmp)/nn<<std::endl;
-      
-      lo_band=hi_band;
-    }
-    std::cout << GridLogMessage << " PowerSpectrum total power "<<ss/nn<<std::endl;
-    std::cout << GridLogMessage << " PowerSpectrum total power (unnormalised) "<<nn<<std::endl;
-
-    return 0;
-  };
-};
-  
-}
@@ -112,7 +112,7 @@ public:
    }

    std::cout<<GridLogMessage<<"PrecConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
+    assert(0);
  }
 };
 NAMESPACE_END(Grid);
@@ -43,7 +43,7 @@ NAMESPACE_BEGIN(Grid);
 template<class Field>
 class PrecGeneralisedConjugateResidual : public LinearFunction<Field> {
 public:                                                
-  using LinearFunction<Field>::operator();
+
  RealD   Tolerance;
  Integer MaxIterations;
  int verbose;
@@ -118,7 +118,7 @@ public:

    }
    GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    //    GRID_ASSERT(0);
+    //    assert(0);
  }

  RealD GCRnStep(const Field &src, Field &psi,RealD rsq){
@@ -221,7 +221,7 @@ public:
      int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
      for(int back=0;back<northog;back++){

-	int peri_back=(k-back)%mmax;   	  GRID_ASSERT((k-back)>=0);
+	int peri_back=(k-back)%mmax;   	  assert((k-back)>=0);

 	b=-real(innerProduct(q[peri_back],Az))/qq[peri_back];
 	p[peri_kp]=p[peri_kp]+b*p[peri_back];
@@ -231,10 +231,9 @@ public:
      qq[peri_kp]=norm2(q[peri_kp]); // could use axpy_norm
      LinalgTimer.Stop();
    }
-    GRID_ASSERT(0); // never reached
+    assert(0); // never reached
    return cp;
  }
 };
 NAMESPACE_END(Grid);
-#undef GCRLogLevel
 #endif
@@ -28,7 +28,6 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 /*  END LEGAL */
 #ifndef GRID_PREC_GCR_NON_HERM_H
 #define GRID_PREC_GCR_NON_HERM_H
-#include <Grid/algorithms/iterative/GCRCoefficients.h>

 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 //VPGCR Abe and Zhang, 2005.
@@ -39,14 +38,13 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 NAMESPACE_BEGIN(Grid);

-#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< name<<" "
+#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< " Level "<<level<<" " 

 template<class Field>
 class PrecGeneralisedConjugateResidualNonHermitian : public LinearFunction<Field> {
 public:                                                
-  using LinearFunction<Field>::operator();
+
  RealD   Tolerance;
-  RealD   SSQ;
  Integer MaxIterations;
  int verbose;
  int mmax;
@@ -56,42 +54,11 @@ public:
  GridStopWatch PrecTimer;
  GridStopWatch MatTimer;
  GridStopWatch LinalgTimer;
-  std::string name;
-  std::string trace_step = "PGCR_step";   // name + step; see Name()
-  int ZeroGuess  = 0;  // caller contract: guess is always zero => first-cycle r0 = src, skip the apply
-  // persistent GCR history (see GCRnStep)
-  GridBase           *hist_grid = nullptr;
-  std::vector<Field>  q;
-  std::vector<Field>  p;
-  std::vector<RealD>  qq;
-  int FirstCycle = 0;

  LinearFunction<Field>     &Preconditioner;
  LinearOperatorBase<Field> &Linop;

-  // The name is also the trace range's, so a profile separates the four
-  // instances (Fouter, Fsmoother, Couter, Csmoother) that otherwise nest
-  // indistinguishably as one shared range.
-  void Name(std::string _name) { name = _name; trace_step = name + " PGCR_step"; };
-
-  void Level(int n) { Name("Level " + std::to_string(n)); level = n; }
-
-  void SetZeroGuess(int z) { ZeroGuess = z; };
-  // Coefficient logging: one line per step with the step length a_k and the
-  // orthogonalisation coefficients b_{k,j}.  These are the data from which a
-  // FIXED polynomial smoother can be harvested: if they are stable from call
-  // to call, the adaptive GCR can be replaced by a stationary p(A) with the
-  // same applies and no reductions.  Off by default; boss rank prints.
-  int  LogCoeffs = 0;
-  void LogCoefficients(int l) { LogCoeffs = l; };
-  // Optional recorder of the per-step coefficients (means over calls), for
-  // replay by GCRReplaySmoother (Smoothers.h).  Records only; no effect on
-  // the iteration.
-  GCRCoefficients *Recorder = nullptr;
-  void SetCoefficientRecorder(GCRCoefficients *r) { Recorder = r; if(r) r->mmax = mmax; };
-  // Free the persistent history (e.g. when this solver is replaced by a
-  // replayed polynomial): re-made on the next call if ever needed again.
-  void ReleaseHistory(void) { q.clear(); p.clear(); qq.clear(); hist_grid = nullptr; };
+  void Level(int lv) { level=lv; };

  PrecGeneralisedConjugateResidualNonHermitian(RealD tol,Integer maxit,LinearOperatorBase<Field> &_Linop,LinearFunction<Field> &Prec,int _mmax,int _nstep) : 
    Tolerance(tol), 
@@ -100,17 +67,16 @@ public:
    Preconditioner(Prec),
    mmax(_mmax),
    nstep(_nstep)
-  {
-    Level(1);
+  { 
+    level=1;
    verbose=1;
  };

  void operator() (const Field &src, Field &psi){

-    //    psi=Zero();
+    psi=Zero();
    RealD cp, ssq,rsq;
    ssq=norm2(src);
-    SSQ=ssq;
    rsq=Tolerance*Tolerance*ssq;
      
    Field r(src.Grid());
@@ -123,12 +89,11 @@ public:
    SolverTimer.Start();

    steps=0;
-    FirstCycle=1;
    for(int k=0;k<MaxIterations;k++){

      cp=GCRnStep(src,psi,rsq);

-      GCRLogLevel <<"PGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<sqrt(cp/ssq)<<" target "<<sqrt(rsq/ssq) <<std::endl;
+      GCRLogLevel <<"PGCR("<<mmax<<","<<nstep<<") "<< steps <<" steps cp = "<<cp<<" target "<<rsq <<std::endl;

      if(cp<rsq) {

@@ -148,85 +113,76 @@ public:

    }
    GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    //    GRID_ASSERT(0);
+    //    assert(0);
  }

  RealD GCRnStep(const Field &src, Field &psi,RealD rsq){

    RealD cp;
-    ComplexD a, b;
+    ComplexD a, b, zAz;
+    RealD zAAz;
    ComplexD rq;

    GridBase *grid = src.Grid();

-    // Only r and one scratch for the restart residual; the new p/q directions
-    // are produced directly in their persistent history slots.
    Field r(grid);
+    Field z(grid);
+    Field tmp(grid);
+    Field ttmp(grid);
    Field Az(grid);

    ////////////////////////////////
    // history for flexible orthog
    ////////////////////////////////
-    // History arrays are PERSISTENT across calls (allocated once per grid,
-    // re-made only if the grid or mmax changes).  The per-call form
-    // std::vector<Field>(mmax,grid) built a temporary and copy-constructed it
-    // mmax times on every restart cycle -- measured ~5 ms per fine-smoother
-    // call.  Safe: every entry is written before it is read within a cycle
-    // (q[kp],p[kp] assigned before the northog loop can reach them), so no
-    // stale content is ever consumed.
-    if ( hist_grid != grid || (int)q.size() != mmax ) {
-      q.clear(); p.clear();
-      q.reserve(mmax); p.reserve(mmax);
-      for(int i=0;i<mmax;i++){ q.emplace_back(grid); p.emplace_back(grid); }
-      qq.assign(mmax, 0.0);
-      hist_grid = grid;
-    }
+    std::vector<Field> q(mmax,grid);
+    std::vector<Field> p(mmax,grid);
+    std::vector<RealD> qq(mmax);
      
    GCRLogLevel<< "PGCR nStep("<<nstep<<")"<<std::endl;

    //////////////////////////////////
-    // r0 = src - A x0.  ZeroGuess: on the first cycle x0==0 by caller
-    // contract (enforced here), so r0 = src exactly; skip the apply.
-    // Restart cycles (psi!=0) always do the full computation.
+    // initial guess x0 is taken as nonzero.
+    // r0=src-A x0 = src
    //////////////////////////////////
-    if (ZeroGuess && FirstCycle) {
-      psi = Zero();
-      LinalgTimer.Start();
-      r = src;
-      LinalgTimer.Stop();
-    } else {
-      MatTimer.Start();
-      Linop.Op(psi,Az);
-      MatTimer.Stop();
-      LinalgTimer.Start();
-      r=src-Az;
-      LinalgTimer.Stop();
-    }
-    FirstCycle=0;
+    MatTimer.Start();
+    Linop.Op(psi,Az);
+    zAz = innerProduct(Az,psi);
+    zAAz= norm2(Az);
+    MatTimer.Stop();
+    

+    LinalgTimer.Start();
+    r=src-Az;
+    LinalgTimer.Stop();
+    GCRLogLevel<< "PGCR true residual r = src - A psi   "<<norm2(r) <<std::endl;
+    
    /////////////////////
    // p = Prec(r)
    /////////////////////

-    // p[0] = Prec(r), q[0] = A p[0], written straight into the history slots
    PrecTimer.Start();
-    Preconditioner(r,p[0]);
+    Preconditioner(r,z);
    PrecTimer.Stop();

    MatTimer.Start();
-    Linop.Op(p[0],q[0]);
+    Linop.Op(z,Az);
    MatTimer.Stop();

    LinalgTimer.Start();

-    qq[0]= norm2(q[0]);
+    zAz = innerProduct(Az,psi);
+    zAAz= norm2(Az);

+    //p[0],q[0],qq[0] 
+    p[0]= z;
+    q[0]= Az;
+    qq[0]= zAAz;
+    
    cp =norm2(r);
    LinalgTimer.Stop();
-    GCRLogLevel<< "PGCR true residual "<< sqrt(cp/SSQ)     <<std::endl;

    for(int k=0;k<nstep;k++){
-      GRID_TRACE(trace_step.c_str());
+
      steps++;

      int kp     = k+1;
@@ -236,76 +192,50 @@ public:
      LinalgTimer.Start();
      rq= innerProduct(q[peri_k],r); // what if rAr not real?
      a = rq/qq[peri_k];
-      if ( Recorder ) Recorder->RecordA(k,a);

      axpy(psi,a,p[peri_k],psi);         

      cp = axpy_norm(r,-a,q[peri_k],r);
      LinalgTimer.Stop();
-      if ( LogCoeffs ) {
-        GCRLogLevel<<"coeff["<<k<<"] a=("<<real(a)<<","<<imag(a)<<")"
-                   <<" |r|/|r0|="<<sqrt(cp/SSQ)<<std::endl;
-      }

-      GCRLogLevel<< "PGCR step["<<steps<<"]  resid " << sqrt(cp/SSQ)<<std::endl;
+      GCRLogLevel<< "PGCR step["<<steps<<"]  resid " << cp << " target " <<rsq<<std::endl; 

      if((k==nstep-1)||(cp<rsq)){
 	return cp;
      }

-      // New direction written straight into its history slot: p = Prec(r), q = A p.
+
      PrecTimer.Start();
-      Preconditioner(r,p[peri_kp]);
+      Preconditioner(r,z);// solve Az = r
      PrecTimer.Stop();

      MatTimer.Start();
-      Linop.Op(p[peri_kp],q[peri_kp]);
+      Linop.Op(z,Az);
      MatTimer.Stop();
+      zAz = innerProduct(Az,psi);
+      zAAz= norm2(Az);

      LinalgTimer.Start();

-      int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
-      std::ostringstream bs;
+      q[peri_kp]=Az;
+      p[peri_kp]=z;

-      // Classical Gram-Schmidt: every coefficient is taken against the
-      // UN-updated new q (so all northog inner products are independent and
-      // batchable), then the window is applied.  The coefficient is complex:
-      // for a non-Hermitian operator <q_j,Aq> is complex and keeping only the
-      // real part left the q's non-orthogonal.
-      // Batched: one fused kernel + one reduction for all coefficients,
-      // one fused pass per update (independent of mmax).
-      std::vector<const Field*> qwin(northog), pwin(northog);
+      int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
      for(int back=0;back<northog;back++){
-	int peri_back=(k-back)%mmax;   	  GRID_ASSERT((k-back)>=0);
-	GRID_ASSERT(peri_back!=peri_kp);
-	qwin[back] = &q[peri_back];
-	pwin[back] = &p[peri_back];
-      }
-      std::vector<ComplexD> bcoef;
-      innerProductMulti(bcoef,qwin,q[peri_kp]);
-      for(int back=0;back<northog;back++){
-	int peri_back=(k-back)%mmax;
-	bcoef[back] = -bcoef[back]/qq[peri_back];
-        if ( LogCoeffs ) bs<<" b["<<back<<"]="<<bcoef[back];
-      }
-      if ( Recorder && northog ) Recorder->RecordB(k,bcoef);
-      if ( northog ) {
-	axpyMulti(p[peri_kp],bcoef,pwin);
-	qq[peri_kp]=axpyMultiNorm(q[peri_kp],bcoef,qwin);
-      } else {
-	qq[peri_kp]=norm2(q[peri_kp]);
-      }
-      if ( LogCoeffs && northog ) {
-        GCRLogLevel<<"coeff["<<k<<"]"<<bs.str()<<std::endl;
+
+	int peri_back=(k-back)%mmax;   	  assert((k-back)>=0);
+
+	b=-real(innerProduct(q[peri_back],Az))/qq[peri_back];
+	p[peri_kp]=p[peri_kp]+b*p[peri_back];
+	q[peri_kp]=q[peri_kp]+b*q[peri_back];
+
      }
      qq[peri_kp]=norm2(q[peri_kp]); // could use axpy_norm
      LinalgTimer.Stop();
    }
-    GRID_ASSERT(0); // never reached
+    assert(0); // never reached
    return cp;
  }
 };
 NAMESPACE_END(Grid);
-
-#undef GCRLogLevel
 #endif
@@ -79,7 +79,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {

    LinOp.Op(x,r); r = b - r;

-    GRID_ASSERT(normb> 0.0);
+    assert(normb> 0.0);

    resid = norm2(r)/normb;
    if (resid <= Tolerance) {
@@ -105,8 +105,8 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
    for (int i = 1; i <= MaxIterations; i++) {

      // Breakdown tests
-      GRID_ASSERT( rho != 0.0);
-      GRID_ASSERT( xi  != 0.0);
+      assert( rho != 0.0);
+      assert( xi  != 0.0);

      v = (1. / rho) * v_tld;
      y = (1. / rho) * y;
@@ -134,10 +134,10 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
      ep=Zep.real();
      std::cout << "Zep "<<Zep <<std::endl;
      // Complex Audit
-      GRID_ASSERT(abs(ep)>0);
+      assert(abs(ep)>0);

      beta = ep / delta;
-      GRID_ASSERT(abs(beta)>0);
+      assert(abs(beta)>0);

      v_tld = p_tld - beta * v;
      y = v_tld;
@@ -158,7 +158,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
      std::cout << "theta "<<theta<<std::endl;
      std::cout << "gamma "<<gamma<<std::endl;

-      GRID_ASSERT(abs(gamma)> 0.0);
+      assert(abs(gamma)> 0.0);

      eta = -eta * rho_1 * gamma* gamma / (beta * gamma_1 * gamma_1);

@@ -178,7 +178,7 @@ class QuasiMinimalResidual : public OperatorFunction<Field> {
      }
      std::cout << "Iteration "<<i<<" resid " << resid<<std::endl;
    }
-    GRID_ASSERT(0);
+    assert(0);
    return;                            // no convergence
  }
 #else
@@ -40,7 +40,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
   *        (-MoeMee^{-1}   1 )   
   * L^{dag} = ( 1       Mee^{-dag} Moe^{dag} )
   *           ( 0       1                    )
-   * L^{-d}  = ( 1      -Mee^{-dag} Moe^{dag} )
+   * L^{-dag}= ( 1      -Mee^{-dag} Moe^{dag} )
   *           ( 0       1                    )
   *
   * U^-1 = (1   -Mee^{-1} Meo)
@@ -82,7 +82,8 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
   * c) M_oo^-dag Doo^{dag} Doo Moo^-1 phi_0 = M_oo^-dag (D_oo)^dag L^{-1}  eta_o
   *                              eta_o'     = M_oo^-dag (D_oo)^dag (eta_o - Moe Mee^{-1} eta_e)
   *                              psi_o = M_oo^-1 phi_o
-   * TODO: Deflation 
+   *
+   *
   */
 namespace Grid {

@@ -97,6 +98,7 @@ namespace Grid {
  protected:
    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
    OperatorFunction<Field> & _HermitianRBSolver;
+    
    int CBfactorise;
    bool subGuess;
    bool useSolnAsInitGuess; // if true user-supplied solution vector is used as initial guess for solver
@@ -219,13 +221,20 @@ namespace Grid {
 	/////////////////////////////////////////////////
 	// Check unprec residual if possible
 	/////////////////////////////////////////////////
-	if ( ! subGuess ) {
-	  _Matrix.M(out[b],resid); 
+	if ( ! subGuess ) {	  
+
+	  if ( this->adjoint() ) _Matrix.Mdag(out[b],resid); 
+	  else                   _Matrix.M(out[b],resid); 
+
 	  resid = resid-in[b];
 	  RealD ns = norm2(in[b]);
 	  RealD nr = norm2(resid);
 	
-	  std::cout<<GridLogMessage<< "SchurRedBlackBase solver true unprec resid["<<b<<"] "<<std::sqrt(nr/ns) << std::endl;
+	  std::cout<<GridLogMessage<< "SchurRedBlackBase adjoint "<< this->adjoint() << std::endl;
+	  if ( this->adjoint() ) 
+	    std::cout<<GridLogMessage<< "SchurRedBlackBase adjoint solver true unprec resid["<<b<<"] "<<std::sqrt(nr/ns) << std::endl;
+	  else                   
+	    std::cout<<GridLogMessage<< "SchurRedBlackBase solver true unprec resid["<<b<<"] "<<std::sqrt(nr/ns) << std::endl;
 	} else {
 	  std::cout<<GridLogMessage<< "SchurRedBlackBase Guess subtracted after solve["<<b<<"] " << std::endl;
 	}
@@ -279,12 +288,21 @@ namespace Grid {

      // Verify the unprec residual
      if ( ! subGuess ) {
-        _Matrix.M(out,resid); 
+
+	std::cout<<GridLogMessage<< "SchurRedBlackBase adjoint "<< this->adjoint() << std::endl;
+	
+	if ( this->adjoint() ) _Matrix.Mdag(out,resid); 
+	else                   _Matrix.M(out,resid); 
+
        resid = resid-in;
        RealD ns = norm2(in);
        RealD nr = norm2(resid);

-        std::cout<<GridLogMessage << "SchurRedBlackBase solver true unprec resid "<< std::sqrt(nr/ns) << std::endl;
+	  if ( this->adjoint() ) 
+	    std::cout<<GridLogMessage<< "SchurRedBlackBase adjoint solver true unprec resid "<<std::sqrt(nr/ns) << std::endl;
+	  else                   
+	    std::cout<<GridLogMessage<< "SchurRedBlackBase solver true unprec resid "<<std::sqrt(nr/ns) << std::endl;
+
      } else {
        std::cout << GridLogMessage << "SchurRedBlackBase Guess subtracted after solve." << std::endl;
      }
@@ -293,6 +311,7 @@ namespace Grid {
    /////////////////////////////////////////////////////////////
    // Override in derived. 
    /////////////////////////////////////////////////////////////
+    virtual bool adjoint(void) { return false; }
    virtual void RedBlackSource  (Matrix & _Matrix,const Field &src, Field &src_e,Field &src_o)                =0;
    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)          =0;
    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)                           =0;
@@ -327,9 +346,9 @@ namespace Grid {
      /////////////////////////////////////////////////////
      // src_o = (source_o - Moe MeeInv source_e)
      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_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);     

      _Matrix.Mooee(tmp,src_o); // Extra factor of "m" in source from dumb choice of matrix norm.
    }
@@ -347,17 +366,17 @@ namespace Grid {
      ///////////////////////////////////////////////////
      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);        GRID_ASSERT(  tmp.Checkerboard()   ==Even);
-      src_e = src_e-tmp;               GRID_ASSERT(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(src_e,sol_e);   GRID_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(sol,sol_e); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o); GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
+      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)
    {
      SchurStaggeredOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
+      this->_HermitianRBSolver(_HermOpEO,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)
    {
@@ -396,13 +415,13 @@ namespace Grid {
      /////////////////////////////////////////////////////
      // src_o = Mdag * (source_o - Moe MeeInv source_e)
      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_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
      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      _HermOpEO.MpcDag(tmp,src_o);     GRID_ASSERT(src_o.Checkerboard() ==Odd);       
+      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       

    }
    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
@@ -416,17 +435,17 @@ namespace Grid {
      ///////////////////////////////////////////////////
      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);          GRID_ASSERT(  tmp.Checkerboard()   ==Even);
-      src_e_i = src_e-tmp;               GRID_ASSERT(  src_e_i.Checkerboard() ==Even);
-      _Matrix.MooeeInv(src_e_i,sol_e);   GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _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); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o); GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
+      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)
    {
      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
+      this->_HermitianRBSolver(_HermOpEO,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)
    {
@@ -461,9 +480,9 @@ namespace Grid {
        /////////////////////////////////////////////////////
        // src_o = Mdag * (source_o - Moe MeeInv source_e)
        /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  GRID_ASSERT( src_o.Checkerboard() == Odd  );     
+        _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)
@@ -478,18 +497,18 @@ namespace Grid {
        ///////////////////////////////////////////////////
        // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
        ///////////////////////////////////////////////////
-        _Matrix.Meooe(sol_o, tmp);         GRID_ASSERT(     tmp.Checkerboard() == Even );
-        src_e_i = src_e - tmp;             GRID_ASSERT( src_e_i.Checkerboard() == Even );
-        _Matrix.MooeeInv(src_e_i, sol_e);  GRID_ASSERT(   sol_e.Checkerboard() == Even );
+        _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); GRID_ASSERT( sol_e.Checkerboard() == Even );
-        setCheckerboard(sol, sol_o); GRID_ASSERT( sol_o.Checkerboard() == Odd  );
+        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);  GRID_ASSERT(sol_o.Checkerboard() == Odd);
+        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)
@@ -499,87 +518,6 @@ namespace Grid {
      }
  };

-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Site diagonal is identity, left preconditioned by Mee^inv
-  // ( 1 - Mee^inv Meo Moo^inv Moe ) phi = Mee_inv ( Mee - Meo Moo^inv Moe Mee^inv  ) phi =  Mee_inv eta
-  //
-  // Solve:
-  // ( 1 - Mee^inv Meo Moo^inv Moe )^dag ( 1 - Mee^inv Meo Moo^inv Moe ) phi = ( 1 - Mee^inv Meo Moo^inv Moe )^dag  Mee_inv eta
-  //
-  // Old notation e<->o
-  //
-  // Left precon by Moo^-1
-  //  b) (Doo^{dag} M_oo^-dag) (Moo^-1 Doo) psi_o =  [ (D_oo)^dag M_oo^-dag ] Moo^-1 L^{-1}  eta_o
-  //                                   eta_o'     = (D_oo)^dag  M_oo^-dag Moo^-1 (eta_o - Moe Mee^{-1} eta_e)
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  template<class Field> class SchurRedBlackDiagOneSolve : public SchurRedBlackBase<Field> {
-  public:
-    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-    /////////////////////////////////////////////////////
-    // Wrap the usual normal equations Schur trick
-    /////////////////////////////////////////////////////
-  SchurRedBlackDiagOneSolve(OperatorFunction<Field> &HermitianRBSolver, const bool initSubGuess = false,
-      const bool _solnAsInitGuess = false)  
-    : SchurRedBlackBase<Field>(HermitianRBSolver,initSubGuess,_solnAsInitGuess) {};
-
-    virtual void RedBlackSource(Matrix & _Matrix,const Field &src, Field &src_e,Field &src_o)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      SchurDiagOneOperator<Matrix,Field> _HermOpEO(_Matrix);
-      
-      Field   tmp(grid);
-      Field  Mtmp(grid);
-
-      pickCheckerboard(Even,src_e,src);
-      pickCheckerboard(Odd ,src_o,src);
-    
-      /////////////////////////////////////////////////////
-      // src_o = Mpcdag *MooeeInv * (source_o - Moe MeeInv source_e)
-      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
-      Mtmp=src_o-Mtmp;                 
-      _Matrix.MooeeInv(Mtmp,tmp);      GRID_ASSERT( tmp.Checkerboard() ==Odd);     
-      
-      // get the right MpcDag
-      _HermOpEO.MpcDag(tmp,src_o);     GRID_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);
-
-
-      ///////////////////////////////////////////////////
-      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);    GRID_ASSERT(  tmp.Checkerboard()   ==Even);
-      tmp = src_e-tmp;             GRID_ASSERT(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(tmp,sol_e); GRID_ASSERT(  sol_e.Checkerboard() ==Even);
-     
-      setCheckerboard(sol,sol_e);  GRID_ASSERT(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o);  GRID_ASSERT(  sol_o.Checkerboard() ==Odd );
-    };
-
-    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
-    {
-      SchurDiagOneOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);
-    };
-    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
-    {
-      SchurDiagOneOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,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
@@ -612,12 +550,12 @@ namespace Grid {
      /////////////////////////////////////////////////////
      // src_o = Mdag * (source_o - Moe MeeInv source_e)
      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  GRID_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);     GRID_ASSERT(src_o.Checkerboard() ==Odd);       
+      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);       
    }

    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
@@ -638,12 +576,12 @@ namespace Grid {
      ///////////////////////////////////////////////////
      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o_i,tmp);    GRID_ASSERT(  tmp.Checkerboard()   ==Even);
-      tmp = src_e-tmp;               GRID_ASSERT(  src_e.Checkerboard() ==Even);
-      _Matrix.MooeeInv(tmp,sol_e);   GRID_ASSERT(  sol_e.Checkerboard() ==Even);
+      _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);    GRID_ASSERT(  sol_e.Checkerboard() ==Even);
-      setCheckerboard(sol,sol_o_i);  GRID_ASSERT(  sol_o_i.Checkerboard() ==Odd );
+      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)
@@ -684,9 +622,9 @@ namespace Grid {
        /////////////////////////////////////////////////////
        // src_o = Mdag * (source_o - Moe MeeInv source_e)
        /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  GRID_ASSERT( src_o.Checkerboard() == Odd  );     
+        _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)
@@ -707,12 +645,12 @@ namespace Grid {
        ///////////////////////////////////////////////////
        // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
        ///////////////////////////////////////////////////
-        _Matrix.Meooe(sol_o_i, tmp);    GRID_ASSERT(   tmp.Checkerboard() == Even );
-        tmp = src_e - tmp;              GRID_ASSERT( src_e.Checkerboard() == Even );
-        _Matrix.MooeeInv(tmp, sol_e);   GRID_ASSERT( sol_e.Checkerboard() == Even );
+        _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);    GRID_ASSERT(   sol_e.Checkerboard() == Even );
-        setCheckerboard(sol, sol_o_i);  GRID_ASSERT( sol_o_i.Checkerboard() == Odd  );
+        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)
@@ -727,6 +665,127 @@ namespace Grid {
        this->_HermitianRBSolver(_OpEO, src_o, sol_o); 
      }
  };
+
+  /*
+   * Red black Schur decomposition
+   *
+   *  M = (Mee Meo) =  (1             0 )   (Mee   0               )  (1 Mee^{-1} Meo)
+   *      (Moe Moo)    (Moe Mee^-1    1 )   (0   Moo-Moe Mee^-1 Meo)  (0   1         )
+   *                =         L                     D                     U
+   *
+   * L^-1 = (1              0 )
+   *        (-MoeMee^{-1}   1 )   
+   * L^{dag} = ( 1       Mee^{-dag} Moe^{dag} )
+   *           ( 0       1                    )
+   *
+   * U^-1 = (1   -Mee^{-1} Meo)
+   *        (0    1           )
+   * U^{dag} = ( 1                 0)
+   *           (Meo^dag Mee^{-dag} 1)
+   * U^{-dag} = (  1                 0)
+   *            (-Meo^dag Mee^{-dag} 1)
+   *
+   *
+   ***********************
+   *     M^dag psi = eta
+   ***********************
+   *
+   * Really for Mobius: (Wilson - easier to just use gamma 5 hermiticity)
+   *
+   *    Mdag psi     =         Udag  Ddag  Ldag psi = eta
+   *
+   * U^{-dag} = (  1                 0)
+   *            (-Meo^dag Mee^{-dag} 1)
+   *
+   *
+   * i)                D^dag phi =  (U^{-dag}  eta)
+   *                        eta'_e = eta_e
+   *                        eta'_o = (eta_o - Meo^dag Mee^{-dag} eta_e)
+   * 
+   *      phi_o = D_oo^-dag eta'_o = D_oo^-dag (eta_o - Meo^dag Mee^{-dag} eta_e)
+   *
+   *      phi_e = D_ee^-dag eta'_e = D_ee^-dag eta_e
+   * 
+   * Solve: 
+   *
+   *      D_oo D_oo^dag phi_o = D_oo (eta_o - Meo^dag Mee^{-dag} eta_e)
+   *
+   * ii) 
+   *      phi = L^dag psi => psi = L^-dag phi. 
+   *
+   * L^{-dag} = ( 1      -Mee^{-dag} Moe^{dag} )
+   *            ( 0       1                    )
+   *
+   *   => sol_e = M_ee^-dag * ( src_e - Moe^dag phi_o )...
+   *   => sol_o = phi_o
+   */
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////
+  // Site diagonal has Mooee on it, but solve the Adjoint system
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////
+  template<class Field> class SchurRedBlackDiagMooeeDagSolve : public SchurRedBlackBase<Field> {
+  public:
+    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
+
+    virtual bool adjoint(void) { return true; }
+    SchurRedBlackDiagMooeeDagSolve(OperatorFunction<Field> &HermitianRBSolver,
+				   const bool initSubGuess = false,
+				   const bool _solnAsInitGuess = false)  
+      : SchurRedBlackBase<Field> (HermitianRBSolver,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 = (source_o - Moe^dag MeeInvDag source_e)
+      /////////////////////////////////////////////////////
+      _Matrix.MooeeInvDag(src_e,tmp);  assert(  tmp.Checkerboard() ==Even);
+      _Matrix.MeooeDag   (tmp,Mtmp);   assert( Mtmp.Checkerboard() ==Odd);     
+      tmp=src_o-Mtmp;                  assert(  tmp.Checkerboard() ==Odd);     
+
+      // get the right Mpc
+      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
+      _HermOpEO.Mpc(tmp,src_o);     assert(src_o.Checkerboard() ==Odd);
+    }
+    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
+    {
+      SchurDiagMooeeDagOperator<Matrix,Field> _HermOpEO(_Matrix);
+      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o); 
+    };
+    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
+    {
+      SchurDiagMooeeDagOperator<Matrix,Field> _HermOpEO(_Matrix);
+      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);
+    }
+    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_e(grid);
+      Field  tmp(grid);
+      ///////////////////////////////////////////////////
+      // sol_e = M_ee^-dag * ( src_e - Moe^dag phi_o )...
+      // sol_o = phi_o
+      ///////////////////////////////////////////////////
+      _Matrix.MeooeDag(sol_o,tmp);      assert(tmp.Checkerboard()==Even);
+      tmp = src_e-tmp;                  assert(tmp.Checkerboard()==Even);
+      _Matrix.MooeeInvDag(tmp,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 );
+    }
+  };
+
 }

 #endif
@@ -1,631 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/Aggregates.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: Peter Boyle <peterboyle@Peters-MacBook-Pro-2.local>
-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 */
-#pragma once
-
-#include <Grid/algorithms/iterative/PrecGeneralisedConjugateResidualNonHermitian.h>
-
-NAMESPACE_BEGIN(Grid);
-
-inline RealD AggregatePowerLaw(RealD x)
-{
-  //  return std::pow(x,-4);
-  //  return std::pow(x,-3);
-  return std::pow(x,-5);
-}
-
-template<class Fobj,class CComplex,int nbasis>
-class Aggregation {
-public:
-  constexpr int Nbasis(void) { return nbasis; };
-  
-  typedef iVector<CComplex,nbasis >             siteVector;
-  typedef Lattice<siteVector>                 CoarseVector;
-  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-
-  typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<Fobj >        FineField;
-
-  GridBase *CoarseGrid;
-  GridBase *FineGrid;
-  std::vector<Lattice<Fobj> > subspace;
-  int checkerboard;
-  int Checkerboard(void){return checkerboard;}
-  Aggregation(GridBase *_CoarseGrid,GridBase *_FineGrid,int _checkerboard) : 
-    CoarseGrid(_CoarseGrid),
-    FineGrid(_FineGrid),
-    subspace(nbasis,_FineGrid),
-    checkerboard(_checkerboard)
-  {
-  };
-  
-  void GlobalOrthonormalise(void)
-  {
-    // Normalise all vectors
-    for(int i=0;i<nbasis; i++){
-      RealD scale = std::pow(norm2(subspace[i]),-0.5); 
-      subspace[i] = subspace[i]*scale;
-    }
-    for(int i=0;i<nbasis; i++){
-      for(int j=0;j<i; j++){
-	basisOrthogonalize(subspace,subspace[i],j);
-      }
-      RealD scale = std::pow(norm2(subspace[i]),-0.5); 
-      subspace[i] = subspace[i]*scale;
-    }
-  }  
-  void Orthogonalise(void){
-    CoarseScalar InnerProd(CoarseGrid); 
-    //    std::cout << GridLogMessage <<" Block Gramm-Schmidt pass 1"<<std::endl;
-    blockOrthogonalise(InnerProd,subspace);
-  } 
-  void ProjectToSubspace(CoarseVector &CoarseVec,const FineField &FineVec){
-    blockProject(CoarseVec,FineVec,subspace);
-  }
-  void PromoteFromSubspace(const CoarseVector &CoarseVec,FineField &FineVec){
-    FineVec.Checkerboard() = subspace[0].Checkerboard();
-    blockPromote(CoarseVec,FineVec,subspace);
-  }
-
-  virtual void CreateSubspaceRandom(GridParallelRNG  &RNG) {
-    int nn=nbasis;
-    RealD scale;
-    FineField noise(FineGrid);
-    for(int b=0;b<nn;b++){
-      subspace[b] = Zero();
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-      subspace[b] = noise;
-    }
-  }
-  virtual void CreateSubspace(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,int nn=nbasis)
-  {
-
-    RealD scale;
-
-    ConjugateGradient<FineField> CG(1.0e-4,2000,false);
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-
-    for(int b=0;b<nn;b++){
-      
-      subspace[b] = Zero();
-      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;
-
-      for(int i=0;i<2;i++){
-
-	CG(hermop,noise,subspace[b]);
-
-	noise = subspace[b];
-	scale = std::pow(norm2(noise),-0.5); 
-	noise=noise*scale;
-	
-	hermop.Op(noise,Mn); std::cout<<GridLogMessage << "intermediate["<<i<<"] <i|MdagM|i> "<<norm2(Mn)<<std::endl;
-	
-      }
-
-      hermop.Op(noise,Mn); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|MdagM|f> "<<norm2(Mn)<<std::endl;
-      subspace[b]   = noise;
-
-    }
-  }
-
-  virtual void CreateSubspaceGCR(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &DiracOp,int nn=nbasis)
-  {
-    RealD scale;
-
-    TrivialPrecon<FineField> simple_fine;
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,10,DiracOp,simple_fine,30,30);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,10,DiracOp,simple_fine,12,12);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.001,30,DiracOp,simple_fine,12,12);
-    //    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.0005,30,DiracOp,simple_fine,20,20);
-    PrecGeneralisedConjugateResidualNonHermitian<FineField> GCR(0.0005,30,DiracOp,simple_fine,10,10);
-    FineField noise(FineGrid);
-    FineField src(FineGrid);
-    FineField guess(FineGrid);
-    FineField Mn(FineGrid);
-
-    for(int b=0;b<nn;b++){
-      
-      subspace[b] = Zero();
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-      
-      DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "noise   ["<<b<<"] <n|Op|n> "<<innerProduct(noise,Mn)<<std::endl;
-
-      for(int i=0;i<3;i++){
-	//  void operator() (const Field &src, Field &psi){
-#if 1
-	if (i==0)std::cout << GridLogMessage << " inverting on noise "<<std::endl;
-	src = noise;
-	guess=Zero();
-	GCR(src,guess);
-	subspace[b] = guess;
-#else
-	if (i==0)std::cout << GridLogMessage << " inverting on zero "<<std::endl;
-	src=Zero();
-	guess = noise;
-	GCR(src,guess);
-	subspace[b] = guess;
-#endif
-	noise = subspace[b];
-	scale = std::pow(norm2(noise),-0.5); 
-	noise=noise*scale;
-	
-	DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "intermediate["<<i<<"] <f|Op|f> "<<innerProduct(noise,Mn)<<" <f|OpDagOp|f>"<<norm2(Mn)<<std::endl;
-
-      }
-
-      DiracOp.Op(noise,Mn); std::cout<<GridLogMessage << "filtered["<<b<<"] <f|Op|f> "<<innerProduct(noise,Mn)<<" <f|OpDagOp|f>"<<norm2(Mn)<<std::endl;
-      subspace[b]   = noise;
-
-    }
-    GlobalOrthonormalise();
-  }
-
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-  // World of possibilities here. But have tried quite a lot of experiments (250+ jobs run on Summit)
-  // and this is the best I found
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-
-  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);
-
-    // New normalised noise
-    gaussian(RNG,noise);
-    scale = std::pow(norm2(noise),-0.5); 
-    noise=noise*scale;
-
-    std::cout << GridLogMessage<<" Chebyshev subspace pass-1 : ord "<<orderfilter<<" ["<<lo<<","<<hi<<"]"<<std::endl;
-    std::cout << GridLogMessage<<" Chebyshev subspace pass-2 : nbasis"<<nn<<" min "
-	      <<ordermin<<" step "<<orderstep
-	      <<" lo"<<filterlo<<std::endl;
-
-    // Initial matrix element
-    hermop.Op(noise,Mn); std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-
-    int b =0;
-    {
-      ComplexD ip;
-      // 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);
-      ip= innerProduct(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|Op|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-
-      hermop.AdjOp(Mn,tmp); 
-      ip = innerProduct(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|AdjOp|n> "<<norm2(tmp)<<" "<<ip<<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);
-
-	autoView( y_v , y, AcceleratorWrite);
-	autoView( Tn_v , (*Tn), AcceleratorWrite);
-	autoView( Tnp_v , (*Tnp), AcceleratorWrite);
-	autoView( Tnm_v , (*Tnm), AcceleratorWrite);
-	const int Nsimd = CComplex::Nsimd();
-	accelerator_for(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;
-
-
-	  ComplexD ip;
-
-	  hermop.Op(Mn,tmp);
-	  ip= innerProduct(Mn,tmp); 
-	  std::cout<<GridLogMessage << "filt ["<<b<<"] <n|Op|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-
-	  hermop.AdjOp(Mn,tmp); 
-	  ip = innerProduct(Mn,tmp); 
-	  std::cout<<GridLogMessage << "filt ["<<b<<"] <n|AdjOp|n> "<<norm2(tmp)<<" "<<ip<<std::endl;
-	  
-	  b++;
-	}
-
-	// Cycle pointers to avoid copies
-	FineField *swizzle = Tnm;
-	Tnm    =Tn;
-	Tn     =Tnp;
-	Tnp    =swizzle;
-	  
-      }
-    }
-    GRID_ASSERT(b==nn);
-  }
-
-
-  virtual void CreateSubspacePolyCheby(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-				       int nn,
-				       double hi,
-				       double lo1,
-				       int orderfilter,
-				       double lo2,
-				       int orderstep)
-  {
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    gaussian(RNG,noise);
-    scale = std::pow(norm2(noise),-0.5); 
-    noise=noise*scale;
-
-    std::cout << GridLogMessage<<" CreateSubspacePolyCheby "<<std::endl;
-    // Initial matrix element
-    hermop.Op(noise,Mn);
-    std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-
-    int b =0;
-    {
-      // Filter
-      std::cout << GridLogMessage << "Cheby "<<lo1<<","<<hi<<" "<<orderstep<<std::endl;
-      Chebyshev<FineField> Cheb(lo1,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;
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|n> "<<norm2(Mn)<<std::endl;
-    }
-
-    // Generate a full sequence of Chebyshevs
-    for(int n=1;n<nn;n++){
-      std::cout << GridLogMessage << "Cheby "<<lo2<<","<<hi<<" "<<orderstep<<std::endl;
-      Chebyshev<FineField> Cheb(lo2,hi,orderstep);
-      Cheb(hermop,subspace[n-1],Mn);
-
-      for(int m=0;m<n;m++){
-	ComplexD c = innerProduct(subspace[m],Mn);
-	Mn = Mn - c*subspace[m];
-      }
-      
-      // normalise
-      scale = std::pow(norm2(Mn),-0.5);
-      Mn=Mn*scale;
-      
-      subspace[n]=Mn;
-      
-      hermop.Op(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<n<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      std::cout<<GridLogMessage << "filt ["<<n<<"] <n|n> "<<norm2(Mn)<<std::endl;
-
-    }
-  }
-
-  virtual void CreateSubspaceChebyshev(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-				       int nn,
-				       double hi,
-				       double lo,
-				       int orderfilter
-				       ) {
-
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    std::cout << GridLogMessage<<" Chebyshev subspace pure noise : ord "<<orderfilter<<" ["<<lo<<","<<hi<<"]"<<std::endl;
-    std::cout << GridLogMessage<<" Chebyshev subspace pure noise  : nbasis "<<nn<<std::endl;
-
-
-    for(int b =0;b<nbasis;b++)
-    {
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-
-      // Initial matrix element
-      hermop.Op(noise,Mn);
-      if(b==0) std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-
-      // Filter
-      Chebyshev<FineField> Cheb(lo,hi,orderfilter);
-      Cheb(hermop,noise,Mn);
-      scale = std::pow(norm2(Mn),-0.5); 	Mn=Mn*scale;
-
-      // Refine
-      Chebyshev<FineField> PowerLaw(lo,hi,1000,AggregatePowerLaw);
-      noise = Mn;
-      PowerLaw(hermop,noise,Mn);
-      scale = std::pow(norm2(Mn),-0.5); 	Mn=Mn*scale;
-
-      // normalise
-      subspace[b]   = Mn;
-      hermop.Op(Mn,tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-    }
-
-  }
-
-  virtual void CreateSubspaceChebyshevPowerLaw(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-					       int nn,
-					       double hi,
-					       int orderfilter
-					       ) {
-
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    std::cout << GridLogMessage<<" Chebyshev subspace pure noise : ord "<<orderfilter<<" [0,"<<hi<<"]"<<std::endl;
-    std::cout << GridLogMessage<<" Chebyshev subspace pure noise  : nbasis "<<nn<<std::endl;
-
-    for(int b =0;b<nbasis;b++)
-    {
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-
-      // Initial matrix element
-      hermop.Op(noise,Mn);
-      if(b==0) std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-      // Filter
-      Chebyshev<FineField> Cheb(0.0,hi,orderfilter,AggregatePowerLaw);
-      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;
-    }
-
-  }
-  virtual void CreateSubspaceChebyshevNew(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-					  double hi
-					  ) {
-
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    for(int b =0;b<nbasis;b++)
-    {
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-
-      // Initial matrix element
-      hermop.Op(noise,Mn);
-      if(b==0) std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-      // Filter
-      //#opt2(x) =  acheb(x,3,90,300)* acheb(x,1,90,50) * acheb(x,0.5,90,200) * acheb(x,0.05,90,400) * acheb(x,0.01,90,1500)
-      /*266
-      Chebyshev<FineField> Cheb1(3.0,hi,300);
-      Chebyshev<FineField> Cheb2(1.0,hi,50);
-      Chebyshev<FineField> Cheb3(0.5,hi,300);
-      Chebyshev<FineField> Cheb4(0.05,hi,500);
-      Chebyshev<FineField> Cheb5(0.01,hi,2000);
-      */
-      /* 242 */
-      /*
-      Chebyshev<FineField> Cheb3(0.1,hi,300);
-      Chebyshev<FineField> Cheb2(0.02,hi,1000);
-      Chebyshev<FineField> Cheb1(0.003,hi,2000);
-      8?
-      */
-      /* How many??
-      */
-      Chebyshev<FineField> Cheb2(0.001,hi,2500); // 169 iters on HDCG after refine
-      Chebyshev<FineField> Cheb1(0.02,hi,600);
-
-      //      Chebyshev<FineField> Cheb2(0.001,hi,1500);
-      //      Chebyshev<FineField> Cheb1(0.02,hi,600);
-      Cheb1(hermop,noise,Mn); scale = std::pow(norm2(Mn),-0.5); 	noise=Mn*scale;
-      hermop.Op(noise,tmp); std::cout<<GridLogMessage << "Cheb1 <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      Cheb2(hermop,noise,Mn); scale = std::pow(norm2(Mn),-0.5); 	noise=Mn*scale;
-      hermop.Op(noise,tmp); std::cout<<GridLogMessage << "Cheb2 <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      //      Cheb3(hermop,noise,Mn); scale = std::pow(norm2(Mn),-0.5); 	noise=Mn*scale;
-      //      hermop.Op(noise,tmp); std::cout<<GridLogMessage << "Cheb3 <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      //      Cheb4(hermop,noise,Mn); scale = std::pow(norm2(Mn),-0.5); 	noise=Mn*scale;
-      //      hermop.Op(noise,tmp); std::cout<<GridLogMessage << "Cheb4 <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      //      Cheb5(hermop,noise,Mn); scale = std::pow(norm2(Mn),-0.5); 	noise=Mn*scale;
-      //      hermop.Op(noise,tmp); std::cout<<GridLogMessage << "Cheb5 <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-      subspace[b]   = noise;
-      hermop.Op(subspace[b],tmp); 
-      std::cout<<GridLogMessage << "filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<< " norm " << norm2(noise)<<std::endl;
-    }
-
-  }
-
-  virtual void CreateSubspaceMultishift(GridParallelRNG  &RNG,LinearOperatorBase<FineField> &hermop,
-					double Lo,double tol,int maxit)
-  {
-
-    RealD scale;
-
-    FineField noise(FineGrid);
-    FineField Mn(FineGrid);
-    FineField tmp(FineGrid);
-
-    // New normalised noise
-    std::cout << GridLogMessage<<" Multishift subspace : Lo "<<Lo<<std::endl;
-
-    // Filter
-    // [ 1/6(x+Lo)  - 1/2(x+2Lo) + 1/2(x+3Lo)  -1/6(x+4Lo) = Lo^3 /[ (x+1Lo)(x+2Lo)(x+3Lo)(x+4Lo) ]
-    //
-    // 1/(x+Lo)  - 1/(x+2 Lo)
-    double epsilon      = Lo/3;
-    std::vector<RealD> alpha({1.0/6.0,-1.0/2.0,1.0/2.0,-1.0/6.0});
-    std::vector<RealD> shifts({Lo,Lo+epsilon,Lo+2*epsilon,Lo+3*epsilon});
-    std::vector<RealD> tols({tol,tol,tol,tol});
-    std::cout << "sizes "<<alpha.size()<<" "<<shifts.size()<<" "<<tols.size()<<std::endl;
-
-    MultiShiftFunction msf(4,0.0,95.0);
-    std::cout << "msf constructed "<<std::endl;
-    msf.poles=shifts;
-    msf.residues=alpha;
-    msf.tolerances=tols;
-    msf.norm=0.0;
-    msf.order=alpha.size();
-    ConjugateGradientMultiShift<FineField> MSCG(maxit,msf);
-    
-    for(int b =0;b<nbasis;b++)
-    {
-      gaussian(RNG,noise);
-      scale = std::pow(norm2(noise),-0.5); 
-      noise=noise*scale;
-
-      // Initial matrix element
-      hermop.Op(noise,Mn);
-      if(b==0) std::cout<<GridLogMessage << "noise <n|MdagM|n> "<<norm2(Mn)<<std::endl;
-
-      MSCG(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;
-
-    }
-
-  }
-  virtual void RefineSubspace(LinearOperatorBase<FineField> &hermop,
-			      double Lo,double tol,int maxit)
-  {
-    FineField tmp(FineGrid);
-    for(int b =0;b<nbasis;b++)
-    {
-      ConjugateGradient<FineField>  CGsloppy(tol,maxit,false);
-      ShiftedHermOpLinearOperator<FineField> ShiftedFineHermOp(hermop,Lo);
-      tmp=Zero();
-      CGsloppy(hermop,subspace[b],tmp);
-      RealD 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;
-    }
-  }
-  virtual void RefineSubspaceHDCG(LinearOperatorBase<FineField> &hermop,
-				  TwoLevelCGmrhs<FineField> & theHDCG,
-				  int nrhs)
-  {
-    std::vector<FineField> src_mrhs(nrhs,FineGrid);
-    std::vector<FineField> res_mrhs(nrhs,FineGrid);
-    FineField tmp(FineGrid);
-    for(int b =0;b<nbasis;b+=nrhs)
-    {
-      tmp = subspace[b];
-      RealD scale = std::pow(norm2(tmp),-0.5); 	tmp=tmp*scale;
-      subspace[b] =tmp;
-      hermop.Op(subspace[b],tmp);
-      std::cout<<GridLogMessage << "before filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-
-      for(int r=0;r<MIN(nbasis-b,nrhs);r++){
-	src_mrhs[r] = subspace[b+r];
-      }
-      for(int r=0;r<nrhs;r++){
-	res_mrhs[r] = Zero();
-      }
-      theHDCG(src_mrhs,res_mrhs);
-
-      for(int r=0;r<MIN(nbasis-b,nrhs);r++){
-	tmp = res_mrhs[r];
-	RealD scale = std::pow(norm2(tmp),-0.5); tmp=tmp*scale;
-	subspace[b+r]=tmp;
-      }
-      hermop.Op(subspace[b],tmp);
-      std::cout<<GridLogMessage << "after filt ["<<b<<"] <n|MdagM|n> "<<norm2(tmp)<<std::endl;
-    }
-  }
-
-  
-  
-};
-NAMESPACE_END(Grid);
-
@@ -1,235 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/BlockCyclic.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// Scalar of the distributed dense inversion: block-cyclic redistribution,
-// SUMMA, the Schur recursion and its LU leaf.  A configure-time choice
-// (--enable-dense-inverse-precision=double|single), INDEPENDENT of the
-// coarse-space precision: the matrix elements arrive in the coarse scalar
-// and the apply slab is fp32 either way; only the factorisation's
-// arithmetic and footprint follow this type.
-///////////////////////////////////////////////////////////////////////////////
-#ifdef GRID_DENSE_INVERSE_SINGLE
-typedef ComplexF DenseInverseScalar;
-#else
-typedef ComplexD DenseInverseScalar;
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// BlockCyclicLayout: the index arithmetic of a 2D block-cyclic distribution
-// of an N x N matrix over a Pr x Pc logical process grid with block size nb.
-//
-// This is stage 1 of the 2D distributed dense inverse
-// (documentation/DistributedDenseInverse2D.tex).  It is deliberately
-// COMMUNICATOR-FREE: every mapping is a static pure function of
-// (N, nb, Pr, Pc), so the whole layout is exhaustively unit-testable on one
-// rank with no MPI in the loop (Test_blockcyclic).  A thin instance layer
-// binds a world rank to a grid coordinate and caches local extents.
-//
-// Conventions (fixed here, relied on by every later stage):
-//
-//  * Global block b of a dimension with Pg processes is owned by process
-//    coordinate  b % Pg  (ScaLAPACK csrc=0), and is that process's local
-//    block  b / Pg.
-//  * Rank <-> grid coordinate is ROW MAJOR over the process grid:
-//        rank = p*Pc + q ,  p = rank/Pc ,  q = rank%Pc .
-//    The eventual ring transport must construct its neighbour tables with
-//    the same convention.
-//  * Local storage is COLUMN MAJOR with ld = mloc, matching BlockRows:
-//    local element (i,j) lives at  data[i + j*mloc].
-//  * The trailing partial block (N % nb != 0) belongs to the owner of the
-//    last full-size block position; only that one block is short.
-//
-// Element (gi,gj) therefore lives on grid coordinate
-//    ( (gi/nb) % Pr , (gj/nb) % Pc )
-// at local coordinate
-//    ( ((gi/nb)/Pr)*nb + gi%nb , ((gj/nb)/Pc)*nb + gj%nb ).
-//
-// Everything here is host-side integer arithmetic; nothing allocates.
-///////////////////////////////////////////////////////////////////////////////
-
-class BlockCyclicLayout
-{
-public:
-  ///////////////////////////////////////////////////////////////////////////
-  // Closest-to-square factorisation Pr*Pc == P with Pr <= Pc.
-  // For fixed P the per-rank SUMMA volume  N^2 (1/Pr + 1/Pc)  is minimised
-  // at the most square grid.  P=288 -> 16 x 18.
-  ///////////////////////////////////////////////////////////////////////////
-  // Nearest-to-square factorisation with Pr >= Pc.  The orientation matters
-  // for SUMMA: B panels travel along process columns in slots of
-  // S = ceil(Pc/Pr) panels, padded; with Pr >= Pc, S == 1 and there is no
-  // padding.  (288 as 16x18 had S=2 -- half the B-ring bytes were zeros;
-  // 18x16 moves ~30% fewer bytes for the same inverse.)
-  static void ChooseProcessGrid(int P, int &Pr, int &Pc)
-  {
-    GRID_ASSERT(P >= 1);
-    int r = 1;
-    for(int f=1; (int64_t)f*f <= (int64_t)P; f++)
-      if ( P % f == 0 ) r = f;
-    Pc = r;
-    Pr = P / r;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Number of rows (or columns) of a dimension of global extent N, block nb,
-  // owned by process coordinate p of Pg.  ScaLAPACK "numroc", csrc=0.
-  ///////////////////////////////////////////////////////////////////////////
-  static int64_t NumLocal(int64_t N, int64_t nb, int p, int Pg)
-  {
-    GRID_ASSERT(N  >= 0);
-    GRID_ASSERT(nb >= 1);
-    GRID_ASSERT(p  >= 0);
-    GRID_ASSERT(p  <  Pg);
-    int64_t nblocks = N / nb;            // full blocks
-    int64_t extra   = N % nb;            // trailing partial block
-    int64_t full    = nblocks / Pg;      // full blocks everyone owns
-    int64_t rem     = nblocks % Pg;      // coords [0,rem) own one more
-    int64_t n = full*nb;
-    if ( p <  (int)rem ) n += nb;        // an extra full block
-    if ( p == (int)rem ) n += extra;     // the partial block, if any
-    return n;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Global index -> (owner coordinate, local index) in one dimension.
-  ///////////////////////////////////////////////////////////////////////////
-  static void GlobalToLocal(int64_t g, int64_t nb, int Pg,
-                            int &owner, int64_t &loc)
-  {
-    GRID_ASSERT(g >= 0);
-    int64_t b = g / nb;                  // global block
-    owner = (int)(b % Pg);
-    loc   = (b / Pg)*nb + (g % nb);
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // (process coordinate, local index) -> global index in one dimension.
-  // Inverse of GlobalToLocal on the owned set.
-  ///////////////////////////////////////////////////////////////////////////
-  static int64_t LocalToGlobal(int64_t l, int64_t nb, int p, int Pg)
-  {
-    GRID_ASSERT(l >= 0);
-    int64_t lb = l / nb;                 // local block
-    int64_t b  = lb*Pg + p;              // global block
-    return b*nb + (l % nb);
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Instance layer: bind a rank of a Pr x Pc grid.
-  ///////////////////////////////////////////////////////////////////////////
-  int64_t N;         // global matrix dimension (square)
-  int64_t nb;        // block size
-  int     Pr, Pc;    // process grid
-  int     me;        // world rank within the grid, row major
-  int     prow, pcol;// my grid coordinate
-  int64_t mloc,nloc; // my local extents; storage column major, ld = mloc
-
-  BlockCyclicLayout(int64_t N_, int64_t nb_, int Pr_, int Pc_, int me_)
-  {
-    N  = N_;
-    nb = nb_;
-    Pr = Pr_;
-    Pc = Pc_;
-    me = me_;
-    GRID_ASSERT( N  >= 0 );
-    GRID_ASSERT( nb >= 1 );
-    GRID_ASSERT( Pr >= 1 );
-    GRID_ASSERT( Pc >= 1 );
-    GRID_ASSERT( me >= 0 );
-    GRID_ASSERT( me <  Pr*Pc );
-    prow = me / Pc;                      // ROW MAJOR rank convention
-    pcol = me % Pc;
-    mloc = NumLocal(N, nb, prow, Pr);
-    nloc = NumLocal(N, nb, pcol, Pc);
-  }
-
-  // Owning rank of global element (gi,gj), row-major rank convention.
-  int OwnerRank(int64_t gi, int64_t gj) const
-  {
-    int pr,pc; int64_t li,lj;
-    GlobalToLocal(gi, nb, Pr, pr, li);
-    GlobalToLocal(gj, nb, Pc, pc, lj);
-    return pr*Pc + pc;
-  }
-
-  // My local storage offset of global element (gi,gj).
-  // The caller must know I own it; asserted, not assumed.
-  int64_t LocalOffset(int64_t gi, int64_t gj) const
-  {
-    int pr,pc; int64_t li,lj;
-    GlobalToLocal(gi, nb, Pr, pr, li);
-    GlobalToLocal(gj, nb, Pc, pc, lj);
-    GRID_ASSERT( pr == prow );
-    GRID_ASSERT( pc == pcol );
-    return li + lj*mloc;                 // column major, ld = mloc
-  }
-
-  // Do I own global element (gi,gj)?
-  int Owns(int64_t gi, int64_t gj) const
-  {
-    return OwnerRank(gi,gj) == me;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Block-aligned global range [g0,g1) -> my contiguous local range [l0,l1).
-  //
-  // For fixed owner p the local index is monotone in the global index, so a
-  // coordinate's owned elements of ANY global range are contiguous in local
-  // storage; and for a BLOCK-ALIGNED range the bounds are exactly
-  // NumLocal(g0) and NumLocal(g1), because NumLocal(g,...) counts the owned
-  // elements below g.  This is what lets a windowed product view the local
-  // sub-matrix of a global window as &data[l0 + c0*mloc] with the SAME ld --
-  // no gather, no copy.  Verified exhaustively in Test_blockcyclic T7.
-  //
-  // g0 must be a block multiple; g1 a block multiple or N itself.
-  ///////////////////////////////////////////////////////////////////////////
-  static void RangeToLocal(int64_t g0, int64_t g1,
-                           int64_t N, int64_t nb, int p, int Pg,
-                           int64_t &l0, int64_t &l1)
-  {
-    GRID_ASSERT( 0 <= g0 );
-    GRID_ASSERT( g0 <= g1 );
-    GRID_ASSERT( g1 <= N );
-    GRID_ASSERT( g0 % nb == 0 );
-    GRID_ASSERT( (g1 % nb == 0) || (g1 == N) );
-    l0 = NumLocal(g0, nb, p, Pg);
-    l1 = NumLocal(g1, nb, p, Pg);
-  }
-
-  // Instance forms, rows and columns of my own coordinate.
-  void RowRange(int64_t g0, int64_t g1, int64_t &l0, int64_t &l1) const
-  { RangeToLocal(g0,g1,N,nb,prow,Pr,l0,l1); }
-  void ColRange(int64_t g0, int64_t g1, int64_t &l0, int64_t &l1) const
-  { RangeToLocal(g0,g1,N,nb,pcol,Pc,l0,l1); }
-
-  // Size of global block b (the trailing block may be short).
-  int64_t BlockSize(int64_t b) const
-  {
-    int64_t lo = b*nb;
-    GRID_ASSERT( lo < N );
-    return std::min(N, lo+nb) - lo;
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,283 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/BlockCyclicRedistribute.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/multigrid/BlockCyclicSumma.h>
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// My rows of a distributed dense matrix in the 1D rank-major row layout:
-// rank r owns contiguous global rows [rowStart[r], rowStart[r+1]) of an
-// N x N matrix, stored rows x cols column major, ld = rows; element (i,j)
-// at data[i + j*ld].  This is the layout the stencil->dense import
-// produces and the apply slab consumes; the 2D inverse slots between them
-// through the redistribution below.
-///////////////////////////////////////////////////////////////////////////////
-class BlockRows
-{
-public:
-  deviceVector<DenseInverseScalar> data;
-  int64_t                rows;
-  int64_t                cols;
-  int64_t                ld;
-
-  BlockRows()
-  {
-    rows = 0;
-    cols = 0;
-    ld   = 0;
-  }
-  void Resize(int64_t r, int64_t c)
-  {
-    rows = r;
-    cols = c;
-    ld   = r;
-    data.resize((uint64_t)r*c);
-  }
-  DenseInverseScalar *ColumnWindow(int64_t col0)
-  {
-    GRID_ASSERT( col0 >= 0 );
-    GRID_ASSERT( col0 <= cols );
-    return &data[(uint64_t)col0*ld];
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// Stage 4 of the 2D distributed dense inverse: redistribution between the
-// 1D rank-major row layout (BlockRows above) and the 2D block-cyclic
-// layout.
-//
-// This is what lets the EXISTING stencil->dense import, its certificate,
-// the fp32 slab conversion and the apply path all remain byte-for-byte
-// untouched: the 2D inverse slots between them as
-//
-//    RowsToCyclic -> BlockCyclicSchurInverse::Invert -> CyclicToRows
-//
-// Volume is one matrix pass each way -- N^2/P elements per rank (~1 GB at
-// production), trivial against the inversion itself.
-//
-// Transport: PURE POINT-TO-POINT, like everything else in this stack.
-// Ranks exchange in a round-robin TOURNAMENT (the circle method, on an odd
-// modulus M so it covers every pair exactly once for any P, with byes):
-// at round r, ranks x and y are partners iff x+y == r (mod M).  Each
-// meeting handles both directed edges of the pair in ONE SendToRecvFrom,
-// padded to the larger of the two edge sizes -- SendToRecvFrom carries a
-// single byte count for both directions, and both endpoints compute the
-// same max from the shared descriptors, so there is no asymmetric-size
-// case and no zero-count shape.  Pairs with nothing to exchange skip the
-// round, decided identically at both ends.
-//
-// Element enumeration within an edge is canonical -- ascending global
-// column outer, ascending global row inner -- and each endpoint builds its
-// OWN local offset tables from the shared descriptors, so no index data is
-// ever transmitted.  The round trip is BITWISE exact (pure data movement,
-// no arithmetic): Test_schur2d_redist proves it.
-///////////////////////////////////////////////////////////////////////////////
-
-class BlockCyclicRedistribute
-{
-public:
-  /////////////////////////////////////////////////////////////////////////
-  // The directed edge (1D rank r1, 2D rank r2): global rows of r1's range
-  // whose row-block coordinate is r2's prow; ALL global columns whose
-  // column-block coordinate is r2's pcol.  Every rank can enumerate any
-  // edge from (rowStart, layout) alone.
-  /////////////////////////////////////////////////////////////////////////
-  static void EdgeRows(const std::vector<int64_t> &rowStart, int r1,
-                       const BlockCyclicLayout &L, int r2,
-                       std::vector<int64_t> &rows)
-  {
-    rows.clear();
-    int p = r2 / L.Pc;                       // row-major rank convention
-    for(int64_t i=rowStart[r1]; i<rowStart[r1+1]; i++)
-      if ( (int)((i/L.nb) % L.Pr) == p ) rows.push_back(i);
-  }
-  static void EdgeCols(const BlockCyclicLayout &L, int r2,
-                       std::vector<int64_t> &cols)
-  {
-    cols.clear();
-    int q = r2 % L.Pc;
-    for(int64_t b=0; b*L.nb<L.N; b++){
-      if ( (int)(b % L.Pc) != q ) continue;
-      int64_t g0=b*L.nb, g1=std::min(L.N,(b+1)*L.nb);
-      for(int64_t j=g0;j<g1;j++) cols.push_back(j);
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////
-  // Gather/scatter one edge between a matrix (device, column major, ld)
-  // and a dense edge buffer, through device offset tables.
-  //   buffer(a,b) = elem(rows[a], cols[b]),  a fastest.
-  /////////////////////////////////////////////////////////////////////////
-  static void MoveEdge(int toBuffer,
-                       DenseInverseScalar *mat, int64_t ld,
-                       const std::vector<int64_t> &roff,  // per-row offset in mat
-                       const std::vector<int64_t> &coff,  // per-col offset in mat
-                       DenseInverseScalar *buf)
-  {
-    int64_t nr = roff.size();
-    int64_t nc = coff.size();
-    if ( !(nr && nc) ) return;
-    deviceVector<int64_t> dro(nr), dco(nc);
-    acceleratorCopyToDevice((void *)&roff[0], (void *)&dro[0], nr*sizeof(int64_t));
-    acceleratorCopyToDevice((void *)&coff[0], (void *)&dco[0], nc*sizeof(int64_t));
-    int64_t *ro = &dro[0];
-    int64_t *co = &dco[0];
-    if ( toBuffer ) {
-      accelerator_for(idx, (uint64_t)(nr*nc), 1, {
-        int64_t b = idx / nr;
-        int64_t a = idx - b*nr;
-        buf[a + b*nr] = mat[ ro[a] + co[b]*ld ];
-      });
-    } else {
-      accelerator_for(idx, (uint64_t)(nr*nc), 1, {
-        int64_t b = idx / nr;
-        int64_t a = idx - b*nr;
-        mat[ ro[a] + co[b]*ld ] = buf[a + b*nr];
-      });
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////
-  // My offset tables for an edge, on whichever side I am.
-  /////////////////////////////////////////////////////////////////////////
-  static void Offsets1D(const std::vector<int64_t> &rows,
-                        const std::vector<int64_t> &cols,
-                        int64_t row0,
-                        std::vector<int64_t> &roff, std::vector<int64_t> &coff)
-  {
-    roff.resize(rows.size());  coff.resize(cols.size());
-    for(uint64_t a=0;a<rows.size();a++) roff[a] = rows[a]-row0;   // local row
-    for(uint64_t b=0;b<cols.size();b++) coff[b] = cols[b];        // global col
-  }
-  static void Offsets2D(const BlockCyclicLayout &L,
-                        const std::vector<int64_t> &rows,
-                        const std::vector<int64_t> &cols,
-                        std::vector<int64_t> &roff, std::vector<int64_t> &coff)
-  {
-    roff.resize(rows.size());  coff.resize(cols.size());
-    for(uint64_t a=0;a<rows.size();a++){
-      int p; int64_t l;
-      BlockCyclicLayout::GlobalToLocal(rows[a], L.nb, L.Pr, p, l);
-      GRID_ASSERT( p == L.prow );
-      roff[a] = l;
-    }
-    for(uint64_t b=0;b<cols.size();b++){
-      int q; int64_t l;
-      BlockCyclicLayout::GlobalToLocal(cols[b], L.nb, L.Pc, q, l);
-      GRID_ASSERT( q == L.pcol );
-      coff[b] = l;
-    }
-  }
-
-  /////////////////////////////////////////////////////////////////////////
-  // The worker.  dir=+1 : 1D rows -> block cyclic ;  dir=-1 : back.
-  /////////////////////////////////////////////////////////////////////////
-  static void Redistribute(int dir, GridBase *grid,
-                           const std::vector<int64_t> &rowStart,
-                           DenseInverseScalar *rows1d, int64_t myrows,
-                           BlockCyclicMatrix &A)
-  {
-    BlockCyclicLayout &L = A.layout;
-    int P  = grid->ProcessorCount();
-    int me = grid->ThisRank();
-    GRID_ASSERT( (int)rowStart.size() == P+1 );
-    GRID_ASSERT( rowStart[P] == L.N );
-    GRID_ASSERT( rowStart[me+1]-rowStart[me] == myrows );
-    int64_t row0 = rowStart[me];
-    int64_t ld1  = myrows ? myrows : 1;
-
-    std::vector<int64_t> rows, cols, roff, coff;
-    deviceVector<DenseInverseScalar> sbuf(1), rbuf(1);
-
-    ///////////////////////////////////////////////////////////////////////
-    // Self edge: purely local, via a bounce buffer (shares all the code).
-    ///////////////////////////////////////////////////////////////////////
-    EdgeRows(rowStart, me, L, me, rows);
-    EdgeCols(L, me, cols);
-    if ( rows.size() && cols.size() ){
-      uint64_t ne = rows.size()*cols.size();
-      if ( sbuf.size() < ne ) sbuf.resize(ne);
-      std::vector<int64_t> roff2, coff2;
-      Offsets1D(rows, cols, row0, roff, coff);
-      Offsets2D(L,  rows, cols, roff2, coff2);
-      if ( dir > 0 ) {
-        MoveEdge(1, rows1d,     ld1,     roff,  coff,  &sbuf[0]);
-        MoveEdge(0, &A.data[0], L.mloc,  roff2, coff2, &sbuf[0]);
-      } else {
-        MoveEdge(1, &A.data[0], L.mloc,  roff2, coff2, &sbuf[0]);
-        MoveEdge(0, rows1d,     ld1,     roff,  coff,  &sbuf[0]);
-      }
-    }
-
-    ///////////////////////////////////////////////////////////////////////
-    // Tournament over all pairs: odd modulus M, partner = (r - me) mod M.
-    // Every unordered pair meets exactly once; partner==me or >=P is a bye.
-    ///////////////////////////////////////////////////////////////////////
-    int M = (P%2) ? P : P+1;
-    for(int r=0;r<M;r++){
-      int partner = (int)(((int64_t)r - me + 2L*M) % M);
-      if ( partner == me || partner >= P ) continue;
-
-      // outbound edge: my (dir>0 ? 1D rows : 2D data) -> partner
-      // inbound  edge: partner -> my (dir>0 ? 2D data : 1D rows)
-      std::vector<int64_t> orow, ocol, irow, icol;
-      if ( dir > 0 ) { EdgeRows(rowStart, me,      L, partner, orow); EdgeCols(L, partner, ocol);
-                       EdgeRows(rowStart, partner, L, me,      irow); EdgeCols(L, me,      icol); }
-      else           { EdgeRows(rowStart, partner, L, me,      orow); EdgeCols(L, me,      ocol);
-                       EdgeRows(rowStart, me,      L, partner, irow); EdgeCols(L, partner, icol); }
-
-      uint64_t nout = orow.size()*ocol.size();
-      uint64_t nin  = irow.size()*icol.size();
-      if ( !(nout || nin) ) continue;              // both ends compute this identically
-
-      uint64_t nmax = std::max(nout,nin);          // symmetric padded transfer
-      if ( sbuf.size() < nmax ) sbuf.resize(nmax);
-      if ( rbuf.size() < nmax ) rbuf.resize(nmax);
-
-      if ( nout ){
-        if ( dir > 0 ) { Offsets1D(orow, ocol, row0, roff, coff);
-                         MoveEdge(1, rows1d, ld1, roff, coff, &sbuf[0]); }
-        else           { Offsets2D(L, orow, ocol, roff, coff);
-                         MoveEdge(1, &A.data[0], L.mloc, roff, coff, &sbuf[0]); }
-      }
-      grid->SendToRecvFrom((void *)&sbuf[0], partner,
-                           (void *)&rbuf[0], partner,
-                           nmax*sizeof(DenseInverseScalar));
-      if ( nin ){
-        if ( dir > 0 ) { Offsets2D(L, irow, icol, roff, coff);
-                         MoveEdge(0, &A.data[0], L.mloc, roff, coff, &rbuf[0]); }
-        else           { Offsets1D(irow, icol, row0, roff, coff);
-                         MoveEdge(0, rows1d, ld1, roff, coff, &rbuf[0]); }
-      }
-    }
-  }
-
-  static void RowsToCyclic(GridBase *grid, const std::vector<int64_t> &rowStart,
-                           DenseInverseScalar *rows1d, int64_t myrows, BlockCyclicMatrix &A)
-  { Redistribute(+1, grid, rowStart, rows1d, myrows, A); }
-
-  static void CyclicToRows(GridBase *grid, const std::vector<int64_t> &rowStart,
-                           BlockCyclicMatrix &A, DenseInverseScalar *rows1d, int64_t myrows)
-  { Redistribute(-1, grid, rowStart, rows1d, myrows, A); }
-};
-
-NAMESPACE_END(Grid);
@@ -1,446 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/BlockCyclicSchurInverse.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/blas/BatchedInverse.h>
-#include <Grid/algorithms/multigrid/BlockCyclicSumma.h>
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// Stage 3 of the 2D distributed dense inverse: the recursive Schur
-// complement on a block-cyclic matrix, in place.
-//
-// The recursion splits the GLOBAL INDEX RANGE at the block boundary
-// nearest the midpoint -- not the rank range as the retired 1D
-// RecursiveSchurInverse did -- so every rank owns part of every sub-block
-// at every depth, and the ownership gating (inI/inJ, dummy operands,
-// zero-width rank ranges) a 1D scheme needs has no analogue here.
-//
-//   I = [c0,m)   J = [m,c1)      (block-aligned, m the mid block boundary)
-//   1. recurse I  :  A11 -> A11inv                        (in place)
-//   2. Bt = A11inv . A12                                  (scratch, I x J)
-//   3. Ct = A21 . A11inv                                  (scratch, J x I)
-//   4. A22 -= A21 . Bt          == S                      (in place)
-//   5. recurse J  :  S -> Sinv                            (in place)
-//   6. Tt = Sinv . Ct                                     (scratch, J x I)
-//   7. Ut = Bt . Sinv                                     (scratch, I x J)
-//   8. A11 += Ut . Ct           == X11                    (in place)
-//   9. A12 = -Ut ,  A21 = -Tt                             (window copies)
-//
-// SCRATCH SHARING.  Four full-size block-cyclic scratch matrices (Bt, Ct,
-// Tt, Ut) serve the ENTIRE tree, used through windows.  This is safe at
-// every depth because of a window-disjointness invariant:
-//
-//   * every temporary of a node has its row range in one half of the
-//     node's window and its column range in the other (I x J or J x I);
-//   * everything any DESCENDANT touches -- its A windows and its own
-//     temporaries -- has BOTH ranges inside a single half (I x I during
-//     step 1, J x J during step 5).
-//
-// Hence a descendant window and a live ancestor temporary always differ in
-// at least one dimension by disjoint ranges.  Only Bt and Ct are live
-// across the step-5 recursion (Tt, Ut are written after it), and both are
-// covered by the invariant.
-//
-// LEAF.  A leaf is a single diagonal block, and block (b,b) of a
-// block-cyclic layout lives ENTIRELY on rank (b%Pr, b%Pc).  The leaf
-// inversion is therefore purely local -- pack the strided block dense,
-// GridBLASInverse, unpack -- with NO communication and no assembly.
-// Successive leaves cycle over ranks, so leaf work is naturally spread.
-//
-// COMMUNICATION.  Every transfer in the whole inversion is a
-// SendToRecvFrom inside BlockCyclicSumma's rings: pure point-to-point, no
-// collectives on the critical path, deterministic summation order (so
-// repeated inversions are bitwise identical).  ReportTelemetry() is the
-// one optional exception: it performs reductions, and is only ever called
-// explicitly by a caller who wants the numbers.
-//
-// NUMERICS.  No pivoting: every A11 and every Schur complement met on the
-// way down must be non-singular.  The growth telemetry stands in for
-// pivoting.
-///////////////////////////////////////////////////////////////////////////////
-
-class BlockCyclicSchurInverse
-{
-public:
-  BlockCyclicSumma        SUMMA;
-  GridBLASInverse         INV;
-
-  // Telemetry: accumulated LOCALLY, no comms unless ReportTelemetry().
-  double                  telLeafMaxInv;
-  uint64_t                nLeaf;
-  // BIG LEAVES.  Below span s blocks a sub-block lives on <= s of the Pr
-  // process rows / s of the Pc columns; when s is small relative to the grid
-  // the SUMMA rings run on a few ranks while the rest block in their next
-  // SendToRecvFrom.  Instead: gather the (s*nb)^2 sub-block to one rank,
-  // invert locally (inverseLU), scatter back.  Fires only while
-  // span < min(Pr,Pc) -- when the whole grid participates the rings are not
-  // degenerate and gathering would only concentrate memory (and at the top
-  // of the tree would gather the whole matrix).  Larger s concentrates more
-  // memory on the root; smaller s loses ring parallelism.
-  int                     leafSpan = 9;
-  uint64_t                nBigLeaf = 0;  int64_t maxBigW = 0;
-  double                  tBigGather = 0, tBigInv = 0, tBigScatter = 0;
-  uint64_t                nNode;
-  double                  tLeaf;
-  double                  tGemm;      // wall in Multiply calls (comms+gemm)
-  double                  tCopy;
-
-  BlockCyclicSchurInverse()
-  {
-    telLeafMaxInv = 0.0;
-    nLeaf = nNode = 0;
-    tLeaf = tGemm = tCopy = 0.0;
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Window copy-scale:  Dst[i0:i1, j0:j1] = alpha * Src[same window].
-  // Both share one layout, so the local bands coincide; pure local kernel.
-  ///////////////////////////////////////////////////////////////////////////
-  void WindowCopyScale(DenseInverseScalar alpha,
-                       BlockCyclicMatrix &Src, BlockCyclicMatrix &Dst,
-                       int64_t i0, int64_t i1, int64_t j0, int64_t j1)
-  {
-    BlockCyclicLayout &L = Dst.layout;
-    GRID_ASSERT( Src.layout.N==L.N && Src.layout.nb==L.nb );
-    GRID_ASSERT( Src.layout.Pr==L.Pr && Src.layout.Pc==L.Pc );
-    int64_t li0,li1, lj0,lj1;
-    L.RowRange(i0,i1, li0,li1);
-    L.ColRange(j0,j1, lj0,lj1);
-    int64_t m = li1-li0, n = lj1-lj0;
-    if ( !(m && n) ) return;
-    DenseInverseScalar *src = Src.LocalWindow(li0,lj0);
-    DenseInverseScalar *dst = Dst.LocalWindow(li0,lj0);
-    int64_t ldS = Src.layout.mloc;
-    int64_t ldD = L.mloc;
-    tCopy -= usecond();
-    accelerator_for(idx, (uint64_t)(m*n), 1, {
-      int64_t jj = idx / m;
-      int64_t ii = idx - jj*m;
-      dst[ii + jj*ldD] = alpha*src[ii + jj*ldS];
-    });
-    tCopy += usecond();
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Leaf: single diagonal block (b,b), entirely on rank (b%Pr, b%Pc).
-  // Local pack -> dense inverse -> unpack; every other rank does nothing
-  // and needs no synchronisation: the next SUMMA's rings pair them up.
-  ///////////////////////////////////////////////////////////////////////////
-  void Leaf(BlockCyclicMatrix &A, int64_t b)
-  {
-    GRID_TRACE("SchurLeaf");
-    BlockCyclicLayout &L = A.layout;
-    nLeaf++;
-    if ( (int)(b % L.Pr) != L.prow ) return;
-    if ( (int)(b % L.Pc) != L.pcol ) return;
-
-    tLeaf -= usecond();
-    int64_t g0 = b*L.nb;
-    int64_t g1 = std::min(L.N, g0+L.nb);
-    int64_t w  = g1-g0;
-    int64_t lr0,lr1, lc0,lc1;
-    L.RowRange(g0,g1, lr0,lr1);
-    L.ColRange(g0,g1, lc0,lc1);
-    GRID_ASSERT( lr1-lr0 == w );
-    GRID_ASSERT( lc1-lc0 == w );
-
-    // Pack the strided block dense (inverseBatched assumes lda == w).
-    deviceVector<DenseInverseScalar> dense((uint64_t)w*w);
-    {
-      DenseInverseScalar *src = A.LocalWindow(lr0,lc0);
-      DenseInverseScalar *dst = &dense[0];
-      int64_t   ld  = L.mloc;
-      accelerator_for(idx, (uint64_t)(w*w), 1, {
-        int64_t jj = idx / w;
-        int64_t ii = idx - jj*w;
-        dst[ii + jj*w] = src[ii + jj*ld];
-      });
-    }
-    {
-      deviceVector<DenseInverseScalar*> bp(1);
-      std::vector<DenseInverseScalar*>  ptr(1);
-      ptr[0] = &dense[0];
-      acceleratorCopyToDevice(&ptr[0], &bp[0], sizeof(DenseInverseScalar*));
-      INV.inverseBatched(w, bp);
-    }
-    {
-      DenseInverseScalar *src = &dense[0];
-      DenseInverseScalar *dst = A.LocalWindow(lr0,lc0);
-      int64_t   ld  = L.mloc;
-      accelerator_for(idx, (uint64_t)(w*w), 1, {
-        int64_t jj = idx / w;
-        int64_t ii = idx - jj*w;
-        dst[ii + jj*ld] = src[ii + jj*w];
-      });
-    }
-    // Growth telemetry, local only.
-    {
-      std::vector<DenseInverseScalar> h((uint64_t)w*w);
-      acceleratorCopyFromDevice(&dense[0], &h[0], h.size()*sizeof(DenseInverseScalar));
-      double mx = 0.0;
-      for(auto &z : h){
-        double re=z.real(), im=z.imag();
-        mx = std::max(mx, re*re+im*im);
-      }
-      telLeafMaxInv = std::max(telLeafMaxInv, std::sqrt(mx));
-    }
-    tLeaf += usecond();
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // BIG LEAF on block range [b0,b1): gather to root = owner of block (b0,b0),
-  // invert there, scatter back.  Rank q's piece of the sub-block is the
-  // contiguous local window RowRange(c0,c1) x ColRange(c0,c1); its local row
-  // ii maps to global row (brq0 + (ii/nb)*Pr)*nb + ii%nb where brq0 is q's
-  // first block row >= b0 (closed form: no tables).  Transport is pairwise
-  // SendToRecvFrom with root (symmetric byte count: the reverse direction
-  // carries a same-size dummy -- a leaf-local cost, accepted for simplicity).
-  ///////////////////////////////////////////////////////////////////////////
-  static int64_t FirstBlock(int64_t b0, int p, int Pg){ int64_t r = ((b0 % Pg) <= p) ? b0 - (b0 % Pg) + p : b0 - (b0 % Pg) + Pg + p; return r; }
-  void BigLeaf(BlockCyclicMatrix &A, int64_t b0, int64_t b1)
-  {
-    GRID_TRACE("SchurBigLeaf");
-    BlockCyclicLayout &L = A.layout;
-    GridBase *grid = A.grid;
-    const int Pr=L.Pr, Pc=L.Pc, nb=(int)L.nb;
-    GRID_ASSERT( L.me == L.prow*Pc + L.pcol );          // rank convention shared with the SUMMA rings
-    const int64_t c0 = b0*L.nb, c1 = std::min(L.N, b1*L.nb), W = c1-c0;
-    const int root = (int)((b0%Pr)*Pc + (b0%Pc));
-    const int me   = L.me;
-    nBigLeaf++; maxBigW = std::max(maxBigW, W);
-
-    // my piece
-    int64_t lr0,lr1,lc0,lc1; L.RowRange(c0,c1,lr0,lr1); L.ColRange(c0,c1,lc0,lc1);
-    const int64_t mq = lr1-lr0, nq = lc1-lc0;
-
-    deviceVector<DenseInverseScalar> dense;            // root only: W x W column major
-    deviceVector<DenseInverseScalar> piece, dummy;     // piece: my mq x nq contiguous; dummy: reverse-direction filler
-    if ( me == root ) dense.resize((uint64_t)W*W);
-
-    auto pack_piece = [&](DenseInverseScalar *dst, int64_t m, int64_t n, int64_t r0, int64_t cc0){
-      DenseInverseScalar *src = A.LocalWindow(r0,cc0); const int64_t ld = L.mloc;
-      accelerator_for(idx,(uint64_t)(m*n),1,{ int64_t jj=idx/m, ii=idx-jj*m; dst[ii+jj*m] = src[ii+jj*ld]; });
-    };
-    auto unpack_piece = [&](DenseInverseScalar *src, int64_t m, int64_t n, int64_t r0, int64_t cc0){
-      DenseInverseScalar *dst = A.LocalWindow(r0,cc0); const int64_t ld = L.mloc;
-      accelerator_for(idx,(uint64_t)(m*n),1,{ int64_t jj=idx/m, ii=idx-jj*m; dst[ii+jj*ld] = src[ii+jj*m]; });
-    };
-    // root: piece of rank q  <->  dense, via the closed-form block map
-    auto root_place = [&](DenseInverseScalar *pc, int64_t m, int64_t n, int q, int to_dense){
-      const int pq=q/Pc, cq=q%Pc;
-      const int64_t brq0=FirstBlock(b0,pq,Pr), bcq0=FirstBlock(b0,cq,Pc);
-      DenseInverseScalar *dn = &dense[0]; const int64_t WW=W, NB=nb, PR=Pr, PC=Pc, C0=c0;
-      accelerator_for(idx,(uint64_t)(m*n),1,{
-        int64_t jj=idx/m, ii=idx-jj*m;
-        int64_t gr = (brq0 + (ii/NB)*PR)*NB + ii%NB - C0;
-        int64_t gc = (bcq0 + (jj/NB)*PC)*NB + jj%NB - C0;
-        if ( to_dense ) dn[gr + gc*WW] = pc[ii+jj*m]; else pc[ii+jj*m] = dn[gr + gc*WW];
-      });
-    };
-    auto piece_dims = [&](int q, int64_t &m, int64_t &n){
-      const int pq=q/Pc, cq=q%Pc;
-      m = BlockCyclicLayout::NumLocal(c1,L.nb,pq,Pr) - BlockCyclicLayout::NumLocal(c0,L.nb,pq,Pr);
-      n = BlockCyclicLayout::NumLocal(c1,L.nb,cq,Pc) - BlockCyclicLayout::NumLocal(c0,L.nb,cq,Pc);
-    };
-
-    // ---- gather ----
-    tBigGather -= usecond();
-    if ( mq*nq ) { piece.resize((uint64_t)mq*nq); dummy.resize((uint64_t)mq*nq); pack_piece(&piece[0],mq,nq,lr0,lc0); accelerator_barrier(); }
-    if ( me == root ) {
-      deviceVector<DenseInverseScalar> stage;
-      for(int q=0;q<Pr*Pc;q++){
-        int64_t m,n; piece_dims(q,m,n); if ( !(m*n) ) continue;
-        if ( q == root ) { root_place(&piece[0],m,n,q,1); continue; }
-        if ( stage.size() < (uint64_t)(m*n) ) stage.resize((uint64_t)m*n);
-        deviceVector<DenseInverseScalar> junk((uint64_t)m*n);
-        grid->SendToRecvFrom((void *)&junk[0], q, (void *)&stage[0], q, (uint64_t)m*n*sizeof(DenseInverseScalar));
-        root_place(&stage[0],m,n,q,1);
-      }
-      accelerator_barrier();
-    } else if ( mq*nq ) {
-      grid->SendToRecvFrom((void *)&piece[0], root, (void *)&dummy[0], root, (uint64_t)mq*nq*sizeof(DenseInverseScalar));
-    }
-    tBigGather += usecond();
-
-    // ---- invert on root: blocked getrf_64 + identity getrs_64 ----
-    tBigInv -= usecond();
-    if ( me == root ) INV.inverseLU(W, &dense[0]);
-    tBigInv += usecond();
-
-    // ---- scatter ----
-    tBigScatter -= usecond();
-    if ( me == root ) {
-      deviceVector<DenseInverseScalar> stage;
-      for(int q=0;q<Pr*Pc;q++){
-        int64_t m,n; piece_dims(q,m,n); if ( !(m*n) ) continue;
-        if ( q == root ) { root_place(&piece[0],m,n,q,0); accelerator_barrier(); continue; }
-        if ( stage.size() < (uint64_t)(m*n) ) stage.resize((uint64_t)m*n);
-        deviceVector<DenseInverseScalar> junk((uint64_t)m*n);
-        root_place(&stage[0],m,n,q,0); accelerator_barrier();
-        grid->SendToRecvFrom((void *)&stage[0], q, (void *)&junk[0], q, (uint64_t)m*n*sizeof(DenseInverseScalar));
-      }
-    } else if ( mq*nq ) {
-      grid->SendToRecvFrom((void *)&dummy[0], root, (void *)&piece[0], root, (uint64_t)mq*nq*sizeof(DenseInverseScalar));
-    }
-    if ( mq*nq ) { unpack_piece(&piece[0],mq,nq,lr0,lc0); accelerator_barrier(); }
-    tBigScatter += usecond();
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // The recursion, on global BLOCK range [b0,b1).  SPMD: every rank calls
-  // with identical arguments; there is no ownership gating to get wrong.
-  ///////////////////////////////////////////////////////////////////////////
-  void SchurNode(BlockCyclicMatrix &A,
-                 BlockCyclicMatrix &Bt, BlockCyclicMatrix &Ct,
-                 BlockCyclicMatrix &Tt, BlockCyclicMatrix &Ut,
-                 int64_t b0, int64_t b1)
-  {
-    BlockCyclicLayout &L = A.layout;
-    int64_t span = b1-b0;
-    GRID_ASSERT( span >= 1 );
-    if ( span == 1 ) { Leaf(A, b0); return; }
-    if ( span <= leafSpan && span < std::min(L.Pr,L.Pc) ) { BigLeaf(A, b0, b1); return; }
-    GRID_TRACE("SchurNode");
-    nNode++;
-
-    int64_t bm = b0 + span/2;
-    int64_t c0 = b0*L.nb;
-    int64_t m  = bm*L.nb;
-    int64_t c1 = std::min(L.N, b1*L.nb);
-    DenseInverseScalar one (1.0,0.0), mone(-1.0,0.0), zero(0.0,0.0);
-
-    // 1. A11 -> A11inv
-    SchurNode(A,Bt,Ct,Tt,Ut, b0,bm);
-
-    tGemm -= usecond();
-    // 2. Bt[I,J] = A11inv . A12
-    SUMMA.Multiply(one,  A,  A,  zero, Bt, c0,m,  m,c1,  c0,m );
-    // 3. Ct[J,I] = A21 . A11inv
-    SUMMA.Multiply(one,  A,  A,  zero, Ct, m,c1,  c0,m,  c0,m );
-    // 4. A22 -= A21 . Bt   (the Schur complement, in place)
-    SUMMA.Multiply(mone, A,  Bt, one,  A,  m,c1,  m,c1,  c0,m );
-    tGemm += usecond();
-
-    // 5. S -> Sinv          (Bt, Ct live across this call: see invariant)
-    SchurNode(A,Bt,Ct,Tt,Ut, bm,b1);
-
-    tGemm -= usecond();
-    // 6. Tt[J,I] = Sinv . Ct
-    SUMMA.Multiply(one,  A,  Ct, zero, Tt, m,c1,  c0,m,  m,c1 );
-    // 7. Ut[I,J] = Bt . Sinv
-    SUMMA.Multiply(one,  Bt, A,  zero, Ut, c0,m,  m,c1,  m,c1 );
-    // 8. A11 += Ut . Ct
-    SUMMA.Multiply(one,  Ut, Ct, one,  A,  c0,m,  c0,m,  m,c1 );
-    tGemm += usecond();
-
-    // 9. Off-diagonal signs
-    { GRID_TRACE("SchurCopy");
-    WindowCopyScale(mone, Ut, A, c0,m,  m,c1);
-    WindowCopyScale(mone, Tt, A, m,c1,  c0,m);
-    }
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // PUBLIC ENTRY.  In-place inverse of the whole matrix.  Scratch (4x the
-  // matrix footprint) is allocated here and released on return.
-  ///////////////////////////////////////////////////////////////////////////
-  void Invert(BlockCyclicMatrix &A)
-  {
-    BlockCyclicLayout &L = A.layout;
-    GRID_ASSERT( L.N >= 1 );
-    int64_t nblocks = (L.N + L.nb - 1)/L.nb;
-
-    BlockCyclicMatrix Bt(A.grid, L.N, L.nb, L.Pr, L.Pc);
-    BlockCyclicMatrix Ct(A.grid, L.N, L.nb, L.Pr, L.Pc);
-    BlockCyclicMatrix Tt(A.grid, L.N, L.nb, L.Pr, L.Pc);
-    BlockCyclicMatrix Ut(A.grid, L.N, L.nb, L.Pr, L.Pc);
-
-    telLeafMaxInv = 0.0;
-    nLeaf = nNode = 0;
-    tLeaf = tGemm = tCopy = 0.0;
-
-    SchurNode(A, Bt,Ct,Tt,Ut, 0, nblocks);
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // Optional, and the ONLY place any reduction happens: call it if you
-  // want the numbers, never from Invert.
-  ///////////////////////////////////////////////////////////////////////////
-  void ReportTelemetry(GridBase *grid)
-  {
-    RealD mx = telLeafMaxInv;
-    grid->GlobalMax(mx);
-    std::cout << GridLogMessage << "BlockCyclicSchurInverse:"
-              << "  nodes " << nNode << "  leaves " << nLeaf
-              << "  max|leafinv| " << mx
-              << "  (boss secs: gemm+comms " << tGemm/1.0e6
-              << "  leaf " << tLeaf/1.0e6
-              << "  copy " << tCopy/1.0e6 << ")"
-              << std::endl;
-    if ( nBigLeaf ) {
-      RealD ti = tBigInv/1.0e6; grid->GlobalMax(ti);     // inverse runs on the root of each leaf: report the max over ranks
-      std::cout << GridLogMessage << "BlockCyclicSchurInverse: BIG LEAVES (span " << leafSpan
-                << ", inverseLU): " << nBigLeaf
-                << " leaves, max W " << maxBigW
-                << "  boss secs: gather " << tBigGather/1.0e6 << " scatter " << tBigScatter/1.0e6
-                << "  inverse (max over ranks) " << ti << std::endl;
-    }
-    // SUMMA breakdown: boss-rank seconds, plus the ring/gemm time spread over
-    // ranks (min/max) -- skew shows as max >> min.
-    RealD ring = (SUMMA.tRingA+SUMMA.tRingB)/1.0e6;
-    RealD rmin = -ring, rmax = ring; grid->GlobalMax(rmin); grid->GlobalMax(rmax); rmin = -rmin;   // no GlobalMin: max of negation
-    RealD gmin = -SUMMA.tGemm/1.0e6, gmax = SUMMA.tGemm/1.0e6; grid->GlobalMax(gmin); grid->GlobalMax(gmax); gmin = -gmin;
-    double gb  = SUMMA.bytesRing/1.0e9;
-    std::cout << GridLogMessage << "BlockCyclicSumma:"
-              << " multiplies " << SUMMA.nMultiply << " gemms " << SUMMA.nGemm << " ring msgs " << SUMMA.nRingMsg
-              << " | boss secs: alloc " << SUMMA.tAlloc/1.0e6
-              << " pack " << SUMMA.tPack/1.0e6
-              << " ringA " << SUMMA.tRingA/1.0e6 << " ringB " << SUMMA.tRingB/1.0e6
-              << " gemm " << SUMMA.tGemm/1.0e6
-              << " | ring min/max over ranks " << rmin << "/" << rmax
-              << " gemm min/max " << gmin << "/" << gmax
-              << " | ring bytes/rank " << gb << " GB -> " << (ring>0 ? gb/ring : 0.0) << " GB/s/rank (boss)"
-              << std::endl;
-    // Ring time decomposed by message size (boss rank; every rank sends the
-    // same sequence of sizes).  Time is wall time inside SendToRecvFrom, so it
-    // includes waiting for the partner -- a bucket whose GB/s is far below the
-    // probe's for the same size is wait, not wire.
-    std::cout << GridLogMessage << "BlockCyclicSumma ring histogram (boss):  size-bucket  msgs  GB  xfer-secs  GB/s  %time" << std::endl;
-    std::streamsize oldprec = std::cout.precision();
-    for(int b=0;b<SUMMA.NHIST;b++){
-      if ( !SUMMA.histN[b] ) continue;
-      double sec = SUMMA.histUs[b]/1.0e6, g = SUMMA.histBytes[b]/1.0e9;
-      double lo = (double)(1ull<<b);
-      char sz[32]; if (lo>=1048576) snprintf(sz,32,"%6.1f MB",lo/1048576.); else if (lo>=1024) snprintf(sz,32,"%6.1f KB",lo/1024.); else snprintf(sz,32,"%6.0f B ",lo);
-      std::cout << GridLogMessage << "   >=" << sz
-                << std::setw(8) << SUMMA.histN[b]
-                << std::setw(10) << std::setprecision(3) << g
-                << std::setw(9) << std::setprecision(3) << sec
-                << std::setw(9) << std::setprecision(3) << (sec>0 ? g/sec : 0.0)
-                << std::setw(8) << std::setprecision(3) << (ring>0 ? 100.0*sec/ring : 0.0);
-      std::cout << std::endl;
-    }
-    std::cout.precision(oldprec);
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,349 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/BlockCyclicSumma.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/multigrid/BlockCyclic.h>
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// Stage 2 of the 2D distributed dense inverse: the windowed SUMMA product
-//
-//   C[i0:i1, j0:j1]  <-  beta C[i0:i1, j0:j1]
-//                      + alpha A[i0:i1, k0:k1] . B[k0:k1, j0:j1]
-//
-// on block-cyclic matrices sharing one BlockCyclicLayout.  All ranges are
-// BLOCK ALIGNED (multiples of nb, or N itself at the top end): stage 3's
-// recursion splits on block boundaries, so nothing else is ever needed, and
-// alignment makes every local window a contiguous band of local storage
-// (BlockCyclic.h RangeToLocal, Test_blockcyclic T7).
-//
-// Transport is PURE POINT-TO-POINT: SendToRecvFrom on explicit world ranks
-// computed from the row-major rank convention.  No collectives of any kind
-// -- no sub-communicators, no broadcast, no allgather -- by design: the
-// collective pathologies measured on this machine (MPI_Allgatherv at
-// ~0.18 MB/s with skewed counts, mpir_request.h:508 aborts, allreduce at
-// 39% of the P2P rate) motivated this implementation.  SendToRecvFrom is
-// the most exercised device-buffer path in Grid and the only one never
-// implicated.
-//
-// Algorithm: round-based ring allgather SUMMA.  The k range is processed in
-// rounds of Pc consecutive global blocks.  Within a round
-//
-//   * process column c owns at most one A panel  (blocks s with s%Pc == c);
-//     the Pc panels circulate around each process-ROW ring in Pc-1 steps;
-//   * process row r owns up to ceil(Pc/Pr) B panels (blocks s%Pr == r);
-//     they circulate around each process-COLUMN ring in Pr-1 steps;
-//   * every rank then accumulates  Cloc += alpha * Apanel_s . Bpanel_s
-//     for each block s of the round, in ascending s: a fixed summation
-//     order, so REPEATED RUNS ARE BITWISE IDENTICAL (no reduction, no
-//     order ambiguity -- the property the P2P doctrine buys).
-//
-// Ring chunks are PADDED to a fixed size (full nb panels, fixed
-// panels-per-origin): SendToRecvFrom carries one byte count for both
-// directions, so symmetric transfers eliminate every variable-size edge
-// case at a worst-case ~1/Pc extra volume on ragged rounds.  Padding is
-// never read: GEMMs address only the leading nb_s x width of each slot.
-//
-// Per-rank received volume: (k-extent) * (mloc_i + nloc_j) elements --
-// the N^2 (1/Pr + 1/Pc) SUMMA optimum, ~sqrt(P)/2 below the 1D scheme.
-///////////////////////////////////////////////////////////////////////////////
-
-class BlockCyclicMatrix
-{
-public:
-  GridBase              *grid;      // borrowed, never owned
-  BlockCyclicLayout      layout;
-  deviceVector<DenseInverseScalar> data;      // column major, ld = layout.mloc
-
-  BlockCyclicMatrix(GridBase *g, int64_t N, int64_t nb, int Pr, int Pc)
-    : grid(g),
-      layout(N, nb, Pr, Pc, g->ThisRank())
-  {
-    GRID_ASSERT( Pr*Pc == g->ProcessorCount() );
-    uint64_t sz = (uint64_t)layout.mloc*layout.nloc;
-    data.resize( sz ? sz : 1 );
-  }
-
-  DenseInverseScalar *LocalWindow(int64_t li, int64_t lj)
-  {
-    return &data[0] + li + lj*layout.mloc;
-  }
-
-  /////////////////////////////////////////////////////////////////////////
-  // TEST-SCALE import/export of a replicated global matrix (host, O(N^2)
-  // loops, one collective in Export).  For unit tests and the stage-3
-  // oracle only; production data enters through the direct block-cyclic
-  // import, never through these.
-  /////////////////////////////////////////////////////////////////////////
-  void ImportGlobal(const std::vector<DenseInverseScalar> &G)
-  {
-    int64_t N = layout.N;
-    GRID_ASSERT( (int64_t)G.size() == N*N );
-    std::vector<DenseInverseScalar> h((uint64_t)layout.mloc*layout.nloc, DenseInverseScalar(0.0,0.0));
-    for(int64_t j=0;j<N;j++){
-      for(int64_t i=0;i<N;i++){
-        if ( layout.Owns(i,j) ) h[layout.LocalOffset(i,j)] = G[i + j*N];
-      }
-    }
-    if ( h.size() )
-      acceleratorCopyToDevice(&h[0], &data[0], h.size()*sizeof(DenseInverseScalar));
-  }
-  void ExportGlobal(std::vector<DenseInverseScalar> &G)
-  {
-    int64_t N = layout.N;
-    G.assign((uint64_t)N*N, DenseInverseScalar(0.0,0.0));
-    std::vector<DenseInverseScalar> h((uint64_t)layout.mloc*layout.nloc);
-    if ( h.size() )
-      acceleratorCopyFromDevice(&data[0], &h[0], h.size()*sizeof(DenseInverseScalar));
-    for(int64_t j=0;j<N;j++){
-      for(int64_t i=0;i<N;i++){
-        if ( layout.Owns(i,j) ) G[i + j*N] = h[layout.LocalOffset(i,j)];
-      }
-    }
-    if ( N ) grid->GlobalSumVector((DenseInverseScalar *)&G[0], (int)(N*N)); // zero-fill: exact
-  }
-};
-
-class BlockCyclicSumma
-{
-public:
-  GridBLAS BLAS;
-
-  // Per-rank telemetry (boss-rank seconds when printed; no reductions here).
-  // Every Multiply is: buffer alloc, pack panels, ring A along the process
-  // row, ring B along the process column, then the local GEMMs.  The rings
-  // are synchronous SendToRecvFrom, so tRing is time the GPU is idle unless
-  // a future version overlaps them with the GEMMs.
-  // PERSISTENT ring buffers: allocated once (grow-only) and reused by every
-  // Multiply, so the device addresses handed to MPI never change.  Fresh
-  // per-call buffers rotated through the caching allocator's blocks, and a
-  // GPU-direct RDMA registration cache keyed on address then re-registers
-  // per message: measured 1.26 GB/s/rank on 13 MB ring messages (production,
-  // GRID_ALLOC_NCACHE_LARGE=64) against 62 s total for the same inverse when
-  // hipMalloc returned a stable address.
-  deviceVector<DenseInverseScalar> Abuf;
-  deviceVector<DenseInverseScalar> Bbuf;
-  double   tAlloc=0, tPack=0, tRingA=0, tRingB=0, tGemm=0;
-  uint64_t bytesRing=0, nRingMsg=0, nMultiply=0, nGemm=0;
-  // Per-message-size histogram (bucket = floor(log2 bytes)): count, bytes,
-  // microseconds -- decomposes the ring time by packet size so a low average
-  // GB/s can be attributed (many small latency-bound messages vs slow large
-  // ones vs partner-wait).  Time is wall time inside SendToRecvFrom, so a
-  // bucket far below the wire rate for its size is wait, not wire.
-  static const int NHIST=48;
-  uint64_t histN[NHIST]={0}, histBytes[NHIST]={0}; double histUs[NHIST]={0};
-  void HistAdd(uint64_t bytes, double us){ int b=0; while((bytes>>b)>1) b++; histN[b]++; histBytes[b]+=bytes; histUs[b]+=us; }
-  void ResetTelemetry(void){ tAlloc=tPack=tRingA=tRingB=tGemm=0; bytesRing=nRingMsg=nMultiply=nGemm=0; for(int b=0;b<NHIST;b++){histN[b]=histBytes[b]=0; histUs[b]=0;} }
-
-  static int Overlap(int64_t a0,int64_t a1,int64_t b0,int64_t b1)
-  { return (a0 < b1) && (b0 < a1); }
-
-  void Multiply(DenseInverseScalar alpha,
-                BlockCyclicMatrix &A,
-                BlockCyclicMatrix &B,
-                DenseInverseScalar beta,
-                BlockCyclicMatrix &C,
-                int64_t i0, int64_t i1,
-                int64_t j0, int64_t j1,
-                int64_t k0, int64_t k1)
-  {
-    BlockCyclicLayout &L = C.layout;
-    GridBase *grid = C.grid;
-    const int64_t N  = L.N;
-    const int64_t nb = L.nb;
-    const int     Pr = L.Pr,   Pc   = L.Pc;
-    const int     prow = L.prow, pcol = L.pcol;
-
-    ///////////////////////////////////////////////////////////////////////
-    // Conformability: one layout, one communicator, aligned ranges.
-    ///////////////////////////////////////////////////////////////////////
-    auto same = [&](BlockCyclicLayout &X){
-      GRID_ASSERT( X.N==N ); GRID_ASSERT( X.nb==nb );
-      GRID_ASSERT( X.Pr==Pr ); GRID_ASSERT( X.Pc==Pc );
-      GRID_ASSERT( X.me==L.me );
-    };
-    same(A.layout); same(B.layout);
-    GRID_ASSERT( A.grid==grid ); GRID_ASSERT( B.grid==grid );
-    auto aligned = [&](int64_t g0,int64_t g1){
-      GRID_ASSERT( 0<=g0 ); GRID_ASSERT( g0<=g1 ); GRID_ASSERT( g1<=N );
-      GRID_ASSERT( g0%nb==0 ); GRID_ASSERT( (g1%nb==0)||(g1==N) );
-    };
-    aligned(i0,i1); aligned(j0,j1); aligned(k0,k1);
-    GRID_ASSERT( k1 > k0 );                    // pure scaling not supported here
-    // In-place windows are legal only if the written window is disjoint
-    // from anything read (stage 3 uses this; make violation loud).
-    if ( &C==&A ) GRID_ASSERT( !Overlap(j0,j1,k0,k1) );
-    if ( &C==&B ) GRID_ASSERT( !Overlap(i0,i1,k0,k1) );
-
-    ///////////////////////////////////////////////////////////////////////
-    // My local bands of the three windows (contiguous: T7).
-    ///////////////////////////////////////////////////////////////////////
-    int64_t li0,li1, lj0,lj1;
-    L.RowRange(i0,i1, li0,li1);
-    L.ColRange(j0,j1, lj0,lj1);
-    const int64_t mloc_i = li1-li0;            // my rows of the i window
-    const int64_t nloc_j = lj1-lj0;            // my cols of the j window
-
-    const int64_t kb0 = k0/nb;
-    const int64_t kb1 = (k1+nb-1)/nb;          // block-aligned or ==N: exact
-    const int64_t S   = (Pc + Pr - 1)/Pr;      // max B panels per origin row
-
-    ///////////////////////////////////////////////////////////////////////
-    // Round buffers, padded to fixed slot sizes (see header comment).
-    //   A: Pc slots of mloc_i x nb   (slot c = panel of the block owned by c)
-    //   B: Pr slots of S x (nb x nloc_j)
-    ///////////////////////////////////////////////////////////////////////
-    const uint64_t slotA  = (uint64_t)mloc_i*nb;
-    const uint64_t slotB1 = (uint64_t)nb*nloc_j;         // one panel
-    const uint64_t slotB  = (uint64_t)S*slotB1;
-    nMultiply++;
-    tAlloc -= usecond();
-    if ( Abuf.size() < std::max<uint64_t>(slotA*Pc,1) ) Abuf.resize( std::max<uint64_t>(slotA*Pc,1) );
-    if ( Bbuf.size() < std::max<uint64_t>(slotB*Pr,1) ) Bbuf.resize( std::max<uint64_t>(slotB*Pr,1) );
-    tAlloc += usecond();
-
-    deviceVector<DenseInverseScalar *> ap(1), bp(1), cp(1);
-    std::vector<DenseInverseScalar *>  ptr(1);
-
-    int firstblock = 1;
-    for(int64_t r0=kb0; r0<kb1; r0+=Pc){       // rounds of Pc k-blocks
-      int64_t r1 = std::min(kb1, r0+Pc);
-
-      /////////////////////////////////////////////////////////////////////
-      // Pack MY panels of this round into my origin slots.
-      /////////////////////////////////////////////////////////////////////
-      tPack -= usecond();
-      { GRID_TRACE("SummaPack");
-      for(int64_t s=r0; s<r1; s++){
-        int64_t nb_s = L.BlockSize(s);
-        if ( (int)(s%Pc) == pcol && mloc_i ){  // my A panel: block-column s
-          int64_t lc0, lc1;
-          L.ColRange(s*nb, std::min(N,(s+1)*nb), lc0, lc1);
-          GRID_ASSERT( lc1-lc0 == nb_s );
-          DenseInverseScalar *src = A.LocalWindow(li0, lc0);
-          DenseInverseScalar *dst = &Abuf[0] + slotA*pcol;
-          int64_t   ld  = A.layout.mloc;
-          int64_t   m   = mloc_i;
-          accelerator_for(idx, (uint64_t)(m*nb_s), 1, {
-            int64_t jj = idx / m;
-            int64_t ii = idx - jj*m;
-            dst[ii + jj*m] = src[ii + jj*ld];
-          });
-        }
-        if ( (int)(s%Pr) == prow && nloc_j ){  // my B panel: block-row s
-          int64_t lr0, lr1;
-          L.RowRange(s*nb, std::min(N,(s+1)*nb), lr0, lr1);
-          GRID_ASSERT( lr1-lr0 == nb_s );
-          int64_t idxs = (s - r0 - ((prow - r0%Pr + Pr) % Pr)) / Pr; // my panel # in round
-          GRID_ASSERT( idxs >= 0 ); GRID_ASSERT( idxs < S );
-          DenseInverseScalar *src = B.LocalWindow(lr0, lj0);
-          DenseInverseScalar *dst = &Bbuf[0] + slotB*prow + slotB1*idxs;
-          int64_t   ld  = B.layout.mloc;
-          int64_t   nn  = nloc_j;
-          accelerator_for(idx, (uint64_t)(nb_s*nn), 1, {
-            int64_t jj = idx / nb_s;
-            int64_t ii = idx - jj*nb_s;
-            dst[ii + jj*nb_s] = src[ii + jj*ld];
-          });
-        }
-      }
-      accelerator_barrier();
-      }
-      tPack += usecond();
-
-      /////////////////////////////////////////////////////////////////////
-      // Ring allgather along my process ROW: Pc-1 symmetric steps.  At
-      // step t send the slot of origin (pcol-t+1), receive origin (pcol-t).
-      /////////////////////////////////////////////////////////////////////
-      if ( Pc > 1 && slotA ){
-        GRID_TRACE("SummaRingA");
-        tRingA -= usecond();
-        int dest = prow*Pc + (pcol+1)%Pc;
-        int src  = prow*Pc + (pcol-1+Pc)%Pc;
-        for(int t=1;t<Pc;t++){
-          int cs = (pcol - t + 1 + Pc*Pc) % Pc;
-          int cr = (pcol - t     + Pc*Pc) % Pc;
-          double tm = usecond();
-          grid->SendToRecvFrom((void *)(&Abuf[0]+slotA*cs), dest,
-                               (void *)(&Abuf[0]+slotA*cr), src,
-                               slotA*sizeof(DenseInverseScalar));
-          HistAdd(slotA*sizeof(DenseInverseScalar), usecond()-tm);
-          bytesRing += slotA*sizeof(DenseInverseScalar); nRingMsg++;
-        }
-        tRingA += usecond();
-      }
-      /////////////////////////////////////////////////////////////////////
-      // Ring allgather along my process COLUMN: Pr-1 symmetric steps.
-      /////////////////////////////////////////////////////////////////////
-      if ( Pr > 1 && slotB ){
-        GRID_TRACE("SummaRingB");
-        tRingB -= usecond();
-        int dest = ((prow+1)%Pr)*Pc + pcol;
-        int src  = ((prow-1+Pr)%Pr)*Pc + pcol;
-        for(int t=1;t<Pr;t++){
-          int rs = (prow - t + 1 + Pr*Pr) % Pr;
-          int rr = (prow - t     + Pr*Pr) % Pr;
-          double tm = usecond();
-          grid->SendToRecvFrom((void *)(&Bbuf[0]+slotB*rs), dest,
-                               (void *)(&Bbuf[0]+slotB*rr), src,
-                               slotB*sizeof(DenseInverseScalar));
-          HistAdd(slotB*sizeof(DenseInverseScalar), usecond()-tm);
-          bytesRing += slotB*sizeof(DenseInverseScalar); nRingMsg++;
-        }
-        tRingB += usecond();
-      }
-
-      /////////////////////////////////////////////////////////////////////
-      // Local update, ascending s: fixed order, bitwise-reproducible.
-      /////////////////////////////////////////////////////////////////////
-      tGemm -= usecond();
-      { GRID_TRACE("SummaGEMM");
-      for(int64_t s=r0; s<r1; s++){
-        int64_t nb_s = L.BlockSize(s);
-        if ( !(mloc_i && nloc_j && nb_s) ) { firstblock = 0; continue; }
-        int cA = (int)(s%Pc);
-        int rB = (int)(s%Pr);
-        int64_t idxs = (s - r0 - ((rB - r0%Pr + Pr) % Pr)) / Pr;
-        DenseInverseScalar beta_use = firstblock ? beta : DenseInverseScalar(1.0,0.0);
-        firstblock = 0;
-
-        ptr[0] = &Abuf[0] + slotA*cA;
-        acceleratorCopyToDevice(&ptr[0], &ap[0], sizeof(DenseInverseScalar *));
-        ptr[0] = &Bbuf[0] + slotB*rB + slotB1*idxs;
-        acceleratorCopyToDevice(&ptr[0], &bp[0], sizeof(DenseInverseScalar *));
-        ptr[0] = C.LocalWindow(li0, lj0);
-        acceleratorCopyToDevice(&ptr[0], &cp[0], sizeof(DenseInverseScalar *));
-
-        BLAS.gemmBatched(GridBLAS_OP_N, GridBLAS_OP_N,
-                         (int)mloc_i, (int)nloc_j, (int)nb_s,
-                         alpha,    ap, (int)mloc_i,
-                                   bp, (int)nb_s,
-                         beta_use, cp, (int)C.layout.mloc);
-        BLAS.synchronise();
-        nGemm++;
-      }
-      }
-      tGemm += usecond();
-    }
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,877 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/algorithms/multigrid/DenseCoarseMatrix.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-#include <Grid/algorithms/blas/BatchedBlas.h>
-#include <Grid/algorithms/blas/BatchedInverse.h>
-#include <Grid/algorithms/multigrid/BlockCyclicSchurInverse.h>
-#include <Grid/algorithms/multigrid/BlockCyclicRedistribute.h>
-
-#include <unordered_map>
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// DenseCoarseMatrix: a coarsened operator treated as a DENSE matrix -- explicit,
-// row-distributed A^{-1} of a GeneralCoarsenedMatrix.
-//
-//  - Stencil -> dense DIRECT IMPORT.  The coarse operator IS the dense matrix
-//    unrolled: Dense[(s,a),(s+shift_p,b)] += A[p][s]_{a,b}.  Rows of my sites are
-//    assembled from purely LOCAL _A[p] data: no operator applies, no comms.
-//    ACCUMULATE (+=) because on short axes distinct shifts wrap to the same
-//    neighbour.  An IMPORT CERTIFICATE compares the dense apply against Op.M on a
-//    NON-CONSTANT vector (a constant one cannot see a shift-sign error).
-//
-//  - Inversion is END-TO-END fp64 through the 2D block-cyclic recursive Schur
-//    complement (BlockCyclicSchurInverse): fp64 rank-major import ->
-//    RowsToCyclic -> in-place recursion (pure point-to-point SUMMA rings and
-//    local leaves; bitwise reproducible) -> CyclicToRows -> ONE terminal
-//    rounding into the fp32 apply slab.  Distributed at every N and P.
-//
-//  - Split-K apply through GridBLAS.gemmBatched with EXPLICIT leading dimensions
-//    (arXiv:2409.03904 fig 11): the tiny-output/huge-K GEMM Y = slab^T X becomes
-//    SPLITK chunk-GEMMs by pointer offset into the resident slab (lda = N),
-//    partials reduced in one accelerator_for.  The source vector is assembled by
-//    a cartesian ring ALLGATHER of device buffers (pure P2P; ~8x fewer bytes
-//    than a padded allreduce, and no collective size cliffs).  Platform-agnostic:
-//    deviceVector + GridBLAS run the SAME code on HIP/CUDA/SYCL and CPU(Eigen).
-//
-// VERIFY ||A Ainv x - x||/||x|| certifies the DEVICE slab + split-K path at the
-// end of Import, since the single-RHS apply routes through the same core.
-//
-// Tensor-depth agnostic: site scalar objects treated as contiguous coarse
-// scalars (ComplexF or ComplexD, following the coefficient precision)
-// (iScalar wrappers add no data), so any MG level's coarse operator imports.
-//////////////////////////////////////////////////////////////////////////////////////
-//
-// Depends on a coarse operator only to extract its matrix elements; thereafter
-// it is given a coarse vector and applies the inverse. Import() is a template
-// member so any of the coarse classes will do, and the type of a
-// DenseCoarseMatrix does not record which one built it.
-//
-template<class CComplex,int nbasis>
-class DenseCoarseMatrix : public LinearFunction<Lattice<iVector<CComplex,nbasis> > > {
-public:
-  typedef iVector<CComplex,nbasis >           siteVector;
-  typedef Lattice<siteVector>                 CoarseVector;
-  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-  typedef CoarseVector                        Field;
-  using LinearFunction<Field>::operator();
-  typedef typename Field::vector_object vobj;
-  typedef typename vobj::scalar_object  sobj;
-  typedef typename CoarseMatrix::vector_object Mvobj;
-  typedef typename Mvobj::scalar_object        Msobj;
-  // Scalar of the coarse site objects (ComplexF or ComplexD): the apply slab
-  // is always fp32 and the inversion always fp64, but the SOURCE of both --
-  // the coarse operator's matrix elements -- carries this precision.
-  typedef typename GridTypeMapper<CComplex>::scalar_type CoarseScalar;
-
-  GridBase *grid;
-  int      nd;
-  int64_t  N;                       // dense rank = gSites * nbasis
-  int      lsites;                  // my local sites
-  int64_t  nrows;                   // my rows = lsites * nbasis
-  std::vector<Coordinate> myLcoor;  // local coordinate of my site ss
-  std::vector<int64_t>    myGsite;  // global lex site index of my site ss
-  std::vector<ComplexF>   slab;     // nrows x N row-major: A during setup, rows of A^{-1} after
-
-  static const int MRHS_MAX = 32;
-  static const int SPLITK   = 32;   // requested split-K chunk count, snapped DOWN to a divisor of N
-
-  // Apply machinery: resident slab + persistent buffers + AOT split-K pointers.
-  GridBLAS BLAS;
-  deviceVector<ComplexF>  dSlab;
-  deviceVector<ComplexF>  dX;       // N x MRHS_MAX
-  deviceVector<ComplexF>  dY;       // nrows x MRHS_MAX
-  deviceVector<ComplexF>  dG;       // N x MRHS_MAX lex-major staging for the allgather
-  deviceVector<int>       dLex2Rank;// lex index of a process coordinate -> its rank (allgather block order -> row-block order)
-  deviceVector<int64_t>   dRm2G;    // rank-major index (rank*nrows + ss*nbasis + b) -> global column (gsite*nbasis + b) of x / the slab
-  int                     myLex;
-  deviceVector<ComplexF>  dPartial; // NK x (nrows x MRHS_MAX)
-  deviceVector<ComplexF*> aptrs;    // slab K-chunk pointers   (lda = N)
-  deviceVector<ComplexF*> xptrs;    // X    K-chunk pointers   (ldb = N)
-  deviceVector<ComplexF*> cptrs;    // partial buffers         (ldc = nrows)
-  std::vector<ComplexF>   hX;
-  std::vector<ComplexF>   hY;
-  int NK;                           // split-K chunk count (divides N)
-
-  // Resident device memory: the apply slab and its staging.  deviceVector is
-  // not evictable, so this counts against the hard budget, not the cache.
-  uint64_t DeviceBytes(void)
-  {
-    return (uint64_t)(dSlab.capacity()+dX.capacity()+dY.capacity()+dG.capacity()+dPartial.capacity())*sizeof(ComplexF)
-         + (uint64_t)dLex2Rank.capacity()*sizeof(int)
-         + (uint64_t)dRm2G.capacity()*sizeof(int64_t);
-  }
-
-  DenseCoarseMatrix(GridBase *g)
-    : grid(g)
-  {
-    GRID_ASSERT( sizeof(sobj)  == nbasis*sizeof(CoarseScalar) );
-    GRID_ASSERT( sizeof(Msobj) == nbasis*nbasis*sizeof(CoarseScalar) );
-    nd     = grid->_ndimension;
-    N      = grid->gSites() * nbasis;
-    lsites = grid->lSites();
-    nrows  = (int64_t)lsites * nbasis;
-
-    std::cout << GridLogMessage << "DenseCoarseMatrix: N = " << N
-              << " (" << grid->gSites() << " sites x " << nbasis << ")"
-              << "  rows/rank = " << nrows
-              << "  slab = " << (double)nrows*N*sizeof(ComplexF)/1024./1024. << " MB/rank"
-              << std::endl;
-
-    ////////////////////////////////////////////////////////////////////
-    // Enumerate my sites: local coords and global lexicographic indices
-    ////////////////////////////////////////////////////////////////////
-    Coordinate ldims = grid->LocalDimensions();
-    Coordinate gdims = grid->GlobalDimensions();
-    myLcoor.resize(lsites);
-    myGsite.resize(lsites);
-    for(int ss=0; ss<lsites; ss++){
-      Coordinate lcoor(nd);
-      Lexicographic::CoorFromIndex(lcoor, ss, ldims);
-      Coordinate gcoor(nd);
-      for(int d=0; d<nd; d++) gcoor[d] = grid->_lstart[d] + lcoor[d];
-      int64_t gsite;
-      Lexicographic::IndexFromCoor(gcoor, gsite, gdims);
-      myLcoor[ss] = lcoor;
-      myGsite[ss] = gsite;
-    }
-
-    slab.resize((uint64_t)nrows * N);
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // The only place a coarse operator is needed: pull its elements, invert,
-  // and make the slab resident. Any class exposing Geometry() and
-  // ExtractMatrix(p,A) will do -- single RHS or either multiRHS.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void Import(CoarseOp &Op)
-  {
-    double t0 = usecond();
-    {
-      ImportDense(Op);        // slab <- my rows of A   (LOCAL, no comms)
-      ImportCertificate(Op);  // dense apply == Op.M, before inversion
-      InvertDense(Op);        // slab <- my rows of A^{-1}
-      double t1 = usecond();
-      std::cout << GridLogMessage << "DenseCoarseMatrix: import+invert took "
-                << (t1-t0)/1.0e6 << " s" << std::endl;
-    }
-
-    ////////////////////////////////////////////////////////////////////
-    // Device residency + persistent apply buffers + AOT split-K pointers
-    ////////////////////////////////////////////////////////////////////
-    {
-      uint64_t sbytes = (uint64_t)nrows * N * sizeof(ComplexF);
-      dSlab.resize((uint64_t)nrows*N);
-      acceleratorCopyToDevice(&slab[0],&dSlab[0],sbytes);
-
-      // Split-K chunk count, snapped DOWN to a divisor of N.
-      NK = 1;
-      for(int j=1;j<=SPLITK;j++) if ( (N % j) == 0 ) NK = j;
-      int64_t Kc = N / NK;
-
-      dX.resize((uint64_t)N*MRHS_MAX);
-      dY.resize((uint64_t)nrows*MRHS_MAX);
-      dPartial.resize((uint64_t)NK*nrows*MRHS_MAX);
-      hX.resize((uint64_t)N*MRHS_MAX);
-      hY.resize((uint64_t)nrows*MRHS_MAX);
-
-      aptrs.resize(NK); xptrs.resize(NK); cptrs.resize(NK);
-      std::vector<ComplexF*> h(NK);
-      for(int j=0;j<NK;j++) h[j] = &dSlab[0]    + (uint64_t)j*Kc;              // K-offset, lda=N
-      acceleratorCopyToDevice(&h[0],&aptrs[0],NK*sizeof(ComplexF*));
-      for(int j=0;j<NK;j++) h[j] = &dX[0]       + (uint64_t)j*Kc;              // K-offset, ldb=N
-      acceleratorCopyToDevice(&h[0],&xptrs[0],NK*sizeof(ComplexF*));
-      for(int j=0;j<NK;j++) h[j] = &dPartial[0] + (uint64_t)j*nrows*MRHS_MAX;  // compact, ldc=nrows
-      acceleratorCopyToDevice(&h[0],&cptrs[0],NK*sizeof(ComplexF*));
-
-      {
-        dG.resize((uint64_t)N*MRHS_MAX);
-        // allgather delivers blocks in lexicographic-coordinate order; the row
-        // blocks of x are in RANK order.  Same table as BuildRankMajorMap.
-        int P = grid->ProcessorCount();
-        std::vector<int> l2r(P);
-        for(int lp=0; lp<P; lp++){ Coordinate pc(nd); Lexicographic::CoorFromIndex(pc, lp, grid->_processors); l2r[lp] = grid->RankFromProcessorCoor(pc); }
-        dLex2Rank.resize(P);
-        acceleratorCopyToDevice(&l2r[0], &dLex2Rank[0], P*sizeof(int));
-        myLex = CartesianLexIndex(grid);
-        GRID_ASSERT( l2r[myLex] == grid->ThisRank() );
-        // x and the slab columns are in GLOBAL-SITE order (hX[myGsite*nbasis+b]);
-        // the gathered blocks are in RANK-MAJOR order (rank*nrows + ss*nbasis + b).
-        // The two coincide only on one rank, so scatter through the inverse map.
-        std::vector<int64_t> g2rm; BuildRankMajorMap(g2rm);
-        std::vector<int64_t> rm2g(N); for(int64_t g=0; g<N; g++) rm2g[g2rm[g]] = g;
-        for(int ss=0; ss<lsites; ss++) GRID_ASSERT( rm2g[(int64_t)grid->ThisRank()*nrows + (int64_t)ss*nbasis] == myGsite[ss]*nbasis );
-        dRm2G.resize(N);
-        acceleratorCopyToDevice(&rm2g[0], &dRm2G[0], N*sizeof(int64_t));
-      }
-      std::cout << GridLogMessage << "DenseCoarseMatrix: slab resident on device ("
-                << sbytes/1024./1024. << " MB/rank), split-K NK=" << NK << " (Kc=" << Kc
-                << "); DEVICE cartesian ring ALLGATHER (P2P)" << std::endl;
-    }
-
-    ////////////////////////////////////////////////////////////////////
-    // VERIFY: || A (Ainv x) - x || / ||x|| through the DEVICE split-K core.
-    ////////////////////////////////////////////////////////////////////
-    {
-      Field x(grid); Field y(grid); Field z(grid);
-      x = CoarseScalar(1.0,0.0);
-      double ta = usecond();
-      (*this)(x, y);
-      double tb = usecond();
-      ApplyOracle(Op, y, z);
-      z = z - x;
-      RealD rel = std::sqrt(norm2(z)/norm2(x));
-      std::cout << GridLogMessage << "DenseCoarseMatrix: VERIFY ||A Ainv x - x||/||x|| = "
-                << rel << "   (one apply took " << (tb-ta)/1000.0 << " ms)" << std::endl;
-      GRID_ASSERT(rel < 1.0e-2);
-    }
-    std::cout << GridLogMessage << "DenseCoarseMatrix: setup complete, total "
-              << (usecond()-t0)/1.0e6 << " s" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Apply the source operator to a D dimensional field, whichever kind it is.
-  //
-  // A multiRHS operator lives on the D+1 grid, so drive it with several right
-  // hand sides at once: slice r carries (r+1)*in, and linearity says the
-  // results must scale likewise. One apply, and unlike a single rhs check it
-  // also catches rhs mixing. Cheap check, not a production path.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void ApplyOracle(CoarseOp &Op,const Field &in, Field &out)
-  {
-    if ( Op.Grid() == grid ) { Op.M(in,out); return; }
-
-    GridBase *mgrid = Op.Grid();
-    GRID_ASSERT(mgrid->_ndimension == nd+1);
-    int nr = mgrid->_fdimensions[0];
-
-    Field min(mgrid), mout(mgrid);
-    for(int r=0;r<nr;r++){
-      Field scaled(grid);
-      scaled = CoarseScalar(r+1.0,0.0)*in;
-      InsertSliceFast(scaled,min,r,0);
-    }
-
-    Op.M(min,mout);
-
-    ExtractSliceFast(out,mout,0,0);
-    for(int r=1;r<nr;r++){
-      Field sr(grid),d(grid);
-      ExtractSliceFast(sr,mout,r,0);
-      d = sr - CoarseScalar(r+1.0,0.0)*out;
-      RealD rel = std::sqrt(norm2(d)/norm2(sr));
-      // Slices differ by rounding amplified by the operator's conditioning
-      // when the product cancels (A applied to A^-1 x): the tolerance follows
-      // the coarse precision (fp32 measured ~5e-6 here).  A genuine rhs
-      // mix-up is O(1).
-      const RealD otol = (sizeof(CoarseScalar)==sizeof(ComplexF)) ? 1.0e-4 : 1.0e-6;
-      if ( rel >= otol ) {
-        std::cout << GridLogMessage << "DenseCoarseMatrix: oracle rhs "<<r
-                  <<" inconsistent with rhs 0, rel "<<rel<<std::endl;
-      }
-      GRID_ASSERT( rel < otol );
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 1. Direct stencil -> dense import of MY ROWS of A (no comms):
-  //      Dense[(s,a),(wrap(s+shift_p),b)] += A[p][s]_{a,b}
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void ImportDense(CoarseOp &Op)
-  {
-    double t = -usecond();
-    Coordinate gdims = grid->GlobalDimensions();
-
-    uint64_t nelem = (uint64_t)nrows * N;
-    thread_for(i, nelem, { slab[i] = ComplexF(0.0,0.0); });
-
-    for(int p=0; p<Op.Geometry().npoint; p++){
-      Coordinate shift = Op.Geometry().shifts[p];
-      // _A[p] is PADDED after ExchangeCoarseLinks (end of CoarsenOperator):
-      // extract the unpadded field before peeking with unpadded coordinates
-      // (exactly as MultiGeneralCoarsenedMatrix::CopyMatrix does).
-      CoarseMatrix Aun(grid);  Op.ExtractMatrix(p,Aun);
-      autoView(Av, Aun, CpuRead);
-      thread_for(ss, lsites, {
-        Coordinate ncoor(nd);
-        for(int d=0; d<nd; d++){
-          int64_t g = grid->_lstart[d] + myLcoor[ss][d] + shift[d];
-          ncoor[d] = (int)((g % gdims[d] + gdims[d]) % gdims[d]);
-        }
-        int64_t nsite;
-        Lexicographic::IndexFromCoor(ncoor, nsite, gdims);
-        Msobj m;
-        peekLocalSite(m, Av, myLcoor[ss]);
-        CoarseScalar *md = (CoarseScalar *)&m;
-        // The operator contracts out(s,b) = sum_a A[p](s)(a,b) in(nbr,a)
-        // (GeneralCoarsenedMatrix.h Mult kernel): the stored site matrix
-        // acts TRANSPOSED, so element (a,b) lands at dense row (s,b),
-        // column (nbr,a).
-        for(int b=0; b<nbasis; b++){
-          ComplexF *row = &slab[(uint64_t)(ss*nbasis+b)*N + nsite*nbasis];
-          for(int a=0; a<nbasis; a++)
-            row[a] += ComplexF(md[a*nbasis+b]);   // += : wrapped shifts may collide
-        }
-      });
-    }
-    t += usecond();
-
-    // Structural diagnostic: identically-zero rows of my slab (a healthy
-    // coarse operator has none; dead rows mean a rank-deficient import
-    // or operator and the inverse will be NaN).
-    int64_t zrows = 0;
-    for(int64_t r=0; r<nrows; r++)
-    {
-      double mx = 0.0;
-      const ComplexF *row = &slab[(uint64_t)r*N];
-      for(int64_t j=0; j<N; j++)
-      {
-        mx = std::max(mx, (double)abs(row[j]));
-      }
-      if ( mx < 1.0e-30 ) zrows++;
-    }
-    RealD gz = (RealD)zrows;
-    grid->GlobalSumVector(&gz, 1);
-
-    std::cout << GridLogMessage << "DenseCoarseMatrix: stencil->dense import took "
-              << t/1.0e6 << " s  (" << Op.Geometry().npoint << " points, local, no comms)"
-              << "  zero rows " << (int64_t)gz << "/" << N << std::endl;
-
-    // Debug: coordinate pattern of live sites (mechanism fingerprint)
-    if ( (int64_t)gz > 0 )
-    {
-      int shown = 0;
-      for(int ss=0; ss<lsites && shown<24; ss++)
-      {
-        double mx = 0.0;
-        const ComplexF *row = &slab[(uint64_t)(ss*nbasis)*N];
-        for(int64_t j=0; j<N; j++)
-        {
-          mx = std::max(mx, (double)abs(row[j]));
-        }
-        if ( mx > 1.0e-30 )
-        {
-          std::cout << GridLogMessage << "DenseCoarseMatrix: LIVE site ss=" << ss
-                    << " lcoor " << myLcoor[ss] << std::endl;
-          shown++;
-        }
-      }
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 2. IMPORT CERTIFICATE: dense rows vs Op.M on a NON-CONSTANT vector.
-  //    (Constant x has x[s+d]==x[s-d]: blind to a shift-sign error.)
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void ImportCertificate(CoarseOp &Op)
-  {
-    Field x(grid); Field Ax(grid); Field Dx(grid);
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      for(int b=0; b<nbasis; b++){
-        double ph = 0.37*(double)(myGsite[ss]*nbasis+b);
-        ((CoarseScalar *)&s)[b] = CoarseScalar(std::cos(ph),std::sin(0.61*ph));
-      }
-      pokeLocalSite(s, x, myLcoor[ss]);
-    }
-    // gather full x (zero-fill + exact GlobalSum), dense rows on host
-    std::vector<ComplexD> xh((uint64_t)N, ComplexD(0.0,0.0));
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      peekLocalSite(s, x, myLcoor[ss]);
-      for(int b=0; b<nbasis; b++) xh[ myGsite[ss]*nbasis + b ] = ComplexD(((CoarseScalar *)&s)[b]);
-    }
-    grid->GlobalSumVector(&xh[0], (int)N);
-    std::vector<ComplexD> yh(nrows);
-    thread_for(r, nrows, {
-      ComplexD acc(0.0,0.0);
-      const ComplexF *row = &slab[(uint64_t)r * N];
-      for(int64_t j=0; j<N; j++) acc += ComplexD(row[j]) * xh[j];
-      yh[r] = acc;
-    });
-    for(int ss=0; ss<lsites; ss++){
-      sobj s;
-      for(int b=0; b<nbasis; b++) ((CoarseScalar *)&s)[b] = CoarseScalar(yh[ss*nbasis+b]);
-      pokeLocalSite(s, Dx, myLcoor[ss]);
-    }
-    ApplyOracle(Op, x, Ax);
-    Field d(grid); d = Dx - Ax;
-    RealD rel = std::sqrt(norm2(d)/norm2(Ax));
-    std::cout << GridLogMessage << "DenseCoarseMatrix: IMPORT CERTIFICATE ||Dense x - A x||/||A x|| = "
-              << rel << std::endl;
-    if ( rel >= 1.0e-3 ) {
-      std::cout << GridLogMessage << "DenseCoarseMatrix: IMPORT CERTIFICATE FAILED. If O(1), the "
-                << "stencil shift-sign convention of the coarse operator has changed: "
-                << "the import in ImportDense/ImportDenseForInversion must change with it"
-                << std::endl;
-    }
-    GRID_ASSERT(rel < 1.0e-3);
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 3a. Global column -> rank-major column map, computed LOCALLY.
-  //    Rank-major ordering: rank q's rows/columns are the contiguous
-  //    block [q*nrows, (q+1)*nrows), ordered by q's local site index
-  //    (uniform local volumes make ownership arithmetic exact).
-  //    MPI_Cart_rank is queried ONCE PER RANK (serial, P calls) into a
-  //    lex-processor table; the per-site sweep is then pure arithmetic.
-  ////////////////////////////////////////////////////////////////////
-  void BuildRankMajorMap(std::vector<int64_t> &g2rm)
-  {
-    int P = grid->ProcessorCount();
-    Coordinate pdims = grid->_processors;
-    Coordinate gdims = grid->GlobalDimensions();
-    Coordinate ldims = grid->LocalDimensions();
-
-    std::vector<int> lexp2rank(P);
-    for(int lp=0; lp<P; lp++)
-    {
-      Coordinate pcoor(nd);
-      Lexicographic::CoorFromIndex(pcoor, lp, pdims);
-      lexp2rank[lp] = grid->RankFromProcessorCoor(pcoor);
-    }
-
-    int64_t gsites = grid->gSites();
-    g2rm.resize(N);
-    thread_for(gsite, gsites, {
-      Coordinate gcoor(nd);
-      Coordinate pcoor(nd);
-      Coordinate lcoor(nd);
-      Lexicographic::CoorFromIndex(gcoor, gsite, gdims);
-      for(int d=0; d<nd; d++)
-      {
-        pcoor[d] = gcoor[d]/ldims[d];
-        lcoor[d] = gcoor[d]-pcoor[d]*ldims[d];
-      }
-      int64_t lexp;
-      int64_t lsite;
-      Lexicographic::IndexFromCoor(pcoor, lexp,  pdims);
-      Lexicographic::IndexFromCoor(lcoor, lsite, ldims);
-      int64_t base = (int64_t)lexp2rank[lexp]*nrows + lsite*nbasis;
-      for(int b=0; b<nbasis; b++)
-      {
-        g2rm[(uint64_t)gsite*nbasis + b] = base + b;
-      }
-    });
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 3b. Direct stencil -> rank-major import of MY ROWS of A in the
-  //    inversion precision (DenseInverseScalar): the stencil source is
-  //    read once, straight into the buffer the Schur recursion factorises,
-  //    never via the fp32 apply slab.  Same
-  //    loop/sign/accumulate/transposed-contraction discipline as
-  //    ImportDense; output is column-major rows x N with columns in
-  //    rank-major order (g2rm).
-  //    ALWAYS-ON CERTIFICATE: this import, rounded, must agree with
-  //    the fp32 slab entry at the corresponding global column, over the
-  //    WHOLE of my rows (few ulp: wrapped-shift collisions accumulate in
-  //    different precision order).  NaN-proof: non-finite entries are
-  //    counted explicitly since max() silently masks NaN.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void ImportDenseForInversion(CoarseOp &Op, BlockRows &S, std::vector<int64_t> &g2rm)
-  {
-    Coordinate gdims = grid->GlobalDimensions();
-
-    std::vector<DenseInverseScalar> h((uint64_t)nrows*N, DenseInverseScalar(0.0,0.0));
-    for(int p=0; p<Op.Geometry().npoint; p++)
-    {
-      Coordinate shift = Op.Geometry().shifts[p];
-      CoarseMatrix Aun(grid);  Op.ExtractMatrix(p,Aun);
-      autoView(Av, Aun, CpuRead);
-      thread_for(ss, lsites, {
-        Coordinate ncoor(nd);
-        for(int d=0; d<nd; d++)
-        {
-          int64_t g = grid->_lstart[d] + myLcoor[ss][d] + shift[d];
-          ncoor[d] = (int)((g % gdims[d] + gdims[d]) % gdims[d]);
-        }
-        int64_t nsite;
-        Lexicographic::IndexFromCoor(ncoor, nsite, gdims);
-        Msobj m;
-        peekLocalSite(m, Av, myLcoor[ss]);
-        CoarseScalar *md = (CoarseScalar *)&m;
-        // Transposed contraction as ImportDense: (a,b) lands at
-        // row (s,b), column (nbr,a); column index in rank-major order.
-        for(int a=0; a<nbasis; a++)
-        {
-          int64_t jj = g2rm[ nsite*nbasis + a ];
-          for(int b=0; b<nbasis; b++)
-          {
-            h[(uint64_t)(ss*nbasis+b) + (uint64_t)jj*nrows] += DenseInverseScalar(md[a*nbasis+b]);
-          }
-        }
-      });
-    }
-
-    // Certificate vs the fp32 slab (slab holds A at this point)
-    double  mx   = 0.0;
-    int64_t nbad = 0;
-    for(int64_t i=0; i<nrows; i++)
-    {
-      for(int64_t gcol=0; gcol<N; gcol++)
-      {
-        ComplexD d64 = ComplexD(h[(uint64_t)(i + g2rm[gcol]*nrows)]);
-        ComplexF f32 = slab[(uint64_t)i*N + gcol];
-        double dev = abs(ComplexD(f32) - d64);
-        if ( !std::isfinite(dev) ) nbad++;
-        else mx = std::max(mx, dev);
-      }
-    }
-    RealD gmx  = mx;
-    RealD gbad = (RealD)nbad;
-    grid->GlobalMax(gmx);
-    grid->GlobalSumVector(&gbad, 1);
-    std::cout << GridLogMessage << "DenseCoarseMatrix: inversion-source import certificate "
-              << "max|A_inv - A_slab| = " << gmx
-              << "  non-finite entries " << (int64_t)gbad << std::endl;
-    GRID_ASSERT( gbad == 0 );
-    GRID_ASSERT( gmx < 1.0e-5 );
-
-    S.Resize(nrows, N);
-    acceleratorCopyToDevice(&h[0], &S.data[0], (uint64_t)nrows*N*sizeof(DenseInverseScalar));
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 3c. The inverse: distributed recursive Schur, end to end in the
-  //    inversion precision (DenseInverseScalar, a configure-time choice):
-  //    stencil -> rank-major import -> recursion -> ONE terminal rounding
-  //    into the fp32 apply slab.  Everything downstream (device
-  //    residency, split-K apply, VERIFY) is fp32 regardless.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void InvertDense(CoarseOp &Op)
-  {
-    double t1 = usecond();
-    int P  = grid->ProcessorCount();
-    int me = grid->ThisRank();
-
-    // Uniform local volumes => contiguous uniform ownership
-    std::vector<int64_t> rowStart(P+1);
-    for(int r=0; r<=P; r++)
-    {
-      rowStart[r] = (int64_t)r*nrows;
-    }
-    GRID_ASSERT( rowStart[P] == N );
-
-    std::vector<int64_t> g2rm;
-    BuildRankMajorMap(g2rm);
-
-    // Self-certifying map: my own global rows land at my rank-major slots
-    for(int ss=0; ss<lsites; ss++)
-    {
-      for(int a=0; a<nbasis; a++)
-      {
-        GRID_ASSERT( g2rm[ myGsite[ss]*nbasis + a ] == (int64_t)me*nrows + ss*nbasis + a );
-      }
-    }
-
-    BlockRows S;
-    ImportDenseForInversion(Op, S, g2rm);
-
-    ////////////////////////////////////////////////////////////////
-    // The 2D block-cyclic recursion (BlockCyclicSchurInverse).
-    // Everything in it -- redistribution, SUMMA rings, leaves -- is
-    // point-to-point SendToRecvFrom; no collectives at all.  Block size
-    // nb = rows-per-rank makes the redistribution edges maximally
-    // regular.
-    ////////////////////////////////////////////////////////////////
-    double t2, t3;
-    {
-      int Pr,Pc;
-      BlockCyclicLayout::ChooseProcessGrid(P, Pr, Pc);
-      int64_t nb = nrows;
-      GRID_ASSERT( nb >= 1 );
-      std::cout << GridLogMessage << "DenseCoarseMatrix: 2D SCHUR invert, process grid "
-                << Pr << " x " << Pc << "  nb " << nb
-                << "  (pure P2P: redistribute + SUMMA rings + local leaves)" << std::endl;
-      BlockCyclicMatrix A2(grid, N, nb, Pr, Pc);
-      BlockCyclicSchurInverse RSI2;
-      t2 = usecond();
-      BlockCyclicRedistribute::RowsToCyclic(grid, rowStart, &S.data[0], nrows, A2);
-      RSI2.Invert(A2);
-      BlockCyclicRedistribute::CyclicToRows(grid, rowStart, A2, &S.data[0], nrows);
-      t3 = usecond();
-      RSI2.ReportTelemetry(grid);
-    }
-
-    // The single terminal rounding: fp64 inverse -> fp32 apply slab
-    // (row-major, global columns)
-    {
-      std::vector<DenseInverseScalar> h((uint64_t)nrows*N);
-      acceleratorCopyFromDevice(&S.data[0], &h[0], (uint64_t)nrows*N*sizeof(DenseInverseScalar));
-      thread_for(gcol, N, {
-        int64_t jj = g2rm[gcol];
-        for(int64_t i=0; i<nrows; i++)
-        {
-          slab[(uint64_t)i*N + gcol] = ComplexF(h[(uint64_t)(i + jj*nrows)]);
-        }
-      });
-    }
-    double t4 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: SCHUR "
-              << (sizeof(DenseInverseScalar)==sizeof(ComplexF) ? "fp32" : "fp64")
-              << " distributed invert took "
-              << (t4-t1)/1.0e6 << " s (recursion " << (t3-t2)/1.0e6 << " s)" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // CORE apply on packed data: hX[N x nr] (zero-filled, my sites only)
-  // -> ring allgather -> split-K GEMM against the resident slab ->
-  // reduce partials -> hY[nrows x nr] (column major).  Platform-agnostic:
-  // deviceVector + GridBLAS (Eigen fallback on CPU builds).
-  // tprof (optional): per-phase microseconds {allgather, H2D, gemm+reduce,
-  // D2H}, printed by the caller on GridLogPerformance.
-  ////////////////////////////////////////////////////////////////////
-  void SlabApplyPacked(int nr, double *tprof)
-  {
-    GRID_TRACE("DenseSlabApply");
-    GRID_ASSERT(nr <= MRHS_MAX);
-    uint64_t nY = (uint64_t)nrows * nr;
-    int64_t  Kc = N / NK;
-    double t1 = usecond();
-    double t2, t3;
-    {
-      // ALLGATHER: x is not a reduction -- every rank owns the rows of x at
-      // global columns myGsite[ss]*nbasis+b (scattered by site coordinate, NOT
-      // a contiguous block) and needs all of it.  Only MY rows go host->device
-      // (nrows x nr, ~15 KB at nr=1), packed rank-major [r][ss*nbasis+b],
-      // gathered along the process grid, then scattered through rm2g into the
-      // column-major dX (ld = N, global-site columns) the split-K GEMM reads.
-      const uint64_t chunk = (uint64_t)nrows*nr;              // my block: [r][ss*nbasis+b]
-      { GRID_TRACE("DenseH2D");
-        std::vector<ComplexF> hG(chunk);
-        for(int r=0;r<nr;r++)
-          for(int ss=0; ss<lsites; ss++)
-            memcpy(&hG[(uint64_t)r*nrows + (uint64_t)ss*nbasis], &hX[(uint64_t)r*N + (uint64_t)myGsite[ss]*nbasis], nbasis*sizeof(ComplexF));
-        acceleratorCopyToDevice(&hG[0], &dG[(uint64_t)myLex*chunk], chunk*sizeof(ComplexF));   // my slot is my LEX index
-      }
-      t2 = usecond();
-      { GRID_TRACE("DenseAllgather");
-        CartesianRingAllGather(grid, (ComplexF *)&dG[0], chunk);
-        // scatter lex block L=[r][i] -> dX[r*N + rm2g[rank(L)*nrows + i]]
-        ComplexF *g = &dG[0]; ComplexF *x = &dX[0]; int *l2r = &dLex2Rank[0]; int64_t *rm2g = &dRm2G[0];
-        const int64_t nrw = nrows; const int64_t NN = N; const int nrr = nr;
-        accelerator_for(idx, (uint64_t)N*nr, 1, {
-          int64_t r = idx / NN;  int64_t gi = idx - r*NN;
-          int64_t L = gi / nrw;  int64_t i  = gi - L*nrw;
-          x[r*NN + rm2g[(int64_t)l2r[L]*nrw + i]] = g[L*(nrw*nrr) + r*nrw + i];
-        });
-      }
-      t3 = usecond();
-    }
-    // Y = op(slab,T) . X : row-major slab (nrows x N) == col-major A^T
-    // (N x nrows, lda=N) => transpose gives the nrows x N operator.
-    // Split-K: NK chunk-GEMMs by pointer offset (AOT lists), then reduce.
-    ComplexF one (1.0,0.0);
-    ComplexF zero(0.0,0.0);
-    { GRID_TRACE("DenseSplitKGEMM");
-      BLAS.gemmBatched(GridBLAS_OP_T, GridBLAS_OP_N,
-                       (int)nrows, nr, (int)Kc,
-                       one,  aptrs, (int)N,
-                             xptrs, (int)N,
-                       zero, cptrs, (int)nrows);
-      BLAS.synchronise();
-      ComplexF *pp = &dPartial[0];
-      ComplexF *py = &dY[0];
-      uint64_t stride = (uint64_t)nrows*MRHS_MAX;
-      int nk = NK;
-      accelerator_for(i, nY, 1, {
-        ComplexF acc(0.0,0.0);
-        for(int j=0;j<nk;j++) acc += pp[(uint64_t)j*stride + i];
-        py[i] = acc;
-      });
-    }
-    double t4 = usecond();
-    { GRID_TRACE("DenseD2H");
-      acceleratorCopyFromDevice(&dY[0],&hY[0],nY*sizeof(ComplexF));
-    }
-    double t5 = usecond();
-    if (tprof) {
-      tprof[0] = t3-t2;                        // allgather
-      tprof[1] = t2-t1;                        // H2D
-      tprof[2] = t4-t3;                        // gemm+reduce
-      tprof[3] = t5-t4;                        // D2H
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Single-RHS apply (also the VERIFY path => certifies device slab).
-  ////////////////////////////////////////////////////////////////////
-  virtual void operator()(const Field &src, Field &psi)
-  {
-    GRID_TRACE("DenseApply1");
-    uint64_t nX = (uint64_t)N;
-    { GRID_TRACE("DensePack");
-      thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-      for(int ss=0; ss<lsites; ss++){
-        sobj s;
-        peekLocalSite(s, src, myLcoor[ss]);
-        for(int b=0; b<nbasis; b++)
-          hX[ myGsite[ss]*nbasis + b ] = ComplexF(((CoarseScalar *)&s)[b]);
-      }
-    }
-    SlabApplyPacked(1, nullptr);
-    { GRID_TRACE("DenseUnpack");
-      for(int ss=0; ss<lsites; ss++){
-        sobj s;
-        for(int b=0; b<nbasis; b++)
-          ((CoarseScalar *)&s)[b] = CoarseScalar(hY[ss*nbasis + b]);
-        pokeLocalSite(s, psi, myLcoor[ss]);
-      }
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Defect of an applied inverse. Was a DENSE_CC_CHECK block inside
-  // operator(), but that is virtual and cannot take an operator, so the
-  // caller now asks for it explicitly.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void CheckApply(CoarseOp &Op,const Field &src,const Field &psi)
-  {
-    Field tmp(grid);
-    Op.M(psi, tmp);
-    tmp = tmp - src;
-    std::cout << GridLogMessage << "DenseCoarseMatrix: apply defect ||A x - b||/||b|| = "
-              << std::sqrt(norm2(tmp)/norm2(src)) << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Batched (vector-of-fields) apply.
-  ////////////////////////////////////////////////////////////////////
-  void ApplyBatch(std::vector<Field> &src, std::vector<Field> &psi)
-  {
-    int nr = src.size();
-    GRID_ASSERT(nr <= MRHS_MAX);
-    double t0 = usecond();
-    uint64_t nX = (uint64_t)N*nr;
-    { GRID_TRACE("DensePack");
-      thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-      for(int rr=0; rr<nr; rr++){
-        for(int ss=0; ss<lsites; ss++){
-          sobj s;
-          peekLocalSite(s, src[rr], myLcoor[ss]);
-          for(int b=0; b<nbasis; b++)
-            hX[ (uint64_t)rr*N + myGsite[ss]*nbasis + b ] = ComplexF(((CoarseScalar *)&s)[b]);
-        }
-      }
-    }
-    SlabApplyPacked(nr, nullptr);
-    { GRID_TRACE("DenseUnpack");
-      for(int rr=0; rr<nr; rr++){
-        for(int ss=0; ss<lsites; ss++){
-          sobj s;
-          for(int b=0; b<nbasis; b++)
-            ((CoarseScalar *)&s)[b] = CoarseScalar(hY[(uint64_t)rr*nrows + (ss*nbasis+b)]);
-          pokeLocalSite(s, psi[rr], myLcoor[ss]);
-        }
-      }
-    }
-    double t1 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: batched apply " << nr << " rhs took "
-              << (t1-t0)/1000.0 << " ms  (" << (t1-t0)/1000.0/nr << " ms/rhs)" << std::endl;
-  }
-
-  template<class CoarseOp>
-  void CheckApplyBatch(CoarseOp &Op,std::vector<Field> &src,std::vector<Field> &psi,int nr)
-  {
-    Field tmp(grid);
-    for(int rr=0; rr<nr; rr++){
-      Op.M(psi[rr], tmp);
-      tmp = tmp - src[rr];
-      std::cout << GridLogMessage << "DenseCoarseMatrix: batch defect["<<rr<<"] = "
-                << std::sqrt(norm2(tmp)/norm2(src[rr])) << std::endl;
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 6D mrhs apply: operates DIRECTLY on the packed 6D field (rhs = dim 0).
-  ////////////////////////////////////////////////////////////////////
-  void ApplyBatch6D(const Field &in6, Field &out6, int nr)
-  {
-    GRID_ASSERT(nr <= MRHS_MAX);
-    GRID_ASSERT(in6.Grid()->_ndimension == nd+1);   // {rhs, s, x,y,z,t}
-    double t0 = usecond();
-    Field &in = const_cast<Field &>(in6);
-    uint64_t nX = (uint64_t)N * nr;
-    thread_for(i, nX, { hX[i]=ComplexF(0.0,0.0); });
-    { GRID_TRACE("DensePack");
-      autoView(iv, in, CpuRead);
-      Coordinate c6(nd+1);
-      for(int ss=0; ss<lsites; ss++){
-        for(int d=0; d<nd; d++) c6[d+1] = myLcoor[ss][d];
-        for(int rr=0; rr<nr; rr++){
-          c6[0] = rr;
-          sobj s;
-          peekLocalSite(s, iv, c6);
-          for(int b=0; b<nbasis; b++)
-            hX[(uint64_t)rr*N + myGsite[ss]*nbasis + b] = ComplexF(((CoarseScalar *)&s)[b]);
-        }
-      }
-    }
-    double t1 = usecond();
-    double tprof[4];
-    SlabApplyPacked(nr, tprof);
-    double t5 = usecond();
-    { GRID_TRACE("DenseUnpack");
-      autoView(ov, out6, CpuWrite);
-      Coordinate c6(nd+1);
-      for(int ss=0; ss<lsites; ss++){
-        for(int d=0; d<nd; d++) c6[d+1] = myLcoor[ss][d];
-        for(int rr=0; rr<nr; rr++){
-          c6[0] = rr;
-          sobj s;
-          for(int b=0; b<nbasis; b++)
-            ((CoarseScalar *)&s)[b] = CoarseScalar(hY[(uint64_t)rr*nrows + (ss*nbasis+b)]);  // Y col-major
-          pokeLocalSite(s, ov, c6);
-        }
-      }
-    }
-    double t6 = usecond();
-    std::cout << GridLogMessage << "DenseCoarseMatrix: apply6D " << nr << " rhs took "
-              << (t6-t0)/1000.0 << " ms" << std::endl;
-    std::cout << GridLogPerformance << "DenseCoarseMatrix: apply6D profile:"
-              << " pack "        << (t1-t0)/1000.0
-              << "  allgather "  << tprof[0]/1000.0
-              << "  H2D "        << tprof[1]/1000.0
-              << "  gemm+reduce "<< tprof[2]/1000.0
-              << "  D2H "        << tprof[3]/1000.0
-              << "  unpack "     << (t6-t5)/1000.0
-              << "  ms" << std::endl;
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,238 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/GeneralCoarsenedMatrix.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-
-/////////////////////////////////////////////////////////////////
-// Geometry class in cartesian case
-/////////////////////////////////////////////////////////////////
-
-class Geometry {
-public:
-  int npoint;
-  int base;
-  std::vector<int> directions   ;
-  std::vector<int> displacements;
-  std::vector<int> points_dagger;
-
-  Geometry(int _d)  {
-    
-    base = (_d==5) ? 1:0;
-
-    // make coarse grid stencil for 4d , not 5d
-    if ( _d==5 ) _d=4;
-
-    npoint = 2*_d+1;
-    directions.resize(npoint);
-    displacements.resize(npoint);
-    points_dagger.resize(npoint);
-    for(int d=0;d<_d;d++){
-      directions[d   ] = d+base;
-      directions[d+_d] = d+base;
-      displacements[d  ] = +1;
-      displacements[d+_d]= -1;
-      points_dagger[d   ] = d+_d;
-      points_dagger[d+_d] = d;
-    }
-    directions   [2*_d]=0;
-    displacements[2*_d]=0;
-    points_dagger[2*_d]=2*_d;
-  }
-
-  int point(int dir, int disp) {
-    GRID_ASSERT(disp == -1 || disp == 0 || disp == 1);
-    GRID_ASSERT(base+0 <= dir && dir < base+4);
-
-    // directions faster index = new indexing
-    // 4d (base = 0):
-    // point 0  1  2  3  4  5  6  7  8
-    // dir   0  1  2  3  0  1  2  3  0
-    // disp +1 +1 +1 +1 -1 -1 -1 -1  0
-    // 5d (base = 1):
-    // point 0  1  2  3  4  5  6  7  8
-    // dir   1  2  3  4  1  2  3  4  0
-    // disp +1 +1 +1 +1 -1 -1 -1 -1  0
-
-    // displacements faster index = old indexing
-    // 4d (base = 0):
-    // point 0  1  2  3  4  5  6  7  8
-    // dir   0  0  1  1  2  2  3  3  0
-    // disp +1 -1 +1 -1 +1 -1 +1 -1  0
-    // 5d (base = 1):
-    // point 0  1  2  3  4  5  6  7  8
-    // dir   1  1  2  2  3  3  4  4  0
-    // disp +1 -1 +1 -1 +1 -1 +1 -1  0
-
-    if(dir == 0 and disp == 0)
-      return 8;
-    else // New indexing
-      return (1 - disp) / 2 * 4 + dir - base;
-    // else // Old indexing
-    //   return (4 * (dir - base) + 1 - disp) / 2;
-  }
-};
-
-/////////////////////////////////////////////////////////////////
-// Less local equivalent of Geometry class in cartesian case
-/////////////////////////////////////////////////////////////////
-class NonLocalStencilGeometry {
-public:
-  //  int depth;
-  int skip;
-  int hops;
-  int npoint;
-  std::vector<Coordinate> shifts;
-  Coordinate stencil_size;
-  Coordinate stencil_lo;
-  Coordinate stencil_hi;
-  GridCartesian *grid;
-  GridCartesian *Grid() {return grid;};
-  int Depth(void){return 1;};   // Ghost zone depth
-  int Hops(void){return hops;}; // # of hops=> level of corner fill in in stencil
-  int DimSkip(void){return skip;};
-
-  virtual ~NonLocalStencilGeometry() {};
-
-  int  Reverse(int point)
-  {
-    int Nd = Grid()->Nd();
-    Coordinate shft = shifts[point];
-    Coordinate rev(Nd);
-    for(int mu=0;mu<Nd;mu++) rev[mu]= -shft[mu];
-    for(int p=0;p<npoint;p++){
-      if(rev==shifts[p]){
-	return p;
-      }
-    }
-    GRID_ASSERT(0);
-    return -1;
-  }
-  void BuildShifts(void)
-  {
-    this->shifts.resize(0);
-    int Nd = this->grid->Nd();
-
-    int dd = this->DimSkip();
-    for(int s0=this->stencil_lo[dd+0];s0<=this->stencil_hi[dd+0];s0++){
-    for(int s1=this->stencil_lo[dd+1];s1<=this->stencil_hi[dd+1];s1++){
-    for(int s2=this->stencil_lo[dd+2];s2<=this->stencil_hi[dd+2];s2++){
-    for(int s3=this->stencil_lo[dd+3];s3<=this->stencil_hi[dd+3];s3++){
-      Coordinate sft(Nd,0);
-      sft[dd+0] = s0;
-      sft[dd+1] = s1;
-      sft[dd+2] = s2;
-      sft[dd+3] = s3;
-      int nhops = abs(s0)+abs(s1)+abs(s2)+abs(s3);
-      if(nhops<=this->hops) this->shifts.push_back(sft);
-    }}}}
-    this->npoint = this->shifts.size();
-    std::cout << GridLogMessage << "NonLocalStencilGeometry has "<< this->npoint << " terms in stencil "<<std::endl;
-  }
-  
-  NonLocalStencilGeometry(GridCartesian *_coarse_grid,int _hops,int _skip) : grid(_coarse_grid), hops(_hops), skip(_skip)
-  {
-    Coordinate latt = grid->GlobalDimensions();
-    stencil_size.resize(grid->Nd());
-    stencil_lo.resize(grid->Nd());
-    stencil_hi.resize(grid->Nd());
-    for(int d=0;d<grid->Nd();d++){
-     if ( latt[d] == 1 ) {
-      stencil_lo[d] = 0;
-      stencil_hi[d] = 0;
-      stencil_size[d]= 1;
-     } else if ( latt[d] == 2 ) {
-      stencil_lo[d] = -1;
-      stencil_hi[d] = 0;
-      stencil_size[d]= 2;
-     } else if ( latt[d] > 2 ) {
-       stencil_lo[d] = -1;
-       stencil_hi[d] =  1;
-       stencil_size[d]= 3;
-     }
-    }
-    this->BuildShifts();
-  };
-
-};
-
-// Need to worry about red-black now
-class NonLocalStencilGeometry4D : public NonLocalStencilGeometry {
-public:
-  virtual int DerivedDimSkip(void) { return 0;};
-  NonLocalStencilGeometry4D(GridCartesian *Coarse,int _hops) : NonLocalStencilGeometry(Coarse,_hops,0) { };
-  virtual ~NonLocalStencilGeometry4D() {};
-};
-class NonLocalStencilGeometry5D : public NonLocalStencilGeometry {
-public:
-  virtual int DerivedDimSkip(void) { return 1; }; 
-  NonLocalStencilGeometry5D(GridCartesian *Coarse,int _hops) : NonLocalStencilGeometry(Coarse,_hops,1)  { };
-  virtual ~NonLocalStencilGeometry5D() {};
-};
-/*
- * Bunch of different options classes
- */
-class NextToNextToNextToNearestStencilGeometry4D : public NonLocalStencilGeometry4D {
-public:
-  NextToNextToNextToNearestStencilGeometry4D(GridCartesian *Coarse) :  NonLocalStencilGeometry4D(Coarse,4)
-  {
-  };
-};
-class NextToNextToNextToNearestStencilGeometry5D : public  NonLocalStencilGeometry5D {
-public:
-  NextToNextToNextToNearestStencilGeometry5D(GridCartesian *Coarse) :  NonLocalStencilGeometry5D(Coarse,4)
-  {
-  };
-};
-class NextToNearestStencilGeometry4D : public  NonLocalStencilGeometry4D {
-public:
-  NextToNearestStencilGeometry4D(GridCartesian *Coarse) :  NonLocalStencilGeometry4D(Coarse,2)
-  {
-  };
-};
-class NextToNearestStencilGeometry5D : public  NonLocalStencilGeometry5D {
-public:
-  NextToNearestStencilGeometry5D(GridCartesian *Coarse) :  NonLocalStencilGeometry5D(Coarse,2)
-  {
-  };
-};
-class NearestStencilGeometry4D : public  NonLocalStencilGeometry4D {
-public:
-  NearestStencilGeometry4D(GridCartesian *Coarse) :  NonLocalStencilGeometry4D(Coarse,1)
-  {
-  };
-};
-class NearestStencilGeometry5D : public  NonLocalStencilGeometry5D {
-public:
-  NearestStencilGeometry5D(GridCartesian *Coarse) :  NonLocalStencilGeometry5D(Coarse,1)
-  {
-  };
-};
-
-NAMESPACE_END(Grid);
@@ -1,632 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/HDCGMultiGrid.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/iterative/ImplicitlyRestartedBlockLanczos.h>
-#include <Grid/algorithms/iterative/ImplicitlyRestartedBlockLanczosCoarse.h>
-#include <Grid/algorithms/multigrid/PVdagMMultiGrid.h>
-#include <Grid/algorithms/multigrid/HDCGMultiGridParams.h>
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// The two-level mrhs HDCG (arXiv:1402.2585, mrhs form arXiv:2409.03904) as
-// objects, the shape of PVdagMMultiGrid.h:
-//
-//   MGCoarseGrids / MGFineGridsF   shared with the PVdagM chain
-//   HDCGCoarsening                 everything that is a function of the gauge
-//                                  field: the raw near-null basis (and its
-//                                  refinement), the transfer operators, the
-//                                  Galerkin coarse operator (V2, Hermitian),
-//                                  the coarse eigenvectors for deflation
-//   HDCGSolver                     the solve chain on a borrowed coarsening:
-//                                  smoother, deflated coarse solve, ADEF-2
-//                                  preconditioner (fp64 or fp32 behind the
-//                                  seam), outer mrhs fPcg / BlockCGrQ
-//
-// The Hermitian operator is the Schur-preconditioned M^dag M on one
-// checkerboard; the near-null basis and the fine fields live on the
-// checkerboarded grid.  The coarse space is unvectorised and ALWAYS the D+1
-// multiRHS field; Nrhs 1 is the extent-1 case.  Grids outlive the
-// coarsening outlives the solver.
-//////////////////////////////////////////////////////////////////////////////////////
-template<class Fobj,class CComplex,int nbasis>
-class HDCGCoarsening {
-public:
-  typedef Lattice<Fobj>                                          FineField;
-  typedef MultiGeneralCoarsenedOperatorV2<Fobj,CComplex,nbasis>  CoarseOperator;
-  typedef typename CoarseOperator::CoarseVector                  CoarseVector;
-  typedef typename GridTypeMapper<Fobj>::SinglePrecision         FobjF;
-  typedef Lattice<FobjF>                                         FineFieldF;
-
-  MGCoarseGrids                    &Grids;     // borrowed
-  MGFineGridsF                     &GridsF;    // borrowed
-  GridBase                         *FrbGrid;   // borrowed: the checkerboarded fine grid
-  int                               cb;
-  HDCGMultiGridParams               Params;
-  NextToNextToNextToNearestStencilGeometry5D geom;   // the coarse stencil of the Schur operator
-  CoarseOperator                    CoarseOp;
-  //////////////////////////////////////////////////////////////////////
-  // ONE fine transfer operator.  Its STORE follows the coarse sector --
-  // the coarse space is what it feeds -- while its import and export
-  // accept EITHER fine precision, because they are already a layout
-  // transformation and a scalar conversion inside one costs nothing.
-  //////////////////////////////////////////////////////////////////////
-  static const bool CoarseIsSingle =
-    ( sizeof(typename GridTypeMapper<CComplex>::scalar_type) == sizeof(ComplexF) );
-  typedef typename std::conditional<CoarseIsSingle,FineFieldF,FineField>::type ProjectorField;
-  typedef MultiRHSBlockProject<ProjectorField>                        ProjectorL1_t;
-
-  ProjectorL1_t                     MrhsProjectorL1;
-  std::vector<FineField>            rawNull;         // RAW fine near-null basis
-  std::vector<CoarseVector>         evec;            // coarse eigenvectors, on Coarse5d
-  std::vector<RealD>                eval;
-  MultiRHSDeflation<CoarseVector>   Deflator;        // nev==0 until CoarseLanczos
-  GridCartesian                    *CMrhs;           // transient solve grid, owned
-  int                               nrhs;
-
-  HDCGCoarsening(MGCoarseGrids &_Grids, MGFineGridsF &_GridsF, GridBase *_FrbGrid, int _cb,
-                 const HDCGMultiGridParams &P)
-    : Grids(_Grids), GridsF(_GridsF), FrbGrid(_FrbGrid), cb(_cb), Params(P),
-      geom(_Grids.Coarse5d),
-      CoarseOp(geom,_Grids.Coarse5d),
-      CMrhs(nullptr),
-      nrhs(-1)
-  {
-    Deflator.Deallocate();
-    // The coarse stencil is a max-norm-1 box (Geometry.h) and the Schur
-    // operator M^dag M reaches four fine hops, so a block shorter than 4
-    // leaves couplings outside the stencil: the Fourier extraction then
-    // folds them into the retained points and the Galerkin certificate
-    // reads it.  Warn here; the certificate is the guard.
-    for(int d=0;d<4;d++){
-      if ( Params.Setup.Block1[d] < 4 )
-        std::cout << GridLogWarning << "HDCGCoarsening: Block1[" << d << "] = " << Params.Setup.Block1[d]
-                  << " < 4: the Schur operator's range exceeds the coarse stencil; "
-                  << "expect a Galerkin defect" << std::endl;
-    }
-  };
-  ~HDCGCoarsening()
-  {
-    CoarseOp.ReleaseGrid();       // borrowers let go before their grids die
-    if ( CMrhs ) delete CMrhs;
-  }
-
-  int FileExists(const std::string &fname)
-  {
-    uint64_t exists=0;
-    if ( fname.length() ) {
-      if ( Grids.FGrid->IsBoss() ){ std::ifstream f(fname); exists=f.good()?1:0; }
-      Grids.FGrid->GlobalSum(exists);
-    }
-    return (int)exists;
-  }
-  FineField FineNoise(GridParallelRNG &RNG)
-  {
-    FineField v(FrbGrid); v.Checkerboard()=cb; gaussian(RNG,v);
-    return v;
-  }
-  // Chebyshev upper bound: the parameter, or 1.1 x a power-method estimate
-  RealD UpperBound(RealD param, LinearOperatorBase<FineField> &HermOp, GridParallelRNG &RNG)
-  {
-    if ( param > 0.0 ) return param;
-    FineField src = FineNoise(RNG);
-    PowerMethod<FineField> PM;
-    RealD lam = PM(HermOp,src);
-    std::cout << GridLogMessage << "HDCGCoarsening: fine power method " << lam
-              << ", Chebyshev upper bound " << 1.1*lam << std::endl;
-    return 1.1*lam;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // The RAW basis: a refined basis on disk wins, then a raw basis on
-  // disk, else built by the chosen method (and saved if named).  CG
-  // refinement happens here; HDCG refinement needs a solver, see
-  // HDCGRefineSubspace below.  The Aggregation is scaffolding for the
-  // Chebyshev filters only: they run entirely on the fine grid.
-  ////////////////////////////////////////////////////////////////////
-  void GetSubspace(GridParallelRNG &RNG, LinearOperatorBase<FineField> &HermOp)
-  {
-    const HDCGSubspaceParams &S = Params.Subspace;
-    rawNull.clear();
-    rawNull.reserve(nbasis);
-    for(int k=0;k<nbasis;k++){ rawNull.push_back(FineField(FrbGrid)); rawNull[k].Checkerboard()=cb; }
-
-    if ( FileExists(S.RefinedSubspaceFile) ) {
-      std::cout << GridLogMessage << "HDCGCoarsening: loading REFINED subspace " << S.RefinedSubspaceFile << std::endl;
-      loadSubspace(rawNull, S.RefinedSubspaceFile, S.FileControl);
-      return;
-    }
-    if ( FileExists(Params.Setup.SubspaceFile) ) {
-      std::cout << GridLogMessage << "HDCGCoarsening: loading subspace " << Params.Setup.SubspaceFile << std::endl;
-      loadSubspace(rawNull, Params.Setup.SubspaceFile, S.FileControl);
-    } else {
-      Aggregation<Fobj,CComplex,nbasis> Agg(Grids.Coarse5d,FrbGrid,cb);
-      if ( S.Method == HDCGSubspaceMethod::ChebyshevNew ) {
-        RealD hi = UpperBound(S.ChebyHi,HermOp,RNG);
-        std::cout << GridLogMessage << "HDCGCoarsening: CreateSubspaceChebyshevNew hi " << hi << std::endl;
-        Agg.CreateSubspaceChebyshevNew(RNG,HermOp,hi);
-      } else if ( S.Method == HDCGSubspaceMethod::Chebyshev ) {
-        RealD hi = UpperBound(S.ChebyHi,HermOp,RNG);
-        std::cout << GridLogMessage << "HDCGCoarsening: CreateSubspaceChebyshev hi " << hi
-                  << " lo " << S.ChebyLo << " order " << S.ChebyOrder << std::endl;
-        Agg.CreateSubspaceChebyshev(RNG,HermOp,nbasis,hi,S.ChebyLo,S.ChebyOrder);
-      } else {
-        std::cout << GridLogMessage << "HDCGCoarsening: subspace from fine eigenvectors " << S.FineEvecFile
-                  << " summed " << S.FineEvecSample << " per vector" << std::endl;
-        LoadFineEvecSum(Agg.subspace,S.FineEvecFile,S.FineEvecSample,S.FileControl);
-      }
-      for(int k=0;k<nbasis;k++) rawNull[k]=Agg.subspace[k];
-      if ( Params.Setup.SubspaceFile.length() )
-        saveSubspace(rawNull, Params.Setup.SubspaceFile, S.FileControl);
-    }
-    if ( S.Refine == HDCGRefineMethod::CG ) {
-      std::cout << GridLogMessage << "HDCGCoarsening: CG refinement shift " << S.RefineShift
-                << " tol " << S.RefineTol << " maxit " << S.RefineMaxIt << std::endl;
-      Aggregation<Fobj,CComplex,nbasis> Agg(Grids.Coarse5d,FrbGrid,cb);
-      for(int k=0;k<nbasis;k++) Agg.subspace[k]=rawNull[k];
-      Agg.RefineSubspace(HermOp,S.RefineShift,S.RefineTol,S.RefineMaxIt);
-      for(int k=0;k<nbasis;k++) rawNull[k]=Agg.subspace[k];
-      if ( S.RefinedSubspaceFile.length() )
-        saveSubspace(rawNull, S.RefinedSubspaceFile, S.FileControl);
-    }
-  }
-  // Basis vector b = precisionChange of the sum of `sample` consecutive fp32 records
-  void LoadFineEvecSum(std::vector<FineField> &sub, const std::string &file, int sample, int control)
-  {
-#ifdef HAVE_LIME
-    emptyUserRecord record;
-    FineFieldF tmp(GridsF.FrbGridF), sum(GridsF.FrbGridF);
-    tmp.Checkerboard()=cb; sum.Checkerboard()=cb;
-    ScidacReader RD;
-    RD.open(file);
-    for(int b=0;b<nbasis;b++){
-      sum = Zero();
-      for(int n=0;n<sample;n++){
-        RD.readScidacFieldRecord(tmp,record,control);
-        sum = sum + tmp;
-      }
-      precisionChange(sub[b],sum);
-    }
-    RD.close();
-#else
-    GRID_ASSERT(0);
-#endif
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // HDCG refinement of the raw basis (the paper's loop): blocks of
-  // nrhs vectors, normalised, solved with the refining solver, and
-  // renormalised.  The solver was built on the SHIFTED operator and
-  // the coarsening of it; the caller re-coarsens afterwards.
-  ////////////////////////////////////////////////////////////////////
-  void RefineSubspaceHDCG(LinearOperatorBase<FineField> &HermOp, TwoLevelCGmrhs<FineField> &Refiner, int nr)
-  {
-    std::vector<FineField> src(nr,FrbGrid), res(nr,FrbGrid);
-    FineField tmp(FrbGrid); tmp.Checkerboard()=cb;
-    for(int r=0;r<nr;r++){ src[r].Checkerboard()=cb; res[r].Checkerboard()=cb; }
-    for(int b=0;b<nbasis;b+=nr){
-      int nb = std::min(nbasis-b,nr);
-      for(int r=0;r<nb;r++){
-        RealD scale = std::pow(norm2(rawNull[b+r]),-0.5);
-        src[r] = rawNull[b+r]*scale;
-      }
-      for(int r=nb;r<nr;r++) src[r] = src[0];   // pad the block; results discarded
-      for(int r=0;r<nr;r++)  res[r] = Zero();
-      HermOp.HermOp(src[0],tmp);
-      std::cout << GridLogMessage << "HDCGCoarsening: refine block " << b << " before <n|A|n> " << norm2(tmp) << std::endl;
-      Refiner(src,res);
-      for(int r=0;r<nb;r++){
-        RealD scale = std::pow(norm2(res[r]),-0.5);
-        rawNull[b+r] = res[r]*scale;
-      }
-      HermOp.HermOp(rawNull[b],tmp);
-      std::cout << GridLogMessage << "HDCGCoarsening: refine block " << b << " after  <n|A|n> " << norm2(tmp) << std::endl;
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // The Galerkin coarse operator and transfer operators from the RAW
-  // basis.  CoarsenOperator block-orthonormalises its input in place,
-  // so a working copy is taken and the RAW vectors survive.  The
-  // operator handed in must apply the Hermitian operator through Op
-  // (HermOpAdaptor).
-  //
-  // The RAW basis has done its work once this returns, so it is freed --
-  // it is nbasis fine vectors, the single largest resident block of the
-  // setup.  retain_basis keeps it, for the two callers that coarsen more
-  // than once: the HDCG subspace refinement below, and a fixed-basis
-  // rebuild on a changed gauge field (HMC).  Setup.RetainSubspace keeps
-  // it for the whole life of the object.
-  ////////////////////////////////////////////////////////////////////
-  void Coarsen(LinearOperatorBase<FineField> &HermOp, int retain_basis=0)
-  {
-    GRID_ASSERT( rawNull.size() == nbasis );
-    std::vector<FineField> sub(rawNull);
-
-    CoarseOp.SetGrid(Grids.CoarseBatch);
-    std::cout << GridLogMessage << "HDCGCoarsening: CoarsenOperator, batch " << Grids.batch << std::endl;
-    // CoarsenOperator orthonormalises sub in place and imports it into OUR
-    // transfer operator, which it then uses.  One basis store, imported once.
-    // The projector's grid carries the STORE's SIMD layout: the fp32 fine
-    // red-black grid when the coarse sector is fp32.
-    MrhsProjectorL1.Allocate(nbasis,
-                             CoarseIsSingle ? (GridBase *)GridsF.FrbGridF : (GridBase *)FrbGrid,
-                             Grids.Coarse5d);
-    CoarseOp.CoarsenOperator(HermOp,sub,Grids.Coarse5d,Grids.batch,MrhsProjectorL1);
-    if ( !retain_basis && !Params.Setup.RetainSubspace ) DiscardBasis();
-    MrhsProjectorL1.ReleaseScratch();
-    nrhs = -1;                     // the batch grid is set; SetNrhs retargets
-    ReportDeviceFootprint("after Coarsen");
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Retarget the coarse operator to Nrhs: the D+1 grid is owned here
-  // and every borrower re-captures it after this call.
-  ////////////////////////////////////////////////////////////////////
-  void SetNrhs(int nr)
-  {
-    if ( nr == nrhs ) return;
-    CoarseOp.ReleaseGrid();
-    if ( CMrhs ) { delete CMrhs; CMrhs=nullptr; }
-    Coordinate cml({nr,1,Grids.clatt[0],Grids.clatt[1],Grids.clatt[2],Grids.clatt[3]});
-    CMrhs = new GridCartesian(cml,Grids.cmsimd,Grids.cmmpi);
-    CoarseOp.SetGrid(CMrhs);
-    nrhs = nr;
-    std::cout << GridLogMessage << "HDCGCoarsening: coarse operator at Nrhs " << nr << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Coarse eigenvectors for the deflated coarse solve.  Block Lanczos
-  // runs at the solve's Nrhs on the D+1 operator; plain Lanczos at
-  // Nrhs 1 (the extent-1 D+1 grid), its vectors then sliced to the D
-  // grid so both feed the deflator the same way.  Loaded from EvecFile
-  // when present, saved there when named.
-  ////////////////////////////////////////////////////////////////////
-  void CoarseLanczos(int nr)
-  {
-    const HDCGLanczosParams &L = Params.Lanczos;
-    evec.clear(); eval.clear();
-    Deflator.Deallocate();
-    if ( L.Method == HDCGLanczosMethod::None ) {
-      std::cout << GridLogMessage << "HDCGCoarsening: no coarse deflation" << std::endl;
-      return;
-    }
-    if ( FileExists(L.EvecFile) ) {
-      std::cout << GridLogMessage << "HDCGCoarsening: loading coarse eigenpairs " << L.EvecFile << std::endl;
-      loadEigenpairs(evec,eval,L.EvecFile,Grids.Coarse5d,Params.Subspace.FileControl);
-    } else {
-      int Nconv=0;
-      SetNrhs( L.Method == HDCGLanczosMethod::Block ? nr : 1 );
-      HermitianLinearOperator<CoarseOperator,CoarseVector> HermOpC(CoarseOp);
-      GridParallelRNG cRNG(CMrhs); cRNG.SeedFixedIntegers(std::vector<int>({31,32,33,34}));
-      RealD hi = L.ChebyHi;
-      if ( hi <= 0.0 ) {
-        CoarseVector s(CMrhs); random(cRNG,s);
-        PowerMethod<CoarseVector> PM;
-        hi = 1.1*PM(HermOpC,s);
-        std::cout << GridLogMessage << "HDCGCoarsening: coarse Chebyshev upper bound " << hi << std::endl;
-      }
-      Chebyshev<CoarseVector> Cheby(L.ChebyLo,hi,L.ChebyOrder);
-
-      if ( L.Method == HDCGLanczosMethod::Block ) {
-        std::cout << GridLogMessage << "HDCGCoarsening: block Lanczos, Nrhs " << nr
-                  << " Nstop " << L.Nstop << " Nk " << L.Nk << " Nm " << L.Nm << std::endl;
-        ImplicitlyRestartedBlockLanczosCoarse<CoarseVector>
-          IRL(HermOpC,Grids.Coarse5d,CMrhs,nr,Cheby,L.Nstop,1,nr,L.Nk,L.Nm,L.Tol,L.MaxIt);
-        evec.resize(L.Nm,Grids.Coarse5d);
-        eval.resize(L.Nm);
-        std::vector<CoarseVector> src(nr,Grids.Coarse5d);
-        GridParallelRNG dRNG(Grids.Coarse5d); dRNG.SeedFixedIntegers(std::vector<int>({41,42,43,44}));
-        for(int r=0;r<nr;r++) random(dRNG,src[r]);
-        IRL.calc(eval,evec,src,Nconv,LanczosType::irbl);
-        evec.resize(Nconv,Grids.Coarse5d);                 // only the converged pairs
-        eval.resize(Nconv);
-      } else {
-        std::cout << GridLogMessage << "HDCGCoarsening: plain Lanczos at Nrhs 1, Nstop " << L.Nstop
-                  << " Nk " << L.Nk << " Nm " << L.Nm << std::endl;
-        PlainHermOp<CoarseVector>    Op(HermOpC);
-        FunctionHermOp<CoarseVector> OpCheby(Cheby,HermOpC);
-        ImplicitlyRestartedLanczos<CoarseVector> IRL(OpCheby,Op,L.Nstop,L.Nk,L.Nm,L.Tol,L.MaxIt);
-        std::vector<CoarseVector> evec1(L.Nm,CMrhs);
-        std::vector<RealD>        eval1(L.Nm);
-        CoarseVector src(CMrhs); random(cRNG,src);
-        IRL.calc(eval1,evec1,src,Nconv);
-        evec.resize(Nconv,Grids.Coarse5d);
-        eval.resize(Nconv);
-        for(int e=0;e<Nconv;e++){ ExtractSliceFast(evec[e],evec1[e],0,0); eval[e]=eval1[e]; }
-      }
-      // The Lanczos routines set their outputs only on reaching Nstop;
-      // a partial result carries no usable eigenpairs.
-      if ( Nconv < L.Nstop ) {
-        std::cout << GridLogWarning << "HDCGCoarsening: coarse Lanczos converged " << Nconv << " < Nstop " << L.Nstop
-                  << " modes (Chebyshev window [" << L.ChebyLo << "," << hi << "] must hold at least Nstop eigenvalues"
-                  << " and Nm must resolve them); coarse solve undeflated" << std::endl;
-        evec.clear(); eval.clear();
-        return;
-      }
-      if ( L.EvecFile.length() ) saveEigenpairs(evec,eval,L.EvecFile,Params.Subspace.FileControl);
-    }
-    const int nev = evec.size();
-    Deflator.ImportEigenBasis(evec,eval);
-    // The Lattice-layout copies have been imported into the BLAS store and
-    // saved if they were going to be; the solve reads only the BLAS store.
-    evec.clear(); evec.shrink_to_fit();
-    std::cout << GridLogMessage << "HDCGCoarsening: " << nev << " coarse eigenvectors imported for deflation"
-              << (nev ? " (lowest "+std::to_string(eval[0])+", highest "+std::to_string(eval[nev-1])+")" : "")
-              << std::endl;
-    ReportDeviceFootprint("after CoarseLanczos");
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Certificates at Nrhs 1 through the solve's own transfer operators:
-  // Galerkin ||A_c x - P^dag A P x|| / ||A_c x||  (the rounding level of
-  // the coarsening: fp64 coarse ~1e-13, fp32 ~1e-6), and Hermiticity
-  // |<x,A_c y> - <A_c x,y>| / |<x,A_c y>|, which CG relies on.
-  ////////////////////////////////////////////////////////////////////
-  RealD CertifyCoarsening(LinearOperatorBase<FineField> &HermOp)
-  {
-    SetNrhs(1);
-    CoarseVector xc(CMrhs), yc(CMrhs), Acx(CMrhs), Acy(CMrhs), PtAPx(CMrhs);
-    GridParallelRNG cRNG(CMrhs); cRNG.SeedFixedIntegers(std::vector<int>({21,22,23,24}));
-    random(cRNG,xc);
-    random(cRNG,yc);
-
-    CoarseOp.M(xc,Acx);                                     // A_c x
-    CoarseOp.M(yc,Acy);                                     // A_c y
-
-    std::vector<FineField> Px(1,FrbGrid), APx(1,FrbGrid);
-    Px[0].Checkerboard()=cb; APx[0].Checkerboard()=cb;
-    MrhsProjectorL1.blockPromote(Px,xc);                      // P x
-    HermOp.HermOp(Px[0],APx[0]);                            // A P x
-    MrhsProjectorL1.blockProject(APx,PtAPx);                  // P^dag A P x
-
-    CoarseVector d(CMrhs); d = Acx - PtAPx;
-    RealD rel = std::sqrt(norm2(d)/norm2(Acx));
-    ComplexD xAy = TensorRemove(innerProduct(xc,Acy));
-    ComplexD Axy = TensorRemove(innerProduct(Acx,yc));
-    RealD herm = abs(xAy-Axy)/abs(xAy);
-    std::cout << GridLogMessage << "HDCGCoarsening: GALERKIN CERTIFICATE ||A_c x - P^dag A P x||/||A_c x|| = " << rel << std::endl;
-    std::cout << GridLogMessage << "HDCGCoarsening: HERMITICITY CERTIFICATE |<x,A_c y> - <A_c x,y>|/|<x,A_c y>| = " << herm << std::endl;
-    return rel;
-  }
-
-
-  //////////////////////////////////////////////////////////////////////
-  // The device memory this coarsening holds that the memory manager
-  // CANNOT evict: BLAS stores, which are plain device allocations.
-  // Lattice fields are omitted on purpose -- they are evictable, so they
-  // cost eviction traffic, not failure.  What is reported is what has to
-  // fit alongside the manager's cache, the comms buffers and the shm
-  // segment, which is the budget an out-of-memory run actually breaks.
-  //////////////////////////////////////////////////////////////////////
-  void ReportDeviceFootprint(const std::string &when)
-  {
-    uint64_t p1 = MrhsProjectorL1.DeviceBytes();
-    uint64_t o1 = CoarseOp.DeviceBytes();
-    uint64_t df = Deflator.DeviceBytes();
-    const double G = 1024.*1024.*1024.;
-    std::cout << GridLogMessage << "HDCGCoarsening (" << when << "): resident device memory/rank "
-              << (p1+o1+df)/G << " GB = transfer L1 " << p1/G
-              << " + operator L1 " << o1/G
-              << " + deflation " << df/G << " GB" << std::endl;
-    std::cout << GridLogMessage << "HDCGCoarsening (" << when << "): not evictable; must fit alongside the "
-              << MemoryManager::DeviceMaxBytes/G
-              << " GB manager cache, the comms buffers and the shm segment" << std::endl;
-  }
-
-  void DiscardBasis(void)
-  {
-    rawNull.clear(); rawNull.shrink_to_fit();
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// The solve chain on a borrowed coarsening.  Both fine precisions are
-// built; the outer picks the fp32 preconditioner through the seam when
-// Setup.FinePrecision is fp32.  OperatorShift is 0 in production; the
-// HDCG-refinement solver runs on the shifted operator.
-//////////////////////////////////////////////////////////////////////
-template<class Matrix,class MatrixF,class Coarsening>
-class HDCGSolver {
-public:
-  typedef typename Coarsening::FineField      FineField;
-  typedef typename Coarsening::FineFieldF     FineFieldF;
-  typedef typename Coarsening::CoarseOperator CoarseOperator;
-  typedef typename Coarsening::CoarseVector   CoarseVector;
-
-  Coarsening          &C;
-  HDCGMultiGridParams  Params;
-  int                  nrhs;
-  int                  _regrid;     // FIRST member-like init: SetNrhs before members capture grids
-  RealD                OperatorShift;
-
-  // fp64 fine chain
-  SchurDiagMooeeOperator<Matrix,FineField>    HermOpEO;
-  ShiftedHermOpLinearOperator<FineField>      HermOpShifted;
-  HermOpAdaptor<FineField>                    FineOp;         // Op = HermOp: the operator of the solve
-  ShiftedHermOpLinearOperator<FineField>      SmootherOp;
-  CGSmoother<FineField>                       SmootherCG;
-  ChebyshevSmoother<FineField>                SmootherCheby;
-  // coarse
-  HermitianLinearOperator<CoarseOperator,CoarseVector> LinOpC;
-  ConjugateGradient<CoarseVector>             CoarseCG;
-  DoNothingGuesser<CoarseVector>              NoGuess;
-  HPDSolver<CoarseVector>                     CoarseDeflatedCG;
-  ChebyshevInverter<CoarseVector>             CoarseCheby;
-  MrhsADEF2Preconditioner<FineField,CoarseVector,typename Coarsening::ProjectorL1_t> ADEF2;
-  // fp32 fine chain, behind the seam; the coarse solve is shared
-  SchurDiagMooeeOperator<MatrixF,FineFieldF>  HermOpEOF;
-  ShiftedHermOpLinearOperator<FineFieldF>     HermOpShiftedF;
-  HermOpAdaptor<FineFieldF>                   FineOpF;
-  ShiftedHermOpLinearOperator<FineFieldF>     SmootherOpF;
-  CGSmoother<FineFieldF>                      SmootherCGF;
-  ChebyshevSmoother<FineFieldF>               SmootherChebyF;
-  MrhsADEF2Preconditioner<FineFieldF,CoarseVector,typename Coarsening::ProjectorL1_t> ADEF2F;
-  MrhsMixedPrecPreconditioner<FineField,FineFieldF> PreconSeam;
-  TwoLevelCGmrhs<FineField>                   Outer;
-
-  LinearFunction<FineField>  &PickSmoother(void) {
-    return (Params.Smoother.Type==HDCGSmootherType::CG)
-      ? static_cast<LinearFunction<FineField>&>(SmootherCG)
-      : static_cast<LinearFunction<FineField>&>(SmootherCheby);
-  }
-  LinearFunction<FineFieldF> &PickSmootherF(void) {
-    return (Params.Smoother.Type==HDCGSmootherType::CG)
-      ? static_cast<LinearFunction<FineFieldF>&>(SmootherCGF)
-      : static_cast<LinearFunction<FineFieldF>&>(SmootherChebyF);
-  }
-  LinearFunction<CoarseVector> &PickCoarseSolve(void) {
-    return (Params.CoarseSolver.Method==HDCGCoarseMethod::DeflatedCG)
-      ? static_cast<LinearFunction<CoarseVector>&>(CoarseDeflatedCG)
-      : static_cast<LinearFunction<CoarseVector>&>(CoarseCheby);
-  }
-  template<class F, class Op, class ShiftedOp>
-  static LinearOperatorBase<F> &Unshifted(RealD shift, Op &op, ShiftedOp &shifted) {
-    return (shift==0.0) ? static_cast<LinearOperatorBase<F>&>(op) : static_cast<LinearOperatorBase<F>&>(shifted);
-  }
-
-  HDCGSolver(Matrix &Ddwf, MatrixF &DdwfF, Coarsening &_C, const HDCGMultiGridParams &P, int nr, RealD shift=0.0)
-    : C(_C), Params(P), nrhs(nr),
-      _regrid((C.SetNrhs(nr),0)),
-      OperatorShift(shift),
-      HermOpEO(Ddwf),
-      HermOpShifted(HermOpEO,shift),
-      FineOp(Unshifted<FineField>(shift,HermOpEO,HermOpShifted)),
-      SmootherOp(FineOp,P.Smoother.Shift),
-      SmootherCG(P.Smoother.Order,SmootherOp),
-      SmootherCheby(P.Smoother.ChebyLo,P.Smoother.ChebyHi,P.Smoother.Order,FineOp),
-      LinOpC(C.CoarseOp),
-      CoarseCG(P.CoarseSolver.Tol,P.CoarseSolver.MaxIt,false),
-      CoarseDeflatedCG(LinOpC,CoarseCG,NoGuess),
-      CoarseCheby(P.CoarseSolver.ChebyLo,P.CoarseSolver.ChebyHi,P.CoarseSolver.ChebyOrder,LinOpC),
-      ADEF2(FineOp,PickSmoother(),PickCoarseSolve(),PickCoarseSolve(),C.MrhsProjectorL1,C.Deflator,C.CMrhs,C.FrbGrid),
-      HermOpEOF(DdwfF),
-      HermOpShiftedF(HermOpEOF,shift),
-      FineOpF(Unshifted<FineFieldF>(shift,HermOpEOF,HermOpShiftedF)),
-      SmootherOpF(FineOpF,P.Smoother.Shift),
-      SmootherCGF(P.Smoother.Order,SmootherOpF),
-      SmootherChebyF(P.Smoother.ChebyLo,P.Smoother.ChebyHi,P.Smoother.Order,FineOpF),
-      ADEF2F(FineOpF,PickSmootherF(),PickCoarseSolve(),PickCoarseSolve(),C.MrhsProjectorL1,C.Deflator,C.CMrhs,C.GridsF.FrbGridF),
-      PreconSeam(ADEF2F,C.FrbGrid,C.GridsF.FrbGridF,nr),
-      Outer(P.Outer.Tol,P.Outer.MaxIt,FineOp,
-            (P.Setup.FinePrecision==MGPrecision::fp32)
-              ? static_cast<MrhsPreconditioner<FineField>&>(PreconSeam)
-              : static_cast<MrhsPreconditioner<FineField>&>(ADEF2),
-            C.FrbGrid,
-            (P.Outer.Algorithm==HDCGOuterAlgorithm::PrecBlockCGrQ) ? MrhsCGAlgorithm::PrecBlockCGrQ : MrhsCGAlgorithm::fPcg)
-  {
-    // BlockCGrQ assumes a stationary preconditioner: the fixed-iteration CG
-    // smoother is fixed WORK but a nonlinear map, and a coarse CG solved to a
-    // tolerance is not stationary either.  Chebyshev on both is.
-    if ( Params.Outer.Algorithm==HDCGOuterAlgorithm::PrecBlockCGrQ &&
-         ( Params.CoarseSolver.Method!=HDCGCoarseMethod::Chebyshev ||
-           Params.Smoother.Type     !=HDCGSmootherType::Chebyshev ) )
-      std::cout << GridLogWarning << "HDCGSolver: PrecBlockCGrQ with a non-stationary preconditioner "
-                << "(needs Smoother.Type Chebyshev AND CoarseSolver.Method Chebyshev); expect stagnation"
-                << std::endl;
-    std::cout << GridLogMessage << "HDCGSolver: Nrhs " << nr
-              << ", operator shift " << shift
-              << ", smoother " << (Params.Smoother.Type==HDCGSmootherType::CG ? "CG" : "Chebyshev")
-              << " order " << Params.Smoother.Order
-              << ", coarse " << (Params.CoarseSolver.Method==HDCGCoarseMethod::DeflatedCG ? "deflated CG" : "Chebyshev")
-              << " (deflation vectors " << C.Deflator.nev << ")"
-              << ", preconditioner fine level "
-              << (Params.Setup.FinePrecision==MGPrecision::fp32 ? "fp32 (seam at the outer CG)" : "fp64")
-              << ", outer " << (Params.Outer.Algorithm==HDCGOuterAlgorithm::PrecBlockCGrQ ? "PrecBlockCGrQ" : "fPcg")
-              << " EXACT fp64" << std::endl;
-  }
-
-  // One right-hand side through the LinearFunction interface (nrhs must be 1)
-  void Solve(const FineField &src, FineField &sol)
-  {
-    GRID_ASSERT( nrhs == 1 );
-    sol.Checkerboard() = src.Checkerboard();
-    GridStopWatch w; w.Start();
-    Outer(src,sol);
-    w.Stop();
-    FineField Ax(src.Grid()); Ax.Checkerboard()=src.Checkerboard();
-    FineOp.HermOp(sol,Ax);
-    Ax=Ax-src;
-    std::cout << GridLogMessage << "HDCGSolver: single rhs total " << w.Elapsed()
-              << "; FINAL Nrhs 1 (LinearFunction): true residual = " << std::sqrt(norm2(Ax)/norm2(src)) << std::endl;
-  }
-  void Solve(std::vector<FineField> &src, std::vector<FineField> &sol)
-  {
-    GRID_ASSERT( (int)src.size() == nrhs );
-    for(int r=0;r<nrhs;r++) sol[r].Checkerboard() = src[r].Checkerboard();
-    MemoryManager::EvictAll();
-    MemoryManager::DropCache();
-
-    GridStopWatch w; w.Start();
-    Outer(src,sol);
-    w.Stop();
-    std::cout << GridLogMessage << "HDCGSolver: Nrhs "<<nrhs<<" total " << w.Elapsed()
-              << "  (per RHS: " << w.useconds()/1.0e6/nrhs << " s)" << std::endl;
-    {
-      FineField Ax(src[0].Grid()); Ax.Checkerboard()=src[0].Checkerboard();
-      RealD worst=0.0;
-      for(int r=0;r<nrhs;r++){
-        FineOp.HermOp(sol[r],Ax);
-        Ax=Ax-src[r];
-        RealD rn=std::sqrt(norm2(Ax)/norm2(src[r]));
-        std::cout << GridLogMessage << "FINAL Nrhs "<<nrhs<<": rhs["<<r<<"] true residual = " << rn << std::endl;
-        worst=std::max(worst,rn);
-      }
-      std::cout << GridLogMessage << "FINAL Nrhs "<<nrhs<<": worst-case residual = " << worst << std::endl;
-    }
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// HDCG refinement of the basis (the paper's loop): coarsen the SHIFTED
-// operator, deflate it, solve each raw basis vector on it with a
-// short-tolerance HDCG, keep the normalised solutions.  A no-op unless
-// Subspace.Refine is HDCG and no refined basis was loaded.  The caller
-// then coarsens the unshifted operator as usual.
-//////////////////////////////////////////////////////////////////////
-template<class Matrix,class MatrixF,class Coarsening>
-void HDCGRefineSubspace(Coarsening &C, Matrix &Ddwf, MatrixF &DdwfF,
-                        LinearOperatorBase<typename Coarsening::FineField> &HermOp, int nr)
-{
-  typedef typename Coarsening::FineField FineField;
-  const HDCGSubspaceParams &S = C.Params.Subspace;
-  if ( S.Refine != HDCGRefineMethod::HDCG ) return;
-  if ( C.FileExists(S.RefinedSubspaceFile) ) return;
-
-  std::cout << GridLogMessage << "HDCGRefineSubspace: shift " << S.RefineShift << " tol " << S.RefineTol
-            << " maxit " << S.RefineMaxIt << " smoother order " << S.RefineSmootherOrder << std::endl;
-  ShiftedHermOpLinearOperator<FineField> Shifted(HermOp,S.RefineShift);
-  HermOpAdaptor<FineField>               ShiftedOp(Shifted);
-  C.Coarsen(ShiftedOp,1);   // refinement below still needs the RAW basis
-  C.CoarseLanczos(nr);
-
-  HDCGMultiGridParams PR = C.Params;
-  PR.Outer.Tol      = S.RefineTol;
-  PR.Outer.MaxIt    = S.RefineMaxIt;
-  PR.Smoother.Order = S.RefineSmootherOrder;
-  HDCGSolver<Matrix,MatrixF,Coarsening> Refiner(Ddwf,DdwfF,C,PR,nr,S.RefineShift);
-  C.RefineSubspaceHDCG(HermOp,Refiner.Outer,nr);
-
-  if ( S.RefinedSubspaceFile.length() )
-    saveSubspace(C.rawNull, S.RefinedSubspaceFile, S.FileControl);
-}
-
-NAMESPACE_END(Grid);
@@ -1,177 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/HDCGMultiGridParams.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// Parameters of the two-level mrhs HDCG (Hermitian, Schur-preconditioned)
-// multigrid, HDCGMultiGrid.h.  Serialisable: read from XML, template written
-// on a missing file.  Setup (blocking, batch, basis file, fine precision) is
-// the same struct as the PVdagM chain's; Block2 is only used when a
-// coarse-coarse level exists but must still divide the coarse lattice.
-//////////////////////////////////////////////////////////////////////////////////////
-
-GRID_SERIALIZABLE_ENUM(HDCGSubspaceMethod, undef, ChebyshevNew, 1, Chebyshev, 2, FineEvecs, 3);
-GRID_SERIALIZABLE_ENUM(HDCGRefineMethod,   undef, None, 1, CG, 2, HDCG, 3);
-GRID_SERIALIZABLE_ENUM(HDCGLanczosMethod,  undef, None, 1, Block, 2, Plain, 3);
-GRID_SERIALIZABLE_ENUM(HDCGCoarseMethod,   undef, DeflatedCG, 1, Chebyshev, 2);
-GRID_SERIALIZABLE_ENUM(HDCGSmootherType,   undef, CG, 1, Chebyshev, 2);
-GRID_SERIALIZABLE_ENUM(HDCGOuterAlgorithm, undef, fPcg, 1, PrecBlockCGrQ, 2);
-
-// Near-null basis.  ChebyshevNew filters noise through the Hermitian operator
-// with the upper bound only; Chebyshev takes lo/hi/order; FineEvecs sums
-// FineEvecSample consecutive fp32 fine eigenvector records per basis vector.
-// A ChebyHi <= 0 means 1.1 x the power-method estimate.  FileControl is the
-// scidac binary-IO control word of the basis files (0 for pre-2026 HDCG files).
-struct HDCGSubspaceParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGSubspaceParams,
-                                  HDCGSubspaceMethod, Method,
-                                  RealD,       ChebyHi,
-                                  RealD,       ChebyLo,
-                                  int,         ChebyOrder,
-                                  std::string, FineEvecFile,
-                                  int,         FineEvecSample,
-                                  int,         FileControl,
-                                  HDCGRefineMethod, Refine,
-                                  RealD,       RefineShift,         // CG: the shift of the refining CG; HDCG: of the refining operator
-                                  RealD,       RefineTol,
-                                  int,         RefineMaxIt,
-                                  int,         RefineSmootherOrder, // HDCG refine only
-                                  std::string, RefinedSubspaceFile);
-  HDCGSubspaceParams()
-    : Method(HDCGSubspaceMethod::ChebyshevNew), ChebyHi(0.0), ChebyLo(0.01), ChebyOrder(500),
-      FineEvecFile(""), FineEvecSample(1),
-      FileControl(BinaryIO::BINARYIO_LEXICOGRAPHIC|BinaryIO::BINARYIO_AGGREGATE),
-      Refine(HDCGRefineMethod::None), RefineShift(1.0e-3), RefineTol(1.0e-3), RefineMaxIt(500),
-      RefineSmootherOrder(11), RefinedSubspaceFile("") {};
-};
-
-// Coarse eigenvectors for the deflated coarse solve: block Lanczos at the
-// solve's Nrhs, or plain Lanczos at Nrhs 1, on the same coarse operator.
-// ChebyHi <= 0 means 1.1 x the power-method estimate on the coarse operator.
-struct HDCGLanczosParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGLanczosParams,
-                                  HDCGLanczosMethod, Method,
-                                  int,   Nstop,
-                                  int,   Nk,
-                                  int,   Nm,
-                                  RealD, ChebyLo,
-                                  RealD, ChebyHi,
-                                  int,   ChebyOrder,
-                                  RealD, Tol,
-                                  int,   MaxIt,
-                                  std::string, EvecFile);
-  HDCGLanczosParams()
-    : Method(HDCGLanczosMethod::Block), Nstop(32), Nk(32), Nm(128),
-      ChebyLo(0.01), ChebyHi(0.0), ChebyOrder(201), Tol(1.0e-4), MaxIt(100), EvecFile("") {};
-};
-
-struct HDCGCoarseSolverParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGCoarseSolverParams,
-                                  HDCGCoarseMethod, Method,
-                                  RealD, Tol,            // DeflatedCG
-                                  int,   MaxIt,
-                                  RealD, ChebyLo,        // Chebyshev polynomial inverse
-                                  RealD, ChebyHi,
-                                  int,   ChebyOrder);
-  HDCGCoarseSolverParams()
-    : Method(HDCGCoarseMethod::DeflatedCG), Tol(5.0e-2), MaxIt(3000),
-      ChebyLo(1.0e-2), ChebyHi(40.0), ChebyOrder(120) {};
-};
-
-// CG: Order iterations of CG on the operator shifted by Shift.
-// Chebyshev: order Order polynomial on [ChebyLo,ChebyHi] of the unshifted operator.
-struct HDCGSmootherParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGSmootherParams,
-                                  HDCGSmootherType, Type,
-                                  RealD, Shift,
-                                  int,   Order,
-                                  RealD, ChebyLo,
-                                  RealD, ChebyHi);
-  HDCGSmootherParams() : Type(HDCGSmootherType::CG), Shift(2.0), Order(7), ChebyLo(2.0), ChebyHi(92.0) {};
-};
-
-struct HDCGOuterParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGOuterParams,
-                                  RealD, Tol,
-                                  int,   MaxIt,
-                                  HDCGOuterAlgorithm, Algorithm);
-  HDCGOuterParams() : Tol(1.0e-8), MaxIt(500), Algorithm(HDCGOuterAlgorithm::fPcg) {};
-};
-
-struct HDCGMultiGridParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(HDCGMultiGridParams,
-                                  MGSetupParams,          Setup,
-                                  HDCGSubspaceParams,     Subspace,
-                                  HDCGLanczosParams,      Lanczos,
-                                  HDCGCoarseSolverParams, CoarseSolver,
-                                  HDCGSmootherParams,     Smoother,
-                                  HDCGOuterParams,        Outer);
-  HDCGMultiGridParams() {};
-};
-
-inline void CheckValidity(const HDCGMultiGridParams &P)
-{
-  GRID_ASSERT( P.Setup.Block1.size() == 4 );
-  GRID_ASSERT( P.Setup.Block2.size() == 4 );
-  GRID_ASSERT( P.Setup.CoarsenBatch  >= 1 );
-  GRID_ASSERT( P.Setup.FinePrecision != MGPrecision::undef );
-  GRID_ASSERT( P.Subspace.Method     != HDCGSubspaceMethod::undef );
-  GRID_ASSERT( P.Subspace.Refine     != HDCGRefineMethod::undef );
-  GRID_ASSERT( P.Subspace.FineEvecSample >= 1 );
-  GRID_ASSERT( P.Lanczos.Method      != HDCGLanczosMethod::undef );
-  GRID_ASSERT( P.Lanczos.Nstop <= P.Lanczos.Nk && P.Lanczos.Nk <= P.Lanczos.Nm );
-  GRID_ASSERT( P.CoarseSolver.Method != HDCGCoarseMethod::undef );
-  GRID_ASSERT( P.CoarseSolver.Tol     > 0.0 );
-  GRID_ASSERT( P.Smoother.Type       != HDCGSmootherType::undef );
-  GRID_ASSERT( P.Smoother.Order       > 0 );
-  GRID_ASSERT( P.Outer.Tol            > 0.0 );
-  GRID_ASSERT( P.Outer.Algorithm     != HDCGOuterAlgorithm::undef );
-}
-
-// As ReadPVdagMMultiGridParams: a missing file gets a template written next
-// to it and false returned; an empty filename means defaults.
-inline bool ReadHDCGMultiGridParams(HDCGMultiGridParams &P, const std::string &xmlfile)
-{
-  if ( xmlfile.length() ) {
-    bool good;
-    { std::ifstream f(xmlfile); good = f.good(); }
-    if ( !good ) {
-      std::cout << GridLogMessage << "HDCGMultiGridParams: " << xmlfile << " does not exist" << std::endl;
-      if ( GlobalSharedMemory::WorldRank == 0 ) {
-        XmlWriter WR(xmlfile+".templ");
-        write(WR, "HDCGMultiGridParams", P);
-        std::cout << GridLogMessage << "HDCGMultiGridParams: template written to "
-                  << xmlfile << ".templ" << std::endl;
-      }
-      return false;
-    }
-    XmlReader RD(xmlfile);
-    read(RD, "HDCGMultiGridParams", P);
-  }
-  CheckValidity(P);
-  std::cout << GridLogMessage << "HDCGMultiGridParams ("
-            << (xmlfile.length() ? xmlfile : std::string("defaults")) << "):" << std::endl;
-  std::cout << P << std::endl;
-  return true;
-}
-
-NAMESPACE_END(Grid);
@@ -1,301 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/MrhsMultiGrid.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/deflation/MultiRHSBlockProject.h>
-#include <Grid/algorithms/multigrid/MrhsPreconditioner.h>
-
-NAMESPACE_BEGIN(Grid);
-
-
-//////////////////////////////////////////////////////////////////////
-// Single-polynomial mrhs PGCR: one step length and one set of
-// orthogonalisation coefficients SHARED across the right-hand sides
-// (vnorm2/vinnerProduct sum over rhs).  For DWF the dense spectrum
-// makes sharing near-free and the summed reductions amortise; see the
-// mrhs-HDCG paper (arXiv:2409.03904).  Orthogonalisation is classical
-// Gram-Schmidt, batched per rhs (rankInnerProductMulti/axpyMulti) with
-// ONE GlobalSumVector for all coefficients.
-//
-// OnStep is a programmatic per-step hook for algorithmic studies
-// (e.g. driving the GCR coefficient recorder); it is not a consumer
-// parameter.
-//////////////////////////////////////////////////////////////////////
-template<class Field>
-class MrhsPGCRNonHermitian {
-public:
-  RealD Tolerance; Integer MaxIterations; int mmax,nstep,steps,level;
-  int ZeroGuess = 0; int FirstCycle = 0;
-  std::string name = "Level 1";
-  // Trace range names carry the instance name, so a profile separates the
-  // solvers that otherwise nest as one shared range.
-  std::string trace_op = "MrhsPGCR::vOp", trace_orthog = "MrhsPGCR orthog";
-  LinearOperatorBase<Field> &Linop;
-  MrhsLinearFunction<Field> &Preconditioner;
-  std::function<void(int)> OnStep;      // called with the outer step count after every step
-  void Level(int lv){ name = "Level " + std::to_string(lv); level=lv; }
-  void Name(std::string n){ name = n; trace_op = name+" MrhsPGCR::vOp"; trace_orthog = name+" MrhsPGCR orthog"; }
-  void SetZeroGuess(int z){ ZeroGuess=z; }
-  MrhsPGCRNonHermitian(RealD tol,Integer maxit,LinearOperatorBase<Field> &_Linop,MrhsLinearFunction<Field> &Prec,int _mmax,int _nstep)
-    : Tolerance(tol),MaxIterations(maxit),Linop(_Linop),Preconditioner(Prec),mmax(_mmax),nstep(_nstep){ level=1; }
-  static RealD vnorm2(std::vector<Field> &x){ RealD s=0; for(auto &f:x) s+=norm2(f); return s; }
-  static ComplexD vinnerProduct(std::vector<Field> &x,std::vector<Field> &y){ ComplexD s(0); for(int r=0;r<(int)x.size();r++) s+=innerProduct(x[r],y[r]); return s; }
-  static void vaxpy(std::vector<Field> &z,ComplexD a,std::vector<Field> &x,std::vector<Field> &y){ for(int r=0;r<(int)z.size();r++) axpy(z[r],a,x[r],y[r]); }
-  void vOp(std::vector<Field> &in,std::vector<Field> &out){ GRID_TRACE(trace_op.c_str()); for(int r=0;r<(int)in.size();r++) Linop.Op(in[r],out[r]); }
-  void operator()(std::vector<Field> &src,std::vector<Field> &psi){
-    RealD cp,ssq,rsq; int nrhs=src.size(); GridBase *grid=src[0].Grid();
-    ssq=vnorm2(src); rsq=Tolerance*Tolerance*ssq;
-    std::vector<Field> r(nrhs,grid);
-    GridStopWatch T; T.Start(); steps=0; FirstCycle=1;
-    for(int k=0;k<MaxIterations;k++){
-      cp=GCRnStep(src,psi,rsq);
-      std::cout<<GridLogMessage<<std::string(level,'\t')<<" "<<name<<" MrhsPGCR("<<mmax<<","<<nstep<<") "<<steps<<" steps cp = "<<cp<<" target "<<rsq<<std::endl;
-      if(cp<rsq){
-        T.Stop(); vOp(psi,r); for(int rr=0;rr<nrhs;rr++) axpy(r[rr],-1.0,src[rr],r[rr]);
-        RealD tr=vnorm2(r);
-        std::cout<<GridLogMessage<<std::string(level,'\t')<<" "<<name<<" MrhsPGCR: Converged on iteration "<<steps
-                 <<" computed residual "<<std::sqrt(cp/ssq)<<" true residual "<<std::sqrt(tr/ssq)<<" target "<<Tolerance<<std::endl;
-        std::cout<<GridLogMessage<<std::string(level,'\t')<<" "<<name<<" MrhsPGCR Time elapsed: Total "<<T.Elapsed()<<std::endl;
-        return;
-      }
-    }
-    std::cout<<GridLogMessage<<"MrhsPGCR: did not converge"<<std::endl;
-  }
-  RealD GCRnStep(std::vector<Field> &src,std::vector<Field> &psi,RealD rsq){
-    RealD cp; ComplexD a,rq; int nrhs=src.size(); GridBase *grid=src[0].Grid();
-    std::vector<Field> r(nrhs,grid),Az(nrhs,grid);   // Az: restart residual scratch only
-    std::vector< std::vector<Field> > q(mmax,std::vector<Field>(nrhs,grid));
-    std::vector< std::vector<Field> > p(mmax,std::vector<Field>(nrhs,grid));
-    std::vector<RealD> qq(mmax);
-    if (ZeroGuess && FirstCycle) { for(int rr=0;rr<nrhs;rr++){ psi[rr]=Zero(); r[rr]=src[rr]; } }
-    else                         { vOp(psi,Az); for(int rr=0;rr<nrhs;rr++) r[rr]=src[rr]-Az[rr]; }
-    FirstCycle=0;
-    // p[0]=Prec(r), q[0]=A p[0], produced directly in the history slots (no copies)
-    Preconditioner(r,p[0]); vOp(p[0],q[0]); qq[0]=vnorm2(q[0]); cp=vnorm2(r);
-    for(int k=0;k<nstep;k++){
-      steps++; int kp=k+1, peri_k=k%mmax, peri_kp=kp%mmax;
-      if ( OnStep ) OnStep(steps);
-      rq=vinnerProduct(q[peri_k],r); a=rq/qq[peri_k];
-      vaxpy(psi,a,p[peri_k],psi); vaxpy(r,-a,q[peri_k],r); cp=vnorm2(r);
-      std::cout<<GridLogMessage<<std::string(level,'\t')<<" "<<name<<" MrhsPGCR step["<<steps<<"]  resid "<<cp<<" target "<<rsq<<std::endl;
-      if((k==nstep-1)||(cp<rsq)) return cp;
-      // New direction straight into its history slot: p=Prec(r), q=A p.
-      Preconditioner(r,p[peri_kp]);
-      vOp(p[peri_kp],q[peri_kp]);
-      int northog=((kp)>(mmax-1))?(mmax-1):(kp);
-      {
-        GRID_TRACE(trace_orthog.c_str());
-        // Classical Gram-Schmidt: all coefficients against the UN-updated new q
-        // (independent, batchable), then apply.  Complex coefficient: the
-        // operator is non-Hermitian, real(<q_j,Aq>) alone left q's non-orthogonal.
-        // Batched per rhs (one fused kernel + one reduction each), the shared
-        // coefficient summed over rhs on the host, ONE GlobalSumVector.
-        std::vector<ComplexD> bcoef(northog,ComplexD(0.0)), part;
-        for(int rr=0;rr<nrhs;rr++){
-          std::vector<const Field*> qwin(northog);
-          for(int back=0;back<northog;back++){ int peri_back=(k-back)%mmax; GRID_ASSERT((k-back)>=0); qwin[back]=&q[peri_back][rr]; }
-          rankInnerProductMulti(part,qwin,q[peri_kp][rr]);
-          for(int back=0;back<northog;back++) bcoef[back]+=part[back];
-        }
-        if(northog) grid->GlobalSumVector(&bcoef[0],northog);
-        for(int back=0;back<northog;back++){ int peri_back=(k-back)%mmax; bcoef[back]=-bcoef[back]/qq[peri_back]; }
-        for(int rr=0;rr<nrhs;rr++){
-          std::vector<const Field*> qwin(northog), pwin(northog);
-          for(int back=0;back<northog;back++){ int peri_back=(k-back)%mmax; qwin[back]=&q[peri_back][rr]; pwin[back]=&p[peri_back][rr]; }
-          axpyMulti(p[peri_kp][rr],bcoef,pwin);
-          axpyMulti(q[peri_kp][rr],bcoef,qwin);
-        }
-      }
-      qq[peri_kp]=vnorm2(q[peri_kp]);
-    }
-    GRID_ASSERT(0); return cp;
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// Dense L3 solve on the packed D+1 coarse-coarse field.  Adapts any
-// class exposing ApplyBatch6D (DenseCoarseMatrix) to a LinearFunction.
-//////////////////////////////////////////////////////////////////////
-template<class DenseType, class CoarseCoarseField>
-class MrhsDenseCCSolve : public LinearFunction<CoarseCoarseField> {
-public:
-  DenseType &_Dense;
-  int _nrhs;
-  MrhsDenseCCSolve(DenseType &D, int nrhs) : _Dense(D), _nrhs(nrhs) {}
-  using LinearFunction<CoarseCoarseField>::operator();
-  virtual void operator()(const CoarseCoarseField &in, CoarseCoarseField &out){
-    _Dense.ApplyBatch6D(in, out, _nrhs);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// L2->L3 half V-cycle on the D+1 coarse field: coarse-coarse correction
-// through the mixed blockProject, then post-smooth.
-//////////////////////////////////////////////////////////////////////
-template<class CoarseField, class CoarseCoarseField>
-class MrhsCoarseThreeLevelPrec : public LinearFunction<CoarseField> {
-public:
-  LinearOperatorBase<CoarseField>          &_CoarseOp;
-  LinearFunction<CoarseField>              &_CoarseSmoother;
-  MultiRHSBlockProject<CoarseField>        &_Projector;
-  LinearFunction<CoarseCoarseField>        &_CoarseCoarseSolve;
-  GridBase *_Coarse5d, *_CoarseCoarse5d, *_CoarseCoarseMrhs;
-  int _nrhs;
-  MrhsCoarseThreeLevelPrec(LinearOperatorBase<CoarseField> &CoarseOp,
-                           LinearFunction<CoarseField> &CoarseSmoother,
-                           MultiRHSBlockProject<CoarseField> &Projector,
-                           LinearFunction<CoarseCoarseField> &CoarseCoarseSolve,
-                           GridBase *Coarse5d, GridBase *CoarseCoarse5d, GridBase *CoarseCoarseMrhs, int nrhs)
-    : _CoarseOp(CoarseOp), _CoarseSmoother(CoarseSmoother), _Projector(Projector),
-      _CoarseCoarseSolve(CoarseCoarseSolve),
-      _Coarse5d(Coarse5d), _CoarseCoarse5d(CoarseCoarse5d), _CoarseCoarseMrhs(CoarseCoarseMrhs), _nrhs(nrhs) {}
-  using LinearFunction<CoarseField>::operator();
-  virtual void operator()(const CoarseField &in, CoarseField &out) {
-    CoarseField vec1(in.Grid());
-    CoarseField vec2(in.Grid());
-    out = in;
-    _CoarseOp.Op(out,vec1);  sub(vec1,in,vec1);
-
-    // restrict, through the mixed blockProject: D+1 coarse in, D+1 cc out
-    CoarseCoarseField CCsrc(_CoarseCoarseMrhs);
-    CoarseCoarseField CCsol(_CoarseCoarseMrhs);
-    _Projector.blockProject(vec1,CCsrc);
-
-    _CoarseCoarseSolve(CCsrc,CCsol);
-
-    _Projector.blockPromote(vec1,CCsol);
-    add(out,out,vec1);
-
-    _CoarseOp.Op(out,vec1);  sub(vec1,in,vec1);
-    _CoarseSmoother(vec1,vec2);
-    add(out,out,vec2);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// L1->L2 mrhs V-cycle.  The whole V-cycle is preconditioner: its fine
-// residuals and the smoother may run with sloppy halos; the caller
-// (the outer Krylov) gets the exact operator back on exit.  SetSloppy
-// is wired by the composer to PVdagMLinearOperator::SloppyComms (a
-// no-op by default), replacing the file-scope global the example used.
-//////////////////////////////////////////////////////////////////////
-// Projector_t defaults to a transfer operator whose STORE matches FineField,
-// which is the case whenever the coarse sector and the fine level share a
-// precision; pass it explicitly when they differ.
-template<class FineField, class MrhsCoarseVector, class FineSmoother,
-         class Projector_t = MultiRHSBlockProject<FineField> >
-class MrhsTwoLevelMG : public MrhsPreconditioner<FineField> {
-public:
-  typedef MrhsCoarseVector CoarseVector;
-  LinearOperatorBase<FineField>   &_FineOperator;
-  FineSmoother                    &_PostSmoother;
-  Projector_t                     &_Projector;   // store precision need not match FineField
-  LinearFunction<CoarseVector>    &_CoarseSolve;
-  GridBase *_CoarseGrid, *_CoarseGridMrhs;
-  std::function<void(int)> SetSloppy = [](int){};
-  int SloppyComms = 0;                 // value passed to SetSloppy on entry
-  MrhsTwoLevelMG(LinearOperatorBase<FineField> &FineOp, FineSmoother &Post,
-                 Projector_t &Projector, LinearFunction<CoarseVector> &CoarseSolve,
-                 GridBase *CoarseGrid, GridBase *CoarseGridMrhs)
-    : _FineOperator(FineOp),_PostSmoother(Post),_Projector(Projector),_CoarseSolve(CoarseSolve),
-      _CoarseGrid(CoarseGrid),_CoarseGridMrhs(CoarseGridMrhs){}
-  virtual void operator()(std::vector<FineField> &in, std::vector<FineField> &out){
-    GRID_TRACE("MGVcycle");
-    SetSloppy(SloppyComms);
-    int nrhs=in.size(); GridBase *fgrid=in[0].Grid();
-    std::vector<FineField> vec1(nrhs,fgrid),vec2(nrhs,fgrid);
-    for(int r=0;r<nrhs;r++) out[r]=in[r];
-    { GRID_TRACE("MGFineResidual");
-      for(int r=0;r<nrhs;r++){ _FineOperator.Op(out[r],vec1[r]); sub(vec1[r],in[r],vec1[r]); }
-    }
-    // fine vector -> D+1 coarse, via the mixed blockProject
-    CoarseVector CsrcMrhs(_CoarseGridMrhs), CsolMrhs(_CoarseGridMrhs);
-    { GRID_TRACE("MGProject");
-      _Projector.blockProject(vec1,CsrcMrhs);
-    }
-    CsolMrhs=Zero();
-    { GRID_TRACE("MGCoarseSolve");
-      _CoarseSolve(CsrcMrhs,CsolMrhs);
-    }
-    { GRID_TRACE("MGPromote");
-      _Projector.blockPromote(vec1,CsolMrhs);
-      for(int r=0;r<nrhs;r++) add(out[r],out[r],vec1[r]);
-    }
-    { GRID_TRACE("MGFineResidual2");
-      for(int r=0;r<nrhs;r++){ _FineOperator.Op(out[r],vec1[r]); sub(vec1[r],in[r],vec1[r]); }
-    }
-    { GRID_TRACE("MGPostSmooth");
-      for(int r=0;r<nrhs;r++){
-        _PostSmoother(vec1[r],vec2[r]); add(out[r],out[r],vec2[r]);
-      }
-    }
-    SetSloppy(0);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// The fp64/fp32 seam of the solve chain.  The outer Krylov hands fp64
-// residuals to its preconditioner; this adapter converts them to fp32,
-// runs an fp32 preconditioner (the whole V-cycle), and converts the
-// correction back.  Two precisionChange per outer step per rhs, on
-// workspaces built once.  The outer operator never sees fp32.
-//
-// The fp32 scratch is allocated ON FIRST USE, not in the constructor: the
-// solver builds this seam whichever precision is selected, and at Nrhs 12
-// on a 48^3x96 Ls=24 rank the scratch is 2 GB of device memory.  A seam
-// that is never called must cost nothing.  Same idiom as the GCR history
-// vectors: re-made only if the grid or the rhs count changes.
-//////////////////////////////////////////////////////////////////////
-template<class FieldD, class FieldF>
-class MrhsMixedPrecPreconditioner : public MrhsPreconditioner<FieldD> {
-public:
-  MrhsPreconditioner<FieldF> &_Inner;
-  precisionChangeWorkspace    _ws_d2f;   // out fp32, in fp64
-  precisionChangeWorkspace    _ws_f2d;   // out fp64, in fp32
-  GridBase                   *_gridF;
-  std::vector<FieldF>         _in_f, _out_f;
-  MrhsMixedPrecPreconditioner(MrhsPreconditioner<FieldF> &Inner, GridBase *gridD, GridBase *gridF, int nrhs)
-    : _Inner(Inner), _ws_d2f(gridF,gridD), _ws_f2d(gridD,gridF), _gridF(gridF) {}
-  void Scratch(int nrhs){
-    if ( (int)_in_f.size() == nrhs ) return;
-    _in_f.clear();  _in_f.reserve(nrhs);
-    _out_f.clear(); _out_f.reserve(nrhs);
-    for(int r=0;r<nrhs;r++){ _in_f.emplace_back(_gridF); _out_f.emplace_back(_gridF); }
-  }
-  virtual void operator()(std::vector<FieldD> &in, std::vector<FieldD> &out){
-    GRID_TRACE("MGPrecisionSeam");
-    int nrhs=in.size(); Scratch(nrhs);
-    for(int r=0;r<nrhs;r++) precisionChange(_in_f[r],in[r],_ws_d2f);
-    _Inner(_in_f,_out_f);
-    for(int r=0;r<nrhs;r++) precisionChange(out[r],_out_f[r],_ws_f2d);
-  }
-  // The start and the timers are the inner preconditioner's
-  virtual void Vstart(std::vector<FieldD> &x, std::vector<FieldD> &src){
-    GRID_TRACE("MGPrecisionSeamVstart");
-    int nrhs=src.size(); Scratch(nrhs);
-    for(int r=0;r<nrhs;r++) precisionChange(_in_f[r],src[r],_ws_d2f);
-    _Inner.Vstart(_out_f,_in_f);
-    for(int r=0;r<nrhs;r++) precisionChange(x[r],_out_f[r],_ws_f2d);
-  }
-  virtual void ResetTimers(void)                       { _Inner.ResetTimers(); }
-  virtual void ReportTimers(const std::string &prefix) { _Inner.ReportTimers(prefix); }
-};
-
-NAMESPACE_END(Grid);
@@ -1,73 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/MrhsPreconditioner.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////
-// The mrhs interfaces.  This header is in the Algorithms.h include
-// chain (AdefMrhs.h needs it); the concrete mrhs classes are in
-// MrhsMultiGrid.h, reached through PVdagMMultiGrid.h / HDCGMultiGrid.h.
-//
-// MrhsLinearFunction: vector-of-fields in, vector out.  The outer level
-// carries mrhs as std::vector<Field>; below it mrhs is PACKED into a
-// single D+1 field (rhs = dim 0) and the coarse classes are plain
-// LinearFunctions on that.
-//////////////////////////////////////////////////////////////////////
-template<class Field>
-class MrhsLinearFunction {
-public:
-  virtual void operator()(std::vector<Field> &in, std::vector<Field> &out) = 0;
-  virtual ~MrhsLinearFunction(){};
-};
-
-//////////////////////////////////////////////////////////////////////
-// An mrhs preconditioner for the two-level CG family (AdefMrhs.h):
-// operator() is M1; Vstart chooses x_0 from the source (Tang's ADEF-2
-// start x_0 = Q b; the default is the zero start).  The timers are the
-// M1 breakdown the outer solver reports.
-//////////////////////////////////////////////////////////////////////
-template<class Field>
-class MrhsPreconditioner : public MrhsLinearFunction<Field> {
-public:
-  GridStopWatch ProjectTimer, PromoteTimer, DeflateTimer, CoarseTimer, FineTimer, SmoothTimer;
-  virtual void Vstart(std::vector<Field> &x, std::vector<Field> &src)
-  {
-    for(int r=0;r<(int)x.size();r++) x[r] = Zero();
-  }
-  virtual void ResetTimers(void)
-  {
-    ProjectTimer.Reset(); PromoteTimer.Reset(); DeflateTimer.Reset();
-    CoarseTimer.Reset();  FineTimer.Reset();    SmoothTimer.Reset();
-  }
-  virtual void ReportTimers(const std::string &prefix)
-  {
-    std::cout<<GridLogMessage<<"**** M1 breakdown:"<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Project "<<ProjectTimer.Elapsed()<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Promote "<<PromoteTimer.Elapsed()<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Deflate "<<DeflateTimer.Elapsed()<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Coarse  "<<CoarseTimer.Elapsed()<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Fine    "<<FineTimer.Elapsed()<<std::endl;
-    std::cout<<GridLogMessage<<prefix<<"Smooth  "<<SmoothTimer.Elapsed()<<std::endl;
-  }
-  virtual ~MrhsPreconditioner(){};
-};
-
-NAMESPACE_END(Grid);
@@ -1,161 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/algorithms/multigrid/MrhsPromotedOperator.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////
-// Present a D dimensional operator as a D+1 dimensional operator with Nrhs in
-// dimension 0.  Field type is unchanged; only the Grid differs, so this is a
-// LinearOperatorBase and callers need no template parameter: a native mrhs
-// operator derives from the same base and substitutes without a call site
-// change.
-//
-// Slices in and out around the wrapped operator.  No arithmetic beyond the
-// wrapped call, but one ExtractSliceFast/InsertSliceFast pair per right hand
-// side: data motion, not work.
-//
-// AdjOp is carried so that A^dag may be coarsened as a separate coarse
-// operator when needed, rather than doubling coarse storage.
-///////////////////////////////////////////////////////////////////////////////
-template<class Field>
-class MrhsPromotedOperator : public LinearOperatorBase<Field>
-{
-private:
-
-  LinearOperatorBase<Field> &_LinOp;
-  GridBase                  *_LowGrid;
-  int                        _Nrhs;
-
-public:
-
-  MrhsPromotedOperator(LinearOperatorBase<Field> &LinOp,GridBase *LowGrid,int Nrhs)
-    : _LinOp(LinOp), _LowGrid(LowGrid), _Nrhs(Nrhs)
-  {
-    GRID_ASSERT(_Nrhs>=1);
-  }
-
-  GridBase *LowGrid(void) { return _LowGrid; }
-  int       Nrhs(void)    { return _Nrhs;    }
-
-  // Reset on each call; retrieve and accumulate in the caller
-  RealD tslice;
-  RealD top;
-
-  void OpDiag (const Field &in, Field &out)
-  {
-    SliceLoop(in,out,[&](Field &i,Field &o){ _LinOp.OpDiag(i,o); });
-  }
-
-  void Op     (const Field &in, Field &out)
-  {
-    SliceLoop(in,out,[&](Field &i,Field &o){ _LinOp.Op(i,o); });
-  }
-
-  void AdjOp  (const Field &in, Field &out)
-  {
-    SliceLoop(in,out,[&](Field &i,Field &o){ _LinOp.AdjOp(i,o); });
-  }
-
-  void HermOp (const Field &in, Field &out)
-  {
-    SliceLoop(in,out,[&](Field &i,Field &o){ _LinOp.HermOp(i,o); });
-  }
-
-  void OpDir  (const Field &in, Field &out,int dir,int disp)
-  {
-    SliceLoop(in,out,[&](Field &i,Field &o){ _LinOp.OpDir(i,o,dir,disp); });
-  }
-
-  //////////////////////////////////////////////////////////////////
-  // Norms of the D+1 field are the sums over slices
-  //////////////////////////////////////////////////////////////////
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2)
-  {
-    Conformable(in,out);
-    Field lo_in (_LowGrid);
-    Field lo_out(_LowGrid);
-    n1=0.0;
-    n2=0.0;
-    for(int r=0;r<_Nrhs;r++){
-      RealD r1,r2;
-      ExtractSliceFast(lo_in,in,r,0);
-      _LinOp.HermOpAndNorm(lo_in,lo_out,r1,r2);
-      InsertSliceFast(lo_out,out,r,0);
-      n1=n1+r1;
-      n2=n2+r2;
-    }
-  }
-
-  void OpDirAll(const Field &in, std::vector<Field> &out)
-  {
-    int npoint = out.size();
-    Field lo_in(_LowGrid);
-    std::vector<Field> lo_out(npoint,_LowGrid);
-    for(int r=0;r<_Nrhs;r++){
-      ExtractSliceFast(lo_in,in,r,0);
-      _LinOp.OpDirAll(lo_in,lo_out);
-      for(int p=0;p<npoint;p++){
-        InsertSliceFast(lo_out[p],out[p],r,0);
-      }
-    }
-  }
-
-private:
-
-  void Conformable(const Field &in,const Field &out)
-  {
-    conformable(in.Grid(),out.Grid());
-    GRID_ASSERT(in.Grid()->_ndimension == _LowGrid->_ndimension+1);
-    GRID_ASSERT(in.Grid()->_fdimensions[0] == _Nrhs);
-  }
-
-  template<class Kernel>
-  void SliceLoop(const Field &in,Field &out,Kernel K)
-  {
-    Conformable(in,out);
-    Field lo_in (_LowGrid);
-    Field lo_out(_LowGrid);
-    tslice=0.0;
-    top=0.0;
-    for(int r=0;r<_Nrhs;r++){
-      tslice-=usecond();
-      ExtractSliceFast(lo_in,in,r,0);
-      tslice+=usecond();
-      top-=usecond();
-      K(lo_in,lo_out);
-      top+=usecond();
-      tslice-=usecond();
-      InsertSliceFast(lo_out,out,r,0);
-      tslice+=usecond();
-    }
-  }
-
-};
-
-NAMESPACE_END(Grid);
@@ -1,51 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: Grid/algorithms/multigrid/MultiGrid.h
-
-    Copyright (C) 2023
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-#include <Grid/algorithms/multigrid/Aggregates.h>
-#include <Grid/algorithms/multigrid/Geometry.h>
-#include <Grid/algorithms/multigrid/CoarsenedMatrix.h>
-#include <Grid/algorithms/multigrid/GeneralCoarsenedMatrixMultiRHSV2.h>
-// DEPRECATED: the V1 coarse operators and the Aggregation-based single-RHS
-// ADEF-2.  Nothing in the library uses them; the PVdagM and HDCG chains are
-// on V2 (PVdagMMultiGrid.h, HDCGMultiGrid.h).  Kept so the pre-2026 drivers
-// in tests/debug and examples still build; removing this block is the
-// deletion gate for them.
-#include <Grid/algorithms/multigrid/deprecated/GeneralCoarsenedMatrix.h>
-#include <Grid/algorithms/multigrid/deprecated/GeneralCoarsenedMatrixMultiRHS.h>
-#include <Grid/algorithms/multigrid/deprecated/TwoLevelADEF2.h>
-#include <Grid/algorithms/multigrid/MrhsPromotedOperator.h>
-#include <Grid/algorithms/multigrid/Smoothers.h>
-#include <Grid/algorithms/multigrid/PVdagMMultiGridParams.h>
-// PVdagMOperators.h / MrhsMultiGrid.h / PVdagMMultiGrid.h /
-// DenseCoarseMatrix.h / MultiGridIO.h / HDCGMultiGrid.h are NOT in this
-// umbrella: consumers include PVdagMMultiGrid.h or HDCGMultiGrid.h
-// explicitly (they pull the dense stack, BLAS, and the scidac I/O, which
-// is declared after Algorithms.h in Grid.h).  Keeping MrhsMultiGrid.h out
-// of the Algorithms.h chain also keeps its class names away from the
-// pre-2026 drivers that define their own copies.
@@ -1,94 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/MultiGridIO.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////
-// Multigrid setup I/O shared by the PVdagM and HDCG chains: a set of
-// bare-vector scidac records (a near-null basis, or a set of
-// eigenvectors with their eigenvalues beside them in XML).
-//
-// The coarse OPERATOR is not written: coarsening is cheap relative
-// to producing the basis, and is redone.
-//
-// `control` is the scidac binary-IO control word.  The library default
-// is lexicographic + aggregated; pass 0 to read files written by the
-// pre-2026 HDCG drivers, which used control 0.
-//////////////////////////////////////////////////////////////////////
-static const int MultiGridIODefaultControl = BinaryIO::BINARYIO_LEXICOGRAPHIC|BinaryIO::BINARYIO_AGGREGATE;
-
-template <class Field>
-void saveSubspace(std::vector<Field> &subspace, std::string const fname,
-		  int control = MultiGridIODefaultControl)
-{
-#ifdef HAVE_LIME
-  Grid::emptyUserRecord record;
-  Grid::ScidacWriter SW(subspace[0].Grid()->IsBoss());
-  SW.open(fname);
-  for (int k = 0; k < (int)subspace.size(); k++) {
-    SW.writeScidacFieldRecord(subspace[k], record, 0, control);
-  }
-  SW.close();
-#endif
-}
-template <class Field>
-void loadSubspace(std::vector<Field> &subspace, std::string const fname,
-		  int control = MultiGridIODefaultControl)
-{
-#ifdef HAVE_LIME
-  Grid::emptyUserRecord record;
-  Grid::ScidacReader SR;
-  SR.open(fname);
-  for (int k = 0; k < (int)subspace.size(); k++) {
-    SR.readScidacFieldRecord(subspace[k], record, control);
-  }
-  SR.close();
-#endif
-}
-
-//////////////////////////////////////////////////////////////////////
-// Eigenpairs: the vectors as a subspace file, the values in
-// <fname>.evals.xml.  evec.size() fixes how many are read.
-//////////////////////////////////////////////////////////////////////
-template <class Field>
-void saveEigenpairs(std::vector<Field> &evec, std::vector<RealD> &eval, std::string const fname,
-		    int control = MultiGridIODefaultControl)
-{
-  GRID_ASSERT(evec.size()==eval.size());
-  saveSubspace(evec, fname, control);
-  if ( evec[0].Grid()->IsBoss() ) {
-    XmlWriter WR(fname+".evals.xml");
-    write(WR,"evals",eval);
-  }
-}
-// The eigenvalue file sets the count; the vectors are allocated on grid.
-template <class Field>
-void loadEigenpairs(std::vector<Field> &evec, std::vector<RealD> &eval, std::string const fname,
-		    GridBase *grid, int control = MultiGridIODefaultControl)
-{
-  XmlReader RD(fname+".evals.xml");
-  read(RD,"evals",eval);
-  evec.clear();
-  evec.resize(eval.size(), Field(grid));
-  loadSubspace(evec, fname, control);
-}
-
-NAMESPACE_END(Grid);
@@ -1,682 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/PVdagMMultiGrid.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-#include <Grid/algorithms/multigrid/DenseCoarseMatrix.h>
-#include <Grid/algorithms/multigrid/MultiGridIO.h>
-#include <Grid/algorithms/multigrid/PVdagMOperators.h>
-#include <Grid/algorithms/multigrid/MrhsMultiGrid.h>
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// The three-level mrhs PVdagM multigrid, as objects:
-//
-//   MGCoarseGrids              the derived coarse grids (owned here, since
-//                              conformability is pointer identity and someone
-//                              must hold them; declare it BEFORE anything that
-//                              borrows from it)
-//   PVdagMMultiGridCoarsening  ALL the coarsening information for one gauge
-//                              configuration: the raw near-null basis, the
-//                              transfer operators it induces, the Galerkin
-//                              coarse operator at each level, and the dense
-//                              bottom inverse.  Everything here is a function
-//                              of the gauge field -- the state HMC must
-//                              rebuild or maintain as U evolves -- and
-//                              everything is solver-independent.
-//   PVdagMMultiGridSolver      the solve chain composed on a borrowed
-//                              coarsening: smoothers, coarse Krylov, V-cycle,
-//                              outer mrhs PGCR.
-//
-// Scope discipline: grids outlive the coarsening outlives the solver.
-//////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////
-// Subspace I/O is in MultiGridIO.h (shared with the HDCG chain).
-// Loaded vectors are RAW -- deliberately NOT re-orthogonalised:
-// CoarsenOperator block orthonormalises in place, and projecting a
-// block-orthonormal vector onto its own block-orthonormalised
-// aggregation gives e_k with the near-null content silently gone.
-// GramGuard below catches that.
-//////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////
-// ||<v|v> - I||_F over a set of coarse vectors.  Small means the raw
-// near-null content survived the projection.
-//////////////////////////////////////////////////////////////////////
-template<class CoarseField>
-RealD GramDefect(std::vector<CoarseField> &v)
-{
-  RealD s2=0.0;
-  for(int i=0;i<(int)v.size();i++){
-    for(int j=0;j<(int)v.size();j++){
-      ComplexD sij=TensorRemove(innerProduct(v[i],v[j]));
-      ComplexD d=sij-(i==j?ComplexD(1.0):ComplexD(0.0));
-      s2+=real(d)*real(d)+imag(d)*imag(d);
-    }
-  }
-  return std::sqrt(s2);
-}
-
-// On a leak every image collapses to the block unit e_k, the Gram becomes
-// N*I, and the defect lands at (N-1)*sqrt(nbasis) -- orders above the ~0.2
-// of a content-preserving projection.  Trip well below that so a mis-set
-// threshold costs a log line rather than the run.
-template<class CoarseField>
-void GramGuard(const std::string &name,std::vector<CoarseField> &v,GridBase *grid)
-{
-  RealD defect = GramDefect(v);
-  RealD N      = (RealD)grid->gSites();
-  RealD leak   = (N-1.0)*std::sqrt((RealD)v.size());
-  RealD trip   = std::sqrt(N);
-  std::cout << GridLogMessage << "GUARD: ||<"<<name<<"|"<<name<<"> - I||_F = " << defect
-            << "   (e_k leak would be " << leak << ", trip at " << trip << ")" << std::endl;
-  GRID_ASSERT( defect < trip );
-}
-
-//////////////////////////////////////////////////////////////////////
-// The derived grids of the three-level chain, owned in one place.
-// The coarse space is UNVECTORISED (sComplex scalar, simd {1,..,1});
-// the 5D/6D grids are built directly so the SIMD layout is ours.
-// rhs/batch is dim 0 of the 6D grids, undistributed -- no divisibility
-// constraint on nrhs.
-//////////////////////////////////////////////////////////////////////
-class MGCoarseGrids {
-public:
-  GridCartesian *FGrid;                     // borrowed
-  int Ls;
-  int batch;
-  Coordinate clatt;                         // 4d coarse lattice
-  Coordinate cclatt;                        // 4d coarse-coarse lattice
-  Coordinate c5simd, c5mpi;                 // 5D coarse simd/mpi
-  Coordinate cmsimd, cmmpi;                 // 6D coarse simd/mpi
-  // owned:
-  GridCartesian *Coarse5d;
-  GridCartesian *CoarseBatch;               // 6D at the coarsening batch
-  GridCartesian *CoarseCoarse5d;
-  GridCartesian *CoarseCoarseBatch;
-
-  MGCoarseGrids(GridCartesian *_FGrid, const MGSetupParams &P)
-    : FGrid(_FGrid)
-  {
-    Coordinate fdims = FGrid->FullDimensions();      // {Ls, x,y,z,t}
-    Coordinate fmpi  = FGrid->_processors;
-    GRID_ASSERT( fdims.size() == 5 );
-    Ls    = fdims[0];
-    batch = P.CoarsenBatch;
-
-    clatt.resize(4); cclatt.resize(4);
-    for(int d=0;d<4;d++){
-      GRID_ASSERT( fdims[d+1] % P.Block1[d] == 0 );
-      clatt[d] = fdims[d+1] / P.Block1[d];
-    }
-    for(int d=0;d<4;d++){
-      GRID_ASSERT( clatt[d] % P.Block2[d] == 0 );
-      cclatt[d] = clatt[d] / P.Block2[d];
-    }
-    std::cout << GridLogMessage << "MGCoarseGrids: Block1 " << P.Block1 << "  coarse lattice        " << clatt  << std::endl;
-    std::cout << GridLogMessage << "MGCoarseGrids: Block2 " << P.Block2 << "  coarse-coarse lattice " << cclatt << std::endl;
-
-    Coordinate c5latt({1,clatt[0],clatt[1],clatt[2],clatt[3]});
-    c5simd = Coordinate({1,1,1,1,1});
-    c5mpi  = Coordinate({1,fmpi[1],fmpi[2],fmpi[3],fmpi[4]});
-    Coarse5d = new GridCartesian(c5latt,c5simd,c5mpi);
-
-    cmsimd = Coordinate({1,1,1,1,1,1});
-    cmmpi  = Coordinate({1,1,fmpi[1],fmpi[2],fmpi[3],fmpi[4]});
-    Coordinate cblatt({batch,1,clatt[0],clatt[1],clatt[2],clatt[3]});
-    CoarseBatch = new GridCartesian(cblatt,cmsimd,cmmpi);
-
-    Coordinate cc5latt({1,cclatt[0],cclatt[1],cclatt[2],cclatt[3]});
-    CoarseCoarse5d = new GridCartesian(cc5latt,c5simd,c5mpi);
-
-    Coordinate ccblatt({batch,1,cclatt[0],cclatt[1],cclatt[2],cclatt[3]});
-    CoarseCoarseBatch = new GridCartesian(ccblatt,cmsimd,cmmpi);
-  }
-  ~MGCoarseGrids()
-  {
-    delete CoarseCoarseBatch;
-    delete CoarseCoarse5d;
-    delete CoarseBatch;
-    delete Coarse5d;
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// The fp32 fine grids: same lattice and decomposition as the fp64 fine
-// grid, vComplexF SIMD layout.  For the fp32 fine level inside the
-// preconditioner (the fp32 fermion operators and the fp32 transfer
-// operator borrow these).  Owned here; declare BEFORE the coarsening.
-//////////////////////////////////////////////////////////////////////
-class MGFineGridsF {
-public:
-  GridCartesian         *UGridF;
-  GridRedBlackCartesian *UrbGridF;
-  GridCartesian         *FGridF;
-  GridRedBlackCartesian *FrbGridF;
-
-  MGFineGridsF(GridCartesian *FGrid)
-  {
-    Coordinate fdims = FGrid->FullDimensions();      // {Ls, x,y,z,t}
-    Coordinate fmpi  = FGrid->_processors;
-    GRID_ASSERT( fdims.size() == 5 );
-    int Ls = fdims[0];
-    Coordinate latt4({fdims[1],fdims[2],fdims[3],fdims[4]});
-    Coordinate mpi4 ({fmpi[1], fmpi[2], fmpi[3], fmpi[4]});
-    UGridF   = SpaceTimeGrid::makeFourDimGrid(latt4,GridDefaultSimd(Nd,vComplexF::Nsimd()),mpi4);
-    UrbGridF = SpaceTimeGrid::makeFourDimRedBlackGrid(UGridF);
-    FGridF   = SpaceTimeGrid::makeFiveDimGrid(Ls,UGridF);
-    FrbGridF = SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls,UGridF);
-  }
-  ~MGFineGridsF()
-  {
-    delete FrbGridF;
-    delete FGridF;
-    delete UrbGridF;
-    delete UGridF;
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// ALL the coarsening information for one gauge configuration.
-//
-// Owns: the RAW near-null bases (fine and coarse -- retained so the
-// coarse operators can be REBUILT on a changed gauge field with a
-// fixed basis, the cheap HMC maintenance step; DiscardBasis() frees
-// them for valence use), the two coarsened operators, the two block
-// projectors, the dense bottom inverse (raw owning pointer: null in
-// the constructor, allocated by BuildDenseBottom, deleted here), and
-// the transient per-Nrhs solve grids (created by SetNrhs, which owns
-// the ReleaseGrid -> delete -> new -> SetGrid ordering in ONE place).
-//
-// Borrows: the grid bundle.  Declare MGCoarseGrids first.
-//////////////////////////////////////////////////////////////////////
-template<class Fobj,class CComplex,int nbasis>
-class PVdagMMultiGridCoarsening {
-public:
-  typedef Lattice<Fobj>                                                 FineField;
-  typedef MultiGeneralCoarsenedOperatorV2<Fobj,CComplex,nbasis>         CoarseOperator;
-  typedef typename CoarseOperator::CoarseVector                         CoarseVector;
-  typedef typename CoarseVector::vector_object                          CoarseSiteObj;
-  // Every coarse level carries the same site type iVector<CComplex,nbasis>:
-  // the coefficient scalar does not deepen with the level (the operator keeps
-  // its own deeper scratch type for the block inner products).  Levels are
-  // told apart by their grids, not their C++ types.
-  typedef MultiGeneralCoarsenedOperatorV2<CoarseSiteObj,CComplex,nbasis> CoarseCoarseOperator;
-  typedef typename CoarseCoarseOperator::CoarseVector                   CoarseCoarseVector;
-  typedef DenseCoarseMatrix<CComplex,nbasis>                            DenseBottom;
-  // The fp32 fine field, derived from the fp64 one: the fp32 fine level of
-  // the preconditioner projects through the SAME basis in fp32 layout.
-  typedef typename GridTypeMapper<Fobj>::SinglePrecision                FobjF;
-  typedef Lattice<FobjF>                                                FineFieldF;
-
-  //////////////////////////////////////////////////////////////////////
-  // ONE fine transfer operator.  Its STORE follows the coarse sector --
-  // the coarse space is what it feeds -- while its import and export
-  // accept EITHER fine precision, because they are already a layout
-  // transformation and a scalar conversion inside one costs nothing.
-  // So an fp64 outer level and an fp32 V-cycle share this single object,
-  // and no second basis store, handover or retained basis is needed.
-  //////////////////////////////////////////////////////////////////////
-  static const bool CoarseIsSingle =
-    ( sizeof(typename GridTypeMapper<CComplex>::scalar_type) == sizeof(ComplexF) );
-  typedef typename std::conditional<CoarseIsSingle,FineFieldF,FineField>::type ProjectorField;
-  typedef MultiRHSBlockProject<ProjectorField>                          ProjectorL1_t;
-  typedef MultiRHSBlockProject<CoarseVector>                            ProjectorL2_t;
-
-  MGCoarseGrids                     &Grids;      // borrowed
-  MGFineGridsF                      &GridsF;     // borrowed
-  MGSetupParams                      Params;
-  NextToNearestStencilGeometry5D     geom;
-  NextToNearestStencilGeometry5D     geom2;
-  CoarseOperator                     CoarseOpPV;
-  CoarseCoarseOperator               CoarseOpL2;
-  ProjectorL1_t                      MrhsProjectorL1;  // store follows the coarse sector
-  ProjectorL2_t                      MrhsProjectorL2;
-  DenseBottom                       *DenseCC;
-  std::vector<FineField>             rawNull;    // RAW fine near-null basis
-  std::vector<CoarseVector>          rawPsi;     // RAW coarse near-null basis
-  GridCartesian                     *CMrhs;      // transient solve grids, owned
-  GridCartesian                     *CCMrhs;
-  int                                nrhs;
-
-  PVdagMMultiGridCoarsening(MGCoarseGrids &_Grids, MGFineGridsF &_GridsF, const MGSetupParams &P)
-    : Grids(_Grids),
-      GridsF(_GridsF),
-      Params(P),
-      geom (_Grids.Coarse5d),
-      geom2(_Grids.CoarseCoarse5d),
-      CoarseOpPV(geom ,_Grids.Coarse5d),
-      CoarseOpL2(geom2,_Grids.CoarseCoarse5d),
-      DenseCC(nullptr),
-      CMrhs(nullptr),
-      CCMrhs(nullptr),
-      nrhs(-1)
-  {};
-
-  ~PVdagMMultiGridCoarsening()
-  {
-    if ( DenseCC ) delete DenseCC;
-    CoarseOpPV.ReleaseGrid();     // borrowers let go before their grids die
-    CoarseOpL2.ReleaseGrid();
-    if ( CMrhs  ) delete CMrhs;
-    if ( CCMrhs ) delete CCMrhs;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // The RAW fine basis: load from Params.SubspaceFile if it exists,
-  // else GCR inverse iteration from noise (and save if a file name
-  // was given).  The Aggregation is scaffolding for CreateSubspaceGCR
-  // only -- that runs entirely on the fine grid, so the coarse grid
-  // it holds is never dereferenced.
-  ////////////////////////////////////////////////////////////////////
-  void GetSubspace(GridParallelRNG &RNG, LinearOperatorBase<FineField> &FineOp)
-  {
-    uint64_t file_exists=0;
-    if ( Params.SubspaceFile.length() ) {
-      if ( Grids.FGrid->IsBoss() ){ std::ifstream f(Params.SubspaceFile); file_exists=f.good()?1:0; }
-      Grids.FGrid->GlobalSum(file_exists);
-    }
-    rawNull.clear();
-    rawNull.reserve(nbasis);
-    for(int k=0;k<nbasis;k++) rawNull.push_back(FineField(Grids.FGrid));
-    if ( file_exists ){
-      std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: loading subspace "
-                << Params.SubspaceFile << " (kept RAW)" << std::endl;
-      loadSubspace(rawNull, Params.SubspaceFile);
-    } else {
-      std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: GCR subspace generation" << std::endl;
-      Aggregation<Fobj,CComplex,nbasis> Agg(Grids.Coarse5d,Grids.FGrid,0);
-      Agg.CreateSubspaceGCR(RNG,FineOp,nbasis);
-      for(int k=0;k<nbasis;k++)
-	rawNull[k]=Agg.subspace[k];
-      if ( Params.SubspaceFile.length() )
-	saveSubspace(rawNull, Params.SubspaceFile);
-    }
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Both coarsenings from the retained RAW basis.  Calling this again
-  // on a CHANGED fine operator is the fixed-basis rebuild: for the
-  // PVdagM coarsening the coarse operator with a fixed basis is exact
-  // in the changed links.  CoarsenOperator block-orthonormalises its
-  // input in place, so working copies are taken and the RAW vectors
-  // survive for the next rebuild.
-  //
-  // The fine operator must be the PVdagM wrapper (it needs
-  // SloppyComms: the coarsening builds the PRECONDITIONER, so its
-  // halos follow the FineSloppyComms policy, restored EXACT on exit).
-  ////////////////////////////////////////////////////////////////////
-  template<class PVdagMOp>
-  void Coarsen(PVdagMOp &FineOp, int retain_basis=0)
-  {
-    GRID_ASSERT( rawNull.size() == nbasis );
-
-    // L1: working copy of the raw fine basis, orthonormalised in place
-    std::vector<FineField> sub(rawNull);
-
-    CoarseOpPV.SetGrid(Grids.CoarseBatch);
-
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: L1 CoarsenOperator, batch "
-              << Grids.batch << std::endl;
-
-    // CoarsenOperator orthonormalises sub in place and imports it into OUR
-    // transfer operator, which it then uses.  One basis store, imported once.
-    // The projector's grid carries the STORE's SIMD layout, which is the fp32
-    // fine grid when the coarse sector is fp32; fp64 vectors convert on import.
-    MrhsProjectorL1.Allocate(nbasis,
-                             CoarseIsSingle ? (GridBase *)GridsF.FGridF : (GridBase *)Grids.FGrid,
-                             Grids.Coarse5d);
-    FineOp.SloppyComms(Params.FineSloppyComms);
-    CoarseOpPV.CoarsenOperator(FineOp,sub,Grids.Coarse5d,Grids.batch,MrhsProjectorL1);
-    FineOp.SloppyComms(0);
-    // The Lattice copy of the basis has served its purpose: the transfer
-    // operator holds it in BLAS layout from here on.
-    sub.clear(); sub.shrink_to_fit();
-
-    std::vector<CoarseVector> psi(nbasis,Grids.Coarse5d);
-    MrhsProjectorL1.blockProject(rawNull,psi);
-    GramGuard("psi_coarse",psi,Grids.Coarse5d);
-
-    rawPsi.clear();
-    rawPsi.reserve(nbasis);
-    for(int k=0;k<nbasis;k++) rawPsi.push_back(psi[k]);
-
-    // L2: the V2 L1 operator is natively multiRHS at the batch grid
-    CoarseOpL2.SetGrid(Grids.CoarseCoarseBatch);
-    NonHermitianLinearOperator<CoarseOperator,CoarseVector> LinOpCoarse(CoarseOpPV);
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: L2 CoarsenOperator, batch "
-              << Grids.batch << std::endl;
-    MrhsProjectorL2.Allocate(nbasis,Grids.Coarse5d,Grids.CoarseCoarse5d);
-    CoarseOpL2.CoarsenOperator(LinOpCoarse,Grids.CoarseBatch,psi,Grids.CoarseCoarse5d,MrhsProjectorL2);
-    {
-      std::vector<CoarseCoarseVector> psi_cc(nbasis,Grids.CoarseCoarse5d);
-      MrhsProjectorL2.blockProject(rawPsi,psi_cc); // RAW vectors in
-      GramGuard("psi_cc",psi_cc,Grids.CoarseCoarse5d);
-    }
-    // The RAW basis has done its work (the L2 null space above was its last
-    // use) and is the single largest resident block of the setup, so it is
-    // freed.  retain_basis keeps it for a caller that coarsens again from the
-    // same basis; Setup.RetainSubspace keeps it for the object's whole life,
-    // which is what a fixed-basis rebuild on a changed gauge field (HMC)
-    // needs.  A valence solve never rebuilds.
-    if ( !retain_basis && !Params.RetainSubspace ) DiscardBasis();
-    MrhsProjectorL1.ReleaseScratch();
-    MrhsProjectorL2.ReleaseScratch();
-
-    nrhs = -1;                                     // both operators left at the batch grids
-    ReportDeviceFootprint("after Coarsen");
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Dense bottom: import the L2 matrix elements, invert (2D
-  // block-cyclic, fp64), then the check Import cannot run itself --
-  // the mrhs operator applies only on a D+1 grid, so drive it at
-  // Nrhs 1 through a slice: ||A Ainv x - x||/||x||.
-  ////////////////////////////////////////////////////////////////////
-  void BuildDenseBottom(void)
-  {
-    if ( DenseCC ) delete DenseCC;
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: L3 dense bottom import" << std::endl;
-    DenseCC = new DenseBottom(Grids.CoarseCoarse5d);
-    DenseCC->Import(CoarseOpL2);
-
-    Coordinate cc1latt({1,1,Grids.cclatt[0],Grids.cclatt[1],Grids.cclatt[2],Grids.cclatt[3]});
-    GridCartesian *CoarseCoarseOne = new GridCartesian(cc1latt,Grids.cmsimd,Grids.cmmpi);
-    CoarseOpL2.SetGrid(CoarseCoarseOne);
-
-    CoarseCoarseVector x(Grids.CoarseCoarse5d),y(Grids.CoarseCoarse5d),z(Grids.CoarseCoarse5d);
-    GridParallelRNG dRNG(Grids.CoarseCoarse5d); dRNG.SeedFixedIntegers(std::vector<int>({11,12,13,14}));
-    random(dRNG,x);
-
-    (*DenseCC)(x,y);                    // y = Ainv x
-
-    CoarseCoarseVector y1(CoarseCoarseOne),z1(CoarseCoarseOne);
-    InsertSliceFast(y,y1,0,0);
-    CoarseOpL2.M(y1,z1);                // z = A y
-    ExtractSliceFast(z,z1,0,0);
-
-    z = z - x;
-    RealD rel = std::sqrt(norm2(z)/norm2(x));
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: L3 dense ||A Ainv x - x||/||x|| = "
-              << rel << std::endl;
-    GRID_ASSERT( rel < 1.0e-2 );
-
-    CoarseOpL2.ReleaseGrid();           // let go before the grid dies
-    delete CoarseCoarseOne;
-    nrhs = -1;
-    ReportDeviceFootprint("after BuildDenseBottom");
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Retarget both operators to a solve Nrhs.  The matrix elements are
-  // Nrhs independent and survive; only the D+1 grids and BLAS buffers
-  // change.  The ordering discipline (borrowers release BEFORE their
-  // grids are destroyed) lives here and nowhere else.
-  ////////////////////////////////////////////////////////////////////
-  void SetNrhs(int nr)
-  {
-    if ( nr == nrhs ) return;
-    CoarseOpPV.ReleaseGrid();
-    CoarseOpL2.ReleaseGrid();
-    if ( CMrhs  ) { delete CMrhs;  CMrhs =nullptr; }
-    if ( CCMrhs ) { delete CCMrhs; CCMrhs=nullptr; }
-    Coordinate cml ({nr,1,Grids.clatt[0], Grids.clatt[1], Grids.clatt[2], Grids.clatt[3]});
-    Coordinate ccml({nr,1,Grids.cclatt[0],Grids.cclatt[1],Grids.cclatt[2],Grids.cclatt[3]});
-    CMrhs  = new GridCartesian(cml, Grids.cmsimd,Grids.cmmpi);
-    CCMrhs = new GridCartesian(ccml,Grids.cmsimd,Grids.cmmpi);
-    CoarseOpPV.SetGrid(CMrhs);
-    CoarseOpL2.SetGrid(CCMrhs);
-    nrhs = nr;
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: operators at Nrhs " << nr << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Galerkin certificate for the L1 coarsening: ||A_c x - P^dag A P x||
-  // over ||A_c x|| on a random coarse vector, through the SAME transfer
-  // operators the solve uses.  The coarse operator is compared with its
-  // own definition, so this reads the ROUNDING level of the coarsening
-  // (fp64 coarse ~1e-13, fp32 coarse ~1e-6) independently of how the
-  // solve converges.  Drives the fine operator with EXACT halos; at more
-  // than one rank the sloppy-halo coarsening error is included in the
-  // reading.  Nrhs 1; the caller's Nrhs is restored by its own SetNrhs.
-  ////////////////////////////////////////////////////////////////////
-  template<class PVdagMOp>
-  RealD CertifyCoarsening(PVdagMOp &FineOp)
-  {
-    SetNrhs(1);
-    CoarseVector xc(CMrhs), Acx(CMrhs), PtAPx(CMrhs);
-    GridParallelRNG cRNG(CMrhs); cRNG.SeedFixedIntegers(std::vector<int>({21,22,23,24}));
-    random(cRNG,xc);
-
-    CoarseOpPV.M(xc,Acx);                                   // A_c x
-
-    std::vector<FineField> Px(1,Grids.FGrid), APx(1,Grids.FGrid);
-    MrhsProjectorL1.blockPromote(Px,xc);                      // P x
-    FineOp.SloppyComms(0);
-    FineOp.Op(Px[0],APx[0]);                                // A P x
-    MrhsProjectorL1.blockProject(APx,PtAPx);                  // P^dag A P x
-
-    CoarseVector d(CMrhs); d = Acx - PtAPx;
-    RealD rel = std::sqrt(norm2(d)/norm2(Acx));
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening: L1 GALERKIN CERTIFICATE "
-              << "||A_c x - P^dag A P x||/||A_c x|| = " << rel << std::endl;
-    return rel;
-  }
-
-
-  ////////////////////////////////////////////////////////////////////
-  // The device memory this coarsening holds that the memory manager
-  // CANNOT evict: BLAS stores, which are plain device allocations.
-  // Lattice fields are omitted on purpose -- they are evictable, so they
-  // cost eviction traffic, not failure.  What is reported is what has to
-  // fit alongside the manager's cache, the comms buffers and the shm
-  // segment, which is the budget an out-of-memory run actually breaks.
-  ////////////////////////////////////////////////////////////////////
-  void ReportDeviceFootprint(const std::string &when)
-  {
-    uint64_t p1 = MrhsProjectorL1.DeviceBytes();
-    uint64_t p2 = MrhsProjectorL2.DeviceBytes();
-    uint64_t o1 = CoarseOpPV.DeviceBytes();
-    uint64_t o2 = CoarseOpL2.DeviceBytes();
-    uint64_t dn = DenseCC ? DenseCC->DeviceBytes() : 0;
-    uint64_t tot = p1+p2+o1+o2+dn;
-    const double G = 1024.*1024.*1024.;
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening (" << when << "): resident device memory/rank "
-              << tot/G << " GB = transfer L1 " << p1/G << " + L2 " << p2/G
-              << " + operator L1 " << o1/G << " + L2 " << o2/G
-              << " + dense " << dn/G << " GB" << std::endl;
-    std::cout << GridLogMessage << "PVdagMMultiGridCoarsening (" << when << "): not evictable; must fit alongside the "
-              << MemoryManager::DeviceMaxBytes/G
-              << " GB manager cache, the comms buffers and the shm segment" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Free the retained RAW bases (valence use: coarsening is final for
-  // this configuration and the fine basis is ~GB-scale host memory).
-  ////////////////////////////////////////////////////////////////////
-  void DiscardBasis(void)
-  {
-    rawNull.clear(); rawNull.shrink_to_fit();
-    rawPsi.clear();  rawPsi.shrink_to_fit();
-  }
-};
-
-//////////////////////////////////////////////////////////////////////
-// The solve chain on a borrowed coarsening: adaptive PGCR smoothers
-// at both levels (the one correct route for this non-Hermitian
-// chain), dense bottom, mrhs V-cycle, outer shared-coefficient mrhs
-// PGCR.  Construction retargets the coarsening to this Nrhs.
-//
-// Halo policy: the whole V-cycle is preconditioner and runs with
-// sloppy halos when FineSloppyComms is set; the outer Krylov is EXACT
-// (its applications define what "converged" means), asserted by the
-// FINAL true-residual report in Solve.
-//////////////////////////////////////////////////////////////////////
-template<class Matrix,class MatrixF,class Coarsening>
-class PVdagMMultiGridSolver {
-public:
-  typedef typename Coarsening::FineField            FineField;
-  typedef typename Coarsening::FineFieldF           FineFieldF;
-  typedef typename Coarsening::CoarseOperator       CoarseOperator;
-  typedef typename Coarsening::CoarseVector         CoarseVector;
-  typedef typename Coarsening::CoarseCoarseOperator CoarseCoarseOperator;
-  typedef typename Coarsening::CoarseCoarseVector   CoarseCoarseVector;
-  typedef typename Coarsening::DenseBottom          DenseBottom;
-  typedef PrecGeneralisedConjugateResidualNonHermitian<FineField>    FineSmoother_t;
-  typedef PrecGeneralisedConjugateResidualNonHermitian<FineFieldF>   FineSmootherF_t;
-  typedef PrecGeneralisedConjugateResidualNonHermitian<CoarseVector> CoarseKrylov_t;
-
-  Coarsening            &C;
-  PVdagMMultiGridParams  Params;
-  int                    nrhs;
-  int                    _regrid;    // FIRST member-like init: SetNrhs before members capture grids
-
-  PVdagMLinearOperator<Matrix,FineField>        PVdagM;
-  ShiftedPVdagMLinearOperator<Matrix,FineField> ShiftedPVdagM;
-  TrivialPrecon<FineField>                      simple_fine;
-  TrivialPrecon<CoarseVector>                   simpleC;
-  NonHermitianLinearOperator<CoarseOperator,CoarseVector> LinOpC;
-  ShiftedLinearOperator<CoarseVector>           ShiftedC;
-  MrhsDenseCCSolve<DenseBottom,CoarseCoarseVector> ccSolve;
-  CoarseKrylov_t                                CoarseSmootherGCR;
-  MrhsCoarseThreeLevelPrec<CoarseVector,CoarseCoarseVector> L2to3Precon;
-  CoarseKrylov_t                                L2PGCR;
-  // The fp64 fine level of the preconditioner
-  FineSmoother_t                                SmootherGCR;
-  MrhsTwoLevelMG<FineField,CoarseVector,FineSmoother_t,typename Coarsening::ProjectorL1_t> ThreeLevelPrecon;
-  // The fp32 fine level of the preconditioner, behind the fp64/fp32 seam.
-  // Both share the coarse chain (L2PGCR); the outer Krylov picks one.
-  PVdagMLinearOperator<MatrixF,FineFieldF>        PVdagMF;
-  ShiftedPVdagMLinearOperator<MatrixF,FineFieldF> ShiftedPVdagMF;
-  TrivialPrecon<FineFieldF>                       simple_fine_f;
-  FineSmootherF_t                                 SmootherGCRF;
-  MrhsTwoLevelMG<FineFieldF,CoarseVector,FineSmootherF_t,typename Coarsening::ProjectorL1_t> ThreeLevelPreconF;
-  MrhsMixedPrecPreconditioner<FineField,FineFieldF> PreconSeam;
-  MrhsPGCRNonHermitian<FineField>               L1PGCR;
-
-  PVdagMMultiGridSolver(Matrix &Ddwf, Matrix &Dpv, MatrixF &DdwfF, MatrixF &DpvF,
-                        Coarsening &_C, const PVdagMMultiGridParams &P, int nr)
-    : C(_C), Params(P), nrhs(nr),
-      _regrid((C.SetNrhs(nr),0)),              // members below capture C.CMrhs/C.CCMrhs
-      PVdagM(Ddwf,Dpv),
-      ShiftedPVdagM(P.FineSmoother.Shift,Ddwf,Dpv),
-      LinOpC(C.CoarseOpPV),
-      ShiftedC(P.CoarseSmoother.Shift,LinOpC),
-      ccSolve(*C.DenseCC,nr),
-      // Coarse smoother: one preconditioned restart of nstep GCR steps.
-      CoarseSmootherGCR(0.01,1,ShiftedC,simpleC,P.CoarseSmoother.Mmax,P.CoarseSmoother.Nstep),
-      L2to3Precon(LinOpC,CoarseSmootherGCR,C.MrhsProjectorL2,ccSolve,
-                  C.Grids.Coarse5d,C.Grids.CoarseCoarse5d,C.CCMrhs,nr),
-      // Coarse Krylov: Order/16 restarts of 16 steps.
-      L2PGCR(P.CoarseSolver.Tol,P.CoarseSolver.Order/16,LinOpC,L2to3Precon,P.CoarseSolver.Mmax,16),
-      // Fine smoother: one restart of nstep GCR steps, tolerance 0 = fixed work.
-      SmootherGCR(0.0,1,ShiftedPVdagM,simple_fine,P.FineSmoother.Mmax,P.FineSmoother.Nstep),
-      ThreeLevelPrecon(PVdagM,SmootherGCR,C.MrhsProjectorL1,L2PGCR,C.Grids.Coarse5d,C.CMrhs),
-      PVdagMF(DdwfF,DpvF),
-      ShiftedPVdagMF(P.FineSmoother.Shift,DdwfF,DpvF),
-      SmootherGCRF(0.0,1,ShiftedPVdagMF,simple_fine_f,P.FineSmoother.Mmax,P.FineSmoother.Nstep),
-      ThreeLevelPreconF(PVdagMF,SmootherGCRF,C.MrhsProjectorL1,L2PGCR,C.Grids.Coarse5d,C.CMrhs),
-      PreconSeam(ThreeLevelPreconF,Ddwf.FermionGrid(),DdwfF.FermionGrid(),nr),
-      L1PGCR(P.Outer.Tol,P.Outer.MaxIterations,PVdagM,
-             (P.Setup.FinePrecision==MGPrecision::fp32)
-               ? static_cast<MrhsLinearFunction<FineField>&>(PreconSeam)
-               : static_cast<MrhsLinearFunction<FineField>&>(ThreeLevelPrecon),
-             P.Outer.Mmax,P.Outer.Nstep)
-  {
-    GRID_ASSERT( C.DenseCC != nullptr );
-
-    CoarseSmootherGCR.Level(2);
-    CoarseSmootherGCR.Name("Csmoother");
-    CoarseSmootherGCR.SetZeroGuess(1);
-
-    L2PGCR.Level(2);
-    L2PGCR.Name("Couter");
-    L2PGCR.SetZeroGuess(1);
-
-    SmootherGCR.Level(1);
-    SmootherGCR.Name("Fsmoother");
-    SmootherGCR.SetZeroGuess(1);
-
-    SmootherGCRF.Level(1);
-    SmootherGCRF.Name("Fsmoother");
-    SmootherGCRF.SetZeroGuess(1);
-
-    L1PGCR.Level(1);
-    L1PGCR.Name("Fouter");
-    L1PGCR.SetZeroGuess(1);
-
-    // The V-cycle is preconditioner: sloppy halos inside, exact restored on exit.
-    ThreeLevelPrecon.SetSloppy    = [this](int s){ PVdagM.SloppyComms(s); };
-    ThreeLevelPrecon.SloppyComms  = Params.Setup.FineSloppyComms;
-    ThreeLevelPreconF.SetSloppy   = [this](int s){ PVdagMF.SloppyComms(s); };
-    ThreeLevelPreconF.SloppyComms = Params.Setup.FineSloppyComms;
-    PVdagM.SloppyComms(0);
-    PVdagMF.SloppyComms(0);
-    // Three stages, three arithmetics, and a wire format that follows the
-    // ARITHMETIC of the stage it serves: fp32 on an fp64 operator, bf16 on
-    // an fp32 one.  The coarsening always applies the fp64 operator, so its
-    // wire is fp32 whatever the preconditioner runs in.
-    const bool sloppy = Params.Setup.FineSloppyComms;
-    const bool pfp32  = (Params.Setup.FinePrecision==MGPrecision::fp32);
-    std::cout << GridLogMessage << "PVdagMMultiGridSolver: Nrhs " << nr << std::endl;
-    std::cout << GridLogMessage << "  outer Krylov       : fp64, halos EXACT (the true residual is measured here)" << std::endl;
-    std::cout << GridLogMessage << "  preconditioner fine: " << (pfp32 ? "fp32 (seam at the outer Krylov)" : "fp64")
-              << ", halos " << (sloppy ? (pfp32 ? "SLOPPY bf16 wire" : "SLOPPY fp32 wire") : "exact") << std::endl;
-    std::cout << GridLogMessage << "  coarsening (done)  : fp64 operator, halos "
-              << (sloppy ? "SLOPPY fp32 wire" : "exact")
-              << " -- the coarse operator does not follow FinePrecision" << std::endl;
-  }
-
-  void Solve(std::vector<FineField> &src, std::vector<FineField> &sol)
-  {
-    GRID_ASSERT( (int)src.size() == nrhs );
-    // Start the solve from a clean device: evict setup-era Lattice copies
-    // and release the allocation caches' held blocks, so the LRU cap
-    // applies to the solve's own working set (OOM policy, Frontier).
-    MemoryManager::EvictAll();
-    MemoryManager::DropCache();
-
-    GridStopWatch w; w.Start();
-    L1PGCR(src,sol);
-    w.Stop();
-    std::cout << GridLogMessage << "PVdagMMultiGridSolver: Nrhs "<<nrhs<<" total " << w.Elapsed()
-              << "  (per RHS: " << w.useconds()/1.0e6/nrhs << " s)" << std::endl;
-
-    // The outer operator is exact by policy; assert the state rather than
-    // trust it -- a preconditioner that failed to restore would surface here.
-    PVdagM.SloppyComms(0);
-    {
-      FineField Ax(src[0].Grid());
-      RealD worst=0.0;
-      for(int r=0;r<nrhs;r++){
-	PVdagM.Op(sol[r],Ax);
-	Ax=Ax-src[r];
-        RealD rn=std::sqrt(norm2(Ax)/norm2(src[r]));
-        std::cout << GridLogMessage << "FINAL Nrhs "<<nrhs<<": rhs["<<r<<"] true residual = " << rn << std::endl;
-        worst=std::max(worst,rn);
-      }
-      std::cout << GridLogMessage << "FINAL Nrhs "<<nrhs<<": worst-case residual = " << worst
-                << "   (exact-halo verification)" << std::endl;
-    }
-  }
-};
-
-NAMESPACE_END(Grid);
@@ -1,165 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/PVdagMMultiGridParams.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////////////
-// Serialisable parameters for the mrhs PVdagM multigrid solver chain.
-//
-// Named for the multigrid FORM it configures, as WilsonMGParams is for the
-// Wilson MG tests; an MrhsHDCGParams will compose the same generic MG*
-// sub-structs for the Hermitian chain.  Read from XML (or JSON -- the
-// serialisation macros give both) via ReadPVdagMMultiGridParams below and
-// printed at startup by the macro's operator<<, so every log identifies its
-// own run.  The constructor defaults ARE a tuned operating point, not
-// arbitrary: an unconfigured run reproduces it, so changing them changes what
-// an unconfigured run does.  Smoother mmax == nstep (full GCR history).
-//
-// There are NO environment-variable controls anywhere in this subsystem:
-// parameters live here, library-internal constants are hard defaults in their
-// classes, verbosity is the --log channels.
-// Research instruments (GCR coefficient recording/replay, Chebyshev and
-// stationary smoother variants, power iteration) are deliberately NOT part
-// of this interface: they remain programmatic, for algorithmic studies,
-// not consumer knobs.
-//////////////////////////////////////////////////////////////////////////////////////
-
-// Arithmetic precision of the fine level INSIDE the preconditioner -- the
-// smoother and the V-cycle's own fine residuals.  The outer Krylov is
-// always fp64: the fp64/fp32 seam sits at its preconditioner call.
-// Orthogonal to FineSloppyComms, which is the halo WIRE format.
-GRID_SERIALIZABLE_ENUM(MGPrecision, undef, fp64, 1, fp32, 2);
-
-// The smoother is the adaptive shifted PGCR -- the one correct route for
-// this non-Hermitian chain (stationary replay and Chebyshev were explored
-// and did not win here; Chebyshev remains the HERMITIAN chain's smoother).
-struct MGSmootherParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(MGSmootherParams,
-                                  RealD, Shift,
-                                  int,   Nstep,
-                                  int,   Mmax);
-  MGSmootherParams(RealD shift=0.1, int nstep=6, int mmax=6)
-    : Shift(shift), Nstep(nstep), Mmax(mmax) {};
-};
-
-struct MGCoarseSolverParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(MGCoarseSolverParams,
-                                  RealD, Tol,
-                                  int,   Order,
-                                  int,   Mmax);
-  MGCoarseSolverParams() : Tol(0.05), Order(200), Mmax(16) {};
-};
-
-struct MGOuterParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(MGOuterParams,
-                                  RealD, Tol,
-                                  int,   MaxIterations,
-                                  int,   Mmax,
-                                  int,   Nstep);
-  MGOuterParams() : Tol(1.0e-8), MaxIterations(1000), Mmax(4), Nstep(8) {};
-};
-
-struct MGDenseParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(MGDenseParams,
-                                  int, LeafSpan);   // big-leaf span in blocks; see BlockCyclicSchurInverse
-  MGDenseParams() : LeafSpan(9) {};
-};
-
-struct MGSetupParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(MGSetupParams,
-                                  std::vector<int>, Block1,          // fine -> coarse blocking
-                                  std::vector<int>, Block2,          // coarse -> coarse-coarse blocking
-                                  int,              CoarsenBatch,
-                                  std::string,      SubspaceFile,    // scidac; empty = create from noise, no I/O
-                                  int,              FineSloppyComms, // reduced-precision halo WIRE inside the preconditioner only: fp32 on the fp64 operator, bf16 on the fp32 operator
-                                  MGPrecision,      FinePrecision,   // fine-level ARITHMETIC inside the preconditioner
-                                  int,              RetainSubspace); // keep the RAW basis after setup (nbasis fine vectors); needed ONLY for a fixed-basis rebuild on a changed gauge field (HMC).  A valence solve never rebuilds, so 0 frees it.
-  MGSetupParams()
-    : Block1({2,2,3,3}), Block2({4,4,2,4}), CoarsenBatch(9),
-      SubspaceFile(""), FineSloppyComms(1), FinePrecision(MGPrecision::fp64),
-      RetainSubspace(0) {};
-};
-
-struct PVdagMMultiGridParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(PVdagMMultiGridParams,
-                                  MGSetupParams,        Setup,
-                                  MGSmootherParams,     FineSmoother,
-                                  MGSmootherParams,     CoarseSmoother,
-                                  MGCoarseSolverParams, CoarseSolver,
-                                  MGOuterParams,        Outer,
-                                  MGDenseParams,        Dense);
-  PVdagMMultiGridParams()
-    : FineSmoother  (0.1, 6, 6),
-      CoarseSmoother(0.1, 2, 2) {};
-};
-
-inline void CheckValidity(const PVdagMMultiGridParams &P)
-{
-  GRID_ASSERT( P.Setup.Block1.size() == 4 );
-  GRID_ASSERT( P.Setup.Block2.size() == 4 );
-  GRID_ASSERT( P.Setup.CoarsenBatch  >= 1 );
-  GRID_ASSERT( P.Setup.FinePrecision != MGPrecision::undef );
-  GRID_ASSERT( P.FineSmoother.Nstep   > 0 );
-  GRID_ASSERT( P.CoarseSmoother.Nstep > 0 );
-  GRID_ASSERT( P.CoarseSolver.Tol     > 0.0 );
-  GRID_ASSERT( P.Outer.Tol            > 0.0 );
-  GRID_ASSERT( P.Dense.LeafSpan      >= 1 );
-}
-
-//////////////////////////////////////////////////////////////////////////////////////
-// Read from an XML file; on a MISSING file the boss writes <file>.templ from
-// the defaults and returns false so the caller can Grid_finalize() and exit
-// -- the produced template is the documentation of every parameter.  An
-// empty filename means "defaults": no I/O, returns true.  Always prints the
-// effective parameters, so the log describes the run.
-//
-// Drivers fetch the filename themselves, e.g.
-//   std::string pfile("");
-//   if( GridCmdOptionExists(argv,argv+argc,"--multigrid-params") )
-//     pfile = GridCmdOptionPayload(argv,argv+argc,"--multigrid-params");
-//   if( !ReadPVdagMMultiGridParams(Params, pfile) ) { Grid_finalize(); return 0; }
-//////////////////////////////////////////////////////////////////////////////////////
-inline bool ReadPVdagMMultiGridParams(PVdagMMultiGridParams &P, const std::string &xmlfile)
-{
-  if ( xmlfile.length() ) {
-    bool good;
-    { std::ifstream f(xmlfile); good = f.good(); }
-    if ( !good ) {
-      std::cout << GridLogMessage << "PVdagMMultiGridParams: " << xmlfile << " does not exist" << std::endl;
-      if ( GlobalSharedMemory::WorldRank == 0 ) {
-        XmlWriter WR(xmlfile+".templ");
-        write(WR, "PVdagMMultiGridParams", P);
-        std::cout << GridLogMessage << "PVdagMMultiGridParams: template written to "
-                  << xmlfile << ".templ" << std::endl;
-      }
-      return false;
-    }
-    XmlReader RD(xmlfile);
-    read(RD, "PVdagMMultiGridParams", P);
-  }
-  CheckValidity(P);
-  std::cout << GridLogMessage << "PVdagMMultiGridParams ("
-            << (xmlfile.length() ? xmlfile : std::string("defaults")) << "):" << std::endl;
-  std::cout << P << std::endl;
-  return true;
-}
-
-NAMESPACE_END(Grid);
@@ -1,88 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/PVdagMOperators.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////
-// A = PV^dag M (non-Hermitian).  The operator the PVdagM multigrid
-// coarsens and solves.
-//
-// SloppyComms delegates to BOTH underlying fermion operators, so one
-// call controls every fine halo in the chain -- including any shifted
-// wrapper built on the same two matrices.  Halo-precision POLICY:
-// reduced-precision (fp32 wire) halos belong in the PRECONDITIONER --
-// the smoother, the V-cycle's own residuals, the coarsening -- and
-// NEVER in the outer Krylov, whose applications define what
-// "converged" means.  The operators default to EXACT; the V-cycle
-// turns sloppiness on for its own scope only (MrhsTwoLevelMG).
-//////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class PVdagMLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat; Matrix &_PV;
-public:
-  PVdagMLinearOperator(Matrix &Mat,Matrix &PV): _Mat(Mat),_PV(PV) {};
-  void SloppyComms(int sloppy) { _Mat.SloppyComms(sloppy); _PV.SloppyComms(sloppy); }
-  void OpDiag (const Field &in, Field &out) { GRID_ASSERT(0); }
-  void OpDir  (const Field &in, Field &out,int dir,int disp) { GRID_ASSERT(0); }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){ GRID_ASSERT(0); };
-  void Op     (const Field &in, Field &out){ Field tmp(in.Grid()); _Mat.M(in,tmp); _PV.Mdag(tmp,out); }
-  void AdjOp  (const Field &in, Field &out){ Field tmp(in.Grid()); _PV.M(in,tmp); _Mat.Mdag(tmp,out); }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){ HermOp(in,out); ComplexD d=innerProduct(in,out); n1=real(d); n2=norm2(out); }
-  void HermOp(const Field &in, Field &out){ Field tmp(in.Grid()); Op(in,tmp); AdjOp(tmp,out); }
-};
-
-//////////////////////////////////////////////////////////////////////
-// A + shift, built directly on the two matrices (fine level: avoids
-// an extra fine-field pass through a generic shifted wrapper).
-//////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class ShiftedPVdagMLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat; Matrix &_PV;
-public:
-  RealD shift;
-  ShiftedPVdagMLinearOperator(RealD _shift,Matrix &Mat,Matrix &PV): shift(_shift),_Mat(Mat),_PV(PV){};
-  void OpDiag (const Field &in, Field &out) { GRID_ASSERT(0); }
-  void OpDir  (const Field &in, Field &out,int dir,int disp) { GRID_ASSERT(0); }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){ GRID_ASSERT(0); };
-  void Op     (const Field &in, Field &out){ Field tmp(in.Grid()); _Mat.M(in,tmp); _PV.Mdag(tmp,out); out = out + shift*in; }
-  void AdjOp  (const Field &in, Field &out){ Field tmp(in.Grid()); _PV.M(in,tmp); _Mat.Mdag(tmp,out); out = out + shift*in; }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){ GRID_ASSERT(0); }
-  void HermOp(const Field &in, Field &out){ Field tmp(in.Grid()); Op(in,tmp); AdjOp(tmp,out); }
-};
-
-//////////////////////////////////////////////////////////////////////
-// Op + shift for any operator (coarse levels).
-//////////////////////////////////////////////////////////////////////
-template<class Field>
-class ShiftedLinearOperator : public LinearOperatorBase<Field> {
-  LinearOperatorBase<Field> &_Op; RealD shift;
-public:
-  ShiftedLinearOperator(RealD _shift, LinearOperatorBase<Field> &Op) : _Op(Op), shift(_shift) {}
-  void OpDiag  (const Field &in, Field &out) { GRID_ASSERT(0); }
-  void OpDir   (const Field &in, Field &out,int dir,int disp) { GRID_ASSERT(0); }
-  void OpDirAll (const Field &in, std::vector<Field> &out) { GRID_ASSERT(0); }
-  void Op      (const Field &in, Field &out) { _Op.Op(in,out);    out = out + shift*in; }
-  void AdjOp   (const Field &in, Field &out) { _Op.AdjOp(in,out); out = out + shift*in; }
-  void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){ GRID_ASSERT(0); }
-  void HermOp  (const Field &in, Field &out) { Field tmp(in.Grid()); Op(in,tmp); AdjOp(tmp,out); }
-};
-
-NAMESPACE_END(Grid);
@@ -1,318 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./Grid/algorithms/multigrid/Smoothers.h
-
-    Copyright (C) 2026
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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.
-
-    See the full license in the file "LICENSE" in the top level distribution
-    directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-#include <Grid/algorithms/iterative/GCRCoefficients.h>
-
-NAMESPACE_BEGIN(Grid);
-
-//////////////////////////////////////////////////////////////////////////////
-// Multigrid smoothers as LinearFunction<Field> objects.
-//
-// Gathered here from ~15 copies in tests/solver and tests/debug (HDCR /
-// HDCG era), plus the fixed-polynomial smoothers of 2026:
-//
-//   ChebyshevSmoother          Chebyshev approx to 1/x on [lo,hi], applied
-//                              through HermOp (the original HDCG smoother on
-//                              a Hermitian shifted operator).
-//   ChebyshevNonHermitianSmoother  same polynomial applied through Op(), for
-//                              a non-Hermitian (near-normal, real-spectrum)
-//                              smoother operator such as shifted PVdagM.
-//   ChebyshevInverter          one Chebyshev-corrected step with residual print.
-//   MirsSmoother               shifted-MdagM CG, HDCG arXiv:1402.2585.
-//   CGSmoother                 fixed-iteration CG on an already-shifted
-//                              Hermitian operator: the mrhs HDCG smoother.
-//   GCRReplaySmoother          replays a GCR's recorded step lengths a_k and
-//                              orthogonalisation coefficients b_kj with NO
-//                              inner products: one matvec per step, zero
-//                              reductions.  The "PreconditionerMirsPoly"
-//                              idea of 1402.2585 p.13 applied to GCR.
-//
-// Recording: PrecGeneralisedConjugateResidualNonHermitian::SetCoefficientRecorder
-// accumulates per-step means over calls into a GCRCoefficients; construct a
-// GCRReplaySmoother from it.
-//////////////////////////////////////////////////////////////////////////////
-
-inline RealD InverseApproximation(RealD x){ return 1.0/x; }
-
-//////////////////////////////////////////////////////////////////////////////
-// HermOp-based Chebyshev smoother.  The second template parameter and the
-// 5-argument constructor exist only so the historical call sites
-//   ChebyshevSmoother<LatticeFermion,DomainWallFermionD> S(lo,hi,ord,HermOp,Ddwf);
-// compile unchanged; the Matrix argument was never used.
-//////////////////////////////////////////////////////////////////////////////
-template<class Field,class Matrix=void> class ChebyshevSmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  typedef LinearOperatorBase<Field> FineOperator;
-  FineOperator   & _SmootherOperator;
-  Chebyshev<Field> Cheby;
-  ChebyshevSmoother(RealD _lo,RealD _hi,int _ord, FineOperator &SmootherOperator) :
-    _SmootherOperator(SmootherOperator),
-    Cheby(_lo,_hi,_ord,InverseApproximation)
-  {
-    std::cout << GridLogMessage<<" Chebyshev smoother order "<<_ord<<" ["<<_lo<<","<<_hi<<"]"<<std::endl;
-  };
-  template<class M>
-  ChebyshevSmoother(RealD _lo,RealD _hi,int _ord, FineOperator &SmootherOperator, M &) :
-    ChebyshevSmoother(_lo,_hi,_ord,SmootherOperator) {};
-  void operator() (const Field &in, Field &out)
-  {
-    Cheby(_SmootherOperator,in,out);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// Op()-based Chebyshev smoother: x = S(A) r with S the Chebyshev fit to 1/x
-// on [lo,hi].  Same three-term recurrence as Chebyshev<Field>::operator()
-// but through Op, for the non-Hermitian smoother operators of the PVdagM
-// multigrid (real coefficients / near-normal, as the recorded GCR
-// coefficients show).  `order` matvecs, no reductions.
-//////////////////////////////////////////////////////////////////////////////
-template<class Field> class ChebyshevNonHermitianSmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  LinearOperatorBase<Field> &Linop;
-  RealD lo, hi; int order;
-  std::vector<RealD> Coeffs;
-  int Verbose = 0;
-  std::string name = "cheb";
-  ChebyshevNonHermitianSmoother(RealD _lo,RealD _hi,int _order,LinearOperatorBase<Field> &Op)
-    : Linop(Op), lo(_lo), hi(_hi), order(_order)
-  {
-    GRID_ASSERT(order>=2);
-    Coeffs.resize(order);
-    for(int j=0;j<order;j++){
-      RealD s=0;
-      for(int k=0;k<order;k++){
-        RealD y=std::cos(M_PI*(k+0.5)/order);
-        RealD x=0.5*(y*(hi-lo)+(hi+lo));
-        s=s+InverseApproximation(x)*std::cos( j*M_PI*(k+0.5)/order );
-      }
-      Coeffs[j] = s * 2.0/order;
-    }
-    std::cout << GridLogMessage<<" ChebyshevNonHermitian smoother order "<<order<<" ["<<lo<<","<<hi<<"]"<<std::endl;
-  }
-  void operator() (const Field &in, Field &out)
-  {
-    GRID_TRACE("ChebyshevSmoother");
-    GridBase *grid=in.Grid();
-    Field T0(grid); T0 = in;
-    Field T1(grid), T2(grid), y(grid);
-    Field *Tnm=&T0, *Tn=&T1, *Tnp=&T2;
-    RealD xscale = 2.0/(hi-lo);
-    RealD mscale = -(hi+lo)/(hi-lo);
-    Linop.Op(T0,y);
-    axpby(T1,xscale,mscale,y,in);
-    axpby(out,0.5*Coeffs[0],Coeffs[1],T0,T1);
-    for(int n=2;n<order;n++){
-      Linop.Op(*Tn,y);
-      axpby(y,xscale,mscale,y,(*Tn));
-      axpby(*Tnp,2.0,-1.0,y,(*Tnm));
-      if ( Coeffs[n] != 0.0 ) axpy(out,Coeffs[n],*Tnp,out);
-      Field *swizzle=Tnm; Tnm=Tn; Tn=Tnp; Tnp=swizzle;
-    }
-    if ( Verbose ) { Linop.Op(out,y); y = y - in; std::cout << GridLogMessage << " " << name << " cheb |r|/|r0| = " << std::sqrt(norm2(y)/norm2(in)) << std::endl; }
-  }
-};
-
-template<class Field> class ChebyshevInverter : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  typedef LinearOperatorBase<Field> FineOperator;
-  FineOperator   & _Operator;
-  Chebyshev<Field> Cheby;
-  ChebyshevInverter(RealD _lo,RealD _hi,int _ord, FineOperator &Operator) :
-    _Operator(Operator),
-    Cheby(_lo,_hi,_ord,InverseApproximation)
-  {
-    std::cout << GridLogMessage<<" Chebyshev Inverter order "<<_ord<<" ["<<_lo<<","<<_hi<<"]"<<std::endl;
-  };
-  void operator() (const Field &in, Field &out)
-  {
-    Field r(in.Grid());
-    Field AinvR(in.Grid());
-    _Operator.HermOp(out,r);
-    r = in - r; // b - A x
-    Cheby(_Operator,r,AinvR); // A^{-1} ( b - A x ) ~ A^{-1} b - x
-    out = out + AinvR;
-    _Operator.HermOp(out,r);
-    r = in - r; // b - A x
-    RealD rr = norm2(r);
-    RealD ss = norm2(in);
-    std::cout << GridLogMessage << "ChebshevInverse resid " <<::sqrt(rr/ss)<<std::endl;
-  }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// MIRS: CG on the infra-red shifted MdagM (HDCG, arXiv:1402.2585).
-//////////////////////////////////////////////////////////////////////////////
-template<class Field,class Matrix> class MirsSmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  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);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// Fixed-iteration CG on an (already shifted) Hermitian operator, tolerance
-// zero so the work is fixed.  NOT a stationary preconditioner: the CG
-// coefficients depend on the input, so the map is nonlinear.  Use under a
-// flexible outer (fPcg); BlockCGrQ needs the Chebyshev smoother.
-//////////////////////////////////////////////////////////////////////////////
-template<class Field> class CGSmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  LinearOperatorBase<Field> &_Op;
-  int iters;
-  CGSmoother(int _iters, LinearOperatorBase<Field> &Op) : _Op(Op), iters(_iters)
-  {
-    std::cout << GridLogMessage << "CGSmoother order " << iters << std::endl;
-  }
-  void operator() (const Field &in, Field &out)
-  {
-    ConjugateGradient<Field> CG(0.0,iters,false);   // never converges: by design
-    out = Zero();
-    CG(_Op,in,out);
-  }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// Replay of a recorded GCR with a trivial preconditioner:
-//   p_0 = r_0 ;  x_{k+1} = x_k + a_k p_k ;  r_{k+1} = r_k - a_k A p_k ;
-//   p_{k+1} = r_{k+1} + sum_{j<northog(k)} b_kj p_{k-j}
-// One matvec per step, no reductions, history of mmax p vectors held
-// persistently (allocated on first use, per grid).
-//////////////////////////////////////////////////////////////////////////////
-template<class Field> class GCRReplaySmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  LinearOperatorBase<Field> &Linop;
-  int mmax, nstep;
-  std::vector<ComplexD>               a;
-  std::vector<std::vector<ComplexD> > b;
-  GridBase *hist_grid = nullptr;
-  std::vector<Field> p;
-  int Verbose = 0;                       // 1: print |r_m|/|r_0| per call (one extra reduction)
-  std::string name = "replay";
-  GCRReplaySmoother(LinearOperatorBase<Field> &Op, const GCRCoefficients &c) : Linop(Op)
-  {
-    mmax  = c.mmax;  GRID_ASSERT(mmax>=1);
-    nstep = c.Steps(); GRID_ASSERT(nstep>=1);
-    a.resize(nstep); b.resize(nstep);
-    // No std::abs / std::isfinite on ComplexD: it is thrust::complex on HIP
-    // builds and neither overload exists.  Work on the real and imaginary
-    // parts explicitly.
-    auto finite = [](ComplexD z){ RealD x=real(z), y=imag(z); return (x==x) && (y==y) && (x-x==0.0) && (y-y==0.0); };
-    auto cabs   = [](ComplexD z){ RealD x=real(z), y=imag(z); return std::sqrt(x*x+y*y); };
-    RealD amax=0.0, bmax=0.0;
-    for(int k=0;k<nstep;k++){
-      a[k] = c.A(k);
-      GRID_ASSERT( finite(a[k]) );
-      amax = std::max(amax, cabs(a[k]));
-      b[k].resize(c.NB(k));
-      GRID_ASSERT( c.NB(k) <= mmax-1 );
-      for(int j=0;j<c.NB(k);j++){
-        b[k][j] = c.B(k,j);
-        GRID_ASSERT( finite(b[k][j]) );
-        bmax = std::max(bmax, cabs(b[k][j]));
-      }
-    }
-    std::cout << GridLogMessage << " GCRReplaySmoother: max|a| " << amax << " max|b| " << bmax << std::endl;
-    std::cout << GridLogMessage << " GCRReplaySmoother: " << nstep << " steps, mmax " << mmax
-              << ", from " << c.Calls() << " recorded calls" << std::endl;
-  }
-  void operator() (const Field &src, Field &psi)
-  {
-    GRID_TRACE("GCRReplaySmoother");
-    GridBase *grid = src.Grid();
-    if ( hist_grid != grid ) {
-      p.clear(); p.reserve(mmax);
-      for(int i=0;i<mmax;i++) p.emplace_back(grid);
-      hist_grid = grid;
-    }
-    Field r(grid), q(grid);
-    r = src;
-    psi = Zero();
-    p[0] = r;
-    RealD r0 = Verbose ? norm2(src) : 0.0;
-    for(int k=0;k<nstep;k++){
-      int kp=k+1, peri_k=k%mmax, peri_kp=kp%mmax;
-      Linop.Op(p[peri_k],q);                 // q_k = A p_k
-      axpy(psi,  a[k], p[peri_k], psi);
-      if ( k==nstep-1 ) {
-        if ( Verbose ) { axpy(r,-a[k],q,r); std::cout << GridLogMessage << " " << name << " replay |r|/|r0| = " << std::sqrt(norm2(r)/r0) << std::endl; }
-        break;
-      }
-      axpy(r,   -a[k], q,         r);
-      p[peri_kp] = r;
-      for(int j=0;j<(int)b[k].size();j++){
-        int peri_back=(k-j)%mmax;
-        axpy(p[peri_kp], b[k][j], p[peri_back], p[peri_kp]);
-      }
-    }
-  }
-};
-
-//////////////////////////////////////////////////////////////////////////////
-// A LinearFunction that forwards to a replaceable target: lets a V-cycle be
-// built once around a smoother slot whose implementation is swapped at run
-// time (record with the adaptive GCR, then replay the polynomial).
-//////////////////////////////////////////////////////////////////////////////
-template<class Field> class SwitchableSmoother : public LinearFunction<Field>
-{
-public:
-  using LinearFunction<Field>::operator();
-  LinearFunction<Field> *current;
-  std::string label;
-  SwitchableSmoother(LinearFunction<Field> &initial, const std::string &l="initial") : current(&initial), label(l) {}
-  void Set(LinearFunction<Field> &f, const std::string &l)
-  {
-    current = &f; label = l;
-    std::cout << GridLogMessage << " SwitchableSmoother -> " << l << std::endl;
-  }
-  void operator() (const Field &in, Field &out) { (*current)(in,out); }
-};
-
-NAMESPACE_END(Grid);
@@ -1,704 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/GeneralCoarsenedMatrix.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-#include <Grid/qcd/QCD.h> // needed for Dagger(Yes|No), Inverse(Yes|No)
-
-#include <Grid/lattice/PaddedCell.h>
-#include <Grid/stencil/GeneralLocalStencil.h>
-#include <Grid/algorithms/deflation/MultiRHSBlockProject.h>
-
-NAMESPACE_BEGIN(Grid);
-
-// Fine Object == (per site) type of fine field
-// nbasis      == number of deflation vectors
-template<class Fobj,class CComplex,int nbasis>
-class GeneralCoarsenedMatrix : public SparseMatrixBase<Lattice<iVector<CComplex,nbasis > > >  {
-public:
-
-  typedef GeneralCoarsenedMatrix<Fobj,CComplex,nbasis> GeneralCoarseOp;
-  typedef iVector<CComplex,nbasis >           siteVector;
-  typedef iMatrix<CComplex,nbasis >           siteMatrix;
-  typedef Lattice<iScalar<CComplex> >         CoarseComplexField;
-  typedef Lattice<siteVector>                 CoarseVector;
-  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-  typedef iMatrix<CComplex,nbasis >  Cobj;
-  typedef iVector<CComplex,nbasis >  Cvec;
-  typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<Fobj >        FineField;
-  typedef Lattice<CComplex >    FineComplexField;
-  typedef CoarseVector Field;
-  ////////////////////
-  // Data members
-  ////////////////////
-  int hermitian;
-  GridBase      *       _FineGrid; 
-  GridCartesian *       _CoarseGrid; 
-  NonLocalStencilGeometry &geom;
-  PaddedCell Cell;
-  GeneralLocalStencil Stencil;
-  
-  std::vector<CoarseMatrix> _A;
-  std::vector<CoarseMatrix> _Adag;
-  std::vector<CoarseVector> MultTemporaries;
-
-  int64_t MultCalls;
-  double  MultFlopsAccum;
-  double  MultUsecAccum;
-
-  ///////////////////////
-  // Interface
-  ///////////////////////
-  //////////////////////////////////////////////////////////////////////////
-  // Bilingual accessors: everything a consumer needs to read the operator
-  // without knowing which of the three coarse classes it holds. The D
-  // dimensional grid the elements live on, the geometry they are indexed by,
-  // and one unpadded point at a time (a whole npoint vector is too much
-  // memory at production nbasis).
-  //////////////////////////////////////////////////////////////////////////
-  GridCartesian * CoarseGridD(void)             { return _CoarseGrid; };
-  NonLocalStencilGeometry & Geometry(void)      { return geom; };
-  void ExtractMatrix(int p,CoarseMatrix &A)     { A = Cell.Extract(_A[p]); };
-
-  GridBase      * Grid(void)           { return _CoarseGrid; };   // this is all the linalg routines need to know
-  GridBase      * FineGrid(void)       { return _FineGrid; };   // this is all the linalg routines need to know
-  GridCartesian * CoarseGrid(void)     { return _CoarseGrid; };   // this is all the linalg routines need to know
-
-  /*  void ShiftMatrix(RealD shift)
-  {
-    int Nd=_FineGrid->Nd(); 
-    Coordinate zero_shift(Nd,0);
-    for(int p=0;p<geom.npoint;p++){
-      if ( zero_shift==geom.shifts[p] ) {
-	_A[p] = _A[p]+shift;
-	//	_Adag[p] = _Adag[p]+shift;
-      }
-    }    
-  }
-  void ProjectNearestNeighbour(RealD shift, GeneralCoarseOp &CopyMe)
-  {
-    int nfound=0;
-    std::cout << GridLogMessage <<"GeneralCoarsenedMatrix::ProjectNearestNeighbour "<< CopyMe._A[0].Grid()<<std::endl;
-    for(int p=0;p<geom.npoint;p++){
-      for(int pp=0;pp<CopyMe.geom.npoint;pp++){
- 	// Search for the same relative shift
-	// Avoids brutal handling of Grid pointers
-	if ( CopyMe.geom.shifts[pp]==geom.shifts[p] ) {
-	  _A[p] = CopyMe.Cell.Extract(CopyMe._A[pp]);
-	  //	  _Adag[p] = CopyMe.Cell.Extract(CopyMe._Adag[pp]);
-	  nfound++;
-	}
-      }
-    }
-    GRID_ASSERT(nfound==geom.npoint);
-    ExchangeCoarseLinks();
-  }
-  */
-  
-  GeneralCoarsenedMatrix(NonLocalStencilGeometry &_geom,GridBase *FineGrid, GridCartesian * CoarseGrid,int _herm=1)
-    : geom(_geom),
-      _FineGrid(FineGrid),
-      _CoarseGrid(CoarseGrid),
-      hermitian(_herm),
-      Cell(_geom.Depth(),_CoarseGrid),
-      Stencil(Cell.grids.back(),geom.shifts),
-      MultCalls(0), MultFlopsAccum(0.0), MultUsecAccum(0.0)
-  {
-    {
-      int npoint = _geom.npoint;
-    }
-    _A.resize(geom.npoint,CoarseGrid);
-    if ( !hermitian ) _Adag.resize(geom.npoint,CoarseGrid);
-  }
-  void M (const CoarseVector &in, CoarseVector &out)
-  {
-    Mult(_A,in,out);
-  }
-  void Mdag (const CoarseVector &in, CoarseVector &out)
-  {
-    if(hermitian)
-      Mult(_A,in,out);
-    else
-      Mult(_Adag,in,out);
-  }
-  void Mult (std::vector<CoarseMatrix> &A,const CoarseVector &in, CoarseVector &out)
-  {
-    RealD tviews=0;    RealD ttot=0;    RealD tmult=0;   RealD texch=0;    RealD text=0; RealD ttemps=0; RealD tcopy=0;
-    RealD tmult2=0;
-
-    ttot=-usecond();
-    conformable(CoarseGrid(),in.Grid());
-    conformable(in.Grid(),out.Grid());
-    out.Checkerboard() = in.Checkerboard();
-    CoarseVector tin=in;
-
-    texch-=usecond();
-    CoarseVector pin = Cell.ExchangePeriodic(tin);
-    texch+=usecond();
-
-    CoarseVector pout(pin.Grid());
-
-    int npoint = geom.npoint;
-    typedef LatticeView<Cobj> Aview;
-    typedef LatticeView<Cvec> Vview;
-      
-    const int Nsimd = CComplex::Nsimd();
-    
-    int64_t osites=pin.Grid()->oSites();
-
-    RealD flops = 1.0* npoint * nbasis * nbasis * 8.0 * osites * CComplex::Nsimd();
-    RealD bytes = 1.0*osites*sizeof(siteMatrix)*npoint
-                + 2.0*osites*sizeof(siteVector)*npoint;
-      
-    {
-      tviews-=usecond();
-      autoView( in_v , pin, AcceleratorRead);
-      autoView( out_v , pout, AcceleratorWriteDiscard);
-      autoView( Stencil_v  , Stencil, AcceleratorRead);
-      tviews+=usecond();
-
-      // Static and prereserve to keep UVM region live and not resized across multiple calls
-      ttemps-=usecond();
-      MultTemporaries.resize(npoint,pin.Grid());       
-      ttemps+=usecond();
-      std::vector<Aview> AcceleratorViewContainer_h;
-      std::vector<Vview> AcceleratorVecViewContainer_h; 
-
-      tviews-=usecond();
-      for(int p=0;p<npoint;p++) {
-	AcceleratorViewContainer_h.push_back(      A[p].View(AcceleratorRead));
-	AcceleratorVecViewContainer_h.push_back(MultTemporaries[p].View(AcceleratorWrite));
-      }
-      tviews+=usecond();
-
-      static deviceVector<Aview> AcceleratorViewContainer; AcceleratorViewContainer.resize(npoint);
-      static deviceVector<Vview> AcceleratorVecViewContainer; AcceleratorVecViewContainer.resize(npoint); 
-      
-      auto Aview_p = &AcceleratorViewContainer[0];
-      auto Vview_p = &AcceleratorVecViewContainer[0];
-      tcopy-=usecond();
-      acceleratorCopyToDevice(&AcceleratorViewContainer_h[0],&AcceleratorViewContainer[0],npoint *sizeof(Aview));
-      acceleratorCopyToDevice(&AcceleratorVecViewContainer_h[0],&AcceleratorVecViewContainer[0],npoint *sizeof(Vview));
-      tcopy+=usecond();
-
-      tmult-=usecond();
-      accelerator_for(spb, osites*nbasis*npoint, Nsimd, {
-	  typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-	  int32_t ss   = spb/(nbasis*npoint);
-	  int32_t bp   = spb%(nbasis*npoint);
-	  int32_t point= bp/nbasis;
-	  int32_t b    = bp%nbasis;
-	  auto SE  = Stencil_v.GetEntry(point,ss);
-	  auto nbr = coalescedReadGeneralPermute(in_v[SE->_offset],SE->_permute,Nd);
-	  auto res = coalescedRead(Aview_p[point][ss](0,b))*nbr(0);
-	  for(int bb=1;bb<nbasis;bb++) {
-	    res = res + coalescedRead(Aview_p[point][ss](bb,b))*nbr(bb);
-	  }
-	  coalescedWrite(Vview_p[point][ss](b),res);
-      });
-      tmult2-=usecond();
-      accelerator_for(sb, osites*nbasis, Nsimd, {
-	  int ss = sb/nbasis;
-	  int b  = sb%nbasis;
-	  auto res = coalescedRead(Vview_p[0][ss](b));
-	  for(int point=1;point<npoint;point++){
-	    res = res + coalescedRead(Vview_p[point][ss](b));
-	  }
-	  coalescedWrite(out_v[ss](b),res);
-      });
-      tmult2+=usecond();
-      tmult+=usecond();
-      for(int p=0;p<npoint;p++) {
-	AcceleratorViewContainer_h[p].ViewClose();
-	AcceleratorVecViewContainer_h[p].ViewClose();
-      }
-    }
-
-    text-=usecond();
-    out = Cell.Extract(pout);
-    text+=usecond();
-    ttot+=usecond();
-    
-    MultCalls++;
-    MultFlopsAccum += flops;
-    MultUsecAccum  += ttot;
-    std::cout << GridLogPerformance
-	      << "Coarse Mult call " << MultCalls
-	      << "  tot " << ttot << " us"
-	      << "  kernel " << tmult << " us"
-	      << "  kernel " << flops/tmult*1e-3 << " GFlop/s"
-	      << "  overall " << MultFlopsAccum/MultUsecAccum*1e-3 << " GFlop/s (cumul)"
-	      << "  bw " << bytes/tmult*1e-3 << " GB/s"
-	      << std::endl;
-
-  };
-  
-  void PopulateAdag(void)
-  {
-#if 0
-    // Serial global peek/poke reference implementation
-    for(int64_t bidx=0;bidx<CoarseGrid()->gSites() ;bidx++){
-      Coordinate bcoor;
-      CoarseGrid()->GlobalIndexToGlobalCoor(bidx,bcoor);
-
-      for(int p=0;p<geom.npoint;p++){
-	Coordinate scoor = bcoor;
-	for(int mu=0;mu<bcoor.size();mu++){
-	  int L = CoarseGrid()->GlobalDimensions()[mu];
-	  scoor[mu] = (bcoor[mu] - geom.shifts[p][mu] + L) % L; // Modulo arithmetic
-	}
-	// Flip to poke/peekLocalSite and not too bad
-	auto link = peekSite(_A[p],scoor);
-	int pp = geom.Reverse(p);
-	pokeSite(adj(link),_Adag[pp],bcoor);
-      }
-    }
-#else
-    // Parallel: _Adag[pp](x) = adj( _A[p](x + s_pp) ),  pp = Reverse(p), s_pp = -s_p.
-    // The neighbour fetch reuses the same padded-cell + stencil machinery as Mult,
-    // reading one matrix element per coalesced access so no whole site matrix
-    // (230KB at nbasis=60) ever lands on a GPU thread stack (HIP limit 128KB).
-    // Halo sites compute garbage neighbours; Cell.Extract discards them.
-    // Must run on the unpadded _A, i.e. before ExchangeCoarseLinks.
-    const int Nsimd = CComplex::Nsimd();
-    for(int p=0;p<geom.npoint;p++){
-      int pp = geom.Reverse(p);
-      CoarseMatrix Apad = Cell.ExchangePeriodic(_A[p]);
-      CoarseMatrix Dpad(Apad.Grid());
-      int64_t osites = Apad.Grid()->oSites();
-      {
-	autoView( Apad_v   , Apad, AcceleratorRead);
-	autoView( Dpad_v   , Dpad, AcceleratorWriteDiscard);
-	autoView( Stencil_v, Stencil, AcceleratorRead);
-	accelerator_for(sj, osites*nbasis, Nsimd, {
-	    int32_t ss = sj/nbasis;
-	    int32_t j  = sj%nbasis;
-	    auto SE = Stencil_v.GetEntry(pp,ss);
-	    for(int i=0;i<nbasis;i++){
-	      auto z = coalescedReadGeneralPermute(Apad_v[SE->_offset](i,j),SE->_permute,Nd);
-	      coalescedWrite(Dpad_v[ss](j,i),conjugate(z));
-	    }
-	});
-      }
-      _Adag[pp] = Cell.Extract(Dpad);
-    }
-#endif
-  }
-  /////////////////////////////////////////////////////////////
-  // 
-  // A) Only reduced flops option is to use a padded cell of depth 4
-  // and apply MpcDagMpc in the padded cell.
-  //
-  // Makes for ONE application of MpcDagMpc per vector instead of 30 or 80.
-  // With the effective cell size around (B+8)^4 perhaps 12^4/4^4 ratio
-  // Cost is 81x more, same as stencil size.
-  //
-  // But: can eliminate comms and do as local dirichlet.
-  //
-  // Local exchange gauge field once.
-  // Apply to all vectors, local only computation.
-  // Must exchange ghost subcells in reverse process of PaddedCell to take inner products
-  //
-  // B) Can reduce cost: pad by 1, apply Deo      (4^4+6^4+8^4+8^4 )/ (4x 4^4)
-  //                     pad by 2, apply Doe
-  //                     pad by 3, apply Deo
-  //                     then break out 8x directions; cost is ~10x MpcDagMpc per vector
-  //
-  // => almost factor of 10 in setup cost, excluding data rearrangement
-  //
-  // Intermediates -- ignore the corner terms, leave approximate and force Hermitian
-  // Intermediates -- pad by 2 and apply 1+8+24 = 33 times.
-  /////////////////////////////////////////////////////////////
-
-    //////////////////////////////////////////////////////////
-    // BFM HDCG style approach: Solve a system of equations to get Aij
-    //////////////////////////////////////////////////////////
-    /*
-     *     Here, k,l index which possible shift within the 3^Nd "ball" connected by MdagM.
-     *
-     *     conj(phases[block]) proj[k][ block*Nvec+j ] =  \sum_ball  e^{i q_k . delta} < phi_{block,j} | MdagM | phi_{(block+delta),i} > 
-     *                                                 =  \sum_ball e^{iqk.delta} A_ji
-     *
-     *     Must invert matrix M_k,l = e^[i q_k . delta_l]
-     *
-     *     Where q_k = delta_k . (2*M_PI/global_nb[mu])
-     */
-#if 0
-  void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & Subspace)
-  {
-    std::cout << GridLogMessage<< "GeneralCoarsenMatrix "<< std::endl;
-    GridBase *grid = FineGrid();
-
-    RealD tproj=0.0;
-    RealD teigen=0.0;
-    RealD tmat=0.0;
-    RealD tphase=0.0;
-    RealD tinv=0.0;
-
-    /////////////////////////////////////////////////////////////
-    // Orthogonalise the subblocks over the basis
-    /////////////////////////////////////////////////////////////
-    CoarseScalar InnerProd(CoarseGrid()); 
-    blockOrthogonalise(InnerProd,Subspace.subspace);
-
-    const int npoint = geom.npoint;
-      
-    Coordinate clatt = CoarseGrid()->GlobalDimensions();
-    int Nd = CoarseGrid()->Nd();
-
-      /*
-       *     Here, k,l index which possible momentum/shift within the N-points connected by MdagM.
-       *     Matrix index i is mapped to this shift via 
-       *               geom.shifts[i]
-       *
-       *     conj(pha[block]) proj[k (which mom)][j (basis vec cpt)][block] 
-       *       =  \sum_{l in ball}  e^{i q_k . delta_l} < phi_{block,j} | MdagM | phi_{(block+delta_l),i} > 
-       *       =  \sum_{l in ball} e^{iqk.delta_l} A_ji^{b.b+l}
-       *       = M_{kl} A_ji^{b.b+l}
-       *
-       *     Must assemble and invert matrix M_k,l = e^[i q_k . delta_l]
-       *  
-       *     Where q_k = delta_k . (2*M_PI/global_nb[mu])
-       *
-       *     Then A{ji}^{b,b+l} = M^{-1}_{lm} ComputeProj_{m,b,i,j}
-       */
-    teigen-=usecond();
-    Eigen::MatrixXcd Mkl    = Eigen::MatrixXcd::Zero(npoint,npoint);
-    Eigen::MatrixXcd invMkl = Eigen::MatrixXcd::Zero(npoint,npoint);
-    ComplexD ci(0.0,1.0);
-    for(int k=0;k<npoint;k++){ // Loop over momenta
-
-      for(int l=0;l<npoint;l++){ // Loop over nbr relative
-	ComplexD phase(0.0,0.0);
-	for(int mu=0;mu<Nd;mu++){
-	  RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	  phase=phase+TwoPiL*geom.shifts[k][mu]*geom.shifts[l][mu];
-	}
-	phase=exp(phase*ci);
-	Mkl(k,l) = phase;
-      }
-    }
-    invMkl = Mkl.inverse();
-    teigen+=usecond();
-
-    ///////////////////////////////////////////////////////////////////////
-    // Now compute the matrix elements of linop between the orthonormal
-    // set of vectors.
-    ///////////////////////////////////////////////////////////////////////
-    FineField phaV(grid); // Phased block basis vector
-    FineField MphaV(grid);// Matrix applied
-    CoarseVector coarseInner(CoarseGrid());
-
-    std::vector<CoarseVector> ComputeProj(npoint,CoarseGrid());
-    std::vector<CoarseVector>          FT(npoint,CoarseGrid());
-    for(int i=0;i<nbasis;i++){// Loop over basis vectors
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<"/"<<nbasis<< std::endl;
-      for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
-	/////////////////////////////////////////////////////
-	// Stick a phase on every block
-	/////////////////////////////////////////////////////
-	tphase-=usecond();
-	CoarseComplexField coor(CoarseGrid());
-	CoarseComplexField pha(CoarseGrid());	pha=Zero();
-	for(int mu=0;mu<Nd;mu++){
-	  LatticeCoordinate(coor,mu);
-	  RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	  pha = pha + (TwoPiL * geom.shifts[p][mu]) * coor;
-	}
-	pha  =exp(pha*ci);
-	phaV=Zero();
-	blockZAXPY(phaV,pha,Subspace.subspace[i],phaV);
-	tphase+=usecond();
-
-	/////////////////////////////////////////////////////////////////////
-	// Multiple phased subspace vector by matrix and project to subspace
-	// Remove local bulk phase to leave relative phases
-	/////////////////////////////////////////////////////////////////////
-	tmat-=usecond();
-	linop.Op(phaV,MphaV);
-	tmat+=usecond();
-
-	tproj-=usecond();
-	blockProject(coarseInner,MphaV,Subspace.subspace);
-	coarseInner = conjugate(pha) * coarseInner;
-
-	ComputeProj[p] = coarseInner;
-	tproj+=usecond();
-
-      }
-
-      tinv-=usecond();
-      for(int k=0;k<npoint;k++){
-	FT[k] = Zero();
-	for(int l=0;l<npoint;l++){
-	  FT[k]= FT[k]+ invMkl(l,k)*ComputeProj[l];
-	}
-      
-	int osites=CoarseGrid()->oSites();
-	autoView( A_v  , _A[k], AcceleratorWrite);
-	autoView( FT_v  , FT[k], AcceleratorRead);
-	accelerator_for(sss, osites, nbasis, {
-#ifdef GRID_SIMT
-	    int j = acceleratorSIMTlane(nbasis);
-	    A_v[sss](i,j) = FT_v[sss](j);
-#else
-	    // CPU build: acceleratorSIMTlane()==0 -- an un-looped SIMT tensor
-	    // index writes ONLY j=0 and silently drops the other nbasis-1
-	    // columns (caught by Test_schur_dense_coarse import certificate,
-	    // 2026-08-14).  Loop explicitly.
-	    for(int j=0;j<nbasis;j++){
-	      A_v[sss](i,j) = FT_v[sss](j);
-	    }
-#endif
-        });
-      }
-      tinv+=usecond();
-    }
-
-    // Only needed if nonhermitian
-    if ( ! hermitian ) {
-      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-      PopulateAdag();
-    }
-
-    // Need to write something to populate Adag from A
-    ExchangeCoarseLinks();
-    std::cout << GridLogMessage<<"CoarsenOperator eigen  "<<teigen<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator phase  "<<tphase<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator mat    "<<tmat <<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator proj   "<<tproj<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator inv    "<<tinv<<" us"<<std::endl;
-  }
-#else
-  //////////////////////////////////////////////////////////////////////
-  // Galerkin projection of matrix
-  //////////////////////////////////////////////////////////////////////
-  void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & Subspace)
-  {
-    CoarsenOperator(linop,Subspace,Subspace);
-  }
-  //////////////////////////////////////////////////////////////////////
-  // Petrov - Galerkin projection of matrix
-  //////////////////////////////////////////////////////////////////////
-  void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & U,
-		       Aggregation<Fobj,CComplex,nbasis> & V)
-  {
-    std::cout << GridLogMessage<< "GeneralCoarsenMatrix "<< std::endl;
-    GridBase *grid = FineGrid();
-
-    RealD tproj=0.0;
-    RealD teigen=0.0;
-    RealD tmat=0.0;
-    RealD tphase=0.0;
-    RealD tphaseBZ=0.0;
-    RealD tinv=0.0;
-
-    /////////////////////////////////////////////////////////////
-    // Orthogonalise the subblocks over the basis
-    /////////////////////////////////////////////////////////////
-    CoarseScalar InnerProd(CoarseGrid()); 
-    blockOrthogonalise(InnerProd,V.subspace);
-    blockOrthogonalise(InnerProd,U.subspace);
-
-    const int npoint = geom.npoint;
-      
-    Coordinate clatt = CoarseGrid()->GlobalDimensions();
-    int Nd = CoarseGrid()->Nd();
-
-      /*
-       *     Here, k,l index which possible momentum/shift within the N-points connected by MdagM.
-       *     Matrix index i is mapped to this shift via 
-       *               geom.shifts[i]
-       *
-       *     conj(pha[block]) proj[k (which mom)][j (basis vec cpt)][block] 
-       *       =  \sum_{l in ball}  e^{i q_k . delta_l} < phi_{block,j} | MdagM | phi_{(block+delta_l),i} > 
-       *       =  \sum_{l in ball} e^{iqk.delta_l} A_ji^{b.b+l}
-       *       = M_{kl} A_ji^{b.b+l}
-       *
-       *     Must assemble and invert matrix M_k,l = e^[i q_k . delta_l]
-       *  
-       *     Where q_k = delta_k . (2*M_PI/global_nb[mu])
-       *
-       *     Then A{ji}^{b,b+l} = M^{-1}_{lm} ComputeProj_{m,b,i,j}
-       */
-    teigen-=usecond();
-    Eigen::MatrixXcd Mkl    = Eigen::MatrixXcd::Zero(npoint,npoint);
-    Eigen::MatrixXcd invMkl = Eigen::MatrixXcd::Zero(npoint,npoint);
-    ComplexD ci(0.0,1.0);
-    for(int k=0;k<npoint;k++){ // Loop over momenta
-
-      for(int l=0;l<npoint;l++){ // Loop over nbr relative
-	ComplexD phase(0.0,0.0);
-	for(int mu=0;mu<Nd;mu++){
-	  RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	  phase=phase+TwoPiL*geom.shifts[k][mu]*geom.shifts[l][mu];
-	}
-	phase=exp(phase*ci);
-	Mkl(k,l) = phase;
-      }
-    }
-    invMkl = Mkl.inverse();
-    teigen+=usecond();
-
-    ///////////////////////////////////////////////////////////////////////
-    // Now compute the matrix elements of linop between the orthonormal
-    // set of vectors.
-    ///////////////////////////////////////////////////////////////////////
-    std::vector<FineComplexField> phaF(npoint,grid);
-    std::vector<CoarseComplexField> pha(npoint,CoarseGrid());
-
-    typedef typename CComplex::scalar_type SComplex;
-    FineComplexField one(grid); one=SComplex(1.0);
-    FineComplexField zz(grid); zz = Zero();
-    tphase=-usecond();
-    for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
-      /////////////////////////////////////////////////////
-      // Stick a phase on every block
-      /////////////////////////////////////////////////////
-      CoarseComplexField coor(CoarseGrid());
-      pha[p]=Zero();
-      for(int mu=0;mu<Nd;mu++){
-	LatticeCoordinate(coor,mu);
-	RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	pha[p] = pha[p] + (TwoPiL * geom.shifts[p][mu]) * coor;
-      }
-      pha[p]  =exp(pha[p]*ci);
-
-      blockZAXPY(phaF[p],pha[p],one,zz);
-
-    }
-    tphase+=usecond();
-
-    // Import basis into BLAS layout once; blockProject then reads it once per
-    // basis vector rather than once per (i,p) as in scalar blockProject.
-    // Process all npoint in a single batch.
-    MultiRHSBlockProject<FineField> Projector;
-    Projector.Allocate(nbasis, grid, CoarseGrid());
-    Projector.ImportBasis(U.subspace);
-
-    std::vector<FineField>    phaV_batch(npoint, grid);
-    std::vector<FineField>    MphaV_batch(npoint, grid);
-    std::vector<CoarseVector> proj_batch(npoint, CoarseGrid());
-    std::vector<CoarseVector> ComputeProj(npoint, CoarseGrid());
-    std::vector<CoarseVector>          FT(npoint, CoarseGrid());
-
-    // Pre-allocate BLAS_F and BLAS_C to avoid repeated hipMalloc/hipFree of
-    // ~5.6 GB per blockProject call, which hangs on ROCm for large allocations.
-    Projector.BLAS_F.resize(Projector.fine_vol * Projector.words * npoint);
-    Projector.BLAS_C.resize(Projector.coarse_vol * nbasis * npoint);
-
-    for(int i=0;i<nbasis;i++){// Loop over basis vectors
-      accelerator_barrier(); // ensure prior iteration's async writes are retired
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<"/"<<nbasis<< std::endl;
-
-      tphaseBZ-=usecond();
-      for(int p=0;p<npoint;p++)
-	phaV_batch[p] = phaF[p] * V.subspace[i];
-      tphaseBZ+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" phaseBZ done"<< std::endl;
-
-      tmat-=usecond();
-      for(int p=0;p<npoint;p++)
-	linop.Op(phaV_batch[p], MphaV_batch[p]);
-      tmat+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" mat done"<< std::endl;
-
-      // One batched GEMM reads BLAS_V once for all npoint vectors.
-      tproj-=usecond();
-      Projector.blockProject(MphaV_batch, proj_batch);
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" blockProject done"<< std::endl;
-      for(int p=0;p<npoint;p++)
-	ComputeProj[p] = conjugate(pha[p]) * proj_batch[p];
-      tproj+=usecond();
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<" proj done"<< std::endl;
-
-      tinv-=usecond();
-      for(int k=0;k<npoint;k++){
-	FT[k] = Zero();
-	for(int l=0;l<npoint;l++){
-	  FT[k]= FT[k]+ invMkl(l,k)*ComputeProj[l];
-	}
-
-	int osites=CoarseGrid()->oSites();
-	autoView( A_v  , _A[k], AcceleratorWrite);
-	autoView( FT_v  , FT[k], AcceleratorRead);
-	accelerator_for(sss, osites, nbasis, {
-#ifdef GRID_SIMT
-	    int j = acceleratorSIMTlane(nbasis);
-	    A_v[sss](i,j) = FT_v[sss](j);
-#else
-	    // CPU build: acceleratorSIMTlane()==0 -- an un-looped SIMT tensor
-	    // index writes ONLY j=0 and silently drops the other nbasis-1
-	    // columns (caught by Test_schur_dense_coarse import certificate,
-	    // 2026-08-14).  Loop explicitly.
-	    for(int j=0;j<nbasis;j++){
-	      A_v[sss](i,j) = FT_v[sss](j);
-	    }
-#endif
-        });
-      }
-      tinv+=usecond();
-    }
-
-    // Only needed if nonhermitian
-    if ( ! hermitian ) {
-      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-      PopulateAdag();
-    }
-
-    //    for(int p=0;p<geom.npoint;p++){
-    //      std::cout << " _A["<<p<<"] "<<norm2(_A[p])<<std::endl;
-    //    }
-
-    // Need to write something to populate Adag from A
-    ExchangeCoarseLinks();
-    std::cout << GridLogMessage<<"CoarsenOperator eigen  "<<teigen<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator phase  "<<tphase<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator phaseBZ "<<tphaseBZ<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator mat    "<<tmat <<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator proj   "<<tproj<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator inv    "<<tinv<<" us"<<std::endl;
-  }
-#endif  
-  void ExchangeCoarseLinks(void){
-    for(int p=0;p<geom.npoint;p++){
-      _A[p] = Cell.ExchangePeriodic(_A[p]);
-      if ( !hermitian ) _Adag[p]= Cell.ExchangePeriodic(_Adag[p]);
-    }
-  }
-  virtual  void Mdiag    (const Field &in, Field &out){ GRID_ASSERT(0);};
-  virtual  void Mdir     (const Field &in, Field &out,int dir, int disp){assert(0);};
-  virtual  void MdirAll  (const Field &in, std::vector<Field> &out){assert(0);};
-};
-
-
-  
-NAMESPACE_END(Grid);
@@ -1,738 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/GeneralCoarsenedMatrixMultiRHS.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <pboyle@bnl.gov>
-
-    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 */
-#pragma once
-
-
-NAMESPACE_BEGIN(Grid);
-
-
-// Fine Object == (per site) type of fine field
-// nbasis      == number of deflation vectors
-template<class Fobj,class CComplex,int nbasis>
-class MultiGeneralCoarsenedMatrix : public SparseMatrixBase<Lattice<iVector<CComplex,nbasis > > >  {
-public:
-  typedef typename CComplex::scalar_object SComplex;
-  typedef GeneralCoarsenedMatrix<Fobj,CComplex,nbasis> GeneralCoarseOp;
-  typedef MultiGeneralCoarsenedMatrix<Fobj,CComplex,nbasis> MultiGeneralCoarseOp;
-
-  typedef iVector<CComplex,nbasis >           siteVector;
-  typedef iMatrix<CComplex,nbasis >           siteMatrix;
-  typedef iVector<SComplex,nbasis >           calcVector;
-  typedef iMatrix<SComplex,nbasis >           calcMatrix;
-  typedef Lattice<iScalar<CComplex> >         CoarseComplexField;
-  typedef Lattice<siteVector>                 CoarseVector;
-  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-  typedef iMatrix<CComplex,nbasis >  Cobj;
-  typedef iVector<CComplex,nbasis >  Cvec;
-  typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<Fobj >        FineField;
-  typedef Lattice<CComplex >    FineComplexField;
-  typedef CoarseVector Field;
-
-  ////////////////////
-  // Data members
-  ////////////////////
-  GridCartesian *       _CoarseGridMulti; 
-  NonLocalStencilGeometry geom;
-  NonLocalStencilGeometry geom_srhs;
-  PaddedCell Cell;
-  GeneralLocalStencil Stencil;
-
-  deviceVector<calcVector> BLAS_B;
-  deviceVector<calcVector> BLAS_C;
-  std::vector<deviceVector<calcMatrix> > BLAS_A;
-
-  std::vector<deviceVector<ComplexD *> > BLAS_AP;
-  std::vector<deviceVector<ComplexD *> > BLAS_BP;
-  deviceVector<ComplexD *>               BLAS_CP;
-
-  ///////////////////////
-  // Interface
-  ///////////////////////
-  GridBase      * Grid(void)           { return _CoarseGridMulti; };   // this is all the linalg routines need to know
-  GridCartesian * CoarseGrid(void)     { return _CoarseGridMulti; };   // this is all the linalg routines need to know
-
-  //////////////////////////////////////////////////////////////////////////
-  // Bilingual accessors, matching GeneralCoarsenedMatrix. Grid() here is the
-  // D+1 multiRHS grid and this class never holds the D dimensional one, so
-  // ExtractMatrix writes into whatever grid the caller's lattice is on.
-  //////////////////////////////////////////////////////////////////////////
-  NonLocalStencilGeometry & Geometry(void)      { return geom_srhs; };
-  void ExtractMatrix(int p,CoarseMatrix &A)     { BLAStoGrid(A,BLAS_A[p]); };
-
-  // I/O on the operator matrices, via the BLAS layout array. The parameter is
-  // a vector over the geometry points; the body indexes A[p].
-  void SetMatrix (int p,std::vector<CoarseMatrix> & A)
-  {
-    GRID_ASSERT(A.size()==geom_srhs.npoint);
-    GridtoBLAS(A[p],BLAS_A[p]);
-  }
-  void GetMatrix (int p,std::vector<CoarseMatrix> & A)
-  {
-    GRID_ASSERT(A.size()==geom_srhs.npoint);
-    BLAStoGrid(A[p],BLAS_A[p]);
-  }
-  void CopyMatrix (GeneralCoarseOp &_Op)
-  {
-    for(int p=0;p<geom.npoint;p++){
-      auto Aup = _Op.Cell.Extract(_Op._A[p]);
-      //Unpadded
-      GridtoBLAS(Aup,BLAS_A[p]);
-    }
-  }
-  /*
-  void CheckMatrix (GeneralCoarseOp &_Op)
-  {
-    std::cout <<"************* Checking the little direc operator mRHS"<<std::endl;
-    for(int p=0;p<geom.npoint;p++){
-      //Unpadded
-      auto Aup = _Op.Cell.Extract(_Op._A[p]);
-      auto Ack = Aup;
-      BLAStoGrid(Ack,BLAS_A[p]);
-      std::cout << p<<" Ack "<<norm2(Ack)<<std::endl;
-      std::cout << p<<" Aup "<<norm2(Aup)<<std::endl;
-    }
-    std::cout <<"************* "<<std::endl;
-  }
-  */
-  
-  MultiGeneralCoarsenedMatrix(NonLocalStencilGeometry &_geom,GridCartesian *CoarseGridMulti) :
-    _CoarseGridMulti(CoarseGridMulti),
-    geom_srhs(_geom),
-    geom(_CoarseGridMulti,_geom.hops,_geom.skip+1),
-    Cell(geom.Depth(),_CoarseGridMulti),
-    Stencil(Cell.grids.back(),geom.shifts) // padded cell stencil
-  {
-    int32_t padded_sites   = Cell.grids.back()->lSites();
-    int32_t unpadded_sites = CoarseGridMulti->lSites();
-    
-    int32_t nrhs  = CoarseGridMulti->FullDimensions()[0];  // # RHS
-    int32_t orhs  = nrhs/CComplex::Nsimd();
-
-    padded_sites   = padded_sites/nrhs;
-    unpadded_sites = unpadded_sites/nrhs;
-    
-    /////////////////////////////////////////////////
-    // Device data vector storage
-    /////////////////////////////////////////////////
-    BLAS_A.resize(geom.npoint);
-    for(int p=0;p<geom.npoint;p++){
-      BLAS_A[p].resize (unpadded_sites); // no ghost zone, npoint elements
-    }
-    
-    BLAS_B.resize(nrhs *padded_sites);   // includes ghost zone
-    BLAS_C.resize(nrhs *unpadded_sites); // no ghost zone
-    BLAS_AP.resize(geom.npoint);
-    BLAS_BP.resize(geom.npoint);
-    for(int p=0;p<geom.npoint;p++){
-      BLAS_AP[p].resize(unpadded_sites);
-      BLAS_BP[p].resize(unpadded_sites);
-    }
-    BLAS_CP.resize(unpadded_sites);
-
-    /////////////////////////////////////////////////
-    // Pointers to data
-    /////////////////////////////////////////////////
-
-    // Site identity mapping for A
-    for(int p=0;p<geom.npoint;p++){
-      for(int ss=0;ss<unpadded_sites;ss++){
-	ComplexD *ptr = (ComplexD *)&BLAS_A[p][ss];
-	acceleratorPut(BLAS_AP[p][ss],ptr);
-      }
-    }
-    // Site identity mapping for C
-    for(int ss=0;ss<unpadded_sites;ss++){
-      ComplexD *ptr = (ComplexD *)&BLAS_C[ss*nrhs];
-      acceleratorPut(BLAS_CP[ss],ptr);
-    }
-
-    // Neighbour table is more complicated
-    int32_t j=0; // Interior point counter (unpadded)
-    for(int32_t s=0;s<padded_sites;s++){ // 4 volume, padded
-      int ghost_zone=0;
-      for(int32_t point = 0 ; point < geom.npoint; point++){
-	int i=s*orhs*geom.npoint+point;
-	if( Stencil._entries[i]._wrap ) { // stencil is indexed by the oSite of the CoarseGridMulti, hence orhs factor
-	  ghost_zone=1; // If general stencil wrapped in any direction, wrap=1
-	}
-      }
-
-      if( ghost_zone==0) {
-	for(int32_t point = 0 ; point < geom.npoint; point++){
-	  int i=s*orhs*geom.npoint+point;
- 	  int32_t nbr = Stencil._entries[i]._offset*CComplex::Nsimd(); // oSite -> lSite
-	  GRID_ASSERT(nbr<BLAS_B.size());
-	  ComplexD * ptr = (ComplexD *)&BLAS_B[nbr];
-	  acceleratorPut(BLAS_BP[point][j],ptr); // neighbour indexing in ghost zone volume
-	}
-	j++;
-      }
-    }
-    GRID_ASSERT(j==unpadded_sites);
-  }
-  template<class vobj> void GridtoBLAS(const Lattice<vobj> &from,deviceVector<typename vobj::scalar_object> &to)
-  {
-  typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
-  typedef typename vobj::vector_type vector_type;
-
-  GridBase *Fg = from.Grid();
-  GRID_ASSERT(!Fg->_isCheckerBoarded);
-  int nd = Fg->_ndimension;
-
-  to.resize(Fg->lSites());
-
-  Coordinate LocalLatt = Fg->LocalDimensions();
-  size_t nsite = 1;
-  for(int i=0;i<nd;i++) nsite *= LocalLatt[i];
-
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-  // do the index calc on the GPU
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-  Coordinate f_ostride = Fg->_ostride;
-  Coordinate f_istride = Fg->_istride;
-  Coordinate f_rdimensions = Fg->_rdimensions;
-
-  autoView(from_v,from,AcceleratorRead);
-  auto to_v = &to[0];
-
-  const int words=sizeof(vobj)/sizeof(vector_type);
-  accelerator_for(idx,nsite,1,{
-      
-      Coordinate from_coor, base;
-      Lexicographic::CoorFromIndex(base,idx,LocalLatt);
-      for(int i=0;i<nd;i++){
-	from_coor[i] = base[i];
-      }
-      int from_oidx = 0; for(int d=0;d<nd;d++) from_oidx+=f_ostride[d]*(from_coor[d]%f_rdimensions[d]);
-      int from_lane = 0; for(int d=0;d<nd;d++) from_lane+=f_istride[d]*(from_coor[d]/f_rdimensions[d]);
-
-      const vector_type* from = (const vector_type *)&from_v[from_oidx];
-      scalar_type* to = (scalar_type *)&to_v[idx];
-      
-      scalar_type stmp;
-      for(int w=0;w<words;w++){
-	stmp = getlane(from[w], from_lane);
-	to[w] = stmp;
-      }
-    });
-  }    
-  template<class vobj> void BLAStoGrid(Lattice<vobj> &grid,deviceVector<typename vobj::scalar_object> &in)
-  {
-  typedef typename vobj::scalar_object sobj;
-  typedef typename vobj::scalar_type scalar_type;
-  typedef typename vobj::vector_type vector_type;
-
-  GridBase *Tg = grid.Grid();
-  GRID_ASSERT(!Tg->_isCheckerBoarded);
-  int nd = Tg->_ndimension;
-  
-  GRID_ASSERT(in.size()==Tg->lSites());
-
-  Coordinate LocalLatt = Tg->LocalDimensions();
-  size_t nsite = 1;
-  for(int i=0;i<nd;i++) nsite *= LocalLatt[i];
-
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-  // do the index calc on the GPU
-  ////////////////////////////////////////////////////////////////////////////////////////////////
-  Coordinate t_ostride = Tg->_ostride;
-  Coordinate t_istride = Tg->_istride;
-  Coordinate t_rdimensions = Tg->_rdimensions;
-
-  autoView(to_v,grid,AcceleratorWrite);
-  auto from_v = &in[0];
-
-  const int words=sizeof(vobj)/sizeof(vector_type);
-  accelerator_for(idx,nsite,1,{
-      
-      Coordinate to_coor, base;
-      Lexicographic::CoorFromIndex(base,idx,LocalLatt);
-      for(int i=0;i<nd;i++){
-	to_coor[i] = base[i];
-      }
-      int to_oidx = 0; for(int d=0;d<nd;d++) to_oidx+=t_ostride[d]*(to_coor[d]%t_rdimensions[d]);
-      int to_lane = 0; for(int d=0;d<nd;d++) to_lane+=t_istride[d]*(to_coor[d]/t_rdimensions[d]);
-
-      vector_type* to = (vector_type *)&to_v[to_oidx];
-      scalar_type* from = (scalar_type *)&from_v[idx];
-      
-      scalar_type stmp;
-      for(int w=0;w<words;w++){
-	stmp=from[w];
-	putlane(to[w], stmp, to_lane);
-      }
-    });
-  }
-  void CoarsenOperator(LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & Subspace,
-		       GridBase *CoarseGrid)
-  {
-#if 0
-    std::cout << GridLogMessage<< "GeneralCoarsenMatrixMrhs "<< std::endl;
-
-    GridBase *grid = Subspace.FineGrid;
-
-    /////////////////////////////////////////////////////////////
-    // Orthogonalise the subblocks over the basis
-    /////////////////////////////////////////////////////////////
-    CoarseScalar InnerProd(CoarseGrid); 
-    blockOrthogonalise(InnerProd,Subspace.subspace);
-
-    const int npoint = geom_srhs.npoint;
-
-    Coordinate clatt = CoarseGrid->GlobalDimensions();
-    int Nd = CoarseGrid->Nd();
-      /*
-       *     Here, k,l index which possible momentum/shift within the N-points connected by MdagM.
-       *     Matrix index i is mapped to this shift via 
-       *               geom.shifts[i]
-       *
-       *     conj(pha[block]) proj[k (which mom)][j (basis vec cpt)][block] 
-       *       =  \sum_{l in ball}  e^{i q_k . delta_l} < phi_{block,j} | MdagM | phi_{(block+delta_l),i} > 
-       *       =  \sum_{l in ball} e^{iqk.delta_l} A_ji^{b.b+l}
-       *       = M_{kl} A_ji^{b.b+l}
-       *
-       *     Must assemble and invert matrix M_k,l = e^[i q_k . delta_l]
-       *  
-       *     Where q_k = delta_k . (2*M_PI/global_nb[mu])
-       *
-       *     Then A{ji}^{b,b+l} = M^{-1}_{lm} ComputeProj_{m,b,i,j}
-       */
-    Eigen::MatrixXcd Mkl    = Eigen::MatrixXcd::Zero(npoint,npoint);
-    Eigen::MatrixXcd invMkl = Eigen::MatrixXcd::Zero(npoint,npoint);
-    ComplexD ci(0.0,1.0);
-    for(int k=0;k<npoint;k++){ // Loop over momenta
-
-      for(int l=0;l<npoint;l++){ // Loop over nbr relative
-	ComplexD phase(0.0,0.0);
-	for(int mu=0;mu<Nd;mu++){
-	  RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	  phase=phase+TwoPiL*geom_srhs.shifts[k][mu]*geom_srhs.shifts[l][mu];
-	}
-	phase=exp(phase*ci);
-	Mkl(k,l) = phase;
-      }
-    }
-    invMkl = Mkl.inverse();
-
-    ///////////////////////////////////////////////////////////////////////
-    // Now compute the matrix elements of linop between the orthonormal
-    // set of vectors.
-    ///////////////////////////////////////////////////////////////////////
-    FineField phaV(grid); // Phased block basis vector
-    FineField MphaV(grid);// Matrix applied
-    std::vector<FineComplexField> phaF(npoint,grid);
-    std::vector<CoarseComplexField> pha(npoint,CoarseGrid);
-    
-    CoarseVector coarseInner(CoarseGrid);
-    
-    typedef typename CComplex::scalar_type SComplex;
-    FineComplexField one(grid); one=SComplex(1.0);
-    FineComplexField zz(grid); zz = Zero();
-    for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
-      /////////////////////////////////////////////////////
-      // Stick a phase on every block
-      /////////////////////////////////////////////////////
-      CoarseComplexField coor(CoarseGrid);
-      pha[p]=Zero();
-      for(int mu=0;mu<Nd;mu++){
-	LatticeCoordinate(coor,mu);
-	RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	pha[p] = pha[p] + (TwoPiL * geom_srhs.shifts[p][mu]) * coor;
-      }
-      pha[p]  =exp(pha[p]*ci);	
-
-      blockZAXPY(phaF[p],pha[p],one,zz);
-    }
-
-    // Could save on temporary storage here
-    std::vector<CoarseMatrix> _A;
-    _A.resize(geom_srhs.npoint,CoarseGrid);
-
-    std::vector<CoarseVector> ComputeProj(npoint,CoarseGrid);
-    CoarseVector          FT(CoarseGrid);
-    for(int i=0;i<nbasis;i++){// Loop over basis vectors
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<"/"<<nbasis<< std::endl;
-      for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
-
-	phaV = phaF[p]*Subspace.subspace[i];
-
-	/////////////////////////////////////////////////////////////////////
-	// Multiple phased subspace vector by matrix and project to subspace
-	// Remove local bulk phase to leave relative phases
-	/////////////////////////////////////////////////////////////////////
-	linop.Op(phaV,MphaV);
-
-	// Fixme, could use batched block projector here
-	blockProject(coarseInner,MphaV,Subspace.subspace);
-
-	coarseInner = conjugate(pha[p]) * coarseInner;
-
-	ComputeProj[p] = coarseInner;
-      }
-
-      // Could do this with a block promote or similar BLAS call via the MultiRHSBlockProjector with a const matrix.
-      for(int k=0;k<npoint;k++){
-
-	FT = Zero();
-	for(int l=0;l<npoint;l++){
-	  FT= FT+ invMkl(l,k)*ComputeProj[l];
-	}
-      
-	int osites=CoarseGrid->oSites();
-	autoView( A_v  , _A[k], AcceleratorWrite);
-	autoView( FT_v  , FT, AcceleratorRead);
-	accelerator_for(sss, osites, 1, {
-	    for(int j=0;j<nbasis;j++){
-	      A_v[sss](i,j) = FT_v[sss](j);
-	    }
-        });
-      }
-    }
-
-    // Only needed if nonhermitian
-    //    if ( ! hermitian ) {
-    //      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-    //      PopulateAdag();
-    //    }
-    // Need to write something to populate Adag from A
-
-    for(int p=0;p<geom_srhs.npoint;p++){
-      GridtoBLAS(_A[p],BLAS_A[p]);
-    }
-    /*
-Grid : Message : 11698.730546 s : CoarsenOperator eigen  1334 us
-Grid : Message : 11698.730563 s : CoarsenOperator phase  34729 us
-Grid : Message : 11698.730565 s : CoarsenOperator phaseBZ 2423814 us
-Grid : Message : 11698.730566 s : CoarsenOperator mat    127890998 us
-Grid : Message : 11698.730567 s : CoarsenOperator proj   515840840 us
-Grid : Message : 11698.730568 s : CoarsenOperator inv    103948313 us
-Takes 600s to compute matrix elements, DOMINATED by the block project.
-Easy to speed up with the batched block project.
-Store npoint vectors, get npoint x Nbasis block projection, and 81 fold faster.
-
-// Block project below taks to 240s
-Grid : Message : 328.193418 s : CoarsenOperator phase      38338 us
-Grid : Message : 328.193434 s : CoarsenOperator phaseBZ  1711226 us
-Grid : Message : 328.193436 s : CoarsenOperator mat    122213270 us
-//Grid : Message : 328.193438 s : CoarsenOperator proj   1181154 us <-- this is mistimed
-//Grid : Message : 11698.730568 s : CoarsenOperator inv  103948313 us <-- Cut this ~10x if lucky by loop fusion
-     */
-#else
-    RealD tproj=0.0;
-    RealD tmat=0.0;
-    RealD tphase=0.0;
-    RealD tphaseBZ=0.0;
-    RealD tinv=0.0;
-
-    std::cout << GridLogMessage<< "GeneralCoarsenMatrixMrhs "<< std::endl;
-
-    GridBase *grid = Subspace.FineGrid;
-
-    /////////////////////////////////////////////////////////////
-    // Orthogonalise the subblocks over the basis
-    /////////////////////////////////////////////////////////////
-    CoarseScalar InnerProd(CoarseGrid); 
-    blockOrthogonalise(InnerProd,Subspace.subspace);
-
-
-    MultiRHSBlockProject<Lattice<Fobj> >    Projector;
-    Projector.Allocate(nbasis,grid,CoarseGrid);
-    Projector.ImportBasis(Subspace.subspace);
-    
-    const int npoint = geom_srhs.npoint;
-
-    Coordinate clatt = CoarseGrid->GlobalDimensions();
-    int Nd = CoarseGrid->Nd();
-      /*
-       *     Here, k,l index which possible momentum/shift within the N-points connected by MdagM.
-       *     Matrix index i is mapped to this shift via 
-       *               geom.shifts[i]
-       *
-       *     conj(pha[block]) proj[k (which mom)][j (basis vec cpt)][block] 
-       *       =  \sum_{l in ball}  e^{i q_k . delta_l} < phi_{block,j} | MdagM | phi_{(block+delta_l),i} > 
-       *       =  \sum_{l in ball} e^{iqk.delta_l} A_ji^{b.b+l}
-       *       = M_{kl} A_ji^{b.b+l}
-       *
-       *     Must assemble and invert matrix M_k,l = e^[i q_k . delta_l]
-       *  
-       *     Where q_k = delta_k . (2*M_PI/global_nb[mu])
-       *
-       *     Then A{ji}^{b,b+l} = M^{-1}_{lm} ComputeProj_{m,b,i,j}
-       */
-    Eigen::MatrixXcd Mkl    = Eigen::MatrixXcd::Zero(npoint,npoint);
-    Eigen::MatrixXcd invMkl = Eigen::MatrixXcd::Zero(npoint,npoint);
-    ComplexD ci(0.0,1.0);
-    for(int k=0;k<npoint;k++){ // Loop over momenta
-
-      for(int l=0;l<npoint;l++){ // Loop over nbr relative
-	ComplexD phase(0.0,0.0);
-	for(int mu=0;mu<Nd;mu++){
-	  RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	  phase=phase+TwoPiL*geom_srhs.shifts[k][mu]*geom_srhs.shifts[l][mu];
-	}
-	phase=exp(phase*ci);
-	Mkl(k,l) = phase;
-      }
-    }
-    invMkl = Mkl.inverse();
-
-    ///////////////////////////////////////////////////////////////////////
-    // Now compute the matrix elements of linop between the orthonormal
-    // set of vectors.
-    ///////////////////////////////////////////////////////////////////////
-    FineField phaV(grid); // Phased block basis vector
-    FineField MphaV(grid);// Matrix applied
-    std::vector<FineComplexField> phaF(npoint,grid);
-    std::vector<CoarseComplexField> pha(npoint,CoarseGrid);
-    
-    CoarseVector coarseInner(CoarseGrid);
-    
-    tphase=-usecond();
-    typedef typename CComplex::scalar_type SComplex;
-    FineComplexField one(grid); one=SComplex(1.0);
-    FineComplexField zz(grid); zz = Zero();
-    for(int p=0;p<npoint;p++){ // Loop over momenta in npoint
-      /////////////////////////////////////////////////////
-      // Stick a phase on every block
-      /////////////////////////////////////////////////////
-      CoarseComplexField coor(CoarseGrid);
-      pha[p]=Zero();
-      for(int mu=0;mu<Nd;mu++){
-	LatticeCoordinate(coor,mu);
-	RealD TwoPiL =  M_PI * 2.0/ clatt[mu];
-	pha[p] = pha[p] + (TwoPiL * geom_srhs.shifts[p][mu]) * coor;
-      }
-      pha[p]  =exp(pha[p]*ci);	
-
-      blockZAXPY(phaF[p],pha[p],one,zz);
-    }
-    tphase+=usecond();
-
-    // Could save on temporary storage here
-    std::vector<CoarseMatrix> _A;
-    _A.resize(geom_srhs.npoint,CoarseGrid);
-
-    // Count use small chunks than npoint == 81 and save memory
-    int batch = 9;
-    std::vector<FineField>    _MphaV(batch,grid);
-    std::vector<CoarseVector> TmpProj(batch,CoarseGrid);
-
-    std::vector<CoarseVector> ComputeProj(npoint,CoarseGrid);
-    CoarseVector          FT(CoarseGrid);
-    for(int i=0;i<nbasis;i++){// Loop over basis vectors
-      std::cout << GridLogMessage<< "CoarsenMatrixColoured vec "<<i<<"/"<<nbasis<< std::endl;
-
-      //      std::cout << GridLogMessage << " phasing the fine vector "<<std::endl;
-      // Fixme : do this in batches
-      for(int p=0;p<npoint;p+=batch){ // Loop over momenta in npoint
-
-	for(int b=0;b<MIN(batch,npoint-p);b++){
-	  tphaseBZ-=usecond();
-	  phaV = phaF[p+b]*Subspace.subspace[i];
-	  tphaseBZ+=usecond();
-
-	  /////////////////////////////////////////////////////////////////////
-	  // Multiple phased subspace vector by matrix and project to subspace
-	  // Remove local bulk phase to leave relative phases
-	  /////////////////////////////////////////////////////////////////////
-	  // Memory footprint was an issue
-	  tmat-=usecond();
-	  linop.Op(phaV,MphaV);
-	  _MphaV[b] = MphaV;
-	  tmat+=usecond();
-	}      
-
-	//	std::cout << GridLogMessage << " Calling block project "<<std::endl;
-	tproj-=usecond();
-	Projector.blockProject(_MphaV,TmpProj);
-	tproj+=usecond();
-	
-	//	std::cout << GridLogMessage << " conj phasing the coarse vectors "<<std::endl;
-	for(int b=0;b<MIN(batch,npoint-p);b++){
-	  ComputeProj[p+b] = conjugate(pha[p+b])*TmpProj[b];
-	}
-      }
-
-      // Could do this with a block promote or similar BLAS call via the MultiRHSBlockProjector with a const matrix.
-      
-      // std::cout << GridLogMessage << " Starting FT inv "<<std::endl;
-      tinv-=usecond();
-      for(int k=0;k<npoint;k++){
-	FT = Zero();
-	// 81 kernel calls as many ComputeProj vectors
-	// Could fuse with a vector of views, but ugly
-	// Could unroll the expression and run fewer kernels -- much more attractive
-	// Could also do non blocking.
-#if 0	
-	for(int l=0;l<npoint;l++){
-	  FT= FT+ invMkl(l,k)*ComputeProj[l];
-	}
-#else
-	const int radix = 9;
-	int ll;
-	for(ll=0;ll+radix-1<npoint;ll+=radix){
-	  // When ll = npoint-radix, ll+radix-1 = npoint-1, and we do it all.
-	  FT = FT 
-	    + invMkl(ll+0,k)*ComputeProj[ll+0]
-	    + invMkl(ll+1,k)*ComputeProj[ll+1]
-	    + invMkl(ll+2,k)*ComputeProj[ll+2]
-	    + invMkl(ll+3,k)*ComputeProj[ll+3]
-	    + invMkl(ll+4,k)*ComputeProj[ll+4]
-	    + invMkl(ll+5,k)*ComputeProj[ll+5]
-	    + invMkl(ll+6,k)*ComputeProj[ll+6]
-	    + invMkl(ll+7,k)*ComputeProj[ll+7]
-	    + invMkl(ll+8,k)*ComputeProj[ll+8];
-	}
-	for(int l=ll;l<npoint;l++){
-	  FT= FT+ invMkl(l,k)*ComputeProj[l];
-	}
-#endif
-      
-	// 1 kernel call -- must be cheaper
-	int osites=CoarseGrid->oSites();
-	autoView( A_v  , _A[k], AcceleratorWrite);
-	autoView( FT_v  , FT, AcceleratorRead);
-	accelerator_for(sss, osites, 1, {
-	    for(int j=0;j<nbasis;j++){
-	      A_v[sss](i,j) = FT_v[sss](j);
-	    }
-        });
-      }
-      tinv+=usecond();
-    }
-
-    // Only needed if nonhermitian
-    //    if ( ! hermitian ) {
-    //      std::cout << GridLogMessage<<"PopulateAdag  "<<std::endl;
-    //      PopulateAdag();
-    //    }
-    // Need to write something to populate Adag from A
-    //    std::cout << GridLogMessage << " Calling GridtoBLAS "<<std::endl;
-    for(int p=0;p<geom_srhs.npoint;p++){
-      GridtoBLAS(_A[p],BLAS_A[p]);
-    }
-    std::cout << GridLogMessage<<"CoarsenOperator phase  "<<tphase<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator phaseBZ "<<tphaseBZ<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator mat    "<<tmat <<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator proj   "<<tproj<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"CoarsenOperator inv    "<<tinv<<" us"<<std::endl;
-#endif
-  }
-  void Mdag(const CoarseVector &in, CoarseVector &out)
-  {
-    this->M(in,out);
-  }
-  void M (const CoarseVector &in, CoarseVector &out)
-  {
-    //    std::cout << GridLogMessage << "New Mrhs coarse"<<std::endl;
-    conformable(CoarseGrid(),in.Grid());
-    conformable(in.Grid(),out.Grid());
-    out.Checkerboard() = in.Checkerboard();
-
-    RealD t_tot;
-    RealD t_exch;
-    RealD t_GtoB;
-    RealD t_BtoG;
-    RealD t_mult;
-
-    t_tot=-usecond();
-    CoarseVector tin=in;
-    t_exch=-usecond();
-    CoarseVector pin = Cell.ExchangePeriodic(tin); //padded input
-    t_exch+=usecond();
-
-    CoarseVector pout(pin.Grid());
-
-    int npoint = geom.npoint;
-    typedef calcMatrix* Aview;
-    typedef LatticeView<Cvec> Vview;
-      
-    const int Nsimd = CComplex::Nsimd();
-
-    int64_t nrhs  =pin.Grid()->GlobalDimensions()[0];
-    GRID_ASSERT(nrhs>=1);
-
-    RealD flops,bytes;
-    int64_t osites=in.Grid()->oSites(); // unpadded
-    int64_t unpadded_vol = CoarseGrid()->lSites()/nrhs;
-    
-    flops = 1.0* npoint * nbasis * nbasis * 8.0 * osites * CComplex::Nsimd();
-    bytes = 1.0*osites*sizeof(siteMatrix)*npoint/pin.Grid()->GlobalDimensions()[0]
-          + 2.0*osites*sizeof(siteVector)*npoint;
-    
-
-    t_GtoB=-usecond();
-    GridtoBLAS(pin,BLAS_B);
-    t_GtoB+=usecond();
-
-    GridBLAS BLAS;
-
-    t_mult=-usecond();
-    for(int p=0;p<geom.npoint;p++){
-      RealD c = 1.0;
-      if (p==0) c = 0.0;
-      ComplexD beta(c);
-
-      BLAS.gemmBatched(nbasis,nrhs,nbasis,
-		       ComplexD(1.0),
-		       BLAS_AP[p], 
-		       BLAS_BP[p], 
-		       ComplexD(c), 
-		       BLAS_CP);
-    }
-    BLAS.synchronise();
-    t_mult+=usecond();
-
-    t_BtoG=-usecond();
-    BLAStoGrid(out,BLAS_C);
-    t_BtoG+=usecond();
-    t_tot+=usecond();
-    /*
-    std::cout << GridLogMessage << "New Mrhs coarse DONE "<<std::endl;
-    std::cout << GridLogMessage<<"Coarse Mult exch "<<t_exch<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"Coarse Mult mult "<<t_mult<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"Coarse Mult GtoB  "<<t_GtoB<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"Coarse Mult BtoG  "<<t_BtoG<<" us"<<std::endl;
-    std::cout << GridLogMessage<<"Coarse Mult tot  "<<t_tot<<" us"<<std::endl;
-    */
-    //    std::cout << GridLogMessage<<std::endl;
-    //    std::cout << GridLogMessage<<"Coarse Kernel flops "<< flops<<std::endl;
-    //    std::cout << GridLogMessage<<"Coarse Kernel flop/s "<< flops/t_mult<<" mflop/s"<<std::endl;
-    //    std::cout << GridLogMessage<<"Coarse Kernel bytes/s "<< bytes/t_mult/1000<<" GB/s"<<std::endl;
-    //    std::cout << GridLogMessage<<"Coarse overall flops/s "<< flops/t_tot<<" mflop/s"<<std::endl;
-    //    std::cout << GridLogMessage<<"Coarse total bytes   "<< bytes/1e6<<" MB"<<std::endl;
-  };
-  virtual  void Mdiag    (const Field &in, Field &out){ GRID_ASSERT(0);};
-  virtual  void Mdir     (const Field &in, Field &out,int dir, int disp){assert(0);};
-  virtual  void MdirAll  (const Field &in, std::vector<Field> &out){assert(0);};
-};
-  
-NAMESPACE_END(Grid);
@@ -1,136 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./Grid/algorithms/multigrid/deprecated/TwoLevelADEF2.h
-
-    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 */
-#pragma once
-
-// DEPRECATED with the V1 coarse operators: the single-RHS ADEF-2 on an
-// Aggregation (ProjectToSubspace/PromoteFromSubspace) and a D-dimensional
-// coarse operator.  The mrhs solver in AdefMrhs.h covers one right-hand
-// side through its LinearFunction interface, on the V2 coarse operator.
-
-NAMESPACE_BEGIN(Grid);
-
-template<class Field, class CoarseField, class Aggregation>
-class TwoLevelADEF2 : public TwoLevelCG<Field>
-{
- public:
-  ///////////////////////////////////////////////////////////////////////////////////
-  // Need something that knows how to get from Coarse to fine and back again
-  //  void ProjectToSubspace(CoarseVector &CoarseVec,const FineField &FineVec){
-  //  void PromoteFromSubspace(const CoarseVector &CoarseVec,FineField &FineVec){
-  ///////////////////////////////////////////////////////////////////////////////////
-  GridBase *coarsegrid;
-  Aggregation &_Aggregates;                    
-  LinearFunction<CoarseField> &_CoarseSolver;
-  LinearFunction<CoarseField> &_CoarseSolverPrecise;
-  ///////////////////////////////////////////////////////////////////////////////////
-  
-  // more most opertor functions
-  TwoLevelADEF2(RealD tol,
-		Integer maxit,
-		LinearOperatorBase<Field>    &FineLinop,
-		LinearFunction<Field>        &Smoother,
-		LinearFunction<CoarseField>  &CoarseSolver,
-		LinearFunction<CoarseField>  &CoarseSolverPrecise,
-		Aggregation &Aggregates
-		) :
-      TwoLevelCG<Field>(tol,maxit,FineLinop,Smoother,Aggregates.FineGrid),
-      _CoarseSolver(CoarseSolver),
-      _CoarseSolverPrecise(CoarseSolverPrecise),
-      _Aggregates(Aggregates)
-  {
-    coarsegrid = Aggregates.CoarseGrid;
-  };
-
-  virtual void PcgM1(Field & in, Field & out)
-  {
-    GRID_TRACE("MultiGridPreconditioner ");
-    // [PTM+Q] in = [1 - Q A] M in + Q in = Min + Q [ in -A Min]
-
-    Field tmp(this->grid);
-    Field Min(this->grid);
-    CoarseField PleftProj(this->coarsegrid);
-    CoarseField PleftMss_proj(this->coarsegrid);
-
-    this->SmoothTimer.Start();
-    this->_Smoother(in,Min);
-    this->SmoothTimer.Stop();
-    this->SmoothCalls++;
-
-    this->MatrixTimer.Start();
-    this->_FineLinop.HermOp(Min,out);
-    this->MatrixTimer.Stop();
-    this->MatrixCalls++;
-    axpy(tmp,-1.0,out,in);          // tmp  = in - A Min
-
-    this->ProjectTimer.Start();
-    this->_Aggregates.ProjectToSubspace(PleftProj,tmp);
-    this->ProjectTimer.Stop();
-    this->ProjectCalls++;
-    this->CoarseTimer.Start();
-    this->_CoarseSolver(PleftProj,PleftMss_proj); // Ass^{-1} [in - A Min]_s
-    this->CoarseTimer.Stop();
-    this->CoarseCalls++;
-    this->PromoteTimer.Start();
-    this->_Aggregates.PromoteFromSubspace(PleftMss_proj,tmp);// tmp = Q[in - A Min]
-    this->PromoteTimer.Stop();
-    this->PromoteCalls++;
-
-    axpy(out,1.0,Min,tmp); // Min+tmp
-  }
-
-  virtual void Vstart(Field & x,const Field & src)
-  {
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart "<<std::endl;
-    ///////////////////////////////////
-    // Choose x_0 such that 
-    // x_0 = guess +  (A_ss^inv) r_s = guess + Ass_inv [src -Aguess]
-    //                               = [1 - Ass_inv A] Guess + Assinv src
-    //                               = P^T guess + Assinv src 
-    //                               = Vstart  [Tang notation]
-    // This gives:
-    // W^T (src - A x_0) = src_s - A guess_s - r_s
-    //                   = src_s - (A guess)_s - src_s  + (A guess)_s 
-    //                   = 0 
-    ///////////////////////////////////
-    Field r(this->grid);
-    Field mmp(this->grid);
-    CoarseField PleftProj(this->coarsegrid);
-    CoarseField PleftMss_proj(this->coarsegrid);
-
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart projecting "<<std::endl;
-    this->_Aggregates.ProjectToSubspace(PleftProj,src);     
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart coarse solve "<<std::endl;
-    this->_CoarseSolverPrecise(PleftProj,PleftMss_proj); // Ass^{-1} r_s
-    std::cout << GridLogMessage<<"HDCG: fPcg Vstart promote "<<std::endl;
-    this->_Aggregates.PromoteFromSubspace(PleftMss_proj,x);  
-
-  }
-
-};
-
-NAMESPACE_END(Grid);
@@ -54,10 +54,7 @@ public:
    size_type bytes = __n*sizeof(_Tp);
    profilerAllocate(bytes);
    _Tp *ptr = (_Tp*) MemoryManager::CpuAllocate(bytes);
-    if ( (_Tp*)ptr == (_Tp *) NULL ) {
-      printf("Grid CPU Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
-    }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
    return ptr;
  }

@@ -69,7 +66,7 @@ public:
  }

  // FIXME: hack for the copy constructor: it must be avoided to avoid single thread loop
-  void construct(pointer __p, const _Tp& __val) { };
+  void construct(pointer __p, const _Tp& __val) { assert(0);};
  void construct(pointer __p) { };
  void destroy(pointer __p) { };
 };
@@ -103,10 +100,7 @@ public:
    size_type bytes = __n*sizeof(_Tp);
    profilerAllocate(bytes);
    _Tp *ptr = (_Tp*) MemoryManager::SharedAllocate(bytes);
-    if ( (_Tp*)ptr == (_Tp *) NULL ) {
-      printf("Grid Shared Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
-    }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
    return ptr;
  }

@@ -151,10 +145,7 @@ public:
    size_type bytes = __n*sizeof(_Tp);
    profilerAllocate(bytes);
    _Tp *ptr = (_Tp*) MemoryManager::AcceleratorAllocate(bytes);
-    if ( (_Tp*)ptr == (_Tp *) NULL ) {
-      printf("Grid Device Allocator got NULL for %lu bytes\n",(unsigned long) bytes );
-    }
-    GRID_ASSERT( ( (_Tp*)ptr != (_Tp *)NULL ) );
+    assert( ( (_Tp*)ptr != (_Tp *)NULL ) );
    return ptr;
  }

@@ -174,48 +165,18 @@ template<typename _Tp>  inline bool operator!=(const devAllocator<_Tp>&, const d
 ////////////////////////////////////////////////////////////////////////////////
 // Template typedefs
 ////////////////////////////////////////////////////////////////////////////////
-template<class T> using hostVector          = std::vector<T,alignedAllocator<T> >;           // Needs autoview
-template<class T> using Vector              = std::vector<T,uvmAllocator<T> >;               // Really want to deprecate
-template<class T> using uvmVector           = std::vector<T,uvmAllocator<T> >;               // auto migrating page
-template<class T> using deviceVector        = std::vector<T,devAllocator<T> >;               // device vector
+#ifdef ACCELERATOR_CSHIFT
+// Cshift on device
+template<class T> using cshiftAllocator = devAllocator<T>;
+#else
+// Cshift on host
+template<class T> using cshiftAllocator = std::allocator<T>;
+#endif

-/*
-template<class T> class vecView
-{
- protected:
-  T * data;
-  uint64_t size;
-  ViewMode mode;
-  void * cpu_ptr;
- public:
-  // Rvalue accessor
-  accelerator_inline T & operator[](size_t i) const { return this->data[i]; };
-  vecView(Vector<T> &refer_to_me,ViewMode _mode)
-  {
-    cpu_ptr = &refer_to_me[0];
-    size = refer_to_me.size();
-    mode = _mode;
-    data =(T *) MemoryManager::ViewOpen(cpu_ptr,
-					size*sizeof(T),
-					mode,
-					AdviseDefault);
-  }
-  void ViewClose(void)
-  { // Inform the manager
-    MemoryManager::ViewClose(this->cpu_ptr,this->mode);    
-  }
-};
-
-template<class T> vecView<T> VectorView(Vector<T> &vec,ViewMode _mode)
-{
-  vecView<T> ret(vec,_mode); // does the open
-  return ret;                // must be closed
-}
-
-#define autoVecView(v_v,v,mode)					\
-  auto v_v = VectorView(v,mode);				\
-  ViewCloser<decltype(v_v)> _autoView##v_v(v_v);
-*/
+template<class T> using Vector        = std::vector<T,uvmAllocator<T> >;           
+template<class T> using stencilVector = std::vector<T,alignedAllocator<T> >;           
+template<class T> using commVector = std::vector<T,devAllocator<T> >;
+template<class T> using cshiftVector = std::vector<T,cshiftAllocator<T> >;

 NAMESPACE_END(Grid);

@@ -4,56 +4,15 @@ NAMESPACE_BEGIN(Grid);

 /*Allocation types, saying which pointer cache should be used*/
 #define Cpu      (0)
-#define CpuHuge  (1)
-#define CpuSmall (2)
-#define Acc      (3)
-#define AccHuge  (4)
-#define AccSmall (5)
-#define Shared   (6)
-#define SharedHuge  (7)
-#define SharedSmall (8)
+#define CpuSmall (1)
+#define Acc      (2)
+#define AccSmall (3)
+#define Shared   (4)
+#define SharedSmall (5)
 #undef GRID_MM_VERBOSE 
 uint64_t total_shared;
 uint64_t total_device;
 uint64_t total_host;;
-
-#if defined(__has_feature)
-#if __has_feature(leak_sanitizer)
-#define ASAN_LEAK_CHECK
-#endif
-#endif
-
-#ifdef ASAN_LEAK_CHECK
-#include <sanitizer/asan_interface.h>
-#include <sanitizer/common_interface_defs.h>
-#include <sanitizer/lsan_interface.h>
-#define LEAK_CHECK(A) { __lsan_do_recoverable_leak_check(); }
-#else
-#define LEAK_CHECK(A) { }
-#endif
-
-void MemoryManager::DisplayMallinfo(void)
-{
-#ifdef __linux__
-  struct mallinfo mi; // really want mallinfo2, but glibc version isn't uniform
-  
-  mi = mallinfo();
-
-  std::cout << "MemoryManager: Total non-mmapped bytes (arena):       "<< (size_t)mi.arena<<std::endl;
-  std::cout << "MemoryManager: # of free chunks (ordblks):            "<< (size_t)mi.ordblks<<std::endl;
-  std::cout << "MemoryManager: # of free fastbin blocks (smblks):     "<< (size_t)mi.smblks<<std::endl;
-  std::cout << "MemoryManager: # of mapped regions (hblks):           "<< (size_t)mi.hblks<<std::endl;
-  std::cout << "MemoryManager: Bytes in mapped regions (hblkhd):      "<< (size_t)mi.hblkhd<<std::endl;
-  std::cout << "MemoryManager: Max. total allocated space (usmblks):  "<< (size_t)mi.usmblks<<std::endl;
-  std::cout << "MemoryManager: Free bytes held in fastbins (fsmblks): "<< (size_t)mi.fsmblks<<std::endl;
-  std::cout << "MemoryManager: Total allocated space (uordblks):      "<< (size_t)mi.uordblks<<std::endl;
-  std::cout << "MemoryManager: Total free space (fordblks):           "<< (size_t)mi.fordblks<<std::endl;
-  std::cout << "MemoryManager: Topmost releasable block (keepcost):   "<< (size_t)mi.keepcost<<std::endl;
-#endif
-  LEAK_CHECK();
- 
-}
-
 void MemoryManager::PrintBytes(void)
 {
  std::cout << " MemoryManager : ------------------------------------ "<<std::endl;
@@ -63,52 +22,26 @@ void MemoryManager::PrintBytes(void)
  std::cout << " MemoryManager : "<<(total_device>>20)<<" accelerator Mbytes "<<std::endl;
  std::cout << " MemoryManager : "<<(total_host>>20)  <<" cpu         Mbytes "<<std::endl;
  uint64_t cacheBytes;
-  cacheBytes = HostCacheBytes();
-  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" cpu alloc cache Mbytes "<<std::endl;
-  cacheBytes = DeviceCacheBytes();
-  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" acc alloc cache Mbytes "<<std::endl;
+  cacheBytes = CacheBytes[Cpu];
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" cpu cache Mbytes "<<std::endl;
+  cacheBytes = CacheBytes[Acc];
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" acc cache Mbytes "<<std::endl;
+  cacheBytes = CacheBytes[Shared];
+  std::cout << " MemoryManager : "<<(cacheBytes>>20) <<" shared cache Mbytes "<<std::endl;
  
 #ifdef GRID_CUDA
  cuda_mem();
 #endif
-  DisplayMallinfo();
+  
 }

-uint64_t MemoryManager::DeviceCacheBytes() { return CacheBytes[Acc] + CacheBytes[AccHuge] + CacheBytes[AccSmall]; }
-uint64_t MemoryManager::HostCacheBytes()   { return CacheBytes[Cpu] + CacheBytes[CpuHuge] + CacheBytes[CpuSmall]; }
-
 //////////////////////////////////////////////////////////////////////
 // Data tables for recently freed pooiniter caches
 //////////////////////////////////////////////////////////////////////
 MemoryManager::AllocationCacheEntry MemoryManager::Entries[MemoryManager::NallocType][MemoryManager::NallocCacheMax];
 int MemoryManager::Victim[MemoryManager::NallocType];
-int MemoryManager::Ncache[MemoryManager::NallocType] = { 2, 0, 8, 8, 0, 16, 8, 0, 16 };
+int MemoryManager::Ncache[MemoryManager::NallocType] = { 2, 8, 2, 8, 2, 8 };
 uint64_t MemoryManager::CacheBytes[MemoryManager::NallocType];
-uint64_t MemoryManager::DeviceAllocCalls;
-uint64_t MemoryManager::DeviceFreeCalls;
-uint64_t MemoryManager::DeviceAllocBytes;
-uint64_t MemoryManager::DeviceFreeBytes;
-uint64_t MemoryManager::DeviceCacheHits;
-
-void MemoryManager::PrintAllocCounts(void)
-{
-  std::cout << GridLogMemory << "MemoryManager: device allocator calls: acceleratorAllocDevice "
-	    << DeviceAllocCalls <<" ("<< DeviceAllocBytes <<" bytes), acceleratorFreeDevice "
-	    << DeviceFreeCalls  <<" ("<< DeviceFreeBytes  <<" bytes), served from ring cache "
-	    << DeviceCacheHits  << std::endl;
-  std::cout << GridLogMemory << "MemoryManager: view traffic: HostToDevice "
-	    << HostToDeviceXfer <<" transfers ("<< HostToDeviceBytes <<" bytes), DeviceToHost "
-	    << DeviceToHostXfer <<" transfers ("<< DeviceToHostBytes <<" bytes), evictions "
-	    << DeviceEvictions  << std::endl;
-}
-void MemoryManager::Snapshot(const std::string &where)
-{
-  if ( !GridLogMemory.isActive() ) return;
-  std::cout << GridLogMemory << "---------------- memory snapshot: "<< where <<" ----------------"<<std::endl;
-  PrintAllocCounts();
-  PrintBytes();
-  acceleratorMem();
-}
 //////////////////////////////////////////////////////////////////////
 // Actual allocation and deallocation utils
 //////////////////////////////////////////////////////////////////////
@@ -118,11 +51,6 @@ void *MemoryManager::AcceleratorAllocate(size_t bytes)
  void *ptr = (void *) Lookup(bytes,Acc);
  if ( ptr == (void *) NULL ) {
    ptr = (void *) acceleratorAllocDevice(bytes);
-    DeviceAllocCalls++;  DeviceAllocBytes+=bytes;
-    std::cout << GridLogMemory << "MemoryManager: acceleratorAllocDevice size "<< bytes
-	      <<" AccPtr "<< std::hex << (uint64_t)ptr << std::dec << std::endl;
-  } else {
-    DeviceCacheHits++;
  }
 #ifdef GRID_MM_VERBOSE
  std::cout <<"AcceleratorAllocate "<<std::endl;
@@ -133,13 +61,9 @@ void *MemoryManager::AcceleratorAllocate(size_t bytes)
 void  MemoryManager::AcceleratorFree    (void *ptr,size_t bytes)
 {
  total_device-=bytes;
-  size_t freed_bytes=0;
-  void *__freeme = Insert(ptr,bytes,Acc,&freed_bytes);
+  void *__freeme = Insert(ptr,bytes,Acc);
  if ( __freeme ) {
    acceleratorFreeDevice(__freeme);
-    DeviceFreeCalls++;  DeviceFreeBytes+=freed_bytes;
-    std::cout << GridLogMemory << "MemoryManager: acceleratorFreeDevice size "<< freed_bytes
-	      <<" AccPtr "<< std::hex << (uint64_t)__freeme << std::dec << std::endl;
  }
 #ifdef GRID_MM_VERBOSE
  std::cout <<"AcceleratorFree "<<std::endl;
@@ -235,6 +159,7 @@ void MemoryManager::Init(void)

  char * str;
  int Nc;
+  int NcS;
  
  str= getenv("GRID_ALLOC_NCACHE_LARGE");
  if ( str ) {
@@ -246,16 +171,6 @@ void MemoryManager::Init(void)
    }
  }

-  str= getenv("GRID_ALLOC_NCACHE_HUGE");
-  if ( str ) {
-    Nc = atoi(str);
-    if ( (Nc>=0) && (Nc < NallocCacheMax)) {
-      Ncache[CpuHuge]=Nc;
-      Ncache[AccHuge]=Nc;
-      Ncache[SharedHuge]=Nc;
-    }
-  }
-
  str= getenv("GRID_ALLOC_NCACHE_SMALL");
  if ( str ) {
    Nc = atoi(str);
@@ -276,9 +191,7 @@ void MemoryManager::InitMessage(void) {
  
  std::cout << GridLogMessage<< "MemoryManager::Init() setting up"<<std::endl;
 #ifdef ALLOCATION_CACHE
-  std::cout << GridLogMessage<< "MemoryManager::Init() cache pool for recent host   allocations: SMALL "<<Ncache[CpuSmall]<<" LARGE "<<Ncache[Cpu]<<" HUGE "<<Ncache[CpuHuge]<<std::endl;
-  std::cout << GridLogMessage<< "MemoryManager::Init() cache pool for recent device allocations: SMALL "<<Ncache[AccSmall]<<" LARGE "<<Ncache[Acc]<<" Huge "<<Ncache[AccHuge]<<std::endl;
-  std::cout << GridLogMessage<< "MemoryManager::Init() cache pool for recent shared allocations: SMALL "<<Ncache[SharedSmall]<<" LARGE "<<Ncache[Shared]<<" Huge "<<Ncache[SharedHuge]<<std::endl;
+  std::cout << GridLogMessage<< "MemoryManager::Init() cache pool for recent allocations: SMALL "<<Ncache[CpuSmall]<<" LARGE "<<Ncache[Cpu]<<std::endl;
 #endif
  
 #ifdef GRID_UVM
@@ -306,68 +219,25 @@ void MemoryManager::InitMessage(void) {
 #endif

 }
-void *MemoryManager::Insert(void *ptr,size_t bytes,int type,size_t *freed) 
+
+void *MemoryManager::Insert(void *ptr,size_t bytes,int type) 
 {
 #ifdef ALLOCATION_CACHE
-  int cache;
-  if      (bytes < GRID_ALLOC_SMALL_LIMIT) cache = type + 2;
-  else if (bytes >= GRID_ALLOC_HUGE_LIMIT) cache = type + 1;
-  else                                     cache = type;
-
-  return Insert(ptr,bytes,Entries[cache],Ncache[cache],Victim[cache],CacheBytes[cache],freed);  
+  bool small = (bytes < GRID_ALLOC_SMALL_LIMIT);
+  int cache = type + small;
+  return Insert(ptr,bytes,Entries[cache],Ncache[cache],Victim[cache],CacheBytes[cache]);  
 #else
  return ptr;
 #endif
 }
-void MemoryManager::DropCache(void)
-{
-  // Release every block held in the allocation caches (the "recent
-  // allocations" pools: Small/Large/Huge x Cpu/Acc/Shared).  Blocks in these
-  // pools are freed from the caller's point of view but still occupy memory;
-  // after a large setup phase (SUMMA scratch, coarsening temporaries) they can
-  // hold gigabytes of device memory that hipMalloc then cannot get.  Each pool
-  // is freed with the call that pairs with its allocator.
-  for(int sz=0;sz<3;sz++) {
-    int t;
-    t = Acc+sz;
-    for(int e=0;e<Ncache[t];e++) {
-      if( Entries[t][e].valid ) {
-	acceleratorFreeDevice(Entries[t][e].address);
-	Entries[t][e].valid = 0; Entries[t][e].bytes = 0; Entries[t][e].address = NULL;
-      }
-    }
-    CacheBytes[t]=0; Victim[t]=0;
-    t = Shared+sz;
-    for(int e=0;e<Ncache[t];e++) {
-      if( Entries[t][e].valid ) {
-	acceleratorFreeShared(Entries[t][e].address);
-	Entries[t][e].valid = 0; Entries[t][e].bytes = 0; Entries[t][e].address = NULL;
-      }
-    }
-    CacheBytes[t]=0; Victim[t]=0;
-    t = Cpu+sz;
-    for(int e=0;e<Ncache[t];e++) {
-      if( Entries[t][e].valid ) {
-#ifdef GRID_UVM
-	acceleratorFreeShared(Entries[t][e].address);
-#else
-	acceleratorFreeCpu(Entries[t][e].address);
-#endif
-	Entries[t][e].valid = 0; Entries[t][e].bytes = 0; Entries[t][e].address = NULL;
-      }
-    }
-    CacheBytes[t]=0; Victim[t]=0;
-  }
-}

-void *MemoryManager::Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries,int ncache,int &victim, uint64_t &cacheBytes,size_t *freed) 
+void *MemoryManager::Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries,int ncache,int &victim, uint64_t &cacheBytes) 
 {
+  assert(ncache>0);
 #ifdef GRID_OMP
-  GRID_ASSERT(omp_in_parallel()==0);
+  assert(omp_in_parallel()==0);
 #endif 

-  if (ncache == 0) { if(freed) *freed = bytes; return ptr; }   // uncached: the incoming block is the one freed
-
  void * ret = NULL;
  int v = -1;

@@ -385,7 +255,6 @@ void *MemoryManager::Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries

  if ( entries[v].valid ) {
    ret = entries[v].address;
-    if ( freed ) *freed = entries[v].bytes;   // the DISPLACED block is what actually gets freed
    cacheBytes -= entries[v].bytes;
    entries[v].valid = 0;
    entries[v].address = NULL;
@@ -403,11 +272,8 @@ void *MemoryManager::Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries
 void *MemoryManager::Lookup(size_t bytes,int type)
 {
 #ifdef ALLOCATION_CACHE
-  int cache;
-  if      (bytes < GRID_ALLOC_SMALL_LIMIT) cache = type + 2;
-  else if (bytes >= GRID_ALLOC_HUGE_LIMIT) cache = type + 1;
-  else                                     cache = type;
-
+  bool small = (bytes < GRID_ALLOC_SMALL_LIMIT);
+  int cache = type+small;
  return Lookup(bytes,Entries[cache],Ncache[cache],CacheBytes[cache]);
 #else
  return NULL;
@@ -416,8 +282,9 @@ void *MemoryManager::Lookup(size_t bytes,int type)

 void *MemoryManager::Lookup(size_t bytes,AllocationCacheEntry *entries,int ncache,uint64_t & cacheBytes) 
 {
+  assert(ncache>0);
 #ifdef GRID_OMP
-  GRID_ASSERT(omp_in_parallel()==0);
+  assert(omp_in_parallel()==0);
 #endif 
  for(int e=0;e<ncache;e++){
    if ( entries[e].valid && ( entries[e].bytes == bytes ) ) {
@@ -35,12 +35,6 @@ NAMESPACE_BEGIN(Grid);
 // Move control to configure.ac and Config.h?

 #define GRID_ALLOC_SMALL_LIMIT (4096)
-#define GRID_ALLOC_HUGE_LIMIT  (2147483648)
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY(x)
-#define FILE_LINE __FILE__ ":" TOSTRING(__LINE__)
-#define AUDIT(a) MemoryManager::Audit(FILE_LINE)

 /*Pinning pages is costly*/
 ////////////////////////////////////////////////////////////////////////////
@@ -71,21 +65,6 @@ enum ViewMode {
  CpuWriteDiscard = 0x10 // same for now
 };

-struct MemoryStatus {
-  uint64_t     DeviceBytes;
-  uint64_t     DeviceLRUBytes;
-  uint64_t     DeviceMaxBytes;
-  uint64_t     HostToDeviceBytes;
-  uint64_t     DeviceToHostBytes;
-  uint64_t     HostToDeviceXfer;
-  uint64_t     DeviceToHostXfer;
-  uint64_t     DeviceEvictions;
-  uint64_t     DeviceDestroy;
-  uint64_t     DeviceAllocCacheBytes;
-  uint64_t     HostAllocCacheBytes;
-};
-
-
 class MemoryManager {
 private:

@@ -99,7 +78,7 @@ private:
  } AllocationCacheEntry;

  static const int NallocCacheMax=128; 
-  static const int NallocType=9;
+  static const int NallocType=6;
  static AllocationCacheEntry Entries[NallocType][NallocCacheMax];
  static int Victim[NallocType];
  static int Ncache[NallocType];
@@ -108,14 +87,13 @@ private:
  /////////////////////////////////////////////////
  // Free pool
  /////////////////////////////////////////////////
-  static void *Insert(void *ptr,size_t bytes,int type,size_t *freed=nullptr) ;
+  static void *Insert(void *ptr,size_t bytes,int type) ;
  static void *Lookup(size_t bytes,int type) ;
-  static void *Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries,int ncache,int &victim,uint64_t &cbytes,size_t *freed=nullptr) ;
+  static void *Insert(void *ptr,size_t bytes,AllocationCacheEntry *entries,int ncache,int &victim,uint64_t &cbytes) ;
  static void *Lookup(size_t bytes,AllocationCacheEntry *entries,int ncache,uint64_t &cbytes) ;

-public:  
  static void PrintBytes(void);
-  static void Audit(std::string s);
+ public:
  static void Init(void);
  static void InitMessage(void);
  static void *AcceleratorAllocate(size_t bytes);
@@ -135,40 +113,7 @@ public:
  static uint64_t     DeviceToHostBytes;
  static uint64_t     HostToDeviceXfer;
  static uint64_t     DeviceToHostXfer;
-  static uint64_t     DeviceEvictions;
-  static uint64_t     DeviceDestroy;
-  // Calls that actually reach the runtime, as distinct from the Evict/Clone traffic above:
-  // a free only reaches acceleratorFreeDevice when displaced from the allocation ring cache,
-  // and an allocate only reaches acceleratorAllocDevice on a ring miss.
-  static uint64_t     DeviceAllocCalls;
-  static uint64_t     DeviceFreeCalls;
-  static uint64_t     DeviceAllocBytes;
-  static uint64_t     DeviceFreeBytes;
-  static uint64_t     DeviceCacheHits;
-  static void         PrintAllocCounts(void);
-  // Labelled snapshot: allocator counts + footprint + device free/total.  Silent unless
-  // --log Memory is on, so it can be left in hot code.
-  static void         Snapshot(const std::string &where);
-
-  static uint64_t     DeviceCacheBytes();
-  static uint64_t     HostCacheBytes();
-
-  static MemoryStatus GetFootprint(void) {
-    MemoryStatus stat;
-    stat.DeviceBytes       = DeviceBytes;
-    stat.DeviceLRUBytes    = DeviceLRUBytes;
-    stat.DeviceMaxBytes    = DeviceMaxBytes;
-    stat.HostToDeviceBytes = HostToDeviceBytes;
-    stat.DeviceToHostBytes = DeviceToHostBytes;
-    stat.HostToDeviceXfer  = HostToDeviceXfer;
-    stat.DeviceToHostXfer  = DeviceToHostXfer;
-    stat.DeviceEvictions   = DeviceEvictions;
-    stat.DeviceDestroy     = DeviceDestroy;
-    stat.DeviceAllocCacheBytes = DeviceCacheBytes();
-    stat.HostAllocCacheBytes   = HostCacheBytes();
-    return stat;
-  };
-  
+ 
 private:
 #ifndef GRID_UVM
  //////////////////////////////////////////////////////////////////////
@@ -221,15 +166,10 @@ public:
  static void     CpuViewClose(uint64_t Ptr);
  static uint64_t CpuViewOpen(uint64_t  CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint);
 #endif
+  static void NotifyDeletion(void * CpuPtr);

 public:
-  static void DisplayMallinfo(void);
-  static void NotifyDeletion(void * CpuPtr);
  static void Print(void);
-  static void PrintAll(void);
-  static void EvictAll(void);
-  static void DropCache(void);
-  static void PrintState( void* CpuPtr);
  static int   isOpen   (void* CpuPtr);
  static void  ViewClose(void* CpuPtr,ViewMode mode);
  static void *ViewOpen (void* CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint);
@@ -1,15 +1,11 @@
 #include <Grid/GridCore.h>
 #ifndef GRID_UVM

+#warning "Using explicit device memory copies"
 NAMESPACE_BEGIN(Grid);
+//#define dprintf(...) printf ( __VA_ARGS__ ); fflush(stdout);
+#define dprintf(...)

-#define MAXLINE 512
-static char print_buffer [ MAXLINE ];
-
-#define mprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogMemory << print_buffer << std::endl;
-#define dprintf(...) snprintf (print_buffer,MAXLINE, __VA_ARGS__ ); std::cout << GridLogDebug  << print_buffer << std::endl;
-//#define dprintf(...) 
-//#define mprintf(...) 

 ////////////////////////////////////////////////////////////
 // For caching copies of data on device
@@ -27,8 +23,6 @@ uint64_t  MemoryManager::HostToDeviceBytes;
 uint64_t  MemoryManager::DeviceToHostBytes;
 uint64_t  MemoryManager::HostToDeviceXfer;
 uint64_t  MemoryManager::DeviceToHostXfer;
-uint64_t  MemoryManager::DeviceEvictions;
-uint64_t  MemoryManager::DeviceDestroy;

 ////////////////////////////////////
 // Priority ordering for unlocked entries
@@ -50,12 +44,12 @@ int   MemoryManager::EntryPresent(uint64_t CpuPtr)
 {
  if(AccViewTable.empty()) return 0;

-  auto count = AccViewTable.count(CpuPtr);  GRID_ASSERT((count==0)||(count==1));
+  auto count = AccViewTable.count(CpuPtr);  assert((count==0)||(count==1));
  return count;
 }
 void  MemoryManager::EntryCreate(uint64_t CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint)
 {
-  GRID_ASSERT(!EntryPresent(CpuPtr));
+  assert(!EntryPresent(CpuPtr));
  AcceleratorViewEntry AccCache;
  AccCache.CpuPtr = CpuPtr;
  AccCache.AccPtr = (uint64_t)NULL;
@@ -69,9 +63,9 @@ void  MemoryManager::EntryCreate(uint64_t CpuPtr,size_t bytes,ViewMode mode,View
 }
 MemoryManager::AccViewTableIterator MemoryManager::EntryLookup(uint64_t CpuPtr)
 {
-  GRID_ASSERT(EntryPresent(CpuPtr));
+  assert(EntryPresent(CpuPtr));
  auto AccCacheIterator = AccViewTable.find(CpuPtr);
-  GRID_ASSERT(AccCacheIterator!=AccViewTable.end());
+  assert(AccCacheIterator!=AccViewTable.end());
  return AccCacheIterator;
 }
 void MemoryManager::EntryErase(uint64_t CpuPtr)
@@ -79,28 +73,9 @@ void MemoryManager::EntryErase(uint64_t CpuPtr)
  auto AccCache = EntryLookup(CpuPtr);
  AccViewTable.erase(CpuPtr);
 }
-/////////////////////////////////////////////////////////////////////////////////
-// LRU membership invariant:
-//
-//    LRU_valid == 1   <=>   AccPtr != NULL  &&  accLock == 0  &&  cpuLock == 0
-//
-// i.e. the LRU queue contains exactly the device-resident, completely unlocked
-// entries -- the evictable set.  Membership is maintained EAGERLY at the lock
-// 0<->1 edges, O(1) via the stored LRU_entry iterator:
-//
-//    AcceleratorViewOpen   lock 0->1 : LRUremove   (gated on LRU_valid)
-//    AcceleratorViewClose  accLock->0: LRUinsert   (AccPtr necessarily exists)
-//    CpuViewOpen           lock 0->1 : LRUremove   (gated on LRU_valid)
-//    CpuViewClose          cpuLock->0: LRUinsert   (iff AccPtr exists)
-//    Evict/AccDiscard                : LRUremove   (frees the device copy)
-//
-// Consequences: victims taken from LRU.back() are evictable by construction;
-// Evict() on a locked entry is an invariant violation (asserted), and the
-// eviction loops (EvictVictims/EvictAll) cannot spin.
-/////////////////////////////////////////////////////////////////////////////////
 void  MemoryManager::LRUinsert(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.LRU_valid==0);
+  assert(AccCache.LRU_valid==0);
  if (AccCache.transient) { 
    LRU.push_back(AccCache.CpuPtr);
    AccCache.LRU_entry = --LRU.end();
@@ -113,7 +88,7 @@ void  MemoryManager::LRUinsert(AcceleratorViewEntry &AccCache)
 }
 void  MemoryManager::LRUremove(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.LRU_valid==1);
+  assert(AccCache.LRU_valid==1);
  LRU.erase(AccCache.LRU_entry);
  AccCache.LRU_valid = 0;
  DeviceLRUBytes-=AccCache.bytes;
@@ -127,19 +102,17 @@ void MemoryManager::AccDiscard(AcceleratorViewEntry &AccCache)
  // Remove from Accelerator, remove entry, without flush
  // Cannot be locked. If allocated Must be in LRU pool.
  ///////////////////////////////////////////////////////////
-  GRID_ASSERT(AccCache.state!=Empty);
+  assert(AccCache.state!=Empty);
  
-  dprintf("MemoryManager: Discard(%lx) %lx",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
-  GRID_ASSERT(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+   dprintf("MemoryManager: Discard(%llx) %llx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
+  assert(AccCache.accLock==0);
+  assert(AccCache.cpuLock==0);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
  if(AccCache.AccPtr) {
    AcceleratorFree((void *)AccCache.AccPtr,AccCache.bytes);
-    DeviceDestroy++;
    DeviceBytes   -=AccCache.bytes;
    LRUremove(AccCache);
-    AccCache.AccPtr=(uint64_t) NULL;
-    dprintf("MemoryManager: Free(%lx) LRU %ld Total %ld",(uint64_t)AccCache.AccPtr,DeviceLRUBytes,DeviceBytes);  
+    dprintf("MemoryManager: Free(%llx) LRU %lld Total %lld\n",(uint64_t)AccCache.AccPtr,DeviceLRUBytes,DeviceBytes);  
  }
  uint64_t CpuPtr = AccCache.CpuPtr;
  EntryErase(CpuPtr);
@@ -148,63 +121,51 @@ void MemoryManager::AccDiscard(AcceleratorViewEntry &AccCache)
 void MemoryManager::Evict(AcceleratorViewEntry &AccCache)
 {
  ///////////////////////////////////////////////////////////////////////////
-  // Make CPU consistent, remove from Accelerator, remove from LRU, LEAVE CPU only entry
+  // Make CPU consistent, remove from Accelerator, remove entry
  // Cannot be locked. If allocated must be in LRU pool.
-  //
-  // (Historical: a Nov 2022 incident (two CpuPtrs; eviction called from
-  //  CpuViewOpen -- since excised) could present a cpuLocked entry here, and
-  //  silent-return guards were added.  The LRU membership invariant (see
-  //  LRUinsert) now excludes ALL locked entries from the queue eagerly at the
-  //  lock edges, so a locked victim is an invariant violation: asserted.)
  ///////////////////////////////////////////////////////////////////////////
-  GRID_ASSERT(AccCache.state!=Empty);
+  assert(AccCache.state!=Empty);
  
-  mprintf("MemoryManager: Evict CpuPtr %lx AccPtr %lx cpuLock %ld accLock %ld",
-	  (uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr,
-	  (uint64_t)AccCache.cpuLock,(uint64_t)AccCache.accLock); 
-  GRID_ASSERT(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.cpuLock==0);
+  dprintf("MemoryManager: Evict(%llx) %llx\n",(uint64_t)AccCache.CpuPtr,(uint64_t)AccCache.AccPtr); 
+  assert(AccCache.accLock==0);
+  assert(AccCache.cpuLock==0);
  if(AccCache.state==AccDirty) {
    Flush(AccCache);
  }
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
  if(AccCache.AccPtr) {
    AcceleratorFree((void *)AccCache.AccPtr,AccCache.bytes);
-    LRUremove(AccCache);
-    AccCache.AccPtr=(uint64_t)NULL;
-    AccCache.state=CpuDirty; // CPU primary now
    DeviceBytes   -=AccCache.bytes;
-    dprintf("MemoryManager: Free(AccPtr %lx) footprint now %ld ",(uint64_t)AccCache.AccPtr,DeviceBytes);  
+    LRUremove(AccCache);
+    dprintf("MemoryManager: Free(%llx) footprint now %lld \n",(uint64_t)AccCache.AccPtr,DeviceBytes);  
  }
-  //  uint64_t CpuPtr = AccCache.CpuPtr;
-  DeviceEvictions++;
-  //  EntryErase(CpuPtr);
+  uint64_t CpuPtr = AccCache.CpuPtr;
+  EntryErase(CpuPtr);
 }
 void MemoryManager::Flush(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state==AccDirty);
-  GRID_ASSERT(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.AccPtr!=(uint64_t)NULL);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.state==AccDirty);
+  assert(AccCache.cpuLock==0);
+  assert(AccCache.accLock==0);
+  assert(AccCache.AccPtr!=(uint64_t)NULL);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
  acceleratorCopyFromDevice((void *)AccCache.AccPtr,(void *)AccCache.CpuPtr,AccCache.bytes);
-  mprintf("MemoryManager: acceleratorCopyFromDevice Flush size %ld AccPtr %lx -> CpuPtr %lx",(uint64_t)AccCache.bytes,(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
+  dprintf("MemoryManager: Flush  %llx -> %llx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
  DeviceToHostBytes+=AccCache.bytes;
  DeviceToHostXfer++;
  AccCache.state=Consistent;
 }
 void MemoryManager::Clone(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state==CpuDirty);
-  GRID_ASSERT(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.state==CpuDirty);
+  assert(AccCache.cpuLock==0);
+  assert(AccCache.accLock==0);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
  if(AccCache.AccPtr==(uint64_t)NULL){
    AccCache.AccPtr=(uint64_t)AcceleratorAllocate(AccCache.bytes);
    DeviceBytes+=AccCache.bytes;
  }
-  mprintf("MemoryManager: acceleratorCopyToDevice   Clone size %ld AccPtr %lx <- CpuPtr %lx",
-	  (uint64_t)AccCache.bytes,
-	  (uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
+  dprintf("MemoryManager: Clone %llx <- %llx\n",(uint64_t)AccCache.AccPtr,(uint64_t)AccCache.CpuPtr); fflush(stdout);
  acceleratorCopyToDevice((void *)AccCache.CpuPtr,(void *)AccCache.AccPtr,AccCache.bytes);
  HostToDeviceBytes+=AccCache.bytes;
  HostToDeviceXfer++;
@@ -213,10 +174,10 @@ void MemoryManager::Clone(AcceleratorViewEntry &AccCache)

 void MemoryManager::CpuDiscard(AcceleratorViewEntry &AccCache)
 {
-  GRID_ASSERT(AccCache.state!=Empty);
-  GRID_ASSERT(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock==0);
-  GRID_ASSERT(AccCache.CpuPtr!=(uint64_t)NULL);
+  assert(AccCache.state!=Empty);
+  assert(AccCache.cpuLock==0);
+  assert(AccCache.accLock==0);
+  assert(AccCache.CpuPtr!=(uint64_t)NULL);
  if(AccCache.AccPtr==(uint64_t)NULL){
    AccCache.AccPtr=(uint64_t)AcceleratorAllocate(AccCache.bytes);
    DeviceBytes+=AccCache.bytes;
@@ -230,55 +191,34 @@ void MemoryManager::CpuDiscard(AcceleratorViewEntry &AccCache)
 void MemoryManager::ViewClose(void* Ptr,ViewMode mode)
 {
  if( (mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard) ){
-    dprintf("AcceleratorViewClose %lx",(uint64_t)Ptr);
    AcceleratorViewClose((uint64_t)Ptr);
  } else if( (mode==CpuRead)||(mode==CpuWrite)){
    CpuViewClose((uint64_t)Ptr);
  } else { 
-    GRID_ASSERT(0);
+    assert(0);
  }
 }
 void *MemoryManager::ViewOpen(void* _CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint)
 {
  uint64_t CpuPtr = (uint64_t)_CpuPtr;
  if( (mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard) ){
-    dprintf("AcceleratorViewOpen %lx",(uint64_t)CpuPtr);
    return (void *) AcceleratorViewOpen(CpuPtr,bytes,mode,hint);
  } else if( (mode==CpuRead)||(mode==CpuWrite)){
    return (void *)CpuViewOpen(CpuPtr,bytes,mode,hint);
  } else { 
-    GRID_ASSERT(0);
+    assert(0);
    return NULL;
  }
 }
 void  MemoryManager::EvictVictims(uint64_t bytes)
 {
-  if(bytes>=DeviceMaxBytes) {
-    printf("EvictVictims bytes %ld DeviceMaxBytes %ld\n",bytes,DeviceMaxBytes);
-  }
-  GRID_ASSERT(bytes<DeviceMaxBytes);
  while(bytes+DeviceLRUBytes > DeviceMaxBytes){
    if ( DeviceLRUBytes > 0){
-      GRID_ASSERT(LRU.size()>0);
-      uint64_t victim = LRU.back(); // From the LRU
+      assert(LRU.size()>0);
+      uint64_t victim = LRU.back();
      auto AccCacheIterator = EntryLookup(victim);
      auto & AccCache = AccCacheIterator->second;
      Evict(AccCache);
-    } else {
-      return;
-    }
-  }
-}
-void  MemoryManager::EvictAll(void)
-{
-  while(LRU.size()>0){
-    if ( DeviceLRUBytes > 0){
-      uint64_t victim = LRU.back(); // From the LRU
-      auto AccCacheIterator = EntryLookup(victim);
-      auto & AccCache = AccCacheIterator->second;
-      Evict(AccCache);
-    } else {
-      return;
    }
  }
 }
@@ -296,19 +236,18 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
  if (!AccCache.AccPtr) {
    EvictVictims(bytes); 
  } 
-  GRID_ASSERT((mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard));
+  assert((mode==AcceleratorRead)||(mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard));

-  GRID_ASSERT(AccCache.cpuLock==0);  // Programming error
+  assert(AccCache.cpuLock==0);  // Programming error

  if(AccCache.state!=Empty) {
-    dprintf("ViewOpen found entry %lx %lx : sizes %ld %ld accLock %ld",
+    dprintf("ViewOpen found entry %llx %llx : %lld %lld\n",
 		    (uint64_t)AccCache.CpuPtr,
 		    (uint64_t)CpuPtr,
 		    (uint64_t)AccCache.bytes,
-	            (uint64_t)bytes,
-		    (uint64_t)AccCache.accLock);
-    GRID_ASSERT(AccCache.CpuPtr == CpuPtr);
-    GRID_ASSERT(AccCache.bytes  ==bytes);
+		    (uint64_t)bytes);
+    assert(AccCache.CpuPtr == CpuPtr);
+    assert(AccCache.bytes  ==bytes);
  }
 /*
 *  State transitions and actions
@@ -325,7 +264,7 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
 *  AccWrite AccDirty   AccDirty       -        - 
 */
  if(AccCache.state==Empty) {
-    GRID_ASSERT(AccCache.LRU_valid==0);
+    assert(AccCache.LRU_valid==0);
    AccCache.CpuPtr = CpuPtr;
    AccCache.AccPtr = (uint64_t)NULL;
    AccCache.bytes  = bytes;
@@ -341,7 +280,6 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
      AccCache.state  = Consistent; // Empty + AccRead => Consistent
    }
    AccCache.accLock= 1;
-    dprintf("Copied Empty entry into device accLock= %d",AccCache.accLock);
  } else if(AccCache.state==CpuDirty ){
    if(mode==AcceleratorWriteDiscard) {
      CpuDiscard(AccCache);
@@ -354,30 +292,28 @@ uint64_t MemoryManager::AcceleratorViewOpen(uint64_t CpuPtr,size_t bytes,ViewMod
      AccCache.state  = Consistent; // CpuDirty + AccRead => Consistent
    }
    AccCache.accLock++;
-    dprintf("CpuDirty entry into device ++accLock= %d",AccCache.accLock);
+    dprintf("Copied CpuDirty entry into device accLock %d\n",AccCache.accLock);
  } else if(AccCache.state==Consistent) {
    if((mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard))
      AccCache.state  = AccDirty;   // Consistent + AcceleratorWrite=> AccDirty
    else
      AccCache.state  = Consistent; // Consistent + AccRead => Consistent
    AccCache.accLock++;
-    dprintf("Consistent entry into device ++accLock= %d",AccCache.accLock);
+    dprintf("Consistent entry into device accLock %d\n",AccCache.accLock);
  } else if(AccCache.state==AccDirty) {
    if((mode==AcceleratorWrite)||(mode==AcceleratorWriteDiscard))
      AccCache.state  = AccDirty; // AccDirty + AcceleratorWrite=> AccDirty
    else
      AccCache.state  = AccDirty; // AccDirty + AccRead => AccDirty
    AccCache.accLock++;
-    dprintf("AccDirty entry ++accLock= %d",AccCache.accLock);
+    dprintf("AccDirty entry into device accLock %d\n",AccCache.accLock);
  } else {
-    GRID_ASSERT(0);
+    assert(0);
  }

-  GRID_ASSERT(AccCache.accLock>0);
-  // If view is opened on device must remove from LRU
+  // If view is opened on device remove from LRU
  if(AccCache.LRU_valid==1){
    // must possibly remove from LRU as now locked on GPU
-    dprintf("AccCache entry removed from LRU ");
    LRUremove(AccCache);
  }

@@ -394,16 +330,14 @@ void MemoryManager::AcceleratorViewClose(uint64_t CpuPtr)
  auto AccCacheIterator = EntryLookup(CpuPtr);
  auto & AccCache = AccCacheIterator->second;

-  GRID_ASSERT(AccCache.cpuLock==0);
-  GRID_ASSERT(AccCache.accLock>0);
+  assert(AccCache.cpuLock==0);
+  assert(AccCache.accLock>0);

  AccCache.accLock--;
+
  // Move to LRU queue if not locked and close on device
  if(AccCache.accLock==0) {
-    dprintf("AccleratorViewClose %lx AccLock decremented to %ld move to LRU queue",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
    LRUinsert(AccCache);
-  } else {
-    dprintf("AccleratorViewClose %lx AccLock decremented to %ld",(uint64_t)CpuPtr,(uint64_t)AccCache.accLock);
  }
 }
 void MemoryManager::CpuViewClose(uint64_t CpuPtr)
@@ -411,17 +345,10 @@ void MemoryManager::CpuViewClose(uint64_t CpuPtr)
  auto AccCacheIterator = EntryLookup(CpuPtr);
  auto & AccCache = AccCacheIterator->second;

-  GRID_ASSERT(AccCache.cpuLock>0);
-  GRID_ASSERT(AccCache.accLock==0);
+  assert(AccCache.cpuLock>0);
+  assert(AccCache.accLock==0);

  AccCache.cpuLock--;
-  // Return to LRU queue when fully unlocked -- mirrors AcceleratorViewClose.
-  // Asymmetry vs the Acc side: a device copy need not exist for a host view;
-  // only device-resident entries belong in the (evictable) LRU queue.
-  if( (AccCache.cpuLock==0) && (AccCache.AccPtr!=(uint64_t)NULL) ) {
-    dprintf("CpuViewClose %lx cpuLock decremented to zero, move to LRU queue",(uint64_t)CpuPtr);
-    LRUinsert(AccCache);
-  }
 }
 /*
 *  Action  State   StateNext         Flush    Clone
@@ -447,17 +374,16 @@ uint64_t MemoryManager::CpuViewOpen(uint64_t CpuPtr,size_t bytes,ViewMode mode,V
  auto AccCacheIterator = EntryLookup(CpuPtr);
  auto & AccCache = AccCacheIterator->second;

-  // CPU doesn't need to free space
-  //  if (!AccCache.AccPtr) {
-  //    EvictVictims(bytes);
-  //  }
+  if (!AccCache.AccPtr) {
+     EvictVictims(bytes);
+  }

-  GRID_ASSERT((mode==CpuRead)||(mode==CpuWrite));
-  GRID_ASSERT(AccCache.accLock==0);  // Programming error
+  assert((mode==CpuRead)||(mode==CpuWrite));
+  assert(AccCache.accLock==0);  // Programming error

  if(AccCache.state!=Empty) {
-    GRID_ASSERT(AccCache.CpuPtr == CpuPtr);
-    GRID_ASSERT(AccCache.bytes==bytes);
+    assert(AccCache.CpuPtr == CpuPtr);
+    assert(AccCache.bytes==bytes);
  }

  if(AccCache.state==Empty) {
@@ -472,28 +398,20 @@ uint64_t MemoryManager::CpuViewOpen(uint64_t CpuPtr,size_t bytes,ViewMode mode,V
    AccCache.state = CpuDirty; // CpuDirty +CpuRead/CpuWrite => CpuDirty
    AccCache.cpuLock++;
  } else if(AccCache.state==Consistent) {
-    GRID_ASSERT(AccCache.AccPtr != (uint64_t)NULL);
+    assert(AccCache.AccPtr != (uint64_t)NULL);
    if(mode==CpuWrite)
      AccCache.state = CpuDirty;   // Consistent +CpuWrite => CpuDirty
    else 
      AccCache.state = Consistent; // Consistent +CpuRead  => Consistent
    AccCache.cpuLock++;
  } else if(AccCache.state==AccDirty) {
-    GRID_ASSERT(AccCache.AccPtr != (uint64_t)NULL);
+    assert(AccCache.AccPtr != (uint64_t)NULL);
    Flush(AccCache);
    if(mode==CpuWrite) AccCache.state = CpuDirty;   // AccDirty +CpuWrite => CpuDirty, Flush
    else            AccCache.state = Consistent; // AccDirty +CpuRead  => Consistent, Flush
    AccCache.cpuLock++;
  } else {
-    GRID_ASSERT(0); // should be unreachable
-  }
-
-  GRID_ASSERT(AccCache.cpuLock>0);
-  // If view is opened on host must remove from LRU -- mirrors AcceleratorViewOpen.
-  // LRU_valid==1 here implies this is the 0->1 lock edge of a device-resident entry.
-  if(AccCache.LRU_valid==1){
-    dprintf("CpuViewOpen: entry removed from LRU ");
-    LRUremove(AccCache);
+    assert(0); // should be unreachable
  }

  AccCache.transient= transient? EvictNext : 0;
@@ -512,29 +430,20 @@ void  MemoryManager::NotifyDeletion(void *_ptr)
 void  MemoryManager::Print(void)
 {
  PrintBytes();
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
-  std::cout << GridLogMessage << "Memory Manager                             " << std::endl;
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
-  std::cout << GridLogMessage << DeviceBytes   << " bytes allocated on device " << std::endl;
-  std::cout << GridLogMessage << DeviceLRUBytes<< " bytes evictable on device " << std::endl;
-  std::cout << GridLogMessage << DeviceMaxBytes<< " bytes max on device       " << std::endl;
-  std::cout << GridLogMessage << HostToDeviceXfer << " transfers        to   device " << std::endl;
-  std::cout << GridLogMessage << DeviceToHostXfer << " transfers        from device " << std::endl;
-  std::cout << GridLogMessage << HostToDeviceBytes<< " bytes transfered to   device " << std::endl;
-  std::cout << GridLogMessage << DeviceToHostBytes<< " bytes transfered from device " << std::endl;
-  std::cout << GridLogMessage << DeviceEvictions  << " Evictions from device " << std::endl;
-  std::cout << GridLogMessage << DeviceDestroy    << " Destroyed vectors on device " << std::endl;
-  std::cout << GridLogMessage << AccViewTable.size()<< " vectors " << LRU.size()<<" evictable"<< std::endl;
-  acceleratorMem();
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
-}
-void  MemoryManager::PrintAll(void)
-{
-  Print();
-  std::cout << GridLogMessage << std::endl;
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
-  std::cout << GridLogMessage << "CpuAddr\t\tAccAddr\t\tState\t\tcpuLock\taccLock\tLRU_valid "<<std::endl;
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
+  std::cout << GridLogDebug << "--------------------------------------------" << std::endl;
+  std::cout << GridLogDebug << "Memory Manager                             " << std::endl;
+  std::cout << GridLogDebug << "--------------------------------------------" << std::endl;
+  std::cout << GridLogDebug << DeviceBytes   << " bytes allocated on device " << std::endl;
+  std::cout << GridLogDebug << DeviceLRUBytes<< " bytes evictable on device " << std::endl;
+  std::cout << GridLogDebug << DeviceMaxBytes<< " bytes max on device       " << std::endl;
+  std::cout << GridLogDebug << HostToDeviceXfer << " transfers        to   device " << std::endl;
+  std::cout << GridLogDebug << DeviceToHostXfer << " transfers        from device " << std::endl;
+  std::cout << GridLogDebug << HostToDeviceBytes<< " bytes transfered to   device " << std::endl;
+  std::cout << GridLogDebug << DeviceToHostBytes<< " bytes transfered from device " << std::endl;
+  std::cout << GridLogDebug << AccViewTable.size()<< " vectors " << LRU.size()<<" evictable"<< std::endl;
+  std::cout << GridLogDebug << "--------------------------------------------" << std::endl;
+  std::cout << GridLogDebug << "CpuAddr\t\tAccAddr\t\tState\t\tcpuLock\taccLock\tLRU_valid "<<std::endl;
+  std::cout << GridLogDebug << "--------------------------------------------" << std::endl;
  for(auto it=AccViewTable.begin();it!=AccViewTable.end();it++){
    auto &AccCache = it->second;
    
@@ -544,13 +453,13 @@ void  MemoryManager::PrintAll(void)
    if ( AccCache.state==AccDirty ) str = std::string("AccDirty");
    if ( AccCache.state==Consistent)str = std::string("Consistent");

-    std::cout << GridLogMessage << "0x"<<std::hex<<AccCache.CpuPtr<<std::dec
+    std::cout << GridLogDebug << "0x"<<std::hex<<AccCache.CpuPtr<<std::dec
 	      << "\t0x"<<std::hex<<AccCache.AccPtr<<std::dec<<"\t" <<str
 	      << "\t" << AccCache.cpuLock
 	      << "\t" << AccCache.accLock
 	      << "\t" << AccCache.LRU_valid<<std::endl;
  }
-  std::cout << GridLogMessage << "--------------------------------------------" << std::endl;
+  std::cout << GridLogDebug << "--------------------------------------------" << std::endl;

 };
 int   MemoryManager::isOpen   (void* _CpuPtr) 
@@ -564,89 +473,6 @@ int   MemoryManager::isOpen   (void* _CpuPtr)
    return 0;
  }
 }
-void MemoryManager::Audit(std::string s)
-{
-  uint64_t CpuBytes=0;
-  uint64_t AccBytes=0;
-  uint64_t LruBytes1=0;
-  uint64_t LruBytes2=0;
-  uint64_t LruCnt=0;
-  
-  std::cout << " Memory Manager::Audit() from "<<s<<std::endl;
-  for(auto it=LRU.begin();it!=LRU.end();it++){
-    uint64_t cpuPtr = *it;
-    GRID_ASSERT(EntryPresent(cpuPtr));
-    auto AccCacheIterator = EntryLookup(cpuPtr);
-    auto & AccCache = AccCacheIterator->second;
-    LruBytes2+=AccCache.bytes;
-    GRID_ASSERT(AccCache.LRU_valid==1);
-    GRID_ASSERT(AccCache.LRU_entry==it);
-  }
-  std::cout << " Memory Manager::Audit() LRU queue matches table entries "<<std::endl;
-
-  for(auto it=AccViewTable.begin();it!=AccViewTable.end();it++){
-    auto &AccCache = it->second;
-    
-    std::string str;
-    if ( AccCache.state==Empty    ) str = std::string("Empty");
-    if ( AccCache.state==CpuDirty ) str = std::string("CpuDirty");
-    if ( AccCache.state==AccDirty ) str = std::string("AccDirty");
-    if ( AccCache.state==Consistent)str = std::string("Consistent");
-
-    CpuBytes+=AccCache.bytes;
-    if( AccCache.AccPtr )    AccBytes+=AccCache.bytes;
-    if( AccCache.LRU_valid ) LruBytes1+=AccCache.bytes;
-    if( AccCache.LRU_valid ) LruCnt++;
-    
-    if ( AccCache.cpuLock || AccCache.accLock ) {
-      GRID_ASSERT(AccCache.LRU_valid==0);
-
-      std::cout << GridLogError << s<< "\n\t 0x"<<std::hex<<AccCache.CpuPtr<<std::dec
-		<< "\t0x"<<std::hex<<AccCache.AccPtr<<std::dec<<"\t" <<str
-		<< "\t cpuLock  " << AccCache.cpuLock
-		<< "\t accLock  " << AccCache.accLock
-		<< "\t LRUvalid " << AccCache.LRU_valid<<std::endl;
-    }
-
-    GRID_ASSERT( AccCache.cpuLock== 0 ) ;
-    GRID_ASSERT( AccCache.accLock== 0 ) ;
-  }
-  std::cout << " Memory Manager::Audit() no locked table entries "<<std::endl;
-  GRID_ASSERT(LruBytes1==LruBytes2);
-  GRID_ASSERT(LruBytes1==DeviceLRUBytes);
-  std::cout << " Memory Manager::Audit() evictable bytes matches sum over table "<<std::endl;
-  GRID_ASSERT(AccBytes==DeviceBytes);
-  std::cout << " Memory Manager::Audit() device bytes matches sum over table "<<std::endl;
-  GRID_ASSERT(LruCnt == LRU.size());
-  std::cout << " Memory Manager::Audit() LRU entry count matches "<<std::endl;
-
-}
-
-void MemoryManager::PrintState(void* _CpuPtr)
-{
-  uint64_t CpuPtr = (uint64_t)_CpuPtr;
-
-  if ( EntryPresent(CpuPtr) ){
-    auto AccCacheIterator = EntryLookup(CpuPtr);
-    auto & AccCache = AccCacheIterator->second;
-    std::string str;
-    if ( AccCache.state==Empty    ) str = std::string("Empty");
-    if ( AccCache.state==CpuDirty ) str = std::string("CpuDirty");
-    if ( AccCache.state==AccDirty ) str = std::string("AccDirty");
-    if ( AccCache.state==Consistent)str = std::string("Consistent");
-    if ( AccCache.state==EvictNext) str = std::string("EvictNext");
-
-    std::cout << GridLogMessage << "CpuAddr\t\tAccAddr\t\tState\t\tcpuLock\taccLock\tLRU_valid "<<std::endl;
-    std::cout << GridLogMessage << "\tx"<<std::hex<<AccCache.CpuPtr<<std::dec
-    << "\tx"<<std::hex<<AccCache.AccPtr<<std::dec<<"\t" <<str
-    << "\t" << AccCache.cpuLock
-    << "\t" << AccCache.accLock
-    << "\t" << AccCache.LRU_valid<<std::endl;
-
-  } else {
-    std::cout << GridLogMessage << "No Entry in AccCache table." << std::endl; 
-  }
-}

 NAMESPACE_END(Grid);

@@ -12,20 +12,11 @@ uint64_t  MemoryManager::HostToDeviceBytes;
 uint64_t  MemoryManager::DeviceToHostBytes;
 uint64_t  MemoryManager::HostToDeviceXfer;
 uint64_t  MemoryManager::DeviceToHostXfer;
-uint64_t  MemoryManager::DeviceEvictions;
-uint64_t  MemoryManager::DeviceDestroy;

-void  MemoryManager::Audit(std::string s){};
 void  MemoryManager::ViewClose(void* AccPtr,ViewMode mode){};
 void *MemoryManager::ViewOpen(void* CpuPtr,size_t bytes,ViewMode mode,ViewAdvise hint){ return CpuPtr; };
 int   MemoryManager::isOpen   (void* CpuPtr) { return 0;}
-void  MemoryManager::PrintState(void* CpuPtr)
-{
-std::cout << GridLogMessage << "Host<->Device memory movement not currently managed by Grid." << std::endl;
-};
 void  MemoryManager::Print(void){};
-void  MemoryManager::EvictAll(void){};   // nothing to evict in unified memory
-void  MemoryManager::PrintAll(void){};
 void  MemoryManager::NotifyDeletion(void *ptr){};

 NAMESPACE_END(Grid);
@@ -10,16 +10,16 @@ void check_huge_pages(void *Buf,uint64_t BYTES)
 {
 #ifdef __linux__
  int fd = open("/proc/self/pagemap", O_RDONLY);
-  GRID_ASSERT(fd >= 0);
+  assert(fd >= 0);
  const int page_size = 4096;
  uint64_t virt_pfn = (uint64_t)Buf / page_size;
  off_t offset = sizeof(uint64_t) * virt_pfn;
  uint64_t npages = (BYTES + page_size-1) / page_size;
-  std::vector<uint64_t> pagedata(npages);
+  uint64_t pagedata[npages];
  uint64_t ret = lseek(fd, offset, SEEK_SET);
-  GRID_ASSERT(ret == offset);
-  ret = ::read(fd, &pagedata[0], sizeof(uint64_t)*npages);
-  GRID_ASSERT(ret == sizeof(uint64_t) * npages);
+  assert(ret == offset);
+  ret = ::read(fd, pagedata, sizeof(uint64_t)*npages);
+  assert(ret == sizeof(uint64_t) * npages);
  int nhugepages = npages / 512;
  int n4ktotal, nnothuge;
  n4ktotal = 0;
@@ -70,8 +70,8 @@ public:
  Coordinate _istride;    // Inner stride i.e. within simd lane
  int _osites;                  // _isites*_osites = product(dimensions).
  int _isites;
-  int64_t _fsites;                  // _isites*_osites = product(dimensions).
-  int64_t _gsites;
+  int _fsites;                  // _isites*_osites = product(dimensions).
+  int _gsites;
  Coordinate _slice_block;// subslice information
  Coordinate _slice_stride;
  Coordinate _slice_nblock;
@@ -82,7 +82,6 @@ public:
  bool _isCheckerBoarded; 
  int        LocallyPeriodic;
  Coordinate _checker_dim_mask;
-  int              _checker_dim;

 public:

@@ -90,7 +89,7 @@ public:
  // Checkerboarding interface is virtual and overridden by 
  // GridCartesian / GridRedBlackCartesian
  ////////////////////////////////////////////////////////////////
-  virtual int CheckerBoarded(int dim) =0;
+  virtual int CheckerBoarded(int dim)=0;
  virtual int CheckerBoard(const Coordinate &site)=0;
  virtual int CheckerBoardDestination(int source_cb,int shift,int dim)=0;
  virtual int CheckerBoardShift(int source_cb,int dim,int shift,int osite)=0;
@@ -165,7 +164,7 @@ public:
    //
    if ( _simd_layout[dimension] > 2 ) { 
      for(int d=0;d<_ndimension;d++){
-	if ( d != dimension ) GRID_ASSERT ( (_simd_layout[d]==1)  );
+	if ( d != dimension ) assert ( (_simd_layout[d]==1)  );
      }
      permute_type = RotateBit; // How to specify distance; this is not just direction.
      return permute_type;
@@ -184,10 +183,10 @@ public:
  inline int Nsimd(void)  const { return _isites; };// Synonymous with iSites
  inline int oSites(void) const { return _osites; };
  inline int lSites(void) const { return _isites*_osites; }; 
-  inline int64_t gSites(void) const { return (int64_t)_isites*(int64_t)_osites*(int64_t)_Nprocessors; }; 
+  inline int gSites(void) const { return _isites*_osites*_Nprocessors; }; 
  inline int Nd    (void) const { return _ndimension;};

-  inline const Coordinate &LocalStarts(void)            { return _lstart;    };
+  inline const Coordinate LocalStarts(void)             { return _lstart;    };
  inline const Coordinate &FullDimensions(void)         { return _fdimensions;};
  inline const Coordinate &GlobalDimensions(void)       { return _gdimensions;};
  inline const Coordinate &LocalDimensions(void)        { return _ldimensions;};
@@ -215,15 +214,15 @@ public:
  ////////////////////////////////////////////////////////////////
  // Global addressing
  ////////////////////////////////////////////////////////////////
-  void GlobalIndexToGlobalCoor(int64_t gidx,Coordinate &gcoor){
-    GRID_ASSERT(gidx< gSites());
+  void GlobalIndexToGlobalCoor(int gidx,Coordinate &gcoor){
+    assert(gidx< gSites());
    Lexicographic::CoorFromIndex(gcoor,gidx,_gdimensions);
  }
  void LocalIndexToLocalCoor(int lidx,Coordinate &lcoor){
-    GRID_ASSERT(lidx<lSites());
+    assert(lidx<lSites());
    Lexicographic::CoorFromIndex(lcoor,lidx,_ldimensions);
  }
-  void GlobalCoorToGlobalIndex(const Coordinate & gcoor,int64_t & gidx){
+  void GlobalCoorToGlobalIndex(const Coordinate & gcoor,int & gidx){
    gidx=0;
    int mult=1;
    for(int mu=0;mu<_ndimension;mu++) {
@@ -38,7 +38,7 @@ class GridCartesian: public GridBase {

 public:
  int dummy;
-  //  Coordinate _checker_dim_mask;
+  Coordinate _checker_dim_mask;
  virtual int  CheckerBoardFromOindexTable (int Oindex) {
    return 0;
  }
@@ -46,7 +46,7 @@ public:
  {
    return 0;
  }
-  virtual int CheckerBoarded(int dim) {
+  virtual int CheckerBoarded(int dim){
    return 0;
  }
  virtual int CheckerBoard(const Coordinate &site){
@@ -106,7 +106,6 @@ public:
    _rdimensions.resize(_ndimension);
    _simd_layout.resize(_ndimension);
    _checker_dim_mask.resize(_ndimension);;
-    _checker_dim = -1;
    _lstart.resize(_ndimension);
    _lend.resize(_ndimension);

@@ -128,10 +127,10 @@ public:
        // Use a reduced simd grid
        _ldimensions[d] = _gdimensions[d] / _processors[d]; //local dimensions
        //std::cout << _ldimensions[d] << "  " << _gdimensions[d] << "  " << _processors[d] << std::endl;
-        GRID_ASSERT(_ldimensions[d] * _processors[d] == _gdimensions[d]);
+        assert(_ldimensions[d] * _processors[d] == _gdimensions[d]);

        _rdimensions[d] = _ldimensions[d] / _simd_layout[d]; //overdecomposition
-        GRID_ASSERT(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
+        assert(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);

        _lstart[d] = _processor_coor[d] * _ldimensions[d];
        _lend[d] = _processor_coor[d] * _ldimensions[d] + _ldimensions[d] - 1;
@@ -57,17 +57,16 @@ class GridRedBlackCartesian : public GridBase
 {
 public:
  //  Coordinate _checker_dim_mask;
-  //  int              _checker_dim;
+  int              _checker_dim;
  std::vector<int> _checker_board;

-  virtual int isCheckerBoarded(void) const { return 1; };
  virtual int CheckerBoarded(int dim){
    if( dim==_checker_dim) return 1;
    else return 0;
  }
  virtual int CheckerBoard(const Coordinate &site){
    int linear=0;
-    GRID_ASSERT(site.size()==_ndimension);
+    assert(site.size()==_ndimension);
    for(int d=0;d<_ndimension;d++){ 
      if(_checker_dim_mask[d])
 	linear=linear+site[d];
@@ -148,7 +147,7 @@ public:
  {
    Init(base->_fdimensions,base->_simd_layout,base->_processors,checker_dim_mask,checker_dim)  ;
  }
-  
+
  virtual ~GridRedBlackCartesian() = default;

  void Init(const Coordinate &dimensions,
@@ -160,11 +159,11 @@ public:

      _isCheckerBoarded = true;
    _checker_dim = checker_dim;
-    GRID_ASSERT(checker_dim_mask[checker_dim] == 1);
+    assert(checker_dim_mask[checker_dim] == 1);
    _ndimension = dimensions.size();
-    GRID_ASSERT(checker_dim_mask.size() == _ndimension);
-    GRID_ASSERT(processor_grid.size() == _ndimension);
-    GRID_ASSERT(simd_layout.size() == _ndimension);
+    assert(checker_dim_mask.size() == _ndimension);
+    assert(processor_grid.size() == _ndimension);
+    assert(simd_layout.size() == _ndimension);

    _fdimensions.resize(_ndimension);
    _gdimensions.resize(_ndimension);
@@ -190,20 +189,20 @@ public:

        if (d == _checker_dim)
 	  {
-	    GRID_ASSERT((_gdimensions[d] & 0x1) == 0);
+	    assert((_gdimensions[d] & 0x1) == 0);
 	    _gdimensions[d] = _gdimensions[d] / 2; // Remove a checkerboard
 	    _gsites /= 2;
 	  }
        _ldimensions[d] = _gdimensions[d] / _processors[d];
-        GRID_ASSERT(_ldimensions[d] * _processors[d] == _gdimensions[d]);
+        assert(_ldimensions[d] * _processors[d] == _gdimensions[d]);
        _lstart[d] = _processor_coor[d] * _ldimensions[d];
        _lend[d] = _processor_coor[d] * _ldimensions[d] + _ldimensions[d] - 1;

        // Use a reduced simd grid
        _simd_layout[d] = simd_layout[d];
        _rdimensions[d] = _ldimensions[d] / _simd_layout[d]; // this is not checking if this is integer
-        GRID_ASSERT(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
-        GRID_ASSERT(_rdimensions[d] > 0);
+        assert(_rdimensions[d] * _simd_layout[d] == _ldimensions[d]);
+        assert(_rdimensions[d] > 0);

        // all elements of a simd vector must have same checkerboard.
        // If Ls vectorised, this must still be the case; e.g. dwf rb5d
--- a/Show More
+++ b/Show More
				`@@ -1,2 +0,0 @@`

				`mpicxx -qmkl=parallel -fsycl BatchBlasBench.cc -o BatchBlasBench -DGRID_SYCL`