Layout changes and typo fixes

.github/ISSUE_TEMPLATE/bug-report.yml

@@ -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

.gitignore

@@ -1,122 +1,8 @@
-# Doxygen stuff
-html/*
-latex/*
+# Exclude directories
+_site
+.sass-cache
+.jekyll-metadata
+pdf
 
-# Compiled Object files #
-#########################
-*.slo
-*.lo
-*.o
-*.obj
-
-# Editor files #
-################
+# Exclude backup files
 *~
-*#
-*.sublime-*
-
-# Precompiled Headers #
-#######################
-*.gch
-*.pch
-
-# Compiled Dynamic libraries #
-##############################
-*.so
-*.dylib
-*.dll
-
-# Fortran module files #
-########################
-*.mod
-
-# Compiled Static libraries #
-#############################
-*.lai
-*.la
-*.a
-*.lib
-
-# Executables #
-###############
-*.exe
-*.out
-*.app
-
-# http://www.gnu.org/software/automake #
-########################################
-Makefile.in
-Makefile
-Config.h
-Config.h.in
-config.log
-config.status
-.deps
-Make.inc
-eigen.inc
-Eigen.inc
-
-# http://www.gnu.org/software/autoconf #
-########################################
-autom4te.cache
-aclocal.m4
-compile
-configure
-depcomp
-install-sh
-missing
-stamp-h1
-config.sub
-config.guess
-INSTALL
-.dirstamp
-ltmain.sh
- 
-# Logs and databases #
-######################
-*.log
-*.sql
-*.sqlite
- 
-# OS generated files #
-######################
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-.dirstamp
-
-# build directory #
-###################
-build*/*
-Documentation/_build
-
-# IDE related files #
-#####################
-*.xcodeproj/*
-build.sh
-.vscode
-*.code-workspace
-
-# Eigen source #
-################
-Grid/Eigen
-Eigen/*
-
-# libtool macros #
-##################
-m4/lt*
-m4/libtool.m4
-
-# github pages #
-################
-gh-pages/
-
-# generated sources #
-#####################
-Grid/qcd/spin/gamma-gen/*.h
-Grid/qcd/spin/gamma-gen/*.cc
-Grid/util/Version.h

AUTHORS

@@ -1,4 +0,0 @@
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: Peter Boyle <peterboyle@MacBook-Pro.local>
-Author: paboyle <paboyle@ph.ed.ac.uk>

BLAS_benchmark/RocblasSolutionSweep.cc

@@ -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;
-}

BLAS_benchmark/compile-command

@@ -1,2 +0,0 @@
-
-mpicxx -qmkl=parallel -fsycl BatchBlasBench.cc -o BatchBlasBench -DGRID_SYCL

BLAS_benchmark/compile-command-frontier

@@ -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

BLAS_benchmark/compile-command-sunspot

@@ -1,2 +0,0 @@
-
-mpicxx -qmkl=parallel -fsycl BatchBlasBench.cc -o BatchBlasBench -DGRID_SYCL

CHANGELOG.md

@@ -0,0 +1,571 @@
+## [3.4.8](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.8)
+
+### Enhancements
+
+- Improve type readability for larger viewports by bumping up base `font-size`. [#533](https://github.com/mmistakes/minimal-mistakes/issues/533)
+- Update Portuguese localized UI text. [#541](https://github.com/mmistakes/minimal-mistakes/pull/541)
+- Add `page.title` and via parameter to Twitter share link. [#538](https://github.com/mmistakes/minimal-mistakes/pull/538)
+
+### Bug Fixes
+
+- Fix Last.fm author profile URL. [#540](https://github.com/mmistakes/minimal-mistakes/pull/540)
+
+### Maintenance
+
+- Move Brazilian Portuguese localized text under `pt-BR` key.
+
+## [3.4.7](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.7)
+
+### Enhancements
+
+- Add `layout` based and user-defined class names to `<body>` element for added CSS hooks. [#526](https://github.com/mmistakes/minimal-mistakes/pull/526)
+- Add simplified Chinese localized UI text. [#532](https://github.com/mmistakes/minimal-mistakes/pull/532)
+
+### Bug Fixes
+
+- Remove duplicate include of `base_path` in category-list.html [#522](https://github.com/mmistakes/minimal-mistakes/pull/522)
+
+## [3.4.6](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.6)
+
+### Enhancements
+
+- Add Italian "comments" related localized UI text. [#514](https://github.com/mmistakes/minimal-mistakes/pull/514)
+
+### Bug Fixes
+
+- Disable `compress` HTML layout by default. To enable add `layout: compress` to `_layouts/default.html`.
+
+## [3.4.5](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.5)
+
+### Enhancements
+
+- Improve line numbered code block styling when using `{% highlight linenos %}` tag. [#513](https://github.com/mmistakes/minimal-mistakes/issues/513)
+- Add English fallback to "Follow" button label. [#496](https://github.com/mmistakes/minimal-mistakes/pull/496)
+
+### Bug Fixes
+
+- Fix Firefox alignment issues with code blocks generated with the `{% highlight %}` tag. [#512](https://github.com/mmistakes/minimal-mistakes/issues/512)
+
+### Maintenance
+
+- Clarified comment for `author.stackoverflow` value used in author sidebar links. [#487](https://github.com/mmistakes/minimal-mistakes/pull/487)
+- Add list of localized text strings. [#488](https://github.com/mmistakes/minimal-mistakes/pull/488)
+- Add `{% highlight %}` code block examples to demo site.
+- Add documentation for using custom sidebar navigation menus. [#476](https://github.com/mmistakes/minimal-mistakes/issues/476)
+
+## [3.4.4](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.4)
+
+### Enhancements
+
+- Add French "comments" related localized UI text. [#472](https://github.com/mmistakes/minimal-mistakes/pull/472)
+
+### Bug Fixes
+
+- Exclude `vendor` in Jekyll config file.
+- Fix Liquid syntax error for offending parenthesis. [#479](https://github.com/mmistakes/minimal-mistakes/issues/479)
+
+### Maintenance
+
+- Update gems: `colorator` (1.1.0), `forwardable-extended` (2.6.0), `github-pages` (93), `jekyll` (= 3.2.1), `minima` (= 1.0.1).
+
+## [3.4.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.3)
+
+### Enhancements
+
+- Make ["honeypot" `input`](https://github.com/mmistakes/minimal-mistakes/commit/06a8249a69a37dddda7e2a5bfbe32056c1a9a607) in Staticman comment form less obvious to spam bots
+- Add padding to `.highlight` code blocks to better [align `overflow` scrollbar](https://github.com/mmistakes/minimal-mistakes/commit/e4abec0a6f7f8cff72505ca0754615df294fd5b3) to the bottom.
+- Add additional image options for Twitter card social sharing meta tags. [#466](https://github.com/mmistakes/minimal-mistakes/pull/466)
+- Add structured data markup for Staticman comments. [#458](https://github.com/mmistakes/minimal-mistakes/issues/458)
+
+### Bug Fixes
+
+- Format `og:locale` tag with `_` instead of `-`. [#462](https://github.com/mmistakes/minimal-mistakes/issues/462)
+
+### Maintenance
+
+- Add note to docs about using `url: http://localhost:4000` when working locally.
+
+## [3.4.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.2)
+
+### Enhancements
+
+- Improve UX of static comment forms. [#448](https://github.com/mmistakes/minimal-mistakes/issues/448)
+
+## [3.4.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.1)
+
+### Enhancements
+
+- Add `staticman.filename` configuration with UNIX timestamp for sorting data files. example ~> `comment-1470943149`.
+
+### Bug Fixes
+
+- Don't add `<a>` to author name if URL is blank.
+
+## [3.4.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.4.0)
+
+### Enhancements
+
+- Support static-based commenting via [Staticman](https://staticman.net/) for sites hosted with GitHub Pages. [#424](https://github.com/mmistakes/minimal-mistakes/issues/424)
+
+## [3.3.7](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.7)
+
+### Bug Fixes
+
+- Re-enabled Jekyll plugins in `_config.yml` in case they aren't autoloaded in `Gemfile`. [#417](https://github.com/mmistakes/minimal-mistakes/issues/417)
+
+### Enhancements
+
+- Fallback to `site.github.url` for use in `{{ base_path }}` when `site.url` is `nil`.
+- Replace Sass and Autoprefixer `npm` build scripts with [Jekyll's built-in asset support](https://jekyllrb.com/docs/assets/). [#333](https://github.com/mmistakes/minimal-mistakes/issues/333)
+
+### Maintenance
+
+- Document `site.repository` and its role with [`github-metadata`](https://github.com/jekyll/github-metadata) gem.
+- Add sample [archive page with content](https://mmistakes.github.io/minimal-mistakes/archive-layout-with-content/) for testing styles on demo site.
+
+## [3.3.6](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.6)
+
+### Bug Fixes
+
+- Fix blank `site.teaser` bug. [#412](https://github.com/mmistakes/minimal-mistakes/issues/412)
+
+## [3.3.5](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.5)
+
+### Enhancements
+
+- Add English default text `site.locale` strings. [#407](https://github.com/mmistakes/minimal-mistakes/issues/407)
+- Add Portuguese localized UI text. [#411](https://github.com/mmistakes/minimal-mistakes/pull/411)
+- Add Italian localized UI text. [#409](https://github.com/mmistakes/minimal-mistakes/pull/409)
+
+### Maintenance
+
+- Remove unused Google AdSense variables in `_config.yml`. [#404](https://github.com/mmistakes/minimal-mistakes/issues/404)
+- Update `Gemfile` instructions for using `github-pages` vs. native `jekyll` gems.
+- Disable `gems:` in `_config.yml` and enable plugins with Bundler instead.
+- Add `repository` to `_config.yml` to suppress GitHub Pages error `Liquid Exception: No repo name found.`
+
+## [3.3.4](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.4)
+
+### Enhancements
+
+- Add support for configurable feed URL to use a service like FeedBurner instead of linking directly to `feed.xml` in `<head>` and the site footer. [#378](https://github.com/mmistakes/minimal-mistakes/issues/378), [#379](https://github.com/mmistakes/minimal-mistakes/pull/379), [#406](https://github.com/mmistakes/minimal-mistakes/pull/406)
+- Add Turkish localized UI text. [#403](https://github.com/mmistakes/minimal-mistakes/pull/403)
+
+### Maintenance
+
+- Update gems: `activesupport` (4.2.7), `ffi` (1.9.14), `github-pages` (88), `jekyll-redirect-from` (0.11.0), `jekyll-watch` (1.5.0).
+
+## [3.3.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.3)
+
+### Enhancements
+
+- Make footer stick to the bottom of the page.
+
+### Bug Fixes
+
+- Fix `gallery` size bug [#402](https://github.com/mmistakes/minimal-mistakes/issues/402)
+
+### Maintenance
+
+- Set default `lang` to `en`.
+
+## [3.3.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.2)
+
+### Bug Fixes
+
+- Fix JavaScript that triggers "sticky" sidebar to avoid layout issues on screen sizes < `1024px`. [#396](https://github.com/mmistakes/minimal-mistakes/issues/396)
+
+## [3.3.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.3.1)
+
+### Enhancements
+
+- Enable image popup on < 500px wide screens. [#385](https://github.com/mmistakes/minimal-mistakes/issues/385)
+- Indicate the relationship between component URLs in a paginated series by applying `rel="prev"` and `rel="next"` to pages that use `site.paginator`. [#253](https://github.com/mmistakes/minimal-mistakes/issues/253)
+- Improve link posts in archive listings. [#276](https://github.com/mmistakes/minimal-mistakes/issues/276)
+
+### Maintenance
+
+- Update gems: `github-pages` (86), `ffi` 1.9.13, `jekyll-mentions` 1.1.3, and `rouge` 1.11.1
+- Fix note about custom sidebar content appearing below author profile. [#388](https://github.com/mmistakes/minimal-mistakes/issues/388)
+
+## [3.2.13](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.13)
+
+### Enhancements
+
+- Add English default UI text for Canada, Great Britain, and Australia. [#377](https://github.com/mmistakes/minimal-mistakes/issues/377)
+- Switch default locale from `en-US` to `en`.
+
+## [3.2.12](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.12)
+
+### Enhancements
+
+- Remove window width "magic number" from sticky sidebar check in `main.js` for improved flexibility. [#375](https://github.com/mmistakes/minimal-mistakes/pull/375)
+
+### Bug Fixes
+
+- Fix author override conditional where a missing `authors.yml` would show broken sidebar content. Defaults to `site.author`. [#376](https://github.com/mmistakes/minimal-mistakes/pull/376)
+
+## [3.2.11](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.11)
+
+### Bug Fixes
+
+- Fix disappearing author sidebar links [#372](https://github.com/mmistakes/minimal-mistakes/issues/372)
+
+### Maintenance
+
+- Update gems: `github-pages` (84), `jekyll-github-metadata` 2.0.2, and `kramdown` 1.11.1
+- Update vendor JavaScript: jQuery 1.12.4, Stickyfill.js 1.1.4
+- Update Font Awesome 4.6.3
+
+## [3.2.10](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.10)
+
+### Maintenance
+
+- Add `CONTRIBUTING.md`
+
+## [3.2.9](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.9)
+
+### Enhancements
+
+- Add support for [header overlay images](https://mmistakes.github.io/minimal-mistakes/docs/layouts/#header-overlay) for Open Graph images. [#358](https://github.com/mmistakes/minimal-mistakes/pull/358)
+
+### Bug Fixes
+
+- Fix `Person` typo Schema.org type [#358](https://github.com/mmistakes/minimal-mistakes/pull/358)
+
+### Maintenance
+
+- Update `github-pages` gem and dependencies.
+- Remove `minutes_read` to avoid awkward reading time wording [#356](https://github.com/mmistakes/minimal-mistakes/issues/356)
+
+## [3.2.8](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.8)
+
+### Bug Fixes
+
+- Remove `cursor: pointer` that appears on white-space surrounding author side list items and links. [#354](https://github.com/mmistakes/minimal-mistakes/pull/354)
+
+### Maintenance
+
+- Add contributing information to `README.md`. [#357](https://github.com/mmistakes/minimal-mistakes/issues/357)
+
+## [3.2.7](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.7)
+
+### Enhancements
+
+- Add French localized UI text. [#346](https://github.com/mmistakes/minimal-mistakes/pull/346)
+
+### Bug Fixes
+
+- Fix branch logic for Yandex and Alexa in `seo.html`. [#348](https://github.com/mmistakes/minimal-mistakes/pull/348)
+
+## [3.2.6](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.6)
+
+### Bug Fixes
+
+- Fix error `Liquid Exception: divided by 0 in _includes/archive-single.html, included in _layouts/single.html` caused by null `words_per_minute` in `_config.yml`. [#345](https://github.com/mmistakes/minimal-mistakes/pull/345)
+
+## [3.2.5](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.5)
+
+### Bug Fixes
+
+- Fix link color in hero overlay to be white.
+- Remove underlines from archive item titles.
+
+## [3.2.4](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.4)
+
+### Enhancements
+
+- Improve text alignment of masthead, hero overlay, page footer to be flush left and remove awkward white-space gaps. [#342](https://github.com/mmistakes/minimal-mistakes/issues/342)
+- Add Spanish localized UI text. [#338](https://github.com/mmistakes/minimal-mistakes/pull/338)
+
+### Bug Fixes
+
+- Fix alignment of icons in author sidebar [#341](https://github.com/mmistakes/minimal-mistakes/issues/341)
+
+### Maintenance
+
+- Add background color to page footer to set it apart from main content. [#342](https://github.com/mmistakes/minimal-mistakes/issues/342)
+- Add terms and privacy policy to theme's demo site. [#343](https://github.com/mmistakes/minimal-mistakes/issues/343)
+- Update screenshots found in theme documentation.
+
+## [3.2.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.3)
+
+### Enhancements
+
+- Add [Discourse](https://www.discourse.org/) as a commenting provider. [#335](https://github.com/mmistakes/minimal-mistakes/pull/335)
+
+## [3.2.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.2)
+
+### Enhancements
+
+- Add support for image captions in Magnific Popup overlays via the [`gallery`](https://mmistakes.github.io/minimal-mistakes/docs/helpers/#gallery) helper. [#334](https://github.com/mmistakes/minimal-mistakes/issues/334)
+
+## [3.2.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.1)
+
+### Bug Fixes
+
+- Remove need for "double tapping" masthead menu links on iOS devices. [#315](https://github.com/mmistakes/minimal-mistakes/issues/315)
+
+### Maintenance
+
+- Add `ISSUE_TEMPLATE.md` for improve issue submission process.
+
+## [3.2.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.2.0)
+
+### Bug Fixes
+
+- Fix missing category/tag links in post footer due to possible conflict with `site.tags` and `site.categories`. [#329](https://github.com/mmistakes/minimal-mistakes/issues/329#issuecomment-222375568)
+
+## [3.1.8](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.8)
+
+### Bug Fixes
+
+- Fix `Liquid Exception: undefined method 'gsub' for nil:NilClass in _layouts/single.html` error when `page.title` is null. `<h1>` element is now conditional if `title: ` is not set for a `page` or collection item. [#312](https://github.com/mmistakes/minimal-mistakes/issues/312)
+
+### Maintenance
+
+- Remove duplicate `fa-twitter` and `fa-twitter-square` classes from `_utilities.scss`. [#302](https://github.com/mmistakes/minimal-mistakes/issues/302)
+
+- Document installing additional Jekyll gem dependencies when using `gem "jekyll"` instead of `gem "github-pages"` to avoid any errors on run. [#305](https://github.com/mmistakes/minimal-mistakes/issues/305)
+
+## [3.1.7](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.7)
+
+### Enhancements
+
+- Add translation key for "Recent Posts" used in home page `index.html`. [#316](https://github.com/mmistakes/minimal-mistakes/pull/316)
+
+### Maintenance
+
+- Small fix to avoid underlying the whitespace between icons and related text when hovering. [#303](https://github.com/mmistakes/minimal-mistakes/pull/303)
+
+## [3.1.6](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.6)
+
+### Maintenance
+
+- Update gem dependencies. Run `bundle` to update `Gemfile.lock`.
+
+## [3.1.5](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.5)
+
+### Maintenance
+
+- Fix `www` and `https` links in author profile include [#293](https://github.com/mmistakes/minimal-mistakes/pull/293)
+
+## [3.1.4](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.4)
+
+### Enhancements
+
+- Add overlay_filter param to hero headers [#298](https://github.com/mmistakes/minimal-mistakes/pull/298)
+
+## [3.1.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.3)
+
+### Enhancements
+
+- Improve `site.locale` documentation [#284](https://github.com/mmistakes/minimal-mistakes/issues/284)
+- Remove ProTip note about protocol-less `site.url` as it is an anti-pattern [#288](https://github.com/mmistakes/minimal-mistakes/issues/288)
+
+### Bug Fixes
+
+- Fix `og_image` URL in seo.html [#277](https://github.com/mmistakes/minimal-mistakes/issues/277)
+- Fix `author_profile` toggle when assigned in a `_layout` [#285](https://github.com/mmistakes/minimal-mistakes/issues/285)
+- Fix typo in `build:all` npm script [#283](https://github.com/mmistakes/minimal-mistakes/pull/283)
+- Fix URL typo documentation [#287](https://github.com/mmistakes/minimal-mistakes/issues/287)
+- SEO author bug. If `twitter.username` is set and `author.twitter` is `nil` bad things happen. [#289](https://github.com/mmistakes/minimal-mistakes/issues/289)
+
+## [3.1.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.2)
+
+### Enhancements
+
+- Explain how to use `nav_list` helper in [documentation](https://mmistakes.github.io/minimal-mistakes/docs/helpers/#navigation-list).
+- Reduce left/right padding on smaller screens to increase width of main content column.
+
+### Bug Fixes
+
+- Fix alignment issues with related posts [#273](https://github.com/mmistakes/minimal-mistakes/issues/273) and "Follow" button in author profile [#274](https://github.com/mmistakes/minimal-mistakes/issues/274).
+
+## [3.1.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.1)
+
+### Bug Fix
+
+- Fixed reading time bug when `words_per_minute` wasn't set in `_config.yml` [#271](https://github.com/mmistakes/minimal-mistakes/issues/271)
+
+## [3.1.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.1.0)
+
+### Enhancements
+
+- Updated [Font Awesome](https://fortawesome.github.io/Font-Awesome/whats-new/) to version 4.6.1
+- Added optional GitHub and Bitbucket links to footer if set on `site.author` in `_config.yml`.
+
+### Bug Fixes
+- Fixed Bitbucket URL typo in author sidebar.
+
+## [3.0.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/3.0.3)
+
+### Enhancements
+
+- Rebuilt the entire theme: layouts, includes, stylesheets, scripts, you name it.
+- Refreshed the look and feel while staying true to the original design of the theme (author sidebar/main content).
+- Replaced grid system with [Susy](http://susy.oddbird.net/).
+- Replaced Grunt tasks with `npm` scripts.
+- Removed Google Fonts and replaced with system fonts to improve performance (they can be [added back](https://mmistakes.github.io/minimal-mistakes/docs/stylesheets/) if desired)
+- Greatly improved [theme documentation](https://mmistakes.github.io/minimal-mistakes/docs/quick-start-guide/).
+- Increased the amount of sample posts, sample pages, and sample collections to throughly test the theme and edge-cases.
+- Moved all sample content and assets out of `master` to keep it as clean as possible for forking.
+- Added new layouts for `splash` pages, archives for [`jekyll-archives`](https://github.com/jekyll/jekyll-archives) if enabled, and [`compress.html`](https://github.com/penibelst/jekyll-compress-html) to improve performance.
+- Added taxonomy links to posts (tags and categories).
+- Added optional "reading time" meta data.
+- Improved Liquid used for Twitter Cards and Open Graph data in `<head>`.
+- Improved `gallery` include helper and added `feature_row` for use with splash page layout.
+- Added Keybase.io, author web URI, and Bitbucket optional links to sidebar.
+- Add `feed.xml` link to footer.
+- Added a [UI text data file](https://mmistakes.github.io/minimal-mistakes/docs/ui-text/) to easily change all text found in the theme.
+- Added LinkedIn to optional social share buttons.
+- Added Facebook, Google+, and custom commenting options in addition to Disqus.
+- Added optional breadcrumb links.
+
+## [2.2.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.2.1)
+
+## [2.2.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.2.0)
+
+### Enhancements
+
+- Add support for Jekyll 3.0
+- Minor updates to syntax highlighting CSS and theme documentation
+
+## [2.1.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.1.3)
+
+### Enhancements
+
+- Cleaner print styles that remove the top navigation, social sharing buttons, and other elements not needed when printed.
+
+## [2.1.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.1.2)
+
+### Enhancements
+
+- Add optional CodePen icon/url to author side bar [#156](https://github.com/mmistakes/minimal-mistakes/pull/156)
+- Documented Stackoverflow username explanation in `_config.yml` [#157](https://github.com/mmistakes/minimal-mistakes/pull/157)
+- Simplified Liquid in `post-index.html` to better handle year listings [#166](https://github.com/mmistakes/minimal-mistakes/pull/166)
+
+### Bug Fixes
+
+- Cleanup Facebook related Open Graph meta tags [#149](https://github.com/mmistakes/minimal-mistakes/issues/149)
+- Corrected minor typos [#158](https://github.com/mmistakes/minimal-mistakes/pull/158) [#175](https://github.com/mmistakes/minimal-mistakes/issues/175)
+
+## [2.1.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.1.1)
+
+### Enhancements
+
+- Add optional XING profile link to author sidebar
+- Include open graph meta tags for feature image (if assigned) [#149](https://github.com/mmistakes/minimal-mistakes/issues/149)
+- Create an include for feed footer
+
+### Bug Fixes
+
+- Remove http protocol from Google search form on sample 404 page
+- Only show related posts if there are one or more available
+- Fix alignment of email address link in author sidebar
+
+## [2.1.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/2.1.0)
+
+### Enhancements
+
+- Add optional social sharing buttons ([#42](https://github.com/mmistakes/minimal-mistakes/issues/42))
+
+![social sharing buttons](https://cloud.githubusercontent.com/assets/1376749/5860522/d9f28a96-a22f-11e4-9b83-940a3a9a766a.png)
+
+- Add Soundcloud, YouTube ([#95](https://github.com/mmistakes/minimal-mistakes/pull/95)), Flickr ([#119](https://github.com/mmistakes/minimal-mistakes/pull/119)), and Weibo ([#116](https://github.com/mmistakes/minimal-mistakes/pull/116)) icons for use in author sidebar.
+- Fix typos in posts and documentation and remove references to Less
+- Include note about Octopress gem being optional
+- Post author override support extended to the Atom feed ([#71](https://github.com/mmistakes/minimal-mistakes/pull/71))
+- Only include email address in feed if specified in `_config.yml` or author `_data`
+- Wrap all page content in `#main` to harmonize article and post index styles ([#86](https://github.com/mmistakes/minimal-mistakes/issues/86))
+- Include new sample feature images for posts and pages
+- Table of contents improvements: fix collapse toggle, indent nested elements, show on small screens, and create an `_include` for reusing in posts and pages.
+- Include note about running Jekyll with `bundle exec` when using Bundler
+- Fix home page path in top navigation
+- Remove Google Authorship ([#120](https://github.com/mmistakes/minimal-mistakes/issues/120))
+- Remove duplicate author content that displayed in `div.article-author-bottom`
+- Removed unused `_sass/print.scss` styles
+- Improve comments in `.scss` files
+
+## [2.0.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/v2.0)
+
+## [1.3.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.3.3)
+
+### Enhancements
+
+- Added new icons and profile links for Stackoverflow, Dribbble, Pinterest, Foursquare, and Steam to the author bio sidebar.
+- Cleaned up the Kramdown auto table of contents styling to be more readable
+- Removed page width specific .less stylesheets and created mixins for easier updating
+- Removed Modernizr since it wasn't being used
+- Added pages to sitemap.xml
+- Added category: to rake new_post task
+- Minor typographic changes
+
+### Bug Fixes
+
+- Corrected various broken links in README and Theme Setup.
+
+## [1.3.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.3.1)
+
+### Enhancements
+
+- Cleaned up table of contents styling
+- Reworked top navigation to be a better experience on small screens. Nav items now display vertically when the menu button is tapped, revealing links with larger touch targets.
+
+![menu animation](https://camo.githubusercontent.com/3fbd8c1326485f4b1ab32c0005c0fca7660b5d31/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313337363734392f323136343037352f31653366303663322d393465372d313165332d383961612d6436623636376562306564662e676966)
+
+## [1.2.0](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.2.0)
+
+### Bug Fixes
+
+- Table weren't filling the entire width of the content container. They now scale at 100%. Thanks [@dhruvbhatia](https://github.com/dhruvbhatia)
+
+### Enhancements
+
+- Decreased spacing between Markdown footnotes
+- Removed dark background on footer
+- Removed UPPERCASE styling on post titles in the index listing
+
+## [1.1.4](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.1.4)
+
+### Bug Fixes
+
+- Fix top navigation bug issue ([#10](https://github.com/mmistakes/minimal-mistakes/issues/10)) for real this time. Remember to clear your floats kids.
+
+## [1.1.3](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.1.3)
+
+### Bug Fixes
+
+- Fix top navigation links that weren't click able on small viewports (Issue [#10](https://github.com/mmistakes/minimal-mistakes/issues/10)).
+- Remove line wrap from top navigation links that may span multiple lines.
+
+## [1.1.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.1.2)
+
+### Enhancements
+
+- Added Grunt build script for compiling Less/JavaScript and optimizing image assets.
+- Added support for large image summary Twitter card.
+- Stylesheet adjustments
+
+## [1.1.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/1.1.1)
+
+### Bug Fixes
+
+- Removed [Typeplate](http://typeplate.com/) styles. Was [causing issues with newer versions of Less](https://github.com/typeplate/typeplate.github.io/issues/108) and is no longer maintained.
+
+### Enhancements
+
+- Added [image attribution](http://mmistakes.github.io/minimal-mistakes/theme-setup/#feature-images) for post and page feature images.
+- Added [404 page](http://mmistakes.github.io/minimal-mistakes/404.html).
+- Cleaned up various Less variables to better align with naming conventions used in other MM Jekyll themes.
+- Removed Chrome Frame references.
+- Added global CSS3 transitions to text and block elements.
+- Improved typography in a few places.
+
+## [1.0.2](https://github.com/mmistakes/minimal-mistakes/releases/tag/v1.0.2)
+
+### Enhancements
+
+- Google Analytics, Google Authorship, webmaster verifies, and Twitter card meta are now optional.
+
+## [1.0.1](https://github.com/mmistakes/minimal-mistakes/releases/tag/v1.0.1)

CLAUDE.md

@@ -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: `GeneralCoarsenedMatrixMultiRHS.h` (`MultiGeneralCoarsenedOperator`, the coarse operator for any number of right-hand sides: 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 superseded coarse operators and the Aggregation-based single-RHS ADEF-2, with class names prefixed `Deprecated` (`DeprecatedGeneralCoarsenedMatrix`, `DeprecatedMultiGeneralCoarsenedMatrix`, `DeprecatedTwoLevelADEF2`); nothing in the library uses them, only older drivers in `examples/` and `tests/debug/`. `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 (`MultiGeneralCoarsenedOperator::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`).

ChangeLog

@@ -1,5 +0,0 @@
-Version : 0.8.0
-
-- Clang 3.5 and above, ICPC v16 and above, GCC 6.3 and above recommended
-- MPI and MPI3 comms optimisations for KNL and OPA finished
-- Half precision comms

Gemfile

@@ -0,0 +1,27 @@
+source "https://rubygems.org"
+
+# Hello! This is where you manage which Jekyll version is used to run.
+# When you want to use a different version, change it below, save the
+# file and run `bundle install`. Run Jekyll with `bundle exec`, like so:
+#
+#     bundle exec jekyll serve
+#
+# This will help ensure the proper Jekyll version is running.
+# Happy Jekylling!
+
+gem "github-pages", group: :jekyll_plugins
+
+# If you want to use Jekyll native, uncomment the line below.
+# To upgrade, run `bundle update`.
+
+# gem "jekyll"
+
+gem "wdm", "~> 0.1.0" if Gem.win_platform?
+
+# If you have any plugins, put them here!
+group :jekyll_plugins do
+  # gem "jekyll-archives"
+
+gem 'jekyll-octicons'
+
+end

Gemfile.lock

@@ -0,0 +1,155 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.7)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.4.0)
+    coffee-script (2.4.1)
+      coffee-script-source
+      execjs
+    coffee-script-source (1.10.0)
+    colorator (1.1.0)
+    ethon (0.9.1)
+      ffi (>= 1.3.0)
+    execjs (2.7.0)
+    faraday (0.9.2)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.9.14)
+    ffi (1.9.14-x64-mingw32)
+    forwardable-extended (2.6.0)
+    gemoji (2.1.0)
+    github-pages (104)
+      activesupport (= 4.2.7)
+      github-pages-health-check (= 1.2.0)
+      jekyll (= 3.3.0)
+      jekyll-avatar (= 0.4.2)
+      jekyll-coffeescript (= 1.0.1)
+      jekyll-feed (= 0.8.0)
+      jekyll-gist (= 1.4.0)
+      jekyll-github-metadata (= 2.2.0)
+      jekyll-mentions (= 1.2.0)
+      jekyll-paginate (= 1.1.0)
+      jekyll-redirect-from (= 0.11.0)
+      jekyll-sass-converter (= 1.3.0)
+      jekyll-seo-tag (= 2.1.0)
+      jekyll-sitemap (= 0.12.0)
+      jekyll-swiss (= 0.4.0)
+      jemoji (= 0.7.0)
+      kramdown (= 1.11.1)
+      liquid (= 3.0.6)
+      listen (= 3.0.6)
+      mercenary (~> 0.3)
+      minima (= 2.0.0)
+      rouge (= 1.11.1)
+      terminal-table (~> 1.4)
+    github-pages-health-check (1.2.0)
+      addressable (~> 2.3)
+      net-dns (~> 0.8)
+      octokit (~> 4.0)
+      public_suffix (~> 1.4)
+      typhoeus (~> 0.7)
+    html-pipeline (2.4.2)
+      activesupport (>= 2)
+      nokogiri (>= 1.4)
+    i18n (0.7.0)
+    jekyll (3.3.0)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 1.1)
+      kramdown (~> 1.3)
+      liquid (~> 3.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (~> 1.7)
+      safe_yaml (~> 1.0)
+    jekyll-avatar (0.4.2)
+      jekyll (~> 3.0)
+    jekyll-coffeescript (1.0.1)
+      coffee-script (~> 2.2)
+    jekyll-feed (0.8.0)
+      jekyll (~> 3.3)
+    jekyll-gist (1.4.0)
+      octokit (~> 4.2)
+    jekyll-github-metadata (2.2.0)
+      jekyll (~> 3.1)
+      octokit (~> 4.0, != 4.4.0)
+    jekyll-mentions (1.2.0)
+      activesupport (~> 4.0)
+      html-pipeline (~> 2.3)
+      jekyll (~> 3.0)
+    jekyll-octicons (3.0.1)
+      jekyll (~> 3.1)
+      octicons (~> 3.0)
+    jekyll-paginate (1.1.0)
+    jekyll-redirect-from (0.11.0)
+      jekyll (>= 2.0)
+    jekyll-sass-converter (1.3.0)
+      sass (~> 3.2)
+    jekyll-seo-tag (2.1.0)
+      jekyll (~> 3.3)
+    jekyll-sitemap (0.12.0)
+      jekyll (~> 3.3)
+    jekyll-swiss (0.4.0)
+    jekyll-watch (1.5.0)
+      listen (~> 3.0, < 3.1)
+    jemoji (0.7.0)
+      activesupport (~> 4.0)
+      gemoji (~> 2.0)
+      html-pipeline (~> 2.2)
+      jekyll (>= 3.0)
+    json (1.8.3)
+    kramdown (1.11.1)
+    liquid (3.0.6)
+    listen (3.0.6)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9.7)
+    mercenary (0.3.6)
+    mini_portile2 (2.1.0)
+    minima (2.0.0)
+    minitest (5.9.1)
+    multipart-post (2.0.0)
+    net-dns (0.8.0)
+    nokogiri (1.6.8.1)
+      mini_portile2 (~> 2.1.0)
+    nokogiri (1.6.8.1-x64-mingw32)
+      mini_portile2 (~> 2.1.0)
+    octicons (3.0.1)
+      nokogiri (>= 1.6.3.1)
+    octokit (4.4.1)
+      sawyer (~> 0.7.0, >= 0.5.3)
+    pathutil (0.14.0)
+      forwardable-extended (~> 2.6)
+    public_suffix (1.5.3)
+    rb-fsevent (0.9.8)
+    rb-inotify (0.9.7)
+      ffi (>= 0.5.0)
+    rouge (1.11.1)
+    safe_yaml (1.0.4)
+    sass (3.4.22)
+    sawyer (0.7.0)
+      addressable (>= 2.3.5, < 2.5)
+      faraday (~> 0.8, < 0.10)
+    terminal-table (1.7.3)
+      unicode-display_width (~> 1.1.1)
+    thread_safe (0.3.5)
+    typhoeus (0.8.0)
+      ethon (>= 0.8.0)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.1.1)
+
+PLATFORMS
+  ruby
+  x64-mingw32
+
+DEPENDENCIES
+  github-pages
+  jekyll-octicons
+
+BUNDLED WITH
+   1.13.3

Grid/DisableWarnings.h

@@ -1,75 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/DisableWarnings.h
-
-Copyright (C) 2016
-
-Author: Guido Cossu <guido.cossu@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 DISABLE_WARNINGS_H
-#define DISABLE_WARNINGS_H
-
-
-
-#if defined __GNUC__ && __GNUC__>=6
-#pragma GCC diagnostic ignored "-Wignored-attributes"
-#endif
-
- //disables and intel compiler specific warning (in json.hpp)
-#ifdef __ICC
-#pragma warning disable 488  
-#endif
-
-#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
-#endif
-
-// Disable vectorisation in Eigen on the Power8/9 and PowerPC
-#ifdef  __ALTIVEC__
-#define  EIGEN_DONT_VECTORIZE
-#endif
-#ifdef  __VSX__
-#define  EIGEN_DONT_VECTORIZE
-#endif
-
-#endif

Grid/Grid.h

@@ -1,50 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/Grid.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: azusayamaguchi <ayamaguc@YAMAKAZE.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 */
-//
-//  Grid.h
-//  simd
-//
-//  Created by Peter Boyle on 09/05/2014.
-//  Copyright (c) 2014 University of Edinburgh. All rights reserved.
-//
-
-#ifndef GRID_H
-#define GRID_H
-
-#include <Grid/GridCore.h>
-#include <Grid/GridQCDcore.h>
-#include <Grid/qcd/action/Action.h>
-#include <Grid/qcd/utils/GaugeFix.h>
-#include <Grid/qcd/utils/CovariantSmearing.h>
-#include <Grid/qcd/smearing/Smearing.h>
-#include <Grid/parallelIO/MetaData.h>
-#include <Grid/qcd/hmc/HMC_aggregate.h>
-
-#endif

Grid/GridCore.h

@@ -1,68 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/Grid.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: azusayamaguchi <ayamaguc@YAMAKAZE.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 */
-//
-//  Grid.h
-//  simd
-//
-//  Created by Peter Boyle on 09/05/2014.
-//  Copyright (c) 2014 University of Edinburgh. All rights reserved.
-//
-
-#ifndef GRID_BASE_H
-#define GRID_BASE_H
-
-
-#include <Grid/DisableWarnings.h>
-#include <Grid/Namespace.h>
-#include <Grid/GridStd.h>
-#include <Grid/threads/Pragmas.h>
-#include <Grid/perfmon/Timer.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/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)
-
-#endif

Grid/GridQCDcore.h

@@ -1,44 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/Grid.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: azusayamaguchi <ayamaguc@YAMAKAZE.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 */
-#ifndef GRID_QCD_CORE_H
-#define GRID_QCD_CORE_H
-
-/////////////////////////
-// Core Grid QCD headers
-/////////////////////////
-#include <Grid/GridCore.h>
-#include <Grid/qcd/QCD.h>
-#include <Grid/qcd/spin/Spin.h>
-#include <Grid/qcd/gparity/Gparity.h>
-#include <Grid/qcd/utils/Utils.h>
-#include <Grid/qcd/representations/Representations.h>
-NAMESPACE_CHECK(GridQCDCore);
-
-#endif

Grid/GridStd.h

@@ -1,70 +0,0 @@
-#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>
-#include <vector>
-#include <array>
-#include <string>
-#include <iostream>
-#include <iomanip>
-#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
-
-
-#ifdef TOFU
-#undef GRID_COMMS_THREADS
-#endif
-#endif /* GRID_STD_H */

Grid/Grid_Eigen_Dense.h

@@ -1,75 +0,0 @@
-#include <Grid/GridCore.h>
-#pragma once
-// Force Eigen to use MKL if Grid has been configured with --enable-mkl
-#ifdef USE_MKL
-#define EIGEN_USE_MKL_ALL
-#endif
-
-
-#if defined __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-#endif
-
-/* 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__")
-#undef __CUDA_ARCH__
-#undef __NVCC__
-#undef __CUDACC__
-#define __NVCC__REDEFINE__
-#endif 
-
-/* SYCL save and restore compile environment*/
-#ifdef GRID_SYCL
-#pragma push
-#pragma push_macro("__SYCL_DEVICE_ONLY__")
-#undef __SYCL_DEVICE_ONLY__
-#define EIGEN_DONT_VECTORIZE
-#undef EIGEN_USE_SYCL
-#define __SYCL__REDEFINE__
-#endif
-
-/* HIP save and restore compile environment*/
-#ifdef GRID_HIP
-#pragma push
-#pragma push_macro("__HIP_DEVICE_COMPILE__")
-#endif
-#define EIGEN_NO_HIP
-
-#include <Grid/Eigen/Dense>
-#include <Grid/Eigen/unsupported/CXX11/Tensor>
-
-/* NVCC restore */
-#ifdef __NVCC__REDEFINE__
-#pragma pop_macro("__CUDACC__")
-#pragma pop_macro("__NVCC__")
-#pragma pop_macro("__CUDA_ARCH__")
-#pragma pop
-#endif
-
-/*SYCL restore*/
-#ifdef __SYCL__REDEFINE__
-#pragma pop_macro("__SYCL_DEVICE_ONLY__")
-#pragma pop
-#endif
-
-/*HIP restore*/
-#ifdef __HIP__REDEFINE__
-#pragma pop_macro("__HIP_DEVICE_COMPILE__")
-#pragma pop
-#endif
-
-#if defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-

Grid/Grid_Eigen_Tensor.h

@@ -1 +0,0 @@
-#include <Grid/Grid_Eigen_Dense.h>

Grid/Makefile.am

@@ -1,85 +0,0 @@
-extra_sources=
-extra_headers=
-
-if BUILD_COMMS_MPI3
-  extra_sources+=communicator/Communicator_mpi3.cc
-  extra_sources+=communicator/Communicator_base.cc
-  extra_sources+=communicator/SharedMemoryMPI.cc
-  extra_sources+=communicator/SharedMemory.cc
-endif
-
-if BUILD_COMMS_NONE
-  extra_sources+=communicator/Communicator_none.cc
-  extra_sources+=communicator/Communicator_base.cc
-  extra_sources+=communicator/SharedMemoryNone.cc
-  extra_sources+=communicator/SharedMemory.cc
-endif
-
-if BUILD_HDF5
-  extra_sources+=serialisation/Hdf5IO.cc 
-  extra_headers+=serialisation/Hdf5IO.h
-  extra_headers+=serialisation/Hdf5Type.h
-endif
-
-
-all: version-cache Version.h
-
-version-cache:
-	@if [ `git status --porcelain | grep -v '??' | wc -l` -gt 0 ]; then\
-		a="uncommited changes";\
-	else\
-		a="clean";\
-	fi;\
-	echo "`git log -n 1 --format=format:"#define GITHASH \\"%H:%d $$a\\"%n" HEAD`" > vertmp;\
-	if [ -e version-cache ]; then\
-		d=`diff vertmp version-cache`;\
-		if [ "$${d}" != "" ]; then\
-			mv vertmp version-cache;\
-			rm -f Version.h;\
-		fi;\
-	else\
-		mv vertmp version-cache;\
-		rm -f Version.h;\
-	fi;\
-	rm -f vertmp
-
-Version.h: version-cache
-	cp version-cache Version.h
-
-.PHONY: version-cache
-
-#
-# Libraries
-#
-include Make.inc
-include Eigen.inc
-
-if BUILD_FERMION_INSTANTIATIONS
-  extra_sources+=$(WILS_FERMION_FILES)
-  extra_sources+=$(STAG_FERMION_FILES)
-if BUILD_ZMOBIUS
-    extra_sources+=$(ZWILS_FERMION_FILES)
-endif
-if BUILD_GPARITY
-    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
-endif
-
-lib_LIBRARIES = libGrid.a
-
-CCFILES += $(extra_sources)
-HFILES  += $(extra_headers) Config.h Version.h
-
-libGrid_a_SOURCES              = $(CCFILES)
-libGrid_adir                   = $(includedir)/Grid
-nobase_dist_pkginclude_HEADERS = $(HFILES) $(eigen_files) $(eigen_unsupp_files)

Grid/Namespace.h

@@ -1,43 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/Namespace.h
-
-Copyright (C) 2016
-
-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 <type_traits>
-#include <exception>
-#include <cassert>
-
-#define NAMESPACE_BEGIN(A) namespace A {
-#define NAMESPACE_END(A)   }
-#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; }
-

Grid/algorithms/Algorithms.h

@@ -1,86 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/Algorithms.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
-#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>
-#include <Grid/algorithms/Preconditioner.h>
-NAMESPACE_CHECK(SparseMatrix);
-
-#include <Grid/algorithms/approx/Zolotarev.h>
-#include <Grid/algorithms/approx/Chebyshev.h>
-#include <Grid/algorithms/approx/JacobiPolynomial.h>
-#include <Grid/algorithms/approx/Remez.h>
-#include <Grid/algorithms/approx/MultiShiftFunction.h>
-#include <Grid/algorithms/approx/Forecast.h>
-#include <Grid/algorithms/approx/RemezGeneral.h>
-#include <Grid/algorithms/approx/ZMobius.h>
-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/ConjugateGradient.h>
-NAMESPACE_CHECK(ConjGrad);
-#include <Grid/algorithms/iterative/BiCGSTAB.h>
-NAMESPACE_CHECK(BiCGSTAB);
-#include <Grid/algorithms/iterative/ConjugateResidual.h>
-#include <Grid/algorithms/iterative/NormalEquations.h>
-#include <Grid/algorithms/iterative/SchurRedBlack.h>
-#include <Grid/algorithms/iterative/ConjugateGradientMultiShift.h>
-#include <Grid/algorithms/iterative/ConjugateGradientMixedPrec.h>
-#include <Grid/algorithms/iterative/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>
-#include <Grid/algorithms/iterative/MinimalResidual.h>
-#include <Grid/algorithms/iterative/GeneralisedMinimalResidual.h>
-#include <Grid/algorithms/iterative/CommunicationAvoidingGeneralisedMinimalResidual.h>
-#include <Grid/algorithms/iterative/FlexibleGeneralisedMinimalResidual.h>
-#include <Grid/algorithms/iterative/FlexibleCommunicationAvoidingGeneralisedMinimalResidual.h>
-#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/FFT.h>
-
-#endif

Grid/algorithms/FFT.h

@@ -1,710 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/Cshift.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 */
-#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)
-#include <fftw/fftw3.h>
-#else
-#include <fftw3.h>
-#endif
-#endif
-#endif
-
-NAMESPACE_BEGIN(Grid);
-
-#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> {
-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
-
-#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();
-  {
-    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
-    });
-  }
-  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;
-      }
-    }
-  }
-
-  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);
-  }
-
-  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;
-    typedef typename vobj::scalar_object sobj;
-    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);
-    }
-  }
-
-  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;
-      }
-    }
-  }
-
-  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);
-  }
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/LinearOperator.h

@@ -1,769 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/LinearOperator.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once 
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// LinearOperators Take a something and return a something.
-/////////////////////////////////////////////////////////////////////////////////////////////
-//
-// Hopefully linearity is satisfied and the AdjOp is indeed the Hermitian Conjugateugate (transpose if real):
-//SBase
-//   i)  F(a x + b y) = aF(x) + b F(y).
-//  ii)  <x|Op|y> = <y|AdjOp|x>^\ast
-//
-// Would be fun to have a test linearity & Herm Conj function!
-/////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class LinearOperatorBase {
-public:
-  // Support for coarsening to a multigrid
-  virtual void OpDiag (const Field &in, Field &out) = 0; // Abstract base
-  virtual void OpDir  (const Field &in, Field &out,int dir,int disp) = 0; // Abstract base
-  virtual void OpDirAll  (const Field &in, std::vector<Field> &out) = 0; // Abstract base
-
-  virtual void Op     (const Field &in, Field &out) = 0; // Abstract base
-  virtual void AdjOp  (const Field &in, Field &out) = 0; // Abstract base
-  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2)=0;
-  virtual void HermOp(const Field &in, Field &out)=0;
-  virtual ~LinearOperatorBase(){};
-};
-
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// By sharing the class for Sparse Matrix across multiple operator wrappers, we can share code
-// between RB and non-RB variants. Sparse matrix is like the fermion action def, and then
-// the wrappers implement the specialisation of "Op" and "AdjOp" to the cases minimising
-// replication of code.
-//
-// 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
-// do it, but I fear it required multiple inheritance and mixed in abstract base classes
-/////////////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////
-// Construct herm op from non-herm matrix
-////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class MdagMLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-public:
-  MdagMLinearOperator(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.MdagM(in,out);
-    ComplexD dot = innerProduct(in,out);
-    n1=real(dot);
-    n2=norm2(out);
-  }
-  void HermOp(const Field &in, Field &out){
-    _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
-////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class ShiftedMdagMLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-  RealD _shift;
-public:
-  ShiftedMdagMLinearOperator(Matrix &Mat,RealD shift): _Mat(Mat), _shift(shift){};
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    _Mat.Mdiag(in,out);
-    GRID_ASSERT(0);
-  }
-  void OpDir  (const Field &in, Field &out,int dir,int disp) {
-    _Mat.Mdir(in,out,dir,disp);
-    GRID_ASSERT(0);
-  }
-  void OpDirAll  (const Field &in, std::vector<Field> &out){
-    GRID_ASSERT(0);
-  };
-  void Op     (const Field &in, Field &out){
-    _Mat.M(in,out);
-    GRID_ASSERT(0);
-  }
-  void AdjOp     (const Field &in, Field &out){
-    _Mat.Mdag(in,out);
-    GRID_ASSERT(0);
-  }
-  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.MdagM(in,out);
-    out = out + _shift*in;
-  }
-};
-
-////////////////////////////////////////////////////////////////////
-// 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
-////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class HermitianLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-public:
-  HermitianLinearOperator(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.M(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.M(in,out);
-  }
-};
-
-template<class Matrix,class Field>
-class NonHermitianLinearOperator : public LinearOperatorBase<Field> {
-  Matrix &_Mat;
-public:
-  NonHermitianLinearOperator(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){
-    GRID_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);
-  }
-};
-
-//////////////////////////////////////////////////////////
-// Even Odd Schur decomp operators; there are several
-// ways to introduce the even odd checkerboarding
-//////////////////////////////////////////////////////////
-
-template<class Field>
-class SchurOperatorBase :  public LinearOperatorBase<Field> {
- public:
-  virtual  void Mpc      (const Field &in, Field &out) =0;
-  virtual  void MpcDag   (const Field &in, Field &out) =0;
-  virtual  void MpcDagMpc(const Field &in, Field &out) {
-    Field tmp(in.Grid());
-    tmp.Checkerboard() = in.Checkerboard();
-    Mpc(in,tmp);
-    MpcDag(tmp,out);
-  }
-  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    out.Checkerboard() = in.Checkerboard();
-    MpcDagMpc(in,out);
-    ComplexD dot= innerProduct(in,out); 
-    n1=real(dot);
-    n2=norm2(out);
-  }
-  virtual void HermOp(const Field &in, Field &out){
-    out.Checkerboard() = in.Checkerboard();
-    MpcDagMpc(in,out);
-  }
-  void Op     (const Field &in, Field &out){
-    Mpc(in,out);
-  }
-  void AdjOp     (const Field &in, Field &out){ 
-    MpcDag(in,out);
-  }
-  // Support for coarsening to a multigrid
-  void OpDiag (const Field &in, Field &out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
-  }
-  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);
-  };
-};
-template<class Matrix,class Field>
-  class SchurDiagMooeeOperator :  public SchurOperatorBase<Field> {
- public:
-    Matrix &_Mat;
-    SchurDiagMooeeOperator (Matrix &Mat): _Mat(Mat){};
-    virtual  void Mpc      (const Field &in, Field &out) {
-      Field tmp(in.Grid());
-      tmp.Checkerboard() = !in.Checkerboard();
-      
-      _Mat.Meooe(in,tmp);
-      _Mat.MooeeInv(tmp,out);
-      _Mat.Meooe(out,tmp);
-      _Mat.Mooee(in,out);
-      axpy(out,-1.0,tmp,out);
-    }
-    virtual void MpcDag   (const Field &in, Field &out){
-      Field tmp(in.Grid());
-	
-      _Mat.MeooeDag(in,tmp);
-      _Mat.MooeeInvDag(tmp,out);
-      _Mat.MeooeDag(out,tmp);
-      _Mat.MooeeDag(in,out);
-      axpy(out,-1.0,tmp,out);
-    }
-};
-template<class Matrix,class Field>
-  class SchurDiagOneOperator :  public SchurOperatorBase<Field> {
- protected:
-    Matrix &_Mat;
- public:
-    SchurDiagOneOperator (Matrix &Mat): _Mat(Mat){};
-    
-    virtual void Mpc      (const Field &in, Field &out) {
-      Field tmp(in.Grid());
-
-      _Mat.Meooe(in,out);
-      _Mat.MooeeInv(out,tmp);
-      _Mat.Meooe(tmp,out);
-      _Mat.MooeeInv(out,tmp);
-      axpy(out,-1.0,tmp,in);
-    }
-    virtual void MpcDag   (const Field &in, Field &out){
-      Field tmp(in.Grid());
-      
-      _Mat.MooeeInvDag(in,out);
-      _Mat.MeooeDag(out,tmp);
-      _Mat.MooeeInvDag(tmp,out);
-      _Mat.MeooeDag(out,tmp);
-      axpy(out,-1.0,tmp,in);
-    }
-};
-template<class Matrix,class Field>
-  class SchurDiagTwoOperator :  public SchurOperatorBase<Field> {
- protected:
-    Matrix &_Mat;
- public:
-    SchurDiagTwoOperator (Matrix &Mat): _Mat(Mat){};
-    
-    virtual void Mpc      (const Field &in, Field &out) {
-      Field tmp(in.Grid());
-      
-      _Mat.MooeeInv(in,out);
-      _Mat.Meooe(out,tmp);
-      _Mat.MooeeInv(tmp,out);
-      _Mat.Meooe(out,tmp);
-      
-      axpy(out,-1.0,tmp,in);
-    }
-    virtual  void MpcDag   (const Field &in, Field &out){
-      Field tmp(in.Grid());
-
-      _Mat.MeooeDag(in,out);
-      _Mat.MooeeInvDag(out,tmp);
-      _Mat.MeooeDag(tmp,out);
-      _Mat.MooeeInvDag(out,tmp);
-
-      axpy(out,-1.0,tmp,in);
-    }
-};
-
-template<class Field>
-class NonHermitianSchurOperatorBase :  public LinearOperatorBase<Field> 
-{
- public:
-  virtual void  Mpc      (const Field& in, Field& out) = 0;
-  virtual void  MpcDag   (const Field& in, Field& out) = 0;
-  virtual void  MpcDagMpc(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    tmp.Checkerboard() = in.Checkerboard();
-    Mpc(in,tmp);
-    MpcDag(tmp,out);
-  }
-  virtual void HermOpAndNorm(const Field& in, Field& out, RealD& n1, RealD& n2) {
-    GRID_ASSERT(0);
-  }
-  virtual void HermOp(const Field& in, Field& out) {
-    GRID_ASSERT(0);
-  }
-  void Op(const Field& in, Field& out) {
-    Mpc(in, out);
-  }
-  void AdjOp(const Field& in, Field& out) { 
-    MpcDag(in, out);
-  }
-  // Support for coarsening to a multigrid
-  void OpDiag(const Field& in, Field& out) {
-    GRID_ASSERT(0); // must coarsen the unpreconditioned system
-  }
-  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);
-  };
-};
-
-template<class Matrix, class Field>
-class NonHermitianSchurDiagMooeeOperator :  public NonHermitianSchurOperatorBase<Field> 
-{
- public:
-  Matrix& _Mat;
- NonHermitianSchurDiagMooeeOperator(Matrix& Mat): _Mat(Mat){};
-  virtual void Mpc(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    tmp.Checkerboard() = !in.Checkerboard();
-    
-    _Mat.Meooe(in, tmp);
-    _Mat.MooeeInv(tmp, out);
-    _Mat.Meooe(out, tmp);
-    
-    _Mat.Mooee(in, out);
-    
-    axpy(out, -1.0, tmp, out);
-  }
-  virtual void MpcDag(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    
-    _Mat.MeooeDag(in, tmp);
-    _Mat.MooeeInvDag(tmp, out);
-    _Mat.MeooeDag(out, tmp);
-	  
-    _Mat.MooeeDag(in, out);
-    
-    axpy(out, -1.0, tmp, out);
-  }
-};
-    
-template<class Matrix,class Field>
-class NonHermitianSchurDiagOneOperator : public NonHermitianSchurOperatorBase<Field> 
-{
- protected:
-  Matrix &_Mat;
-  
- public:
-  NonHermitianSchurDiagOneOperator (Matrix& Mat): _Mat(Mat){};
-  virtual void Mpc(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-	  
-    _Mat.Meooe(in, out);
-    _Mat.MooeeInv(out, tmp);
-    _Mat.Meooe(tmp, out);
-    _Mat.MooeeInv(out, tmp);
-
-    axpy(out, -1.0, tmp, in);
-  }
-  virtual void MpcDag(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    
-    _Mat.MooeeInvDag(in, out);
-    _Mat.MeooeDag(out, tmp);
-    _Mat.MooeeInvDag(tmp, out);
-    _Mat.MeooeDag(out, tmp);
-    
-    axpy(out, -1.0, tmp, in);
-  }
-};
-
-template<class Matrix, class Field>
-class NonHermitianSchurDiagTwoOperator : public NonHermitianSchurOperatorBase<Field> 
-{
- protected:
-  Matrix& _Mat;
-  
- public:
- NonHermitianSchurDiagTwoOperator(Matrix& Mat): _Mat(Mat){};
-
-  virtual void Mpc(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    
-    _Mat.MooeeInv(in, out);
-    _Mat.Meooe(out, tmp);
-    _Mat.MooeeInv(tmp, out);
-    _Mat.Meooe(out, tmp);
-
-    axpy(out, -1.0, tmp, in);
-  }
-  virtual void MpcDag(const Field& in, Field& out) {
-    Field tmp(in.Grid());
-    
-    _Mat.MeooeDag(in, out);
-    _Mat.MooeeInvDag(out, tmp);
-    _Mat.MeooeDag(tmp, out);
-    _Mat.MooeeInvDag(out, tmp);
-
-    axpy(out, -1.0, tmp, in);
-  }
-};
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-// Left  handed Moo^-1 ; (Moo - Moe Mee^-1 Meo) psi = eta  -->  ( 1 - Moo^-1 Moe Mee^-1 Meo ) psi = Moo^-1 eta
-// Right handed Moo^-1 ; (Moo - Moe Mee^-1 Meo) Moo^-1 Moo psi = eta  -->  ( 1 - Moe Mee^-1 Meo Moo^-1) phi=eta ; psi = Moo^-1 phi
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field> using SchurDiagOneRH = SchurDiagTwoOperator<Matrix,Field> ;
-template<class Matrix,class Field> using SchurDiagOneLH = SchurDiagOneOperator<Matrix,Field> ;
-///////////////////////////////////////////////////////////////////////////////////////////////////
-//  Staggered use
-///////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Matrix,class Field>
-class SchurStaggeredOperator :  public SchurOperatorBase<Field> {
- protected:
-  Matrix &_Mat;
-  Field tmp;
-  RealD mass;
- public:
-  SchurStaggeredOperator (Matrix &Mat): _Mat(Mat), tmp(_Mat.RedBlackGrid()) 
-  { 
-    GRID_ASSERT( _Mat.isTrivialEE() );
-    mass = _Mat.Mass();
-  }
-  virtual void HermOpAndNorm(const Field &in, Field &out,RealD &n1,RealD &n2){
-    Mpc(in,out);
-    ComplexD dot= innerProduct(in,out);
-    n1 = real(dot);
-    n2 =0.0;
-  }
-  virtual void HermOp(const Field &in, Field &out){
-    Mpc(in,out);
-    //    _Mat.Meooe(in,out);
-    //    _Mat.Meooe(out,tmp);
-    //    axpby(out,-1.0,mass*mass,tmp,in);
-  }
-  virtual  void Mpc      (const Field &in, Field &out) 
-  {
-    Field tmp(in.Grid());
-    Field tmp2(in.Grid());
-	
-    //    _Mat.Mooee(in,out);
-    //    _Mat.Mooee(out,tmp);
-
-    _Mat.Meooe(in,out);
-    _Mat.Meooe(out,tmp);
-    axpby(out,-1.0,mass*mass,tmp,in);
-  }
-  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
-  }
-};
-template<class Matrix,class Field> using SchurStagOperator = SchurStaggeredOperator<Matrix,Field>;
-
-/////////////////////////////////////////////////////////////
-// Base classes for functions of operators
-/////////////////////////////////////////////////////////////
-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());
-    for(int k=0;k<in.size();k++){
-      (*this)(Linop,in[k],out[k]);
-    }
-  };
-  virtual ~OperatorFunction(){};
-};
-
-template<class Field> class LinearFunction {
-public:
-  virtual void operator() (const Field &in, Field &out) = 0;
-
-  virtual void operator() (const std::vector<Field> &in, std::vector<Field> &out)
-  {
-    GRID_ASSERT(in.size() == out.size());
-
-    for (unsigned int i = 0; i < in.size(); ++i)
-    {
-      (*this)(in[i], out[i]);
-    }
-  }
-  // The identity, if a derived class says so.  A caller can then use its input
-  // where it would otherwise have materialised the output, and skip the copy.
-  virtual int isTrivial(void) { return 0; };
-  virtual ~LinearFunction(){};
-};
-
-template<class Field> class IdentityLinearFunction : public LinearFunction<Field> {
-public:
-  void operator() (const Field &in, Field &out){
-    out = in;
-  };
-};
-
-
-/////////////////////////////////////////////////////////////
-// Base classes for Multishift solvers for operators
-/////////////////////////////////////////////////////////////
-template<class Field> class OperatorMultiFunction {
-public:
-  virtual void operator() (LinearOperatorBase<Field> &Linop, const Field &in, std::vector<Field> &out) = 0;
-};
-
-// FIXME : To think about
-
-// Chroma functionality list defining LinearOperator
-/*
-  virtual void operator() (T& chi, const T& psi, enum PlusMinus isign) const = 0;
-  virtual void operator() (T& chi, const T& psi, enum PlusMinus isign, Real epsilon) const
-  virtual const Subset& subset() const = 0;
-  virtual unsigned long nFlops() const { return 0; }
-  virtual void deriv(P& ds_u, const T& chi, const T& psi, enum PlusMinus isign) const
-  class UnprecLinearOperator : public DiffLinearOperator<T,P,Q>
-  const Subset& subset() const {return all;}
-  };
-*/
-
-////////////////////////////////////////////////////////////////////////////////////////////
-// Hermitian operator Linear function and operator function
-////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field>
-class HermOpOperatorFunction : public OperatorFunction<Field> {
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
-    Linop.HermOp(in,out);
-  };
-};
-
-template<typename Field>
-class PlainHermOp : public LinearFunction<Field> {
-public:
-  using LinearFunction<Field>::operator();
-  LinearOperatorBase<Field> &_Linop;
-      
-  PlainHermOp(LinearOperatorBase<Field>& linop) : _Linop(linop) 
-  {}
-      
-  void operator()(const Field& in, Field& out) {
-    _Linop.HermOp(in,out);
-  }
-};
-
-template<typename Field>
-class FunctionHermOp : public LinearFunction<Field> {
-public:
-  using LinearFunction<Field>::operator(); 
-  OperatorFunction<Field>   & _poly;
-  LinearOperatorBase<Field> &_Linop;
-      
-  FunctionHermOp(OperatorFunction<Field> & poly,LinearOperatorBase<Field>& linop) 
-    : _poly(poly), _Linop(linop) {};
-      
-  void operator()(const Field& in, Field& out) {
-    _poly(_Linop,in,out);
-  }
-};
-
-template<class Field>
-class Polynomial : public OperatorFunction<Field> {
-private:
-  std::vector<RealD> Coeffs;
-public:
-  using OperatorFunction<Field>::operator();
-
-  Polynomial(std::vector<RealD> &_Coeffs) : Coeffs(_Coeffs) { };
-
-  // Implement the required interface
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
-
-    Field AtoN(in.Grid());
-    Field Mtmp(in.Grid());
-    AtoN = in;
-    out = AtoN*Coeffs[0];
-    for(int n=1;n<Coeffs.size();n++){
-      Mtmp = AtoN;
-      Linop.HermOp(Mtmp,AtoN);
-      out=out+AtoN*Coeffs[n];
-    }
-  };
-};
-
-NAMESPACE_END(Grid);

Grid/algorithms/Preconditioner.h

@@ -1,53 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/Preconditioner.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.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_PRECONDITIONER_H
-#define GRID_PRECONDITIONER_H
-
-NAMESPACE_BEGIN(Grid);
-
-template<class Field> using Preconditioner =  LinearFunction<Field> ;
-
-/*
-template<class Field> class Preconditioner :  public LinearFunction<Field> {
-  using LinearFunction<Field>::operator();
-  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){
-    psi = src;
-  }
-  virtual int isTrivial(void) { return 1; };
-  TrivialPrecon(void){};
-};
-
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/SparseMatrix.h

@@ -1,86 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/SparseMatrix.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 */
-#ifndef  GRID_ALGORITHM_SPARSE_MATRIX_H
-#define  GRID_ALGORITHM_SPARSE_MATRIX_H
-
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Interface defining what I expect of a general sparse matrix, such as a Fermion action
-/////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class SparseMatrixBase {
-public:
-  virtual GridBase *Grid(void) =0;
-  // Full checkerboar operations
-  virtual void  M    (const Field &in, Field &out)=0;
-  virtual void  Mdag (const Field &in, Field &out)=0;
-  virtual void  MdagM(const Field &in, Field &out) {
-    Field tmp (in.Grid());
-    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() {};
-};
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Interface augmented by a red black sparse matrix, such as a Fermion action
-/////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class CheckerBoardedSparseMatrixBase : public SparseMatrixBase<Field> {
-public:
-  virtual GridBase *RedBlackGrid(void)=0;
-
-  //////////////////////////////////////////////////////////////////////
-  // Query the even even properties to make algorithmic decisions
-  //////////////////////////////////////////////////////////////////////
-  virtual RealD  Mass(void)        { return 0.0; };
-  virtual int    ConstEE(void)     { return 1; }; // Disable assumptions unless overridden
-  virtual int    isTrivialEE(void) { return 0; }; // by a derived class that knows better
-
-  // half checkerboard operaions
-  virtual  void Meooe    (const Field &in, Field &out)=0;
-  virtual  void Mooee    (const Field &in, Field &out)=0;
-  virtual  void MooeeInv (const Field &in, Field &out)=0;
-
-  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);
-
-#endif

Grid/algorithms/approx/Chebyshev.h

@@ -1,416 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/Chebyshev.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-Author: Christoph Lehner <clehner@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 */
-#ifndef GRID_CHEBYSHEV_H
-#define GRID_CHEBYSHEV_H
-
-#include <Grid/algorithms/LinearOperator.h>
-
-NAMESPACE_BEGIN(Grid);
-
-struct ChebyParams : Serializable {
-  GRID_SERIALIZABLE_CLASS_MEMBERS(ChebyParams,
-				  RealD, alpha,  
-				  RealD, beta,   
-				  int, Npoly);
-};
-
-////////////////////////////////////////////////////////////////////////////////////////////
-// Generic Chebyshev approximations
-////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field>
-class Chebyshev : public OperatorFunction<Field> {
-private:
-  using OperatorFunction<Field>::operator();
-
-  std::vector<RealD> Coeffs;
-  int order;
-  RealD hi;
-  RealD lo;
-
-public:
-  void csv(std::ostream &out){
-    RealD diff = hi-lo;
-    RealD delta = diff*1.0e-9;
-    for (RealD x=lo; x<hi; x+=delta) {
-      delta*=1.02;
-      RealD f = approx(x);
-      out<< x<<" "<<f<<std::endl;
-    }
-    return;
-  }
-
-  // Convenience for plotting the approximation
-  void   PlotApprox(std::ostream &out) {
-    out<<"Polynomial approx ["<<lo<<","<<hi<<"]"<<std::endl;
-    for(RealD x=lo;x<hi;x+=(hi-lo)/50.0){
-      out <<x<<"\t"<<approx(x)<<std::endl;
-    }
-  };
-
-  Chebyshev(){};
-  Chebyshev(ChebyParams p){ Init(p.alpha,p.beta,p.Npoly);};
-  Chebyshev(RealD _lo,RealD _hi,int _order, RealD (* func)(RealD) ) {Init(_lo,_hi,_order,func);};
-  Chebyshev(RealD _lo,RealD _hi,int _order) {Init(_lo,_hi,_order);};
-
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  // c.f. numerical recipes "chebft"/"chebev". This is sec 5.8 "Chebyshev approximation".
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  // CJ: the one we need for Lanczos
-  void Init(RealD _lo,RealD _hi,int _order)
-  {
-    lo=_lo;
-    hi=_hi;
-    order=_order;
-      
-    if(order < 2) exit(-1);
-    Coeffs.resize(order,0.0);
-    Coeffs[order-1] = 1.0;
-  };
-  
-  // PB - more efficient low pass drops high modes above the low as 1/x uses all Chebyshev's.
-  // Similar kick effect below the threshold as Lanczos filter approach
-  void InitLowPass(RealD _lo,RealD _hi,int _order)
-  {
-    lo=_lo;
-    hi=_hi;
-    order=_order;
-      
-    if(order < 2) exit(-1);
-    Coeffs.resize(order);
-    for(int j=0;j<order;j++){
-      RealD k=(order-1.0);
-      RealD s=std::cos( j*M_PI*(k+0.5)/order );
-      Coeffs[j] = s * 2.0/order;
-    }
-    
-  };
-
-  void Init(RealD _lo,RealD _hi,int _order, RealD (* func)(RealD))
-  {
-    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;
-    }
-  };
-  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){
-    RealD M=order;
-    RealD alpha = M_PI/(M+2);
-    RealD lmax = std::cos(alpha);
-    RealD sumUsq =0;
-    std::vector<RealD> U(M);
-    std::vector<RealD> a(M);
-    std::vector<RealD> g(M);
-    for(int n=0;n<=M;n++){
-      U[n] = std::sin((n+1)*std::acos(lmax))/std::sin(std::acos(lmax));
-      sumUsq += U[n]*U[n];
-    }      
-    sumUsq = std::sqrt(sumUsq);
-
-    for(int i=1;i<=M;i++){
-      a[i] = U[i]/sumUsq;
-    }
-    g[0] = 1.0;
-    for(int m=1;m<=M;m++){
-      g[m] = 0;
-      for(int i=0;i<=M-m;i++){
-	g[m]+= a[i]*a[m+i];
-      }
-    }
-    for(int m=1;m<=M;m++){
-      Coeffs[m]*=g[m];
-    }
-  }
-  RealD approx(RealD x) // Convenience for plotting the approximation
-  {
-    RealD Tn;
-    RealD Tnm;
-    RealD Tnp;
-      
-    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));
-      
-    RealD T0=1;
-    RealD T1=y;
-      
-    RealD sum;
-    sum = 0.5*Coeffs[0]*T0;
-    sum+= Coeffs[1]*T1;
-      
-    Tn =T1;
-    Tnm=T0;
-    for(int i=2;i<order;i++){
-      Tnp=2*y*Tn-Tnm;
-      Tnm=Tn;
-      Tn =Tnp;
-      sum+= Tn*Coeffs[i];
-    }
-    return sum;
-  };
-
-  RealD approxD(RealD x)
-  {
-    RealD Un;
-    RealD Unm;
-    RealD Unp;
-      
-    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));
-      
-    RealD U0=1;
-    RealD U1=2*y;
-      
-    RealD sum;
-    sum = Coeffs[1]*U0;
-    sum+= Coeffs[2]*U1*2.0;
-      
-    Un =U1;
-    Unm=U0;
-    for(int i=2;i<order-1;i++){
-      Unp=2*y*Un-Unm;
-      Unm=Un;
-      Un =Unp;
-      sum+= Un*Coeffs[i+1]*(i+1.0);
-    }
-    return sum/(0.5*(hi-lo));
-  };
-    
-  RealD approxInv(RealD z, RealD x0, int maxiter, RealD resid) {
-    RealD x = x0;
-    RealD eps;
-      
-    int i;
-    for (i=0;i<maxiter;i++) {
-      eps = approx(x) - z;
-      if (fabs(eps / z) < resid)
-	return x;
-      x = x - eps / approxD(x);
-    }
-      
-    return std::numeric_limits<double>::quiet_NaN();
-  }
-    
-  // Implement the required interface
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
-
-    GridBase *grid=in.Grid();
-
-    int vol=grid->gSites();
-    typedef typename Field::vector_type vector_type;
-
-    Field T0(grid); T0 = in;  
-    Field T1(grid); 
-    Field T2(grid);
-    Field y(grid);
-      
-    Field *Tnm = &T0;
-    Field *Tn  = &T1;
-    Field *Tnp = &T2;
-
-    // Tn=T1 = (xscale M + mscale)in
-    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;
-    axpby(out,0.5*Coeffs[0],Coeffs[1],T0,T1);
-    for(int n=2;n<order;n++){
-
-      Linop.HermOp(*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);
-      }
-
-      // Cycle pointers to avoid copies
-      Field *swizzle = Tnm;
-      Tnm    =Tn;
-      Tn     =Tnp;
-      Tnp    =swizzle;
-	  
-    }
-  }
-};
-
-
-template<class Field>
-class ChebyshevLanczos : public Chebyshev<Field> {
-private:
-  std::vector<RealD> Coeffs;
-  int order;
-  RealD alpha;
-  RealD beta;
-  RealD mu;
-
-public:
-  ChebyshevLanczos(RealD _alpha,RealD _beta,RealD _mu,int _order) :
-    alpha(_alpha),
-    beta(_beta),
-    mu(_mu)
-  {
-    order=_order;
-    Coeffs.resize(order);
-    for(int i=0;i<_order;i++){
-      Coeffs[i] = 0.0;
-    }
-    Coeffs[order-1]=1.0;
-  };
-
-  void csv(std::ostream &out){
-    for (RealD x=-1.2*alpha; x<1.2*alpha; x+=(2.0*alpha)/10000) {
-      RealD f = approx(x);
-      out<< x<<" "<<f<<std::endl;
-    }
-    return;
-  }
-
-  RealD approx(RealD xx) // Convenience for plotting the approximation
-  {
-    RealD Tn;
-    RealD Tnm;
-    RealD Tnp;
-    Real aa = alpha * alpha;
-    Real bb = beta  *  beta;
-      
-    RealD x = ( 2.0 * (xx-mu)*(xx-mu) - (aa+bb) ) / (aa-bb);
-
-    RealD y= x;
-      
-    RealD T0=1;
-    RealD T1=y;
-      
-    RealD sum;
-    sum = 0.5*Coeffs[0]*T0;
-    sum+= Coeffs[1]*T1;
-      
-    Tn =T1;
-    Tnm=T0;
-    for(int i=2;i<order;i++){
-      Tnp=2*y*Tn-Tnm;
-      Tnm=Tn;
-      Tn =Tnp;
-      sum+= Tn*Coeffs[i];
-    }
-    return sum;
-  };
-
-  // shift_Multiply in Rudy's code
-  void AminusMuSq(LinearOperatorBase<Field> &Linop, const Field &in, Field &out) 
-  {
-    GridBase *grid=in.Grid();
-    Field tmp(grid);
-
-    RealD aa= alpha*alpha;
-    RealD bb= beta * beta;
-
-    Linop.HermOp(in,out);
-    out = out - mu*in;
-
-    Linop.HermOp(out,tmp);
-    tmp = tmp - mu * out;
-
-    out = (2.0/ (aa-bb) ) * tmp -  ((aa+bb)/(aa-bb))*in;
-  };
-  // Implement the required interface
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
-
-    GridBase *grid=in.Grid();
-
-    int vol=grid->gSites();
-
-    Field T0(grid); T0 = in;  
-    Field T1(grid); 
-    Field T2(grid);
-    Field  y(grid);
-      
-    Field *Tnm = &T0;
-    Field *Tn  = &T1;
-    Field *Tnp = &T2;
-
-    // Tn=T1 = (xscale M )*in
-    AminusMuSq(Linop,T0,T1);
-
-    // sum = .5 c[0] T0 + c[1] T1
-    out = (0.5*Coeffs[0])*T0 + Coeffs[1]*T1;
-    for(int n=2;n<order;n++){
-	
-      AminusMuSq(Linop,*Tn,y);
-
-      *Tnp=2.0*y-(*Tnm);
-
-      out=out+Coeffs[n]* (*Tnp);
-
-      // Cycle pointers to avoid copies
-      Field *swizzle = Tnm;
-      Tnm    =Tn;
-      Tn     =Tnp;
-      Tnp    =swizzle;
-	  
-    }
-  }
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/approx/Forecast.h

@@ -1,152 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/approx/Forecast.h
-
-Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-Author: David Murphy <dmurphy@phys.columbia.edu>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-			   /*  END LEGAL */
-
-#ifndef INCLUDED_FORECAST_H
-#define INCLUDED_FORECAST_H
-
-NAMESPACE_BEGIN(Grid);
-
-// Abstract base class.
-// Takes a matrix (Mat), a source (phi), and a vector of Fields (chi)
-// and returns a forecasted solution to the system D*psi = phi (psi).
-template<class Matrix, class Field>
-class Forecast
-{
-public:
-  virtual Field operator()(Matrix &Mat, const Field& phi, const std::vector<Field>& chi) = 0;
-};
-
-// Implementation of Brower et al.'s chronological inverter (arXiv:hep-lat/9509012),
-// used to forecast solutions across poles of the EOFA heatbath.
-//
-// Modified from CPS (cps_pp/src/util/dirac_op/d_op_base/comsrc/minresext.C)
-template<class Matrix, class Field>
-class ChronoForecast : public Forecast<Matrix,Field>
-{
-public:
-  Field operator()(Matrix &Mat, const Field& phi, const std::vector<Field>& prev_solns)
-  {
-    int degree = prev_solns.size();
-    Field chi(phi); // forecasted solution
-
-    // Trivial cases
-    if(degree == 0){ chi = Zero(); return chi; }
-    else if(degree == 1){ return prev_solns[0]; }
-
-    //    RealD dot;
-    ComplexD xp;
-    Field r(phi); // residual
-    Field Mv(phi);
-    std::vector<Field> v(prev_solns); // orthonormalized previous solutions
-    std::vector<Field> MdagMv(degree,phi);
-
-    // Array to hold the matrix elements
-    std::vector<std::vector<ComplexD>> G(degree, std::vector<ComplexD>(degree));
-
-    // Solution and source vectors
-    std::vector<ComplexD> a(degree);
-    std::vector<ComplexD> b(degree);
-
-    // Orthonormalize the vector basis
-    for(int i=0; i<degree; i++){
-      v[i] *= 1.0/std::sqrt(norm2(v[i]));
-      for(int j=i+1; j<degree; j++){ v[j] -= innerProduct(v[i],v[j]) * v[i]; }
-    }
-
-    // Perform sparse matrix multiplication and construct rhs
-    for(int i=0; i<degree; i++){
-      b[i] = innerProduct(v[i],phi);
-      Mat.M(v[i],Mv);
-      Mat.Mdag(Mv,MdagMv[i]);
-      G[i][i] = innerProduct(v[i],MdagMv[i]);
-    }
-
-    // Construct the matrix
-    for(int j=0; j<degree; j++){
-      for(int k=j+1; k<degree; k++){
-	G[j][k] = innerProduct(v[j],MdagMv[k]);
-	G[k][j] = conjugate(G[j][k]);
-      }}
-
-    // Gauss-Jordan elimination with partial pivoting
-    for(int i=0; i<degree; i++){
-
-      // Perform partial pivoting
-      int k = i;
-      for(int j=i+1; j<degree; j++){ if(abs(G[j][j]) > abs(G[k][k])){ k = j; } }
-      if(k != i){
-	xp = b[k];
-	b[k] = b[i];
-	b[i] = xp;
-	for(int j=0; j<degree; j++){
-	  xp = G[k][j];
-	  G[k][j] = G[i][j];
-	  G[i][j] = xp;
-	}
-      }
-
-      // Convert matrix to upper triangular form
-      for(int j=i+1; j<degree; j++){
-	xp = G[j][i]/G[i][i];
-	b[j] -= xp * b[i];
-	for(int k=0; k<degree; k++){ G[j][k] -= xp*G[i][k]; }
-      }
-    }
-
-    // Use Gaussian elimination to solve equations and calculate initial guess
-    chi = Zero();
-    r = phi;
-    for(int i=degree-1; i>=0; i--){
-      a[i] = 0.0;
-      for(int j=i+1; j<degree; j++){ a[i] += G[i][j] * a[j]; }
-      a[i] = (b[i]-a[i])/G[i][i];
-      chi += a[i]*v[i];
-      r -= a[i]*MdagMv[i];
-    }
-
-    RealD true_r(0.0);
-    ComplexD tmp;
-    for(int i=0; i<degree; i++){
-      tmp = -b[i];
-      for(int j=0; j<degree; j++){ tmp += G[i][j]*a[j]; }
-      tmp = conjugate(tmp)*tmp;
-      true_r += std::sqrt(tmp.real());
-    }
-
-    RealD error = std::sqrt(norm2(r)/norm2(phi));
-    std::cout << GridLogMessage << "ChronoForecast: |res|/|src| = " << error << std::endl;
-
-    return chi;
-  };
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/approx/JacobiPolynomial.h

@@ -1,129 +0,0 @@
-#ifndef GRID_JACOBIPOLYNOMIAL_H
-#define GRID_JACOBIPOLYNOMIAL_H
-
-#include <Grid/algorithms/LinearOperator.h>
-
-NAMESPACE_BEGIN(Grid);
-
-template<class Field>
-class JacobiPolynomial : public OperatorFunction<Field> {
- private:
-  using OperatorFunction<Field>::operator();
-
-  int order;
-  RealD hi;
-  RealD lo;
-  RealD alpha;
-  RealD beta;
-
- public:
-  void csv(std::ostream &out){
-    csv(out,lo,hi);
-  }
-  void csv(std::ostream &out,RealD llo,RealD hhi){
-    RealD diff = hhi-llo;
-    RealD delta = diff*1.0e-5;
-    for (RealD x=llo-delta; x<=hhi; x+=delta) {
-      RealD f = approx(x);
-      out<< x<<" "<<f <<std::endl;
-    }
-    return;
-  }
-
-  JacobiPolynomial(){};
-  JacobiPolynomial(RealD _lo,RealD _hi,int _order,RealD _alpha, RealD _beta)
-  {
-      lo=_lo;
-      hi=_hi;
-      alpha=_alpha;
-      beta=_beta;
-      order=_order;
-  };
-
-  RealD approx(RealD x) // Convenience for plotting the approximation                                                       
-  {
-    RealD Tn;
-    RealD Tnm;
-    RealD Tnp;
-
-    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));
-
-    RealD T0=1.0;
-    RealD T1=(alpha-beta)*0.5+(alpha+beta+2.0)*0.5*y;
-
-    Tn =T1;
-    Tnm=T0;
-    for(int n=2;n<=order;n++){
-      RealD cnp = 2.0*n*(n+alpha+beta)*(2.0*n-2.0+alpha+beta);
-      RealD cny = (2.0*n-2.0+alpha+beta)*(2.0*n-1.0+alpha+beta)*(2.0*n+alpha+beta);
-      RealD cn1 = (2.0*n+alpha+beta-1.0)*(alpha*alpha-beta*beta);
-      RealD cnm = - 2.0*(n+alpha-1.0)*(n+beta-1.0)*(2.0*n+alpha+beta);
-      Tnp= ( cny * y *Tn + cn1 * Tn + cnm * Tnm )/ cnp;
-      Tnm=Tn;
-      Tn =Tnp;
-    }
-    return Tnp;
-  };
-
-  // Implement the required interface                                                                                       
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
-    GridBase *grid=in.Grid();
-
-    int vol=grid->gSites();
-
-    Field T0(grid);
-    Field T1(grid);
-    Field T2(grid);
-    Field y(grid);
-
-
-    Field *Tnm = &T0;
-    Field *Tn  = &T1;
-    Field *Tnp = &T2;
-
-    //    RealD T0=1.0;                                                                                                     
-    T0=in;
-
-    //    RealD y=( x-0.5*(hi+lo))/(0.5*(hi-lo));                                                                           
-    //           = x * 2/(hi-lo) - (hi+lo)/(hi-lo)                                                                          
-    Linop.HermOp(T0,y);
-    RealD xscale = 2.0/(hi-lo);
-    RealD mscale = -(hi+lo)/(hi-lo);
-    Linop.HermOp(T0,y);
-    y=y*xscale+in*mscale;
-
-    // RealD T1=(alpha-beta)*0.5+(alpha+beta+2.0)*0.5*y;
-    RealD halfAmB  = (alpha-beta)*0.5;
-    RealD halfApBp2= (alpha+beta+2.0)*0.5;
-    T1 = halfAmB * in + halfApBp2*y;
-
-    for(int n=2;n<=order;n++){
-
-      Linop.HermOp(*Tn,y);
-      y=xscale*y+mscale*(*Tn);
-
-      RealD cnp = 2.0*n*(n+alpha+beta)*(2.0*n-2.0+alpha+beta);
-      RealD cny = (2.0*n-2.0+alpha+beta)*(2.0*n-1.0+alpha+beta)*(2.0*n+alpha+beta);
-      RealD cn1 = (2.0*n+alpha+beta-1.0)*(alpha*alpha-beta*beta);
-      RealD cnm = - 2.0*(n+alpha-1.0)*(n+beta-1.0)*(2.0*n+alpha+beta);
-
-      //      Tnp= ( cny * y *Tn + cn1 * Tn + cnm * Tnm )/ cnp;                                                             
-      cny=cny/cnp;
-      cn1=cn1/cnp;
-      cn1=cn1/cnp;
-      cnm=cnm/cnp;
-
-      *Tnp=cny*y + cn1 *(*Tn) + cnm * (*Tnm);
-
-      // Cycle pointers to avoid copies                                                                                     
-      Field *swizzle = Tnm;
-      Tnm    =Tn;
-      Tn     =Tnp;
-      Tnp    =swizzle;
-    }
-    out=*Tnp;
-
-  }
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/approx/MultiShiftFunction.cc

@@ -1,57 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/MultiShiftFunction.cc
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
-#include <Grid/GridCore.h>
-
-NAMESPACE_BEGIN(Grid);
-
-double MultiShiftFunction::approx(double x)
-{
-  double a = norm;
-  for(int n=0;n<poles.size();n++){
-    a = a + residues[n]/(x+poles[n]);
-  }
-  return a;
-}
-void MultiShiftFunction::gnuplot(std::ostream &out)
-{
-  out<<"f(x) = "<<norm<<"";
-  for(int n=0;n<poles.size();n++){
-    out<<"+("<<residues[n]<<"/(x+"<<poles[n]<<"))";
-  }
-  out<<";"<<std::endl;
-}
-void MultiShiftFunction::csv(std::ostream &out)
-{
-  for (double x=lo; x<hi; x*=1.05) {
-    double f = approx(x);
-    double r = sqrt(x);
-    out<< x<<","<<r<<","<<f<<","<<r-f<<std::endl;
-  }
-  return;
-}
-NAMESPACE_END(Grid);

Grid/algorithms/approx/MultiShiftFunction.h

@@ -1,67 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/MultiShiftFunction.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
-#ifndef MULTI_SHIFT_FUNCTION
-#define MULTI_SHIFT_FUNCTION
-
-NAMESPACE_BEGIN(Grid);
-
-class MultiShiftFunction {
-public:
-  int order;
-  std::vector<RealD> poles;
-  std::vector<RealD> residues;
-  std::vector<RealD> tolerances;
-  RealD norm;
-  RealD lo,hi;
-
-  MultiShiftFunction(int n,RealD _lo,RealD _hi): poles(n), residues(n), tolerances(n), lo(_lo), hi(_hi) {;};
-  RealD approx(RealD x);
-  void csv(std::ostream &out);
-  void gnuplot(std::ostream &out);
-
-  void Init(AlgRemez & remez,double tol,bool inverse) 
-  {
-    order=remez.getDegree();
-    tolerances.resize(remez.getDegree(),tol);
-    poles.resize(remez.getDegree());
-    residues.resize(remez.getDegree());
-    remez.getBounds(lo,hi);
-    if ( inverse ) remez.getIPFE (&residues[0],&poles[0],&norm);
-    else           remez.getPFE (&residues[0],&poles[0],&norm);
-  }
-  // Allow deferred initialisation
-  MultiShiftFunction(void){};
-  MultiShiftFunction(AlgRemez & remez,double tol,bool inverse)
-  {
-    Init(remez,tol,inverse);
-  }
-
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/approx/README

@@ -1,80 +0,0 @@
------------------------------------------------------------------------------------
-
-PAB. Took Mike Clark's AlgRemez from GitHub and (modified a little) include.
-This is open source and license and readme and comments are preserved consistent
-with the license. Mike, thankyou!
------------------------------------------------------------------------------------
------------------------------------------------------------------------------------
-AlgRemez
-
-The archive downloadable here contains an implementation of the Remez
-algorithm which calculates optimal rational (and polynomial)
-approximations to the nth root over a given spectral range.  The Remez
-algorithm, although in principle is extremely straightforward to
-program, is quite difficult to get completely correct, e.g., the Maple
-implementation of the algorithm does not always converge to the
-correct answer.
-
-To use this algorithm you need to install GMP, the GNU Multiple
-Precision Library, and when configuring the install, you must include
-the --enable-mpfr option (see the GMP manual for more details).  You
-also have to edit the Makefile for AlgRemez appropriately for your
-system, namely to point corrrectly to the location of the GMP library.
-
-The simple main program included with this archive invokes the
-AlgRemez class to calculate an approximation given by command line
-arguments.  It is invoked by the following
-
-./test y z n d lambda_low lambda_high precision,
-
-where the function to be approximated is f(x) = x^(y/z), with degree
-(n,d) over the spectral range [lambda_low, lambda_high], using
-precision digits of precision in the arithmetic.  So an example would
-be
-
-./test 1 2 5 5 0.0004 64 40
-
-which corresponds to constructing a rational approximation to the
-square root function, with degree (5,5) over the range [0.0004,64]
-with 40 digits of precision used for the arithmetic.  The parameters y
-and z must be positive, the approximation to f(x) = x^(-y/z) is simply
-the inverse of the approximation to f(x) = x^(y/z).  After the
-approximation has been constructed, the roots and poles of the
-rational function are found, and then the partial fraction expansion
-of both the rational function and it's inverse are found, the results
-of which are output to a file called "approx.dat".  In addition, the
-error function of the approximation is output to "error.dat", where it
-can be checked that the resultant approximation satisfies Chebychev's
-criterion, namely all error maxima are equal in magnitude, and
-adjacent maxima are oppostie in sign.  There are some caveats here
-however, the optimal polynomial approximation has complex roots, and
-the root finding implemented here cannot (yet) handle complex roots.
-In addition, the partial fraction expansion of rational approximations
-is only found for the case n = d, i.e., the degree of numerator
-polynomial equals that of the denominator polynomial.  The convention
-for the partial fraction expansion is that polar shifts are always
-written added to x, not subtracted.
-
-To do list
-
-1.  Include an exponential dampening factor in the function to be
-approximated.  This may sound trivial to implement, but for some
-parameters, the algorithm seems to breakdown.  Also, the roots in the
-rational approximation sometimes become complex, which currently
-breaks the stupidly simple root finding code.
-
-2. Make the algorithm faster - it's too slow when running on qcdoc.
-
-3. Add complex root finding.
-
-4. Add more options for error minimisation - currently the code
-minimises the relative error, should add options for absolute error,
-and other norms.
-
-There will be a forthcoming publication concerning the results
-generated by this software, but in the meantime, if you use this
-software, please cite it as
-"M.A. Clark and A.D. Kennedy, https://github.com/mikeaclark/AlgRemez, 2005".
-
-If you have any problems using the software, then please email scientist.mike@gmail.com.
-

Grid/algorithms/approx/Remez.cc

@@ -1,759 +0,0 @@
-/*
-
-  Mike Clark - 25th May 2005
-
-  alg_remez.C
-
-  AlgRemez is an implementation of the Remez algorithm, which in this
-  case is used for generating the optimal nth root rational
-  approximation.
-
-  Note this class requires the gnu multiprecision (GNU MP) library.
-
-*/
-
-#include<math.h>
-#include<stdio.h>
-#include<stdlib.h>
-#include<string>
-#include<iostream>
-#include<iomanip>
-#include<cassert>
-
-#include<Grid/algorithms/approx/Remez.h>
-
-// Constructor
-AlgRemez::AlgRemez(double lower, double upper, long precision) 
-{
-  prec = precision;
-  bigfloat::setDefaultPrecision(prec);
-
-  apstrt = lower;
-  apend = upper;
-  apwidt = apend - apstrt;
-
-  std::cout<<"Approximation bounds are ["<<apstrt<<","<<apend<<"]\n";
-  std::cout<<"Precision of arithmetic is "<<precision<<std::endl;
-
-  alloc = 0;
-  n = 0;
-  d = 0;
-
-  foundRoots = 0;
-
-  // Only require the approximation spread to be less than 1 ulp
-  tolerance = 1e-15;
-}
-
-// Destructor
-AlgRemez::~AlgRemez()
-{
-  if (alloc) {
-    delete [] param;
-    delete [] roots;
-    delete [] poles;
-    delete [] xx;
-    delete [] mm;
-    delete [] a_power;
-    delete [] a;
-  }
-}
-
-// Free memory and reallocate as necessary
-void AlgRemez::allocate(int num_degree, int den_degree)
-{
-  // Arrays have previously been allocated, deallocate first, then allocate
-  if (alloc) {
-    delete [] param;
-    delete [] roots;
-    delete [] poles;
-    delete [] xx;
-    delete [] mm;
-  }
-
-  // Note use of new and delete in memory allocation - cannot run on qcdsp
-  param = new bigfloat[num_degree+den_degree+1];
-  roots = new bigfloat[num_degree];
-  poles = new bigfloat[den_degree];
-  xx = new bigfloat[num_degree+den_degree+3];
-  mm = new bigfloat[num_degree+den_degree+2];
-
-  if (!alloc) {
-    // The coefficients of the sum in the exponential
-    a = new bigfloat[SUM_MAX];
-    a_power = new int[SUM_MAX];
-  }
-
-  alloc = 1;
-}
-
-// Reset the bounds of the approximation
-void AlgRemez::setBounds(double lower, double upper)
-{
-  apstrt = lower;
-  apend = upper;
-  apwidt = apend - apstrt;
-}
-
-// Generate the rational approximation x^(pnum/pden)
-double AlgRemez::generateApprox(int degree, unsigned long pnum, 
-				unsigned long pden)
-{
-  return generateApprox(degree, degree, pnum, pden);
-}
-
-double AlgRemez::generateApprox(int num_degree, int den_degree, 
-				unsigned long pnum, unsigned long pden)
-{
-  double *a_param = 0;
-  int *a_pow = 0;
-  return generateApprox(num_degree, den_degree, pnum, pden, 0, a_param, a_pow);
-}
-
-// Generate the rational approximation x^(pnum/pden)
-double AlgRemez::generateApprox(int num_degree, int den_degree, 
-				unsigned long pnum, unsigned long pden,
-				int a_len, double *a_param, int *a_pow)
-{
-  std::cout<<"Degree of the approximation is ("<<num_degree<<","<<den_degree<<")\n";
-  std::cout<<"Approximating the function x^("<<pnum<<"/"<<pden<<")\n";
-
-  // Reallocate arrays, since degree has changed
-  if (num_degree != n || den_degree != d) allocate(num_degree,den_degree);
-
-  GRID_ASSERT(a_len<=SUM_MAX);
-
-  step = new bigfloat[num_degree+den_degree+2];
-
-  a_length = a_len;
-  for (int j=0; j<a_len; j++) {
-    a[j]= a_param[j];
-    a_power[j] = a_pow[j];
-  }
-
-  power_num = pnum;
-  power_den = pden;
-  spread = 1.0e37;
-  iter = 0;
-
-  n = num_degree;
-  d = den_degree;
-  neq = n + d + 1;
-
-  initialGuess();
-  stpini(step);
-
-  while (spread > tolerance) { //iterate until convergance
-
-    if (iter++%100==0) 
-      std::cout<<"Iteration " <<iter-1<<" spread "<<(double)spread<<" delta "<<(double)delta<<std::endl; 
-
-    equations();
-    if (delta < tolerance) {
-      std::cout<<"Delta too small, try increasing precision\n";
-      GRID_ASSERT(0);
-    };    
-    GRID_ASSERT( delta>= tolerance);
-
-    search(step);
-  }
-
-  int sign;
-  double error = (double)getErr(mm[0],&sign);
-  std::cout<<"Converged at "<<iter<<" iterations; error = "<<error<<std::endl;
-
-  // Once the approximation has been generated, calculate the roots
-  if(!root()) {
-    std::cout<<"Root finding failed\n";
-  } else {
-    foundRoots = 1;
-  }
-  
-  delete [] step;
-
-  // Return the maximum error in the approximation
-  return error;
-}
-
-// Return the partial fraction expansion of the approximation x^(pnum/pden)
-int AlgRemez::getPFE(double *Res, double *Pole, double *Norm) {
-
-  if (n!=d) {
-    std::cout<<"Cannot handle case: Numerator degree neq Denominator degree\n";
-    return 0;
-  }
-
-  if (!alloc) {
-    std::cout<<"Approximation not yet generated\n";
-    return 0;
-  }
-
-  if (!foundRoots) {
-    std::cout<<"Roots not found, so PFE cannot be taken\n";
-    return 0;
-  }
-
-  bigfloat *r = new bigfloat[n];
-  bigfloat *p = new bigfloat[d];
-  
-  for (int i=0; i<n; i++) r[i] = roots[i];
-  for (int i=0; i<d; i++) p[i] = poles[i];
-  
-  // Perform a partial fraction expansion
-  pfe(r, p, norm);
-
-  // Convert to double and return
-  *Norm = (double)norm;
-  for (int i=0; i<n; i++) Res[i] = (double)r[i];
-  for (int i=0; i<d; i++) Pole[i] = (double)p[i];
-
-  delete [] r;
-  delete [] p;
-
-  // Where the smallest shift is located
-  return 0;
-}
-
-// Return the partial fraction expansion of the approximation x^(-pnum/pden)
-int AlgRemez::getIPFE(double *Res, double *Pole, double *Norm) {
-
-  if (n!=d) {
-    std::cout<<"Cannot handle case: Numerator degree neq Denominator degree\n";
-    return 0;
-  }
-
-  if (!alloc) {
-    std::cout<<"Approximation not yet generated\n";
-    return 0;
-  }
-
-  if (!foundRoots) {
-    std::cout<<"Roots not found, so PFE cannot be taken\n";
-    return 0;
-  }
-
-  bigfloat *r = new bigfloat[d];
-  bigfloat *p = new bigfloat[n];
-  
-  // Want the inverse function
-  for (int i=0; i<n; i++) {
-    r[i] = poles[i];
-    p[i] = roots[i];
-  }
-
-  // Perform a partial fraction expansion
-  pfe(r, p, (bigfloat)1l/norm);
-
-  // Convert to double and return
-  *Norm = (double)((bigfloat)1l/(norm));
-  for (int i=0; i<n; i++) {
-    Res[i] = (double)r[i];
-    Pole[i] = (double)p[i];
-  }
-
-  delete [] r;
-  delete [] p;
-
-  // Where the smallest shift is located
-  return 0;
-}
-
-// Initial values of maximal and minimal errors
-void AlgRemez::initialGuess() {
-
-  // Supply initial guesses for solution points
-  long ncheb = neq;			// Degree of Chebyshev error estimate
-  bigfloat a, r;
-
-  // Find ncheb+1 extrema of Chebyshev polynomial
-
-  a = ncheb;
-  mm[0] = apstrt;
-  for (long i = 1; i < ncheb; i++) {
-    r = 0.5 * (1 - cos((M_PI * i)/(double) a));
-    //r *= sqrt_bf(r);
-    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
-    mm[i] = apstrt + r * apwidt;
-  }
-  mm[ncheb] = apend;
-
-  a = 2.0 * ncheb;
-  for (long i = 0; i <= ncheb; i++) {
-    r = 0.5 * (1 - cos(M_PI * (2*i+1)/(double) a));
-    //r *= sqrt_bf(r); // Squeeze to low end of interval
-    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
-    xx[i] = apstrt + r * apwidt;
-  }
-}
-
-// Initialise step sizes
-void AlgRemez::stpini(bigfloat *step) {
-  xx[neq+1] = apend;
-  delta = 0.25;
-  step[0] = xx[0] - apstrt;
-  for (int i = 1; i < neq; i++) step[i] = xx[i] - xx[i-1];
-  step[neq] = step[neq-1];
-}
-
-// Search for error maxima and minima
-void AlgRemez::search(bigfloat *step) {
-  bigfloat a, q, xm, ym, xn, yn, xx0, xx1;
-  int i, meq, emsign, ensign, steps;
-
-  meq = neq + 1;
-  bigfloat *yy = new bigfloat[meq];
-
-  bigfloat eclose = 1.0e30;
-  bigfloat farther = 0l;
-
-  xx0 = apstrt;
-
-  for (i = 0; i < meq; i++) {
-    steps = 0;
-    xx1 = xx[i]; // Next zero
-    if (i == meq-1) xx1 = apend;
-    xm = mm[i];
-    ym = getErr(xm,&emsign);
-    q = step[i];
-    xn = xm + q;
-    if (xn < xx0 || xn >= xx1) {	// Cannot skip over adjacent boundaries
-      q = -q;
-      xn = xm;
-      yn = ym;
-      ensign = emsign;
-    } else {
-      yn = getErr(xn,&ensign);
-      if (yn < ym) {
-	q = -q;
-	xn = xm;
-	yn = ym;
-	ensign = emsign;
-      }
-    }
-  
-    while(yn >= ym) {		// March until error becomes smaller.
-      if (++steps > 10) break;
-      ym = yn;
-      xm = xn;
-      emsign = ensign;
-      a = xm + q;
-      if (a == xm || a <= xx0 || a >= xx1) break;// Must not skip over the zeros either side.
-      xn = a;
-      yn = getErr(xn,&ensign);
-    }
-
-    mm[i] = xm;			// Position of maximum
-    yy[i] = ym;			// Value of maximum
-
-    if (eclose > ym) eclose = ym;
-    if (farther < ym) farther = ym;
-
-    xx0 = xx1; // Walk to next zero.
-  } // end of search loop
-
-  q = (farther - eclose);	// Decrease step size if error spread increased
-  if (eclose != 0.0) q /= eclose; // Relative error spread
-  if (q >= spread) delta *= 0.5; // Spread is increasing; decrease step size
-  spread = q;
-
-  for (i = 0; i < neq; i++) {
-    q = yy[i+1];
-    if (q != 0.0) q = yy[i] / q  - (bigfloat)1l;
-    else q = 0.0625;
-    if (q > (bigfloat)0.25) q = 0.25;
-    q *= mm[i+1] - mm[i];
-    step[i] = q * delta;
-  }
-  step[neq] = step[neq-1];
-  
-  for (i = 0; i < neq; i++) {	// Insert new locations for the zeros.
-    xm = xx[i] - step[i];
-    if (xm <= apstrt) continue;
-    if (xm >= apend) continue;
-    if (xm <= mm[i]) xm = (bigfloat)0.5 * (mm[i] + xx[i]);
-    if (xm >= mm[i+1]) xm = (bigfloat)0.5 * (mm[i+1] + xx[i]);
-    xx[i] = xm;
-  }
-
-  delete [] yy;
-}
-
-// Solve the equations
-void AlgRemez::equations(void) {
-  bigfloat x, y, z;
-  int i, j, ip;
-  bigfloat *aa;
-
-  bigfloat *AA = new bigfloat[(neq)*(neq)];
-  bigfloat *BB = new bigfloat[neq];
-  
-  for (i = 0; i < neq; i++) {	// set up the equations for solution by simq()
-    ip = neq * i;		// offset to 1st element of this row of matrix
-    x = xx[i];			// the guess for this row
-    y = func(x);		// right-hand-side vector
-
-    z = (bigfloat)1l;
-    aa = AA+ip;
-    for (j = 0; j <= n; j++) {
-      *aa++ = z;
-      z *= x;
-    }
-
-    z = (bigfloat)1l;
-    for (j = 0; j < d; j++) {
-      *aa++ = -y * z;
-      z *= x;
-    }
-    BB[i] = y * z;		// Right hand side vector
-  }
-
-  // Solve the simultaneous linear equations.
-  if (simq(AA, BB, param, neq)) {
-    std::cout<<"simq failed\n";
-    exit(0);
-  }
-
-  delete [] AA;
-  delete [] BB;
-
-}
-
-// Evaluate the rational form P(x)/Q(x) using coefficients
-// from the solution vector param
-bigfloat AlgRemez::approx(const bigfloat x) {
-  bigfloat yn, yd;
-  int i;
-
-  // Work backwards toward the constant term.
-  yn = param[n];		// Highest order numerator coefficient
-  for (i = n-1; i >= 0; i--) yn = x * yn  +  param[i]; 
-  yd = x + param[n+d];	// Highest degree coefficient = 1.0
-  for (i = n+d-1; i > n; i--) yd = x * yd  +  param[i];
-
-  return(yn/yd);
-}
-
-// Compute size and sign of the approximation error at x
-bigfloat AlgRemez::getErr(bigfloat x, int *sign) {
-  bigfloat e, f;
-
-  f = func(x);
-  e = approx(x) - f;
-  if (f != 0) e /= f;
-  if (e < (bigfloat)0.0) {
-    *sign = -1;
-    e = -e;
-  }
-  else *sign = 1;
-  
-  return(e);
-}
-
-// Calculate function required for the approximation.
-bigfloat AlgRemez::func(const bigfloat x) {
-
-  bigfloat z = (bigfloat)power_num / (bigfloat)power_den;
-  bigfloat y;
-
-  if (x == (bigfloat)1.0) y = (bigfloat)1.0;
-  else y = pow_bf(x,z);
-
-  if (a_length > 0) {
-    bigfloat sum = 0l;
-    for (int j=0; j<a_length; j++) sum += a[j]*pow_bf(x,a_power[j]);
-    return y * exp_bf(sum);
-  } else {
-    return y;
-  }
-
-}
-
-// Solve the system AX=B
-int AlgRemez::simq(bigfloat A[], bigfloat B[], bigfloat X[], int n) {
-
-  int i, j, ij, ip, ipj, ipk, ipn;
-  int idxpiv, iback;
-  int k, kp, kp1, kpk, kpn;
-  int nip, nkp, nm1;
-  bigfloat em, q, rownrm, big, size, pivot, sum;
-  bigfloat *aa;
-
-  // simq() work vector
-  int *IPS = new int[(neq) * sizeof(int)];
-
-  nm1 = n - 1;
-  // Initialize IPS and X
-  
-  ij = 0;
-  for (i = 0; i < n; i++) {
-    IPS[i] = i;
-    rownrm = 0.0;
-    for(j = 0; j < n; j++) {
-      q = abs_bf(A[ij]);
-      if(rownrm < q) rownrm = q;
-      ++ij;
-    }
-    if (rownrm == (bigfloat)0l) {
-      std::cout<<"simq rownrm=0\n";
-      delete [] IPS;
-      return(1);
-    }
-    X[i] = (bigfloat)1.0 / rownrm;
-  }
-  
-  for (k = 0; k < nm1; k++) {
-    big = 0.0;
-    idxpiv = 0;
-    
-    for (i = k; i < n; i++) {
-      ip = IPS[i];
-      ipk = n*ip + k;
-      size = abs_bf(A[ipk]) * X[ip];
-      if (size > big) {
-	big = size;
-	idxpiv = i;
-      }
-    }
-    
-    if (big == (bigfloat)0l) {
-      std::cout<<"simq big=0\n";
-      delete [] IPS;
-      return(2);
-    }
-    if (idxpiv != k) {
-      j = IPS[k];
-      IPS[k] = IPS[idxpiv];
-      IPS[idxpiv] = j;
-    }
-    kp = IPS[k];
-    kpk = n*kp + k;
-    pivot = A[kpk];
-    kp1 = k+1;
-    for (i = kp1; i < n; i++) {
-      ip = IPS[i];
-      ipk = n*ip + k;
-      em = -A[ipk] / pivot;
-      A[ipk] = -em;
-      nip = n*ip;
-      nkp = n*kp;
-      aa = A+nkp+kp1;
-      for (j = kp1; j < n; j++) {
-	ipj = nip + j;
-	A[ipj] = A[ipj] + em * *aa++;
-      }
-    }
-  }
-  kpn = n * IPS[n-1] + n - 1;	// last element of IPS[n] th row
-  if (A[kpn] == (bigfloat)0l) {
-    std::cout<<"simq A[kpn]=0\n";
-    delete [] IPS;
-    return(3);
-  }
-
-  
-  ip = IPS[0];
-  X[0] = B[ip];
-  for (i = 1; i < n; i++) {
-    ip = IPS[i];
-    ipj = n * ip;
-    sum = 0.0;
-    for (j = 0; j < i; j++) {
-      sum += A[ipj] * X[j];
-      ++ipj;
-    }
-    X[i] = B[ip] - sum;
-  }
-  
-  ipn = n * IPS[n-1] + n - 1;
-  X[n-1] = X[n-1] / A[ipn];
-  
-  for (iback = 1; iback < n; iback++) {
-    //i goes (n-1),...,1
-    i = nm1 - iback;
-    ip = IPS[i];
-    nip = n*ip;
-    sum = 0.0;
-    aa = A+nip+i+1;
-    for (j= i + 1; j < n; j++) 
-      sum += *aa++ * X[j];
-    X[i] = (X[i] - sum) / A[nip+i];
-  }
-  
-  delete [] IPS;
-  return(0);
-}
-
-// Calculate the roots of the approximation
-int AlgRemez::root() {
-
-  long i,j;
-  bigfloat x,dx=0.05;
-  bigfloat upper=1, lower=-100000;
-  bigfloat tol = 1e-20;
-
-  bigfloat *poly = new bigfloat[neq+1];
-
-  // First find the numerator roots
-  for (i=0; i<=n; i++) poly[i] = param[i];
-
-  for (i=n-1; i>=0; i--) {
-    roots[i] = rtnewt(poly,i+1,lower,upper,tol);
-    if (roots[i] == 0.0) {
-      std::cout<<"Failure to converge on root "<<i+1<<"/"<<n<<"\n";
-      return 0;
-    }
-    poly[0] = -poly[0]/roots[i];
-    for (j=1; j<=i; j++) poly[j] = (poly[j-1] - poly[j])/roots[i];
-  }
-  
- // Now find the denominator roots
-  poly[d] = 1l;
-  for (i=0; i<d; i++) poly[i] = param[n+1+i];
-
-  for (i=d-1; i>=0; i--) {
-    poles[i]=rtnewt(poly,i+1,lower,upper,tol);
-    if (poles[i] == 0.0) {
-      std::cout<<"Failure to converge on pole "<<i+1<<"/"<<d<<"\n";
-      return 0;
-    }
-    poly[0] = -poly[0]/poles[i];
-    for (j=1; j<=i; j++) poly[j] = (poly[j-1] - poly[j])/poles[i];
-  }
-
-  norm = param[n];
-
-  delete [] poly;
-
-  return 1;
-}
-
-// Evaluate the polynomial
-bigfloat AlgRemez::polyEval(bigfloat x, bigfloat *poly, long size) {
-  bigfloat f = poly[size];
-  for (int i=size-1; i>=0; i--) f = f*x + poly[i];
-  return f;
-}
-
-// Evaluate the differential of the polynomial
-bigfloat AlgRemez::polyDiff(bigfloat x, bigfloat *poly, long size) {
-  bigfloat df = (bigfloat)size*poly[size];
-  for (int i=size-1; i>0; i--) df = df*x + (bigfloat)i*poly[i];
-  return df;
-}
-
-
-// Newton's method to calculate roots
-bigfloat AlgRemez::rtnewt(bigfloat *poly, long i, bigfloat x1, 
-			  bigfloat x2, bigfloat xacc) {
-  int j;
-  bigfloat df, dx, f, rtn;
-
-  rtn=(bigfloat)0.5*(x1+x2);
-  for (j=1; j<=JMAX;j++) {
-    f = polyEval(rtn, poly, i);
-    df = polyDiff(rtn, poly, i);
-    dx = f/df;
-    rtn -= dx;
-    if (abs_bf(dx) < xacc) return rtn;
-  }
-  std::cout<<"Maximum number of iterations exceeded in rtnewt\n";
-  return 0.0;
-}
-
-// Evaluate the partial fraction expansion of the rational function
-// with res roots and poles poles.  Result is overwritten on input
-// arrays.
-void AlgRemez::pfe(bigfloat *res, bigfloat *poles, bigfloat norm) {
-  int i,j,small;
-  bigfloat temp;
-  bigfloat *numerator = new bigfloat[n];
-  bigfloat *denominator = new bigfloat[d];
-
-  // Construct the polynomials explicitly 
-  for (i=1; i<n; i++) {
-    numerator[i] = 0l;
-    denominator[i] = 0l;
-  }
-  numerator[0]=1l;
-  denominator[0]=1l;
-
-  for (j=0; j<n; j++) {
-    for (i=n-1; i>=0; i--) {
-      numerator[i] *= -res[j];
-      denominator[i] *= -poles[j];
-      if (i>0) {
-	numerator[i] += numerator[i-1];
-	denominator[i] += denominator[i-1];
-      }
-    }
-  }
-
-  // Convert to proper fraction form.
-  // Fraction is now in the form 1 + n/d, where O(n)+1=O(d)
-  for (i=0; i<n; i++) numerator[i] -= denominator[i];
-
-  // Find the residues of the partial fraction expansion and absorb the
-  // coefficients.
-  for (i=0; i<n; i++) {
-    res[i] = 0l;
-    for (j=n-1; j>=0; j--) {
-      res[i] = poles[i]*res[i]+numerator[j];
-    }
-    for (j=n-1; j>=0; j--) {
-      if (i!=j) res[i] /= poles[i]-poles[j];
-    }
-    res[i] *= norm;
-  }  
-
-  // res now holds the residues
-  j = 0;
-  for (i=0; i<n; i++) poles[i] = -poles[i];
-
-  // Move the ordering of the poles from smallest to largest
-  for (j=0; j<n; j++) {
-    small = j;
-    for (i=j+1; i<n; i++) {
-      if (poles[i] < poles[small]) small = i;
-    }
-    if (small != j) {
-      temp = poles[small];
-      poles[small] = poles[j];
-      poles[j] = temp;
-      temp = res[small];
-      res[small] = res[j];
-      res[j] = temp;
-    }
-  }
-
-  delete [] numerator;
-  delete [] denominator;
-}
-
-double AlgRemez::evaluateApprox(double x) {
-  return (double)approx((bigfloat)x);
-}
-
-double AlgRemez::evaluateInverseApprox(double x) {
-  return 1.0/(double)approx((bigfloat)x);
-}
-
-double AlgRemez::evaluateFunc(double x) {
-  return (double)func((bigfloat)x);
-}
-
-double AlgRemez::evaluateInverseFunc(double x) {
-  return 1.0/(double)func((bigfloat)x);
-}
-
-void AlgRemez::csv(std::ostream & os)
-{
-  double lambda_low = apstrt;
-  double lambda_high= apend;
-  for (double x=lambda_low; x<lambda_high; x*=1.05) {
-    double f = evaluateFunc(x);
-    double r = evaluateApprox(x);
-    os<< x<<","<<r<<","<<f<<","<<r-f<<std::endl;
-  }
-  return;
-}
-

Grid/algorithms/approx/Remez.h

@@ -1,184 +0,0 @@
-/*
-
-  Mike Clark - 25th May 2005
-
-  alg_remez.h
-
-  AlgRemez is an implementation of the Remez algorithm, which in this
-  case is used for generating the optimal nth root rational
-  approximation.
-
-  Note this class requires the gnu multiprecision (GNU MP) library.
-
-*/
-
-#ifndef INCLUDED_ALG_REMEZ_H
-#define INCLUDED_ALG_REMEZ_H
-
-#include <stddef.h>
-#include <Grid/GridStd.h>
-
-#ifdef HAVE_LIBGMP
-#include "bigfloat.h"
-#else
-#include "bigfloat_double.h"
-#endif
-
-#define JMAX 10000 //Maximum number of iterations of Newton's approximation
-#define SUM_MAX 10 // Maximum number of terms in exponential
-
-/*
- *Usage examples
-  AlgRemez remez(lambda_low,lambda_high,precision);
-  error = remez.generateApprox(n,d,y,z);
-  remez.getPFE(res,pole,&norm);
-  remez.getIPFE(res,pole,&norm);
-  remez.csv(ostream &os);
- */
-
-class AlgRemez
-{
- private:
-  char *cname;
-
-  // The approximation parameters
-  bigfloat *param, *roots, *poles;
-  bigfloat norm;
-
-  // The numerator and denominator degree (n=d)
-  int n, d;
-  
-  // The bounds of the approximation
-  bigfloat apstrt, apwidt, apend;
-
-  // the numerator and denominator of the power we are approximating
-  unsigned long power_num; 
-  unsigned long power_den;
-
-  // Flag to determine whether the arrays have been allocated
-  int alloc;
-
-  // Flag to determine whether the roots have been found
-  int foundRoots;
-
-  // Variables used to calculate the approximation
-  int nd1, iter;
-  bigfloat *xx, *mm, *step;
-  bigfloat delta, spread, tolerance;
-
-  // The exponential summation coefficients
-  bigfloat *a;
-  int *a_power;
-  int a_length;
-
-  // The number of equations we must solve at each iteration (n+d+1)
-  int neq;
-
-  // The precision of the GNU MP library
-  long prec;
-
-  // Initial values of maximal and minmal errors
-  void initialGuess();
-
-  // Solve the equations
-  void equations();
-
-  // Search for error maxima and minima
-  void search(bigfloat *step); 
-
-  // Initialise step sizes
-  void stpini(bigfloat *step);
-
-  // Calculate the roots of the approximation
-  int root();
-
-  // Evaluate the polynomial
-  bigfloat polyEval(bigfloat x, bigfloat *poly, long size);
-  //complex_bf polyEval(complex_bf x, complex_bf *poly, long size);
-
-  // Evaluate the differential of the polynomial
-  bigfloat polyDiff(bigfloat x, bigfloat *poly, long size);
-  //complex_bf polyDiff(complex_bf x, complex_bf *poly, long size);
-
-  // Newton's method to calculate roots
-  bigfloat rtnewt(bigfloat *poly, long i, bigfloat x1, bigfloat x2, bigfloat xacc);
-  //complex_bf rtnewt(complex_bf *poly, long i, bigfloat x1, bigfloat x2, bigfloat xacc);
-
-  // Evaluate the partial fraction expansion of the rational function
-  // with res roots and poles poles.  Result is overwritten on input
-  // arrays.
-  void pfe(bigfloat *res, bigfloat* poles, bigfloat norm);
-
-  // Calculate function required for the approximation
-  bigfloat func(bigfloat x);
-
-  // Compute size and sign of the approximation error at x
-  bigfloat getErr(bigfloat x, int *sign);
-
-  // Solve the system AX=B
-  int simq(bigfloat *A, bigfloat *B, bigfloat *X, int n);
-
-  // Free memory and reallocate as necessary
-  void allocate(int num_degree, int den_degree);
-
-  // Evaluate the rational form P(x)/Q(x) using coefficients from the
-  // solution vector param
-  bigfloat approx(bigfloat x);
-
- public:
-  
-  // Constructor
-  AlgRemez(double lower, double upper, long prec);
-
-  // Destructor
-  virtual ~AlgRemez();
-
-  int getDegree(void){ 
-    GRID_ASSERT(n==d);
-    return n;
-  }
-  // Reset the bounds of the approximation
-  void setBounds(double lower, double upper);
-  // Reset the bounds of the approximation
-  void getBounds(double &lower, double &upper) { 
-    lower=(double)apstrt;
-    upper=(double)apend;
-  }
-
-  // Generate the rational approximation x^(pnum/pden)
-  double generateApprox(int num_degree, int den_degree, 
-			unsigned long power_num, unsigned long power_den, 
-			int a_len, double* a_param, int* a_pow);
-  double generateApprox(int num_degree, int den_degree, 
-			unsigned long power_num, unsigned long power_den);
-  double generateApprox(int degree, unsigned long power_num, 
-			unsigned long power_den);
-
-  // Return the partial fraction expansion of the approximation x^(pnum/pden)
-  int getPFE(double *res, double *pole, double *norm);
-
-  // Return the partial fraction expansion of the approximation x^(-pnum/pden)
-  int getIPFE(double *res, double *pole, double *norm);
-
-  // Evaluate the rational form P(x)/Q(x) using coefficients from the
-  // solution vector param
-  double evaluateApprox(double x);
-
-  // Evaluate the rational form Q(x)/P(x) using coefficients from the
-  // solution vector param
-  double evaluateInverseApprox(double x);
-
-  // Calculate function required for the approximation
-  double evaluateFunc(double x);
-
-  // Calculate inverse function required for the approximation
-  double evaluateInverseFunc(double x);
-  
-  // Dump csv of function, approx and error
-  void csv(std::ostream &os);
-};
-
-#endif  // Include guard
-
-
-

Grid/algorithms/approx/RemezGeneral.cc

@@ -1,473 +0,0 @@
-#include<math.h>
-#include<stdio.h>
-#include<stdlib.h>
-#include<string>
-#include<iostream>
-#include<iomanip>
-#include<cassert>
-
-#include<Grid/algorithms/approx/RemezGeneral.h>
-
-
-// Constructor
-AlgRemezGeneral::AlgRemezGeneral(double lower, double upper, long precision,
-				 bigfloat (*f)(bigfloat x, void *data), void *data): f(f), 
-										     data(data), 
-										     prec(precision),
-										     apstrt(lower), apend(upper), apwidt(upper - lower),
-										     n(0), d(0), pow_n(0), pow_d(0)
-{
-  bigfloat::setDefaultPrecision(prec);
-
-  std::cout<<"Approximation bounds are ["<<apstrt<<","<<apend<<"]\n";
-  std::cout<<"Precision of arithmetic is "<<precision<<std::endl;
-}
-
-//Determine the properties of the numerator and denominator polynomials
-void AlgRemezGeneral::setupPolyProperties(int num_degree, int den_degree, PolyType num_type_in, PolyType den_type_in){
-  pow_n = num_degree;
-  pow_d = den_degree;
-
-  if(pow_n % 2 == 0 && num_type_in == PolyType::Odd) GRID_ASSERT(0);
-  if(pow_n % 2 == 1 && num_type_in == PolyType::Even) GRID_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);
-
-  num_type = num_type_in;
-  den_type = den_type_in;
-
-  num_pows.resize(pow_n+1);
-  den_pows.resize(pow_d+1);
-
-  int n_in = 0;
-  bool odd = num_type == PolyType::Full || num_type == PolyType::Odd;
-  bool even = num_type == PolyType::Full || num_type == PolyType::Even;
-  for(int i=0;i<=pow_n;i++){
-    num_pows[i] = -1;
-    if(i % 2 == 0 && even) num_pows[i] = n_in++;
-    if(i % 2 == 1 && odd) num_pows[i] = n_in++;
-  }
-
-  std::cout << n_in << " terms in numerator" << std::endl;
-  --n_in; //power is 1 less than the number of terms, eg  pow=1   a x^1  + b x^0
-
-  int d_in = 0;
-  odd = den_type == PolyType::Full || den_type == PolyType::Odd;
-  even = den_type == PolyType::Full || den_type == PolyType::Even;
-  for(int i=0;i<=pow_d;i++){
-    den_pows[i] = -1;
-    if(i % 2 == 0 && even) den_pows[i] = d_in++;
-    if(i % 2 == 1 && odd) den_pows[i] = d_in++;
-  }
-
-  std::cout << d_in << " terms in denominator" << std::endl;
-  --d_in;
-
-  n = n_in;
-  d = d_in;
-}
-
-//Setup algorithm
-void AlgRemezGeneral::reinitializeAlgorithm(){
-  spread = 1.0e37;
-  iter = 0;
-
-  neq = n + d + 1; //not +2 because highest-power term in denominator is fixed to 1
-
-  param.resize(neq);
-  yy.resize(neq+1);
-
-  //Initialize linear equation temporaries
-  A.resize(neq*neq);
-  B.resize(neq);
-  IPS.resize(neq);
-
-  //Initialize maximum and minimum errors
-  xx.resize(neq+2);
-  mm.resize(neq+1);
-  initialGuess();
-
-  //Initialize search steps
-  step.resize(neq+1);
-  stpini();
-}
-
-double AlgRemezGeneral::generateApprox(const int num_degree, const int den_degree, 
-				       const PolyType num_type_in, const PolyType den_type_in, 
-				       const double _tolerance, const int report_freq){
-  //Setup the properties of the polynomial
-  setupPolyProperties(num_degree, den_degree, num_type_in, den_type_in);
-
-  //Setup the algorithm
-  reinitializeAlgorithm();
-
-  bigfloat tolerance = _tolerance;
-
-  //Iterate until convergance
-  while (spread > tolerance) { 
-    if (iter++ % report_freq==0)
-      std::cout<<"Iteration " <<iter-1<<" spread "<<(double)spread<<" delta "<<(double)delta << std::endl; 
-
-    equations();
-    if (delta < tolerance) {
-      std::cout<<"Iteration " << iter-1 << " delta too small (" << delta << "<" << tolerance << "), try increasing precision\n";
-      GRID_ASSERT(0);
-    };    
-    GRID_ASSERT( delta>= tolerance );
-
-    search();
-  }
-
-  int sign;
-  double error = (double)getErr(mm[0],&sign);
-  std::cout<<"Converged at "<<iter<<" iterations; error = "<<error<<std::endl;
-
-  // Return the maximum error in the approximation
-  return error;
-}
-
-
-// Initial values of maximal and minimal errors
-void AlgRemezGeneral::initialGuess(){
-  // Supply initial guesses for solution points
-  long ncheb = neq;			// Degree of Chebyshev error estimate
-
-  // Find ncheb+1 extrema of Chebyshev polynomial
-  bigfloat a = ncheb;
-  bigfloat r;
-
-  mm[0] = apstrt;
-  for (long i = 1; i < ncheb; i++) {
-    r = 0.5 * (1 - cos((M_PI * i)/(double) a));
-    //r *= sqrt_bf(r);
-    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
-    mm[i] = apstrt + r * apwidt;
-  }
-  mm[ncheb] = apend;
-
-  a = 2.0 * ncheb;
-  for (long i = 0; i <= ncheb; i++) {
-    r = 0.5 * (1 - cos(M_PI * (2*i+1)/(double) a));
-    //r *= sqrt_bf(r); // Squeeze to low end of interval
-    r = (exp((double)r)-1.0)/(exp(1.0)-1.0);
-    xx[i] = apstrt + r * apwidt;
-  }
-}
-
-// Initialise step sizes
-void AlgRemezGeneral::stpini(){
-  xx[neq+1] = apend;
-  delta = 0.25;
-  step[0] = xx[0] - apstrt;
-  for (int i = 1; i < neq; i++) step[i] = xx[i] - xx[i-1];
-  step[neq] = step[neq-1];
-}
-
-// Search for error maxima and minima
-void AlgRemezGeneral::search(){
-  bigfloat a, q, xm, ym, xn, yn, xx1;
-  int emsign, ensign, steps;
-
-  int meq = neq + 1;
-
-  bigfloat eclose = 1.0e30;
-  bigfloat farther = 0l;
-
-  bigfloat xx0 = apstrt;
-
-  for (int i = 0; i < meq; i++) {
-    steps = 0;
-    xx1 = xx[i]; // Next zero
-    if (i == meq-1) xx1 = apend;
-    xm = mm[i];
-    ym = getErr(xm,&emsign);
-    q = step[i];
-    xn = xm + q;
-    if (xn < xx0 || xn >= xx1) {	// Cannot skip over adjacent boundaries
-      q = -q;
-      xn = xm;
-      yn = ym;
-      ensign = emsign;
-    } else {
-      yn = getErr(xn,&ensign);
-      if (yn < ym) {
-	q = -q;
-	xn = xm;
-	yn = ym;
-	ensign = emsign;
-      }
-    }
-  
-    while(yn >= ym) {		// March until error becomes smaller.
-      if (++steps > 10)
-      	break;
-      
-      ym = yn;
-      xm = xn;
-      emsign = ensign;
-      a = xm + q;
-      if (a == xm || a <= xx0 || a >= xx1)
-	break;// Must not skip over the zeros either side.      
-
-      xn = a;
-      yn = getErr(xn,&ensign);
-    }
-
-    mm[i] = xm;			// Position of maximum
-    yy[i] = ym;			// Value of maximum
-
-    if (eclose > ym) eclose = ym;
-    if (farther < ym) farther = ym;
-
-    xx0 = xx1; // Walk to next zero.
-  } // end of search loop
-
-  q = (farther - eclose);	// Decrease step size if error spread increased
-
-  if (eclose != 0.0) q /= eclose; // Relative error spread
-
-  if (q >= spread)
-    delta *= 0.5; // Spread is increasing; decrease step size
-  
-  spread = q;
-
-  for (int i = 0; i < neq; i++) {
-    q = yy[i+1];
-    if (q != 0.0) q = yy[i] / q  - (bigfloat)1l;
-    else q = 0.0625;
-    if (q > (bigfloat)0.25) q = 0.25;
-    q *= mm[i+1] - mm[i];
-    step[i] = q * delta;
-  }
-  step[neq] = step[neq-1];
-  
-  for (int i = 0; i < neq; i++) {	// Insert new locations for the zeros.
-    xm = xx[i] - step[i];
-
-    if (xm <= apstrt)
-      continue;
-
-    if (xm >= apend)
-      continue;
-
-    if (xm <= mm[i])
-      xm = (bigfloat)0.5 * (mm[i] + xx[i]);    
-
-    if (xm >= mm[i+1])
-      xm = (bigfloat)0.5 * (mm[i+1] + xx[i]);
-    
-    xx[i] = xm;
-  }
-}
-
-// Solve the equations
-void AlgRemezGeneral::equations(){
-  bigfloat x, y, z;
-  bigfloat *aa;
-  
-  for (int i = 0; i < neq; i++) {	// set up the equations for solution by simq()
-    int ip = neq * i;		// offset to 1st element of this row of matrix
-    x = xx[i];			// the guess for this row
-    y = func(x);		// right-hand-side vector
-
-    z = (bigfloat)1l;
-    aa = A.data()+ip;
-    int t = 0;
-    for (int j = 0; j <= pow_n; j++) {
-      if(num_pows[j] != -1){ *aa++ = z; t++; }
-      z *= x;
-    }
-    GRID_ASSERT(t == n+1);
-
-    z = (bigfloat)1l;
-    t = 0;
-    for (int j = 0; j < pow_d; j++) {
-      if(den_pows[j] != -1){ *aa++ = -y * z; t++; }
-      z *= x;
-    }
-    GRID_ASSERT(t == d);
-
-    B[i] = y * z;		// Right hand side vector
-  }
-
-  // Solve the simultaneous linear equations.
-  if (simq()){
-    std::cout<<"simq failed\n";
-    exit(0);
-  }
-}
-
-
-// Evaluate the rational form P(x)/Q(x) using coefficients
-// from the solution vector param
-bigfloat AlgRemezGeneral::approx(const bigfloat x) const{
-  // Work backwards toward the constant term.
-  int c = n;
-  bigfloat yn = param[c--];		// Highest order numerator coefficient
-  for (int i = pow_n-1; i >= 0; i--) yn = x * yn  +  (num_pows[i] != -1 ? param[c--] : bigfloat(0l));  
-
-  c = n+d;
-  bigfloat yd = 1l; //Highest degree coefficient is 1.0
-  for (int i = pow_d-1; i >= 0; i--) yd = x * yd  +  (den_pows[i] != -1 ? param[c--] : bigfloat(0l)); 
-
-  return(yn/yd);
-}
-
-// Compute size and sign of the approximation error at x
-bigfloat AlgRemezGeneral::getErr(bigfloat x, int *sign) const{
-  bigfloat f = func(x);
-  bigfloat e = approx(x) - f;
-  if (f != 0) e /= f;
-  if (e < (bigfloat)0.0) {
-    *sign = -1;
-    e = -e;
-  }
-  else *sign = 1;
-  
-  return(e);
-}
-
-// Solve the system AX=B
-int AlgRemezGeneral::simq(){
-
-  int ip, ipj, ipk, ipn;
-  int idxpiv;
-  int kp, kp1, kpk, kpn;
-  int nip, nkp;
-  bigfloat em, q, rownrm, big, size, pivot, sum;
-  bigfloat *aa;
-  bigfloat *X = param.data();
-
-  int n = neq;
-  int nm1 = n - 1;
-  // Initialize IPS and X
-  
-  int ij = 0;
-  for (int i = 0; i < n; i++) {
-    IPS[i] = i;
-    rownrm = 0.0;
-    for(int j = 0; j < n; j++) {
-      q = abs_bf(A[ij]);
-      if(rownrm < q) rownrm = q;
-      ++ij;
-    }
-    if (rownrm == (bigfloat)0l) {
-      std::cout<<"simq rownrm=0\n";
-      return(1);
-    }
-    X[i] = (bigfloat)1.0 / rownrm;
-  }
-  
-  for (int k = 0; k < nm1; k++) {
-    big = 0.0;
-    idxpiv = 0;
-    
-    for (int i = k; i < n; i++) {
-      ip = IPS[i];
-      ipk = n*ip + k;
-      size = abs_bf(A[ipk]) * X[ip];
-      if (size > big) {
-	big = size;
-	idxpiv = i;
-      }
-    }
-    
-    if (big == (bigfloat)0l) {
-      std::cout<<"simq big=0\n";
-      return(2);
-    }
-    if (idxpiv != k) {
-      int j = IPS[k];
-      IPS[k] = IPS[idxpiv];
-      IPS[idxpiv] = j;
-    }
-    kp = IPS[k];
-    kpk = n*kp + k;
-    pivot = A[kpk];
-    kp1 = k+1;
-    for (int i = kp1; i < n; i++) {
-      ip = IPS[i];
-      ipk = n*ip + k;
-      em = -A[ipk] / pivot;
-      A[ipk] = -em;
-      nip = n*ip;
-      nkp = n*kp;
-      aa = A.data()+nkp+kp1;
-      for (int j = kp1; j < n; j++) {
-	ipj = nip + j;
-	A[ipj] = A[ipj] + em * *aa++;
-      }
-    }
-  }
-  kpn = n * IPS[n-1] + n - 1;	// last element of IPS[n] th row
-  if (A[kpn] == (bigfloat)0l) {
-    std::cout<<"simq A[kpn]=0\n";
-    return(3);
-  }
-
-  
-  ip = IPS[0];
-  X[0] = B[ip];
-  for (int i = 1; i < n; i++) {
-    ip = IPS[i];
-    ipj = n * ip;
-    sum = 0.0;
-    for (int j = 0; j < i; j++) {
-      sum += A[ipj] * X[j];
-      ++ipj;
-    }
-    X[i] = B[ip] - sum;
-  }
-  
-  ipn = n * IPS[n-1] + n - 1;
-  X[n-1] = X[n-1] / A[ipn];
-  
-  for (int iback = 1; iback < n; iback++) {
-    //i goes (n-1),...,1
-    int i = nm1 - iback;
-    ip = IPS[i];
-    nip = n*ip;
-    sum = 0.0;
-    aa = A.data()+nip+i+1;
-    for (int j= i + 1; j < n; j++) 
-      sum += *aa++ * X[j];
-    X[i] = (X[i] - sum) / A[nip+i];
-  }
-  
-  return(0);
-}
-
-void AlgRemezGeneral::csv(std::ostream & os) const{
-  os << "Numerator" << std::endl;
-  for(int i=0;i<=pow_n;i++){
-    os << getCoeffNum(i) << "*x^" << i;
-    if(i!=pow_n) os << " + ";
-  }
-  os << std::endl;
-
-  os << "Denominator" << std::endl;
-  for(int i=0;i<=pow_d;i++){
-    os << getCoeffDen(i) << "*x^" << i;
-    if(i!=pow_d) os << " + ";
-  }
-  os << std::endl;
-
-  //For a true minimax solution the errors should all be equal and the signs should oscillate +-+-+- etc
-  int sign;
-  os << "Errors at maxima: coordinate, error, (sign)" << std::endl;
-  for(int i=0;i<neq+1;i++){ 
-    os << mm[i] << " " << getErr(mm[i],&sign) << " (" << sign << ")" << std::endl;
-  }
-
-  os << "Scan over range:" << std::endl;
-  int npt = 60;
-  bigfloat dlt = (apend - apstrt)/bigfloat(npt-1);
-
-  for (bigfloat x=apstrt; x<=apend; x = x + dlt) {
-    double f = evaluateFunc(x);
-    double r = evaluateApprox(x);
-    os<< x<<","<<r<<","<<f<<","<<r-f<<std::endl;
-  }
-  return;
-}

Grid/algorithms/approx/RemezGeneral.h

@@ -1,170 +0,0 @@
-/*
-  C.Kelly Jan 2020 based on implementation by M. Clark May 2005
-
-  AlgRemezGeneral is an implementation of the Remez algorithm for approximating an arbitrary function by a rational polynomial 
-  It includes optional restriction to odd/even polynomials for the numerator and/or denominator
-*/
-
-#ifndef INCLUDED_ALG_REMEZ_GENERAL_H
-#define INCLUDED_ALG_REMEZ_GENERAL_H
-
-#include <stddef.h>
-#include <Grid/GridStd.h>
-
-#ifdef HAVE_LIBGMP
-#include "bigfloat.h"
-#else
-#include "bigfloat_double.h"
-#endif
-
-
-class AlgRemezGeneral{
- public:
-  enum PolyType { Even, Odd, Full };
-
- private:
-
-  // In GSL-style, pass the function as a function pointer. Any data required to evaluate the function is passed in as a void pointer
-  bigfloat (*f)(bigfloat x, void *data);
-  void *data;
-
-  // The approximation parameters
-  std::vector<bigfloat> param;
-  bigfloat norm;
-
-  // The number of non-zero terms in the numerator and denominator
-  int n, d;
-  // The numerator and denominator degree (i.e.  the largest power)
-  int pow_n, pow_d;
-  
-  // Specify if the numerator and/or denominator are odd/even polynomials
-  PolyType num_type;
-  PolyType den_type;
-  std::vector<int> num_pows; //contains the mapping, with -1 if not present
-  std::vector<int> den_pows;
-
-  // The bounds of the approximation
-  bigfloat apstrt, apwidt, apend;
-
-  // Variables used to calculate the approximation
-  int nd1, iter;
-  std::vector<bigfloat> xx;
-  std::vector<bigfloat> mm;
-  std::vector<bigfloat> step;
-
-  bigfloat delta, spread;
-  
-  // Variables used in search
-  std::vector<bigfloat> yy;
-
-  // Variables used in solving linear equations
-  std::vector<bigfloat> A;
-  std::vector<bigfloat> B;
-  std::vector<int> IPS;
-
-  // The number of equations we must solve at each iteration (n+d+1)
-  int neq;
-
-  // The precision of the GNU MP library
-  long prec;
-
-  // Initialize member variables associated with the polynomial's properties
-  void setupPolyProperties(int num_degree, int den_degree, PolyType num_type_in, PolyType den_type_in);
-
-  // Initial values of maximal and minmal errors
-  void initialGuess();
-
-  // Initialise step sizes
-  void stpini();
-
-  // Initialize the algorithm
-  void reinitializeAlgorithm();
-
-  // Solve the equations
-  void equations();
-
-  // Search for error maxima and minima
-  void search(); 
-
-  // Calculate function required for the approximation
-  inline bigfloat func(bigfloat x) const{
-    return f(x, data);
-  }
-
-  // Compute size and sign of the approximation error at x
-  bigfloat getErr(bigfloat x, int *sign) const;
-
-  // Solve the system AX=B   where X = param
-  int simq();
-
-  // Evaluate the rational form P(x)/Q(x) using coefficients from the solution vector param
-  bigfloat approx(bigfloat x) const;
-
- public:
-  
-  AlgRemezGeneral(double lower, double upper, long prec,
-		  bigfloat (*f)(bigfloat x, void *data), void *data);
-
-  inline int getDegree(void) const{ 
-    GRID_ASSERT(n==d);
-    return n;
-  }
-  // Reset the bounds of the approximation
-  inline void setBounds(double lower, double upper) {
-    apstrt = lower;
-    apend = upper;
-    apwidt = apend - apstrt;
-  }
-
-  // Get the bounds of the approximation
-  inline void getBounds(double &lower, double &upper) const{ 
-    lower=(double)apstrt;
-    upper=(double)apend;
-  }
-
-  // Run the algorithm to generate the rational approximation
-  double generateApprox(int num_degree, int den_degree, 
-			PolyType num_type, PolyType den_type,
-			const double tolerance = 1e-15, const int report_freq = 1000);
-  
-  inline double generateApprox(int num_degree, int den_degree, 
-			       const double tolerance = 1e-15, const int report_freq = 1000){
-    return generateApprox(num_degree, den_degree, Full, Full, tolerance, report_freq);
-  }
-  
-  // Evaluate the rational form P(x)/Q(x) using coefficients from the
-  // solution vector param
-  inline double evaluateApprox(double x) const{
-    return (double)approx((bigfloat)x);
-  }
-
-  // Evaluate the rational form Q(x)/P(x) using coefficients from the solution vector param
-  inline double evaluateInverseApprox(double x) const{
-    return 1.0/(double)approx((bigfloat)x);
-  }  
-
-  // Calculate function required for the approximation
-  inline double evaluateFunc(double x) const{
-    return (double)func((bigfloat)x);
-  }
-
-  // Calculate inverse function required for the approximation
-  inline double evaluateInverseFunc(double x) const{
-    return 1.0/(double)func((bigfloat)x);
-  }
-
-  // Dump csv of function, approx and error
-  void csv(std::ostream &os = std::cout) const;
-
-  // Get the coefficient of the term x^i in the numerator
-  inline double getCoeffNum(const int i) const{    
-    return num_pows[i] == -1 ? 0. : double(param[num_pows[i]]);
-  }
-  // Get the coefficient of the term x^i in the denominator
-  inline double getCoeffDen(const int i) const{ 
-    if(i == pow_d) return 1.0;
-    else return den_pows[i] == -1 ? 0. : double(param[den_pows[i]+n+1]); 
-  }
-};
-
-#endif

Grid/algorithms/approx/ZMobius.cc

@@ -1,183 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/ZMobius.cc
-
-    Copyright (C) 2015
-
-Author: Christopher Kelly <ckelly@phys.columbia.edu>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Grid/algorithms/approx/ZMobius.h>
-#include <Grid/algorithms/approx/RemezGeneral.h>
-
-NAMESPACE_BEGIN(Grid);
-NAMESPACE_BEGIN(Approx);
-
-//Compute the tanh approximation
-inline double epsilonMobius(const double x, const std::vector<ComplexD> &w){
-  int Ls = w.size();
-
-  ComplexD fxp = 1., fmp = 1.;
-  for(int i=0;i<Ls;i++){
-    fxp = fxp * ( w[i] + x );
-    fmp = fmp * ( w[i] - x );
-  }
-  return ((fxp - fmp)/(fxp + fmp)).real();
-}
-inline double epsilonMobius(const double x, const std::vector<RealD> &w){
-  int Ls = w.size();
-
-  double fxp = 1., fmp = 1.;
-  for(int i=0;i<Ls;i++){
-    fxp = fxp * ( w[i] + x );
-    fmp = fmp * ( w[i] - x );
-  }
-  return (fxp - fmp)/(fxp + fmp);
-}
-
-
-
-//Compute the tanh approximation in a form suitable for the Remez
-bigfloat epsilonMobius(bigfloat x, void* data){
-  const std::vector<RealD> &omega = *( (std::vector<RealD> const*)data );
-  bigfloat fxp(1.0);
-  bigfloat fmp(1.0);
-
-  for(int i=0;i<omega.size();i++){
-    fxp = fxp * ( bigfloat(omega[i]) + x);
-    fmp = fmp * ( bigfloat(omega[i]) - x);
-  }
-  return (fxp - fmp)/(fxp + fmp);
-}
-
-//Compute the Zmobius Omega parameters suitable for eigenvalue range   -lambda_bound <= lambda <= lambda_bound
-//Note omega_i = 1/(b_i + c_i)   where b_i and c_i are the Mobius parameters
-void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out,
-			 const std::vector<RealD> &omega_in, const int Ls_in,
-			 const RealD lambda_bound){
-  GRID_ASSERT(omega_in.size() == Ls_in);
-  omega_out.resize(Ls_out);
-
-  //Use the Remez algorithm to generate the appropriate rational polynomial
-  //For odd polynomial, to satisfy Haar condition must take either positive or negative half of range (cf https://arxiv.org/pdf/0803.0439.pdf page 6)  
-  AlgRemezGeneral remez(0, lambda_bound, 64, &epsilonMobius, (void*)&omega_in); 
-  remez.generateApprox(Ls_out-1, Ls_out,AlgRemezGeneral::Odd, AlgRemezGeneral::Even, 1e-15, 100);
-  remez.csv(std::cout);
-
-  //The rational approximation has the form  [ f(x) - f(-x) ] / [ f(x) + f(-x) ]  where  f(x) = \Prod_{i=0}^{L_s-1} ( \omega_i + x )
-  //cf https://academiccommons.columbia.edu/doi/10.7916/D8T72HD7  pg 102
-  //omega_i are therefore the negative of the complex roots of f(x)
-
-  //We can find the roots by recognizing that the eigenvalues of a matrix A are the roots of the characteristic polynomial
-  // \rho(\lambda) = det( A - \lambda I )    where I is the unit matrix
-  //The matrix whose characteristic polynomial is an arbitrary monic polynomial a0 + a1 x + a2 x^2 + ... x^n   is the companion matrix 
-  // A = | 0    1   0    0 0 .... 0 |
-  //     | 0    0   1    0 0 .... 0 |
-  //     | :    :   :    : :      : |
-  //     | 0    0   0    0 0      1
-  //     | -a0 -a1 -a2  ...  ... -an|
-
-
-  //Note the Remez defines the largest power to have unit coefficient
-  std::vector<RealD> coeffs(Ls_out+1);
-  for(int i=0;i<Ls_out+1;i+=2) coeffs[i] = coeffs[i] = remez.getCoeffDen(i); //even powers
-  for(int i=1;i<Ls_out+1;i+=2) coeffs[i] = coeffs[i] = remez.getCoeffNum(i); //odd powers
-
-  std::vector<std::complex<RealD> > roots(Ls_out);
-
-  //Form the companion matrix
-  Eigen::MatrixXd compn(Ls_out,Ls_out);
-  for(int i=0;i<Ls_out-1;i++) compn(i,0) = 0.;
-  compn(Ls_out - 1, 0) = -coeffs[0];
-  
-  for(int j=1;j<Ls_out;j++){
-    for(int i=0;i<Ls_out-1;i++) compn(i,j) = i == j-1 ? 1. : 0.;
-    compn(Ls_out - 1, j) = -coeffs[j];
-  }
-
-  //Eigensolve
-  Eigen::EigenSolver<Eigen::MatrixXd> slv(compn, false);
-
-  const auto & ev = slv.eigenvalues();
-  for(int i=0;i<Ls_out;i++)
-    omega_out[i] = -ev(i);
-
-  //Sort ascending (smallest at start of vector!)
-  std::sort(omega_out.begin(), omega_out.end(), 
-	    [&](const ComplexD &a, const ComplexD &b){ return a.real() < b.real() || (a.real() == b.real() && a.imag() < b.imag()); });
-
-  //McGlynn thesis pg 122 suggest improved iteration counts if magnitude of omega diminishes towards the center of the 5th dimension
-  std::vector<ComplexD> omega_tmp = omega_out;
-  int s_low=0, s_high=Ls_out-1, ss=0;
-  for(int s_from = Ls_out-1; s_from >= 0; s_from--){ //loop from largest omega
-    int s_to;
-    if(ss % 2 == 0){
-      s_to = s_low++;
-    }else{
-      s_to = s_high--;
-    }
-    omega_out[s_to] = omega_tmp[s_from];
-    ++ss;
-  }
-  
-  std::cout << "Resulting omega_i:" << std::endl;  
-  for(int i=0;i<Ls_out;i++)
-    std::cout << omega_out[i] << std::endl;
-
-  std::cout << "Test result matches the approximate polynomial found by the Remez" << std::endl;
-  std::cout << "<x> <remez approx> <poly approx> <diff poly approx remez approx> <exact> <diff poly approx exact>\n";
-  
-  int npt = 60;
-  double dlt = lambda_bound/double(npt-1);
-
-  for (int i =0; i<npt; i++){
-    double x = i*dlt;
-    double r = remez.evaluateApprox(x);
-    double p = epsilonMobius(x, omega_out);
-    double e = epsilonMobius(x, omega_in);
-
-    std::cout << x<< " " << r << " " << p <<" " <<r-p << " " << e << " " << e-p << std::endl;
-  }
-
-}
-  
-//mobius_param = b+c   with b-c=1
-void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound){
-  std::vector<RealD> omega_in(Ls_in, 1./mobius_param);
-  computeZmobiusOmega(omega_out, Ls_out, omega_in, Ls_in, lambda_bound);
-}
-
-//ZMobius class takes  gamma_i = (b+c) omega_i as its input, where b, c are factored out
-void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, 
-			 const RealD mobius_param_out, const int Ls_out, 
-			 const RealD mobius_param_in, const int Ls_in,
-			 const RealD lambda_bound){
-  computeZmobiusOmega(gamma_out, Ls_out, mobius_param_in, Ls_in, lambda_bound);
-  for(int i=0;i<Ls_out;i++) gamma_out[i] = gamma_out[i] * mobius_param_out;
-}
-//Assumes mobius_param_out == mobius_param_in
-void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound){
-  computeZmobiusGamma(gamma_out, mobius_param, Ls_out, mobius_param, Ls_in, lambda_bound);
-}
-
-NAMESPACE_END(Approx);
-NAMESPACE_END(Grid);

Grid/algorithms/approx/ZMobius.h

@@ -1,57 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/ZMobius.h
-
-    Copyright (C) 2015
-
-Author: Christopher Kelly <ckelly@phys.columbia.edu>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_ZMOBIUS_APPROX_H
-#define GRID_ZMOBIUS_APPROX_H
-
-#include <Grid/GridCore.h>
-
-NAMESPACE_BEGIN(Grid);
-NAMESPACE_BEGIN(Approx);
-
-//Compute the Zmobius Omega parameters suitable for eigenvalue range   -lambda_bound <= lambda <= lambda_bound
-//Note omega_i = 1/(b_i + c_i)   where b_i and c_i are the Mobius parameters
-void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out,
-			 const std::vector<RealD> &omega_in, const int Ls_in,
-			 const RealD lambda_bound);
-  
-//mobius_param = b+c   with b-c=1
-void computeZmobiusOmega(std::vector<ComplexD> &omega_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound);
-
-//ZMobius class takes  gamma_i = (b+c) omega_i as its input, where b, c are factored out
-void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, 
-			 const RealD mobius_param_out, const int Ls_out, 
-			 const RealD mobius_param_in, const int Ls_in,
-			 const RealD lambda_bound);
-
-//Assumes mobius_param_out == mobius_param_in
-void computeZmobiusGamma(std::vector<ComplexD> &gamma_out, const int Ls_out, const RealD mobius_param, const int Ls_in, const RealD lambda_bound);
-
-NAMESPACE_END(Approx);
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/approx/Zolotarev.cc

@@ -1,730 +0,0 @@
-/* -*- Mode: C; comment-column: 22; fill-column: 79; compile-command: "gcc -o zolotarev zolotarev.c -ansi -pedantic -lm -DTEST"; -*- */
-#define VERSION Source Time-stamp: <2015-05-18 16:32:08 neo>
-
-/* These C routines evalute the optimal rational approximation to the signum
- * function for epsilon < |x| < 1 using Zolotarev's theorem.
- *
- * To obtain reliable results for high degree approximations (large n) it is
- * necessary to compute using sufficiently high precision arithmetic. To this
- * end the code has been parameterised to work with the preprocessor names
- * INTERNAL_PRECISION and PRECISION set to float, double, or long double as
- * appropriate. INTERNAL_PRECISION is used in computing the Zolotarev
- * coefficients, which are converted to PRECISION before being returned to the
- * caller. Presumably even higher precision could be obtained using GMP or
- * similar package, but bear in mind that rounding errors might also be
- * significant in evaluating the resulting polynomial. The convergence criteria
- * have been written in a precision-independent form. */
-
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#define MAX(a,b) ((a) > (b) ? (a) : (b))
-#define MIN(a,b) ((a) < (b) ? (a) : (b))
-
-#ifndef INTERNAL_PRECISION
-#define INTERNAL_PRECISION double
-#endif
-
-#include "Zolotarev.h"
-#define ZOLOTAREV_INTERNAL
-#undef ZOLOTAREV_DATA
-#define ZOLOTAREV_DATA izd
-#undef ZPRECISION
-#define ZPRECISION INTERNAL_PRECISION
-#include "Zolotarev.h"
-#undef ZOLOTAREV_INTERNAL
-
-/* The ANSI standard appears not to know what pi is */
-
-#ifndef M_PI
-#define M_PI ((INTERNAL_PRECISION) 3.141592653589793238462643383279502884197\
-169399375105820974944592307816406286208998628034825342117068)
-#endif
-
-#define ZERO ((INTERNAL_PRECISION) 0)
-#define ONE ((INTERNAL_PRECISION) 1)
-#define TWO ((INTERNAL_PRECISION) 2)
-#define THREE ((INTERNAL_PRECISION) 3)
-#define FOUR ((INTERNAL_PRECISION) 4)
-#define HALF (ONE/TWO)
-
-/* The following obscenity seems to be the simplest (?) way to coerce the C
- * preprocessor to convert the value of a preprocessor token into a string. */
-
-#define PP2(x) #x
-#define PP1(a,b,c) a ## b(c)
-#define STRINGIFY(name) PP1(PP,2,name)
-
-/* Compute the partial fraction expansion coefficients (alpha) from the
- * factored form */
-NAMESPACE_BEGIN(Grid);
-NAMESPACE_BEGIN(Approx);
-
-static void construct_partfrac(izd *z) {
-  int dn = z -> dn, dd = z -> dd, type = z -> type;
-  int j, k, da = dd + 1 + type;
-  INTERNAL_PRECISION A = z -> A, *a = z -> a, *ap = z -> ap, *alpha;
-  alpha = (INTERNAL_PRECISION*) malloc(da * sizeof(INTERNAL_PRECISION));
-  for (j = 0; j < dd; j++)
-    for (k = 0, alpha[j] = A; k < dd; k++)
-      alpha[j] *=
-	(k < dn ? ap[j] - a[k] : ONE) / (k == j ? ONE : ap[j] - ap[k]);
-  if(type == 1)	      /* implicit pole at zero? */
-    for (k = 0, alpha[dd] = A * (dn > dd ? - a[dd] : ONE); k < dd; k++) {
-      alpha[dd] *= a[k] / ap[k];
-      alpha[k] *= (dn > dd ? ap[k] - a[dd] : ONE) / ap[k];
-    }
-  alpha[da-1] = dn == da - 1 ? A : ZERO;
-  z -> alpha = alpha;
-  z -> da = da;
-  return;
-}
-
-/* Convert factored polynomial into dense polynomial. The input is the overall
- * factor A and the roots a[i], such that p = A product(x - a[i], i = 1..d) */
-
-static INTERNAL_PRECISION *poly_factored_to_dense(INTERNAL_PRECISION A, 
-						  INTERNAL_PRECISION *a,
-						  int d) {
-  INTERNAL_PRECISION *p;
-  int i, j;
-  p = (INTERNAL_PRECISION *) malloc((d + 2) * sizeof(INTERNAL_PRECISION));
-  p[0] = A;
-  for (i = 0; i < d; i++) {
-    p[i+1] = p[i];
-    for (j = i; j > 0; j--) p[j] = p[j-1] - a[i]*p[j];
-    p[0] *= - a[i];
-  }
-  return p;
-}
-
-/* Convert a rational function of the form R0(x) = x p(x^2)/q(x^2) (type 0) or
- * R1(x) = p(x^2)/[x q(x^2)] (type 1) into its continued fraction
- * representation. We assume that 0 <= deg(q) - deg(p) <= 1 for type 0 and 0 <=
- * deg(p) - deg(q) <= 1 for type 1. On input p and q are in factored form, and
- * deg(q) = dq, deg(p) = dp.  The output is the continued fraction coefficients
- * beta, where R(x) = beta[0] x + 1/(beta[1] x + 1/(...)).
- *
- * The method used is as follows. There are four cases to consider:
- *
- * 0.i.  Type 0, deg p = deg q
- *
- * 0.ii. Type 0, deg p = deg q - 1
- *
- * 1.i.  Type 1, deg p = deg q
- *
- * 1.ii. Type 1, deg p = deg q + 1
- *
- * and these are connected by two transformations:
- *
- * A. To obtain a continued fraction expansion of type 1 we use a single-step
- * polynomial division we find beta and r(x) such that p(x) = beta x q(x) +
- * r(x), with deg(r) = deg(q). This implies that p(x^2) = beta x^2 q(x^2) +
- * r(x^2), and thus R1(x) = x beta + r(x^2)/(x q(x^2)) = x beta + 1/R0(x)
- * with R0(x) = x q(x^2)/r(x^2).
- *
- * B. A continued fraction expansion of type 0 is obtained in a similar, but
- * not identical, manner. We use the polynomial division algorithm to compute
- * the quotient beta and the remainder r that satisfy p(x) = beta q(x) + r(x)
- * with deg(r) = deg(q) - 1. We thus have x p(x^2) = x beta q(x^2) + x r(x^2),
- * so R0(x) = x beta + x r(x^2)/q(x^2) = x beta + 1/R1(x) with R1(x) = q(x^2) /
- * (x r(x^2)).
- *
- * Note that the deg(r) must be exactly deg(q) for (A) and deg(q) - 1 for (B)
- * because p and q have disjoint roots all of multiplicity 1. This means that
- * the division algorithm requires only a single polynomial subtraction step.
- *
- * The transformations between the cases form the following finite state
- * automaton:
- *
- * +------+            +------+            +------+            +------+
- * |      |            |      | ---(A)---> |      |            |      |
- * | 0.ii | ---(B)---> | 1.ii |            | 0.i  | <---(A)--- | 1.i  |
- * |      |            |      | <---(B)--- |      |            |      |
- * +------+            +------+            +------+            +------+
- */
-
-static INTERNAL_PRECISION *contfrac_A(INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *, int, int);
-
-static INTERNAL_PRECISION *contfrac_B(INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *,
-				      INTERNAL_PRECISION *, int, int);
-
-static void construct_contfrac(izd *z){
-  INTERNAL_PRECISION *r, A = z -> A, *p = z -> a, *q = z -> ap;
-  int dp = z -> dn, dq = z -> dd, type = z -> type;
-
-  z -> db = 2 * dq + 1 + type;
-  z -> beta = (INTERNAL_PRECISION *)
-    malloc(z -> db * sizeof(INTERNAL_PRECISION));
-  p = poly_factored_to_dense(A, p, dp);
-  q = poly_factored_to_dense(ONE, q, dq);
-  r = (INTERNAL_PRECISION *) malloc((MAX(dp,dq) + 1) *
-				    sizeof(INTERNAL_PRECISION));
-  if (type == 0) (void) contfrac_B(z -> beta, p, q, r, dp, dq);
-  else (void) contfrac_A(z -> beta, p, q, r, dp, dq);
-  free(p); free(q); free(r);
-  return;
-}
-
-static INTERNAL_PRECISION *contfrac_A(INTERNAL_PRECISION *beta,
-				      INTERNAL_PRECISION *p,
-				      INTERNAL_PRECISION *q,
-				      INTERNAL_PRECISION *r, int dp, int dq) {
-  INTERNAL_PRECISION quot, *rb;
-  int j;
-
-  /* p(x) = x beta q(x) + r(x); dp = dq or dp = dq + 1 */
-
-  quot = dp == dq ? ZERO : p[dp] / q[dq];
-  r[0] = p[0];
-  for (j = 1; j <= dp; j++) r[j] = p[j] - quot * q[j-1];
-#ifdef DEBUG
-  printf("%s: Continued Fraction form: deg p = %2d, deg q = %2d, beta = %g\n",
-	 __FUNCTION__, dp, dq, (float) quot);
-  for (j = 0; j <= dq + 1; j++)
-    printf("\tp[%2d] = %14.6g\tq[%2d] = %14.6g\tr[%2d] = %14.6g\n",
-	   j, (float) (j > dp ? ZERO : p[j]),
-	   j, (float) (j == 0 ? ZERO : q[j-1]),
-	   j, (float) (j == dp ? ZERO : r[j]));
-#endif /* DEBUG */
-  *(rb = contfrac_B(beta, q, r, p, dq, dq)) = quot;
-  return rb + 1;
-}
-
-static INTERNAL_PRECISION *contfrac_B(INTERNAL_PRECISION *beta,
-				      INTERNAL_PRECISION *p,
-				      INTERNAL_PRECISION *q,
-				      INTERNAL_PRECISION *r, int dp, int dq) {
-  INTERNAL_PRECISION quot, *rb;
-  int j;
-
-  /* p(x) = beta q(x) + r(x); dp = dq or dp = dq - 1 */
-
-  quot = dp == dq ? p[dp] / q[dq] : ZERO;
-  for (j = 0; j < dq; j++) r[j] = p[j] - quot * q[j];
-#ifdef DEBUG
-  printf("%s: Continued Fraction form: deg p = %2d, deg q = %2d, beta = %g\n",
-	 __FUNCTION__, dp, dq, (float) quot);
-  for (j = 0; j <= dq; j++)
-    printf("\tp[%2d] = %14.6g\tq[%2d] = %14.6g\tr[%2d] = %14.6g\n",
-	   j, (float) (j > dp ? ZERO : p[j]),
-	   j, (float) q[j],
-	   j, (float) (j == dq ? ZERO : r[j]));
-#endif /* DEBUG */
-  *(rb = dq > 0 ? contfrac_A(beta, q, r, p, dq, dq-1) : beta) = quot;
-  return rb + 1;
-}
-
-/* The global variable U is used to hold the argument u throughout the AGM
- * recursion. The global variables F and K are set in the innermost
- * instantiation of the recursive function AGM to the values of the elliptic
- * integrals F(u,k) and K(k) respectively. They must be made thread local to
- * make this code thread-safe in a multithreaded environment. */
-
-static INTERNAL_PRECISION U, F, K;	/* THREAD LOCAL */
-
-/* Recursive implementation of Gauss' arithmetico-geometric mean, which is the
- * kernel of the method used to compute the Jacobian elliptic functions
- * sn(u,k), cn(u,k), and dn(u,k) with parameter k (where 0 < k < 1), as well
- * as the elliptic integral F(s,k) satisfying F(sn(u,k)) = u and the complete
- * elliptic integral K(k).
- *
- * The algorithm used is a recursive implementation of the Gauss (Landen)
- * transformation.
- *
- * The function returns the value of sn(u,k'), where k' is the dual parameter,
- * and also sets the values of the global variables F and K.  The latter is
- * used to determine the sign of cn(u,k').
- *
- * The algorithm is deemed to have converged when b ceases to increase. This
- * works whatever INTERNAL_PRECISION is specified. */
-
-static INTERNAL_PRECISION AGM(INTERNAL_PRECISION a,
-			      INTERNAL_PRECISION b,
-			      INTERNAL_PRECISION s) {
-  static INTERNAL_PRECISION pb = -ONE;
-  INTERNAL_PRECISION c, d, xi;
-
-  if (b <= pb) {
-    pb = -ONE;
-    F = asin(s) / a;		/* Here, a is the AGM */
-    K = M_PI / (TWO * a);
-    return sin(U * a);
-  }
-  pb = b;
-  c = a - b;
-  d = a + b;
-  xi = AGM(HALF*d, sqrt(a*b), ONE + c*c == ONE ?
-	   HALF*s*d/a : (a - sqrt(a*a - s*s*c*d))/(c*s));
-  return 2*a*xi / (d + c*xi*xi);
-}
-
-/* Computes sn(u,k), cn(u,k), dn(u,k), F(u,k), and K(k). It is essentially a
- * wrapper for the routine AGM. The sign of cn(u,k) is defined to be -1 if
- * K(k) < u < 3*K(k) and +1 otherwise, and thus sign is computed by some quite
- * unnecessarily obfuscated bit manipulations. */
-
-static void sncndnFK(INTERNAL_PRECISION u, INTERNAL_PRECISION k,
-		     INTERNAL_PRECISION* sn, INTERNAL_PRECISION* cn,
-		     INTERNAL_PRECISION* dn, INTERNAL_PRECISION* elF,
-		     INTERNAL_PRECISION* elK) {
-  int sgn;
-  U = u;
-  *sn = AGM(ONE, sqrt(ONE - k*k), u);
-  sgn = ((int) (fabs(u) / K)) % 4; /* sgn = 0, 1, 2, 3 */
-  sgn ^= sgn >> 1;    /* (sgn & 1) = 0, 1, 1, 0 */
-  sgn = 1 - ((sgn & 1) << 1);	/* sgn = 1, -1, -1, 1 */
-  *cn = ((INTERNAL_PRECISION) sgn) * sqrt(ONE - *sn * *sn);
-  *dn = sqrt(ONE - k*k* *sn * *sn);
-  *elF = F;
-  *elK = K;
-}
-
-/* Compute the coefficients for the optimal rational approximation R(x) to
- * sgn(x) of degree n over the interval epsilon < |x| < 1 using Zolotarev's
- * formula. 
- *
- * 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) {
-  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;
-  zolotarev_data *zd;
-  izd *d = (izd*) malloc(sizeof(izd));
-
-  d -> type = type;
-  d -> epsilon = (INTERNAL_PRECISION) epsilon;
-  d -> n = n;
-  d -> dd = n / 2;
-  d -> dn = d -> dd - 1 + n % 2; /* n even: dn = dd - 1, n odd: dn = dd */
-  d -> deg_denom = 2 * d -> dd;
-  d -> deg_num = 2 * d -> dn + 1;
-
-  d -> a = (INTERNAL_PRECISION*) malloc((1 + d -> dn) *
-					sizeof(INTERNAL_PRECISION));
-  d -> ap = (INTERNAL_PRECISION*) malloc(d -> dd *
-					 sizeof(INTERNAL_PRECISION));
-  ksq = d -> epsilon * d -> epsilon;
-  kp = sqrt(ONE - ksq);
-  sncndnFK(ZERO, kp, &sn, &cn, &dn, &F, &Kp); /* compute Kp = K(kp) */
-  z0 = TWO * Kp / (INTERNAL_PRECISION) n;
-  M = ONE;
-  A = ONE / d -> epsilon;
-
-  sncndnFK(HALF * z0, kp, &sn, &cn, &dn, &F, &Kj); /* compute xi */
-  xi = ONE / dn;
-  xisq = xi * xi;
-  invlambda = xi;
-
-  for (m = 0; m < d -> dd; m++) {
-    czero = 2 * (m + 1) == n; /* n even and m = dd -1 */
-
-    z = z0 * ((INTERNAL_PRECISION) m + ONE);
-    sncndnFK(z, kp, &sn, &cn, &dn, &F, &Kj);
-    t = cn / sn;
-    c = - t*t;
-    if (!czero) (d -> a)[d -> dn - 1 - m] = ksq / c;
-
-    z = z0 * ((INTERNAL_PRECISION) m + HALF);
-    sncndnFK(z, kp, &sn, &cn, &dn, &F, &Kj);
-    t = cn / sn;
-    cp = - t*t;
-    (d -> ap)[d -> dd - 1 - m] = ksq / cp;
-
-    M *= (ONE - c) / (ONE - cp);
-    A *= (czero ? -ksq : c) * (ONE - cp) / (cp * (ONE - c));
-    invlambda *= (ONE - c*xisq) / (ONE - cp*xisq);
-  }
-  invlambda /= M;
-  d -> A = TWO / (ONE + invlambda) * A;
-  d -> Delta = (invlambda - ONE) / (invlambda + ONE);
-
-  d -> gamma = (INTERNAL_PRECISION*) malloc((1 + d -> n) *
-					    sizeof(INTERNAL_PRECISION));
-  l = ONE / invlambda;
-  opl = ONE + l;
-  sncndnFK(sqrt( d -> type == 1
-		   ? (THREE + l) / (FOUR * opl)
-		   : (ONE + THREE*l) / (opl*opl*opl)
-	       ), sqrt(ONE - l*l), &sn, &cn, &dn, &F, &Kj);
-  s = M * F;
-  for (m = 0; m < d -> n; m++) {
-    sncndnFK(s + TWO*Kp*m/n, kp, &sn, &cn, &dn, &F, &Kj);
-    d -> gamma[m] = d -> epsilon / dn;
-  }
-
-  /* If R(x) is a Zolotarev rational approximation of degree (n,m) with maximum
-   * error Delta, then (1 - Delta^2) / R(x) is also an optimal Chebyshev
-   * approximation of degree (m,n) */
-
-  if (d -> type == 1) {
-    d -> A = (ONE - d -> Delta * d -> Delta) / d -> A;
-    tv = d -> a; d -> a = d -> ap; d -> ap = tv;
-    ts = d -> dn; d -> dn = d -> dd; d -> dd = ts;
-    ts = d -> deg_num; d -> deg_num = d -> deg_denom; d -> deg_denom = ts;
-  }
-
-  construct_partfrac(d);
-  construct_contfrac(d);
-
-  /* Converting everything to ZOLO_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 -> n = d -> n;
-  zd -> type = d -> type;
-  zd -> dn = d -> dn;
-  zd -> dd = d -> dd;
-  zd -> da = d -> da;
-  zd -> db = d -> db;
-  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];
-  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];
-  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];
-  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];
-  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];
-  free(d -> gamma);
-
-  free(d);
-  return zd;
-}
-
-
-void zolotarev_free(zolotarev_data *zdata)
-{
-    free(zdata -> a);
-    free(zdata -> ap);
-    free(zdata -> alpha);
-    free(zdata -> beta);
-    free(zdata -> gamma);
-    free(zdata);
-}
-
-
-zolotarev_data* higham(ZOLO_PRECISION epsilon, int n) {
-  INTERNAL_PRECISION A, M, c, cp, z, z0, t, epssq;
-  int m, czero;
-  zolotarev_data *zd;
-  izd *d = (izd*) malloc(sizeof(izd));
-
-  d -> type = 0;
-  d -> epsilon = (INTERNAL_PRECISION) epsilon;
-  d -> n = n;
-  d -> dd = n / 2;
-  d -> dn = d -> dd - 1 + n % 2; /* n even: dn = dd - 1, n odd: dn = dd */
-  d -> deg_denom = 2 * d -> dd;
-  d -> deg_num = 2 * d -> dn + 1;
-
-  d -> a = (INTERNAL_PRECISION*) malloc((1 + d -> dn) *
-					sizeof(INTERNAL_PRECISION));
-  d -> ap = (INTERNAL_PRECISION*) malloc(d -> dd *
-					 sizeof(INTERNAL_PRECISION));
-  A = (INTERNAL_PRECISION) n;
-  z0 = M_PI / A;
-  A = n % 2 == 0 ? A : ONE / A;
-  M = d -> epsilon * A;
-  epssq = d -> epsilon * d -> epsilon;
-
-  for (m = 0; m < d -> dd; m++) {
-    czero = 2 * (m + 1) == n; /* n even and m = dd - 1*/
-
-    if (!czero) {
-      z = z0 * ((INTERNAL_PRECISION) m + ONE);
-      t = tan(z);
-      c = - t*t;
-      (d -> a)[d -> dn - 1 - m] = c;
-      M *= epssq - c;
-    }
-
-    z = z0 * ((INTERNAL_PRECISION) m + HALF);
-    t = tan(z);
-    cp = - t*t;
-    (d -> ap)[d -> dd - 1 - m] = cp;
-    M /= epssq - cp;
-  }
-
-  d -> gamma = (INTERNAL_PRECISION*) malloc((1 + d -> n) *
-					    sizeof(INTERNAL_PRECISION));
-  for (m = 0; m < d -> n; m++) d -> gamma[m] = ONE;
-
-  d -> A = A;
-  d -> Delta = ONE - M;
-
-  construct_partfrac(d);
-  construct_contfrac(d);
-
-  /* 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 -> n = d -> n;
-  zd -> type = d -> type;
-  zd -> dn = d -> dn;
-  zd -> dd = d -> dd;
-  zd -> da = d -> da;
-  zd -> db = d -> db;
-  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];
-  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];
-  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];
-  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];
-  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];
-  free(d -> gamma);
-
-  free(d);
-  return zd;
-}
-
-NAMESPACE_END(Approx);
-NAMESPACE_END(Grid);
-
-#ifdef TEST
-
-#undef ZERO
-#define ZERO ((ZOLO_PRECISION) 0)
-#undef ONE
-#define ONE ((ZOLO_PRECISION) 1)
-#undef TWO
-#define TWO ((ZOLO_PRECISION) 2)
-
-/* Evaluate the rational approximation R(x) using the factored form */
-
-static ZOLO_PRECISION zolotarev_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
-  int m;
-  ZOLO_PRECISION R;
-
-  if (rdata -> type == 0) {
-    R = rdata -> A * x;
-    for (m = 0; m < rdata -> deg_denom/2; m++)
-      R *= (2*(m+1) > rdata -> deg_num ? ONE : x*x - rdata -> a[m]) /
-	(x*x - rdata -> ap[m]);
-  } else {
-    R = rdata -> A / x;
-    for (m = 0; m < rdata -> deg_num/2; m++)
-      R *= (x*x - rdata -> a[m]) /
-	(2*(m+1) > rdata -> deg_denom ? ONE : x*x - rdata -> ap[m]);
-  }
-  return R;
-}
-
-/* Evaluate the rational approximation R(x) using the partial fraction form */
-
-static ZOLO_PRECISION zolotarev_partfrac_eval(ZOLO_PRECISION x, zolotarev_data* rdata) {
-  int m;
-  ZOLO_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);
-  return R * x;
-}    
-
-/* Evaluate the rational approximation R(x) using continued fraction form. 
- *
- * If x = 0 and type = 1 then the result should be INF, whereas if x = 0 and
- * type = 0 then the result should be 0, but division by zero will occur at
- * intermediate stages of the evaluation. For IEEE implementations with
- * 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) {
-  int m;
-  ZOLO_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) {
-  int m;
-  ZOLO_PRECISION T;
-
-  T = rdata -> type == 0 ? ONE : -ONE;
-  for (m = 0; m < rdata -> n; m++)
-    T *= (rdata -> gamma[m] - x) / (rdata -> gamma[m] + x);
-  return (ONE - T) / (ONE + T);
-}
-
-
-/* Test program. Apart from printing out the parameters for R(x) it produces
- * the following data files for plotting (unless NPLOT is defined):
- *
- * zolotarev-fn is a plot of R(x) for |x| < 1.2. This should look like sgn(x).
- *
- * zolotarev-err is a plot of the error |R(x) - sgn(x)| scaled by 1/Delta. This
- * should oscillate deg_num + deg_denom + 2 times between +1 and -1 over the
- * domain epsilon <= |x| <= 1.
- *
- * If ALLPLOTS is defined then zolotarev-partfrac (zolotarev-contfrac) is a
- * plot of the difference between the values of R(x) computed using the
- * factored form and the partial fraction (continued fraction) form, scaled by
- * 1/Delta. It should be zero everywhere. */
-
-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;
-  FILE *plot_function, *plot_error, 
-    *plot_partfrac, *plot_contfrac, *plot_cayley;
-
-  if (argc < 3 || argc > 4) {
-    fprintf(stderr, "Usage: %s epsilon n [type]\n", *argv);
-    exit(EXIT_FAILURE);
-  }
-  sscanf(argv[1], "%g", &eps);	/* First argument is epsilon */
-  sscanf(argv[2], "%d", &n);	/* Second argument is n */
-  if (argc == 4) sscanf(argv[3], "%d", &type); /* Third argument is type */
-
-  if (type < 0 || type > 2) {
-    fprintf(stderr, "%s: type must be 0 (Zolotarev R(0) = 0),\n"
-	    "\t\t1 (Zolotarev R(0) = Inf, or 2 (Higham)\n", *argv);
-    exit(EXIT_FAILURE);
-  }
-
-  rdata = type == 2 
-    ? higham((ZOLO_PRECISION) eps, n) 
-    : zolotarev((ZOLO_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)
-	 "\n\n\tRational approximation of degree (%d,%d), %s at x = 0\n"
-	 "\tDelta = %g (maximum error)\n\n"
-	 "\tA = %g (overall factor)\n",
-	 (float) rdata -> epsilon, rdata -> n, type,
-	 rdata -> deg_num, rdata -> deg_denom,
-	 rdata -> type == 1 ? "infinite" : "zero",
-	 (float) rdata -> Delta, (float) rdata -> A);
-  for (m = 0; m < MIN(rdata -> dd, rdata -> dn); m++)
-    printf("\ta[%2d] = %14.8g\t\ta'[%2d] = %14.8g\n",
-	   m + 1, (float) rdata -> a[m], m + 1, (float) rdata -> ap[m]);
-  if (rdata -> dd > rdata -> dn)
-    printf("\t\t\t\t\ta'[%2d] = %14.8g\n",
-	   rdata -> dn + 1, (float) rdata -> ap[rdata -> dn]);
-  if (rdata -> dd < rdata -> dn)
-    printf("\ta[%2d] = %14.8g\n",
-	   rdata -> dd + 1, (float) rdata -> a[rdata -> dd]);
-
-  printf("\n\tPartial fraction coefficients\n");
-  printf("\talpha[ 0] = %14.8g\n",
-	 (float) rdata -> alpha[rdata -> da - 1]);
-  for (m = 0; m < rdata -> dd; m++)
-    printf("\talpha[%2d] = %14.8g\ta'[%2d] = %14.8g\n",
-	   m + 1, (float) rdata -> alpha[m], m + 1, (float) rdata -> ap[m]);
-  if (rdata -> type == 1)
-    printf("\talpha[%2d] = %14.8g\ta'[%2d] = %14.8g\n",
-	   rdata -> dd + 1, (float) rdata -> alpha[rdata -> dd],
-	   rdata -> dd + 1, (float) ZERO);
-
-  printf("\n\tContinued fraction coefficients\n");
-  for (m = 0; m < rdata -> db; m++)
-    printf("\tbeta[%2d] = %14.8g\n", m, (float) rdata -> beta[m]);
-
-  printf("\n\tCayley transform coefficients\n");
-  for (m = 0; m < rdata -> n; m++)
-    printf("\tgamma[%2d] = %14.8g\n", m, (float) rdata -> gamma[m]);
-
-#ifndef NPLOT
-  plot_function = fopen("zolotarev-fn.dat", "w");
-  plot_error = fopen("zolotarev-err.dat", "w");
-#ifdef ALLPLOTS
-  plot_partfrac = fopen("zolotarev-partfrac.dat", "w");
-  plot_contfrac = fopen("zolotarev-contfrac.dat", "w");
-  plot_cayley = fopen("zolotarev-cayley.dat", "w");
-#endif /* ALLPLOTS */
-  for (m = 0, maxypferr = maxycferr = maxycaylerr = 0.0; m <= plotpts; m++) {
-    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);
-      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)
-		       / rdata -> Delta);
-      ycferr = (float)((zolotarev_contfrac_eval((ZOLO_PRECISION) x, rdata) - y)
-		       / rdata -> Delta);
-      ycaylerr = (float)((zolotarev_cayley_eval((ZOLO_PRECISION) x, rdata) - y)
-		       / rdata -> Delta);
-      if (fabs(x) < 1.0 && fabs(x) > rdata -> epsilon) {
-	maxypferr = MAX(maxypferr, fabs(ypferr));
-	maxycferr = MAX(maxycferr, fabs(ycferr));
-	maxycaylerr = MAX(maxycaylerr, fabs(ycaylerr));
-      }
-#ifdef ALLPLOTS
-      fprintf(plot_partfrac, "%g %g\n", x, ypferr);
-      fprintf(plot_contfrac, "%g %g\n", x, ycferr);
-      fprintf(plot_cayley, "%g %g\n", x, ycaylerr);
-#endif /* ALLPLOTS */
-    }
-  }
-#ifdef ALLPLOTS
-  fclose(plot_cayley);
-  fclose(plot_contfrac);
-  fclose(plot_partfrac);
-#endif /* ALLPLOTS */
-  fclose(plot_error);
-  fclose(plot_function);
-
-  printf("\n\tMaximum PF error = %g (relative to Delta)\n", maxypferr);
-  printf("\tMaximum CF error = %g (relative to Delta)\n", maxycferr);
-  printf("\tMaximum Cayley error = %g (relative to Delta)\n", maxycaylerr);
-#endif /* NPLOT */
-
-  free(rdata -> a);
-  free(rdata -> ap);
-  free(rdata -> alpha);
-  free(rdata -> beta);
-  free(rdata -> gamma);
-  free(rdata);
-
-  return EXIT_SUCCESS;
-}
-
-#endif /* TEST */
-

Grid/algorithms/approx/Zolotarev.h

@@ -1,89 +0,0 @@
-/* -*- Mode: C; comment-column: 22; fill-column: 79; -*- */
-
-#ifdef __cplusplus
-#include <Grid/Namespace.h>
-NAMESPACE_BEGIN(Grid);
-NAMESPACE_BEGIN(Approx);
-#endif
-
-#define HVERSION Header Time-stamp: <14-OCT-2004 09:26:51.00 adk@MISSCONTRARY>
-
-#ifndef ZOLOTAREV_INTERNAL
-#ifndef ZOLO_PRECISION
-#define ZOLO_PRECISION double
-#endif
-#define ZPRECISION ZOLO_PRECISION
-#define ZOLOTAREV_DATA zolotarev_data
-#endif
-
-/* This struct contains the coefficients which parameterise an optimal rational
- * approximation to the signum function.
- *
- * The parameterisations used are:
- *
- * Factored form for type 0 (R0(0) = 0)
- *
- * R0(x) = A * x * prod(x^2 - a[j], j = 0 .. dn-1) / prod(x^2 - ap[j], j = 0
- * .. dd-1),
- *
- * where deg_num = 2*dn + 1 and deg_denom = 2*dd.
- *
- * Factored form for type 1 (R1(0) = infinity)
- *
- * R1(x) = (A / x) * prod(x^2 - a[j], j = 0 .. dn-1) / prod(x^2 - ap[j], j = 0
- * .. dd-1),
- *
- * where deg_num = 2*dn and deg_denom = 2*dd + 1. 
- *
- * Partial fraction form
- *
- * R(x) = alpha[da] * x + sum(alpha[j] * x / (x^2 - ap[j]), j = 0 .. da-1)
- *
- * where da = dd for type 0 and da = dd + 1 with ap[dd] = 0 for type 1.
- *
- * Continued fraction form 
- *
- * R(x) = beta[db-1] * x + 1 / (beta[db-2] * x + 1 / (beta[db-3] * x + ...))
- *
- * with the final coefficient being beta[0], with d' = 2 * dd + 1 for type 0
- * and db = 2 * dd + 2 for type 1.
- *
- * Cayley form (Chiu's domain wall formulation)
- *
- * R(x) = (1 - T(x)) / (1 + T(x))
- *
- * where T(x) = prod((x - gamma[j]) / (x + gamma[j]), j = 0 .. n-1)
- */
-
-typedef struct {
-  ZPRECISION *a,      /* zeros of numerator, a[0 .. dn-1] */
-    *ap,	      /* poles (zeros of denominator), ap[0 .. dd-1] */
-    A,		      /* overall factor */
-    *alpha,	      /* coefficients of partial fraction, alpha[0 .. da-1] */
-    *beta,	      /* coefficients of continued fraction, beta[0 .. db-1] */
-    *gamma,	      /* zeros of numerator of T in Cayley form */
-    Delta,	      /* maximum error, |R(x) - sgn(x)| <= Delta */
-    epsilon;	      /* minimum x value, epsilon < |x| < 1 */
-  int n,	      /* approximation degree */
-    type,	      /* 0: R(0) = 0, 1: R(0) = infinity */
-    dn, dd, da, db,   /* number of elements of a, ap, alpha, and beta */
-    deg_num,	      /* degree of numerator = deg_denom +/- 1 */
-    deg_denom;	      /* degree of denominator */
-} ZOLOTAREV_DATA;
-
-#ifndef ZOLOTAREV_INTERNAL
-
-/* zolotarev(epsilon, n, type) returns a pointer to an initialised
- * 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);
-void zolotarev_free(zolotarev_data *zdata);
-#endif
-
-#ifdef __cplusplus
-NAMESPACE_END(Approx);
-NAMESPACE_END(Grid);
-#endif
-

Grid/algorithms/approx/bigfloat.h

@@ -1,208 +0,0 @@
-/*
-  Mike Clark - 25th May 2005
-
-  bigfloat.h
-
-  Simple C++ wrapper for multiprecision datatype used by AlgRemez
-  algorithm
-*/
-
-#ifndef INCLUDED_BIGFLOAT_H
-#define INCLUDED_BIGFLOAT_H
-
-#define __GMP_WITHIN_CONFIGURE
-#include <gmp.h>
-#include <mpf2mpfr.h>
-#include <mpfr.h>
-#undef  __GMP_WITHIN_CONFIGURE
-
-class bigfloat {
-
-private:
-
-  mpf_t x;
-
-public:
-
-  bigfloat() { mpf_init(x); }
-  bigfloat(const bigfloat& y) { mpf_init_set(x, y.x); }
-  bigfloat(const unsigned long u) { mpf_init_set_ui(x, u); }
-  bigfloat(const long i) { mpf_init_set_si(x, i); }
-  bigfloat(const int i) {mpf_init_set_si(x,(long)i);}
-  bigfloat(const float d) { mpf_init_set_d(x, (double)d); }
-  bigfloat(const double d) { mpf_init_set_d(x, d); }  
-  bigfloat(const char *str) { mpf_init_set_str(x, (char*)str, 10); }
-  ~bigfloat(void) { mpf_clear(x); }
-  operator double (void) const { return (double)mpf_get_d(x); }
-  static void setDefaultPrecision(unsigned long dprec) {
-    unsigned long bprec =  (unsigned long)(3.321928094 * (double)dprec);
-    mpf_set_default_prec(bprec);
-  }
-
-  void setPrecision(unsigned long dprec) {
-    unsigned long bprec =  (unsigned long)(3.321928094 * (double)dprec);
-    mpf_set_prec(x,bprec);
-  }
-  
-  unsigned long getPrecision(void) const { return mpf_get_prec(x); }
-
-  unsigned long getDefaultPrecision(void) const { return mpf_get_default_prec(); }
-
-  bigfloat& operator=(const bigfloat& y) {
-    mpf_set(x, y.x); 
-    return *this;
-  }
-
-  bigfloat& operator=(const unsigned long y) { 
-    mpf_set_ui(x, y);
-    return *this; 
-  }
-  
-  bigfloat& operator=(const signed long y) {
-    mpf_set_si(x, y); 
-    return *this;
-  }
-  
-  bigfloat& operator=(const float y) {
-    mpf_set_d(x, (double)y); 
-    return *this;
-  }
-
-  bigfloat& operator=(const double y) {
-    mpf_set_d(x, y); 
-    return *this;
-  }
-
-  size_t write(void);
-  size_t read(void);
-
-  /* Arithmetic Functions */
-
-  bigfloat& operator+=(const bigfloat& y) { return *this = *this + y; }
-  bigfloat& operator-=(const bigfloat& y) { return *this = *this - y; }
-  bigfloat& operator*=(const bigfloat& y) { return *this = *this * y; }
-  bigfloat& operator/=(const bigfloat& y) { return *this = *this / y; }
-
-  friend bigfloat operator+(const bigfloat& x, const bigfloat& y) {
-    bigfloat a;
-    mpf_add(a.x,x.x,y.x);
-    return a;
-  }
-
-  friend bigfloat operator+(const bigfloat& x, const unsigned long y) {
-    bigfloat a;
-    mpf_add_ui(a.x,x.x,y);
-    return a;
-  }
-
-  friend bigfloat operator-(const bigfloat& x, const bigfloat& y) {
-    bigfloat a;
-    mpf_sub(a.x,x.x,y.x);
-    return a;
-  }
-  
-  friend bigfloat operator-(const unsigned long x, const bigfloat& y) {
-    bigfloat a;
-    mpf_ui_sub(a.x,x,y.x);
-    return a;
-  }
-  
-  friend bigfloat operator-(const bigfloat& x, const unsigned long y) {
-    bigfloat a;
-    mpf_sub_ui(a.x,x.x,y);
-    return a;
-  }
-
-  friend bigfloat operator-(const bigfloat& x) {
-    bigfloat a;
-    mpf_neg(a.x,x.x);
-    return a;
-  }
-
-  friend bigfloat operator*(const bigfloat& x, const bigfloat& y) {
-    bigfloat a;
-    mpf_mul(a.x,x.x,y.x);
-    return a;
-  }
-
-  friend bigfloat operator*(const bigfloat& x, const unsigned long y) {
-    bigfloat a;
-    mpf_mul_ui(a.x,x.x,y);
-    return a;
-  }
-
-  friend bigfloat operator/(const bigfloat& x, const bigfloat& y){
-    bigfloat a;
-    mpf_div(a.x,x.x,y.x);
-    return a;
-  }
-
-  friend bigfloat operator/(const unsigned long x, const bigfloat& y){
-    bigfloat a;
-    mpf_ui_div(a.x,x,y.x);
-    return a;
-  }
-
-  friend bigfloat operator/(const bigfloat& x, const unsigned long y){
-    bigfloat a;
-    mpf_div_ui(a.x,x.x,y);
-    return a;
-  }
-
-  friend bigfloat sqrt_bf(const bigfloat& x){
-    bigfloat a;
-    mpf_sqrt(a.x,x.x);
-    return a;
-  }
-
-  friend bigfloat sqrt_bf(const unsigned long x){
-    bigfloat a;
-    mpf_sqrt_ui(a.x,x);
-    return a;
-  }
-
-  friend bigfloat abs_bf(const bigfloat& x){
-    bigfloat a;
-    mpf_abs(a.x,x.x);
-    return a;
-  }
-
-  friend bigfloat pow_bf(const bigfloat& a, long power) {
-    bigfloat b;
-    mpf_pow_ui(b.x,a.x,power);
-    return b;
-  }
-
-  friend bigfloat pow_bf(const bigfloat& a, bigfloat &power) {
-    bigfloat b;
-    mpfr_pow(b.x,a.x,power.x,GMP_RNDN);
-    return b;
-  }
-
-  friend bigfloat exp_bf(const bigfloat& a) {
-    bigfloat b;
-    mpfr_exp(b.x,a.x,GMP_RNDN);
-    return b;
-  }
-
-  /* Comparison Functions */
-
-  friend int operator>(const bigfloat& x, const bigfloat& y) {
-    int test;
-    test = mpf_cmp(x.x,y.x);
-    if (test > 0) return 1;
-    else return 0;
-  }
-
-  friend int operator<(const bigfloat& x, const bigfloat& y) {
-    int test;
-    test = mpf_cmp(x.x,y.x);
-    if (test < 0) return 1;
-    else return 0;
-  }
-
-  friend int sgn(const bigfloat&);
-
-};
-
-#endif

Grid/algorithms/approx/bigfloat_double.h

@@ -1,195 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/approx/bigfloat_double.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 */
-
-#ifndef INCLUDED_BIGFLOAT_DOUBLE_H
-#define INCLUDED_BIGFLOAT_DOUBLE_H
-
-#include <math.h>
-
-typedef double mfloat; 
-class bigfloat {
-private:
-
-  mfloat x;
-
-public:
-
-  bigfloat() { }
-  bigfloat(const bigfloat& y) { x=y.x; }
-  bigfloat(const unsigned long u) { x=u; }
-  bigfloat(const long i) { x=i; }
-  bigfloat(const int i) { x=i;}
-  bigfloat(const float d) { x=d;}
-  bigfloat(const double d) {  x=d;}
-  bigfloat(const char *str) { x=std::stod(std::string(str));}
-  ~bigfloat(void) { }
-  operator double (void) const { return (double)x; }
-  static void setDefaultPrecision(unsigned long dprec) {
-  }
-
-  void setPrecision(unsigned long dprec) {
-  }
-  
-  unsigned long getPrecision(void) const { return 64; }
-  unsigned long getDefaultPrecision(void) const { return 64; }
-
-  bigfloat& operator=(const bigfloat& y)     { x=y.x;    return *this;  }
-  bigfloat& operator=(const unsigned long y) { x=y; return *this; }
-  bigfloat& operator=(const signed long y)   { x=y; return *this; }
-  bigfloat& operator=(const float y)    { x=y; return *this; }
-  bigfloat& operator=(const double y)   { x=y; return *this; }
-
-  size_t write(void);
-  size_t read(void);
-
-  /* Arithmetic Functions */
-
-  bigfloat& operator+=(const bigfloat& y) { return *this = *this + y; }
-  bigfloat& operator-=(const bigfloat& y) { return *this = *this - y; }
-  bigfloat& operator*=(const bigfloat& y) { return *this = *this * y; }
-  bigfloat& operator/=(const bigfloat& y) { return *this = *this / y; }
-
-  friend bigfloat operator+(const bigfloat& x, const bigfloat& y) { 
-    bigfloat a;
-    a.x=x.x+y.x;
-    return a;
-  }
-
-  friend bigfloat operator+(const bigfloat& x, const unsigned long y) {
-    bigfloat a;
-    a.x=x.x+y;
-    return a;
-  }
-
-  friend bigfloat operator-(const bigfloat& x, const bigfloat& y) {
-    bigfloat a;
-    a.x=x.x-y.x;
-    return a;
-  }
-  
-  friend bigfloat operator-(const unsigned long x, const bigfloat& y) {
-    bigfloat bx(x);
-    return bx-y;
-  }
-  
-  friend bigfloat operator-(const bigfloat& x, const unsigned long y) {
-    bigfloat by(y);
-    return x-by;
-  }
-
-  friend bigfloat operator-(const bigfloat& x) {
-    bigfloat a;
-    a.x=-x.x;
-    return a;
-  }
-
-  friend bigfloat operator*(const bigfloat& x, const bigfloat& y) {
-    bigfloat a;
-    a.x=x.x*y.x;
-    return a;
-  }
-
-  friend bigfloat operator*(const bigfloat& x, const unsigned long y) {
-    bigfloat a;
-    a.x=x.x*y;
-    return a;
-  }
-
-  friend bigfloat operator/(const bigfloat& x, const bigfloat& y){
-    bigfloat a;
-    a.x=x.x/y.x;
-    return a;
-  }
-
-  friend bigfloat operator/(const unsigned long x, const bigfloat& y){
-    bigfloat bx(x);
-    return bx/y;
-  }
-
-  friend bigfloat operator/(const bigfloat& x, const unsigned long y){
-    bigfloat by(y);
-    return x/by;
-  }
-
-  friend bigfloat sqrt_bf(const bigfloat& x){
-    bigfloat a;
-    a.x= sqrt(x.x);
-    return a;
-  }
-
-  friend bigfloat sqrt_bf(const unsigned long x){
-    bigfloat a(x);
-    return sqrt_bf(a);
-  }
-
-  friend bigfloat abs_bf(const bigfloat& x){
-    bigfloat a;
-    a.x=fabs(x.x);
-    return a;
-  }
-
-  friend bigfloat pow_bf(const bigfloat& a, long power) {
-    bigfloat b;
-    b.x=pow(a.x,power);
-    return b;
-  }
-
-  friend bigfloat pow_bf(const bigfloat& a, bigfloat &power) {
-    bigfloat b;
-    b.x=pow(a.x,power.x);
-    return b;
-  }
-
-  friend bigfloat exp_bf(const bigfloat& a) {
-    bigfloat b;
-    b.x=exp(a.x);
-    return b;
-  }
-
-  /* Comparison Functions */
-  friend int operator>(const bigfloat& x, const bigfloat& y) {
-    return x.x>y.x;
-  }
-
-  friend int operator<(const bigfloat& x, const bigfloat& y) {
-    return x.x<y.x;
-  }
-
-  friend int sgn(const bigfloat& x) {
-    if ( x.x>=0 )  return 1;   
-    else return 0;
-  }
-
-  /* Miscellaneous Functions */
-
-  //  friend bigfloat& random(void);
-};
-
-#endif
-
-

Grid/algorithms/blas/BatchedBlas.cc

@@ -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);
-

Grid/algorithms/blas/BatchedInverse.h

@@ -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);

Grid/algorithms/blas/MomentumProject.h

@@ -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);

Grid/algorithms/deflation/Deflation.h

@@ -1,156 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ImplicitlyRestartedLanczos.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 */
-#ifndef GRID_DEFLATION_H
-#define GRID_DEFLATION_H
-
-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; };
-};
-
-////////////////////////////////
-// Fine grid deflation
-////////////////////////////////
-template<class Field>
-class DeflatedGuesser: public LinearFunction<Field> {
-private:
-  const std::vector<Field> &evec;
-  const std::vector<RealD> &eval;
-  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())
-  {}
-
-  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());
-  } 
-
-  virtual void operator()(const Field &src,Field &guess) {
-    guess = Zero();
-    for (int i=0;i<N;i++) {
-      const Field& tmp = evec[i];
-      axpy(guess,TensorRemove(innerProduct(tmp,src)) / eval[i],tmp,guess);
-    }
-    guess.Checkerboard() = src.Checkerboard();
-  }
-};
-
-template<class FineField, class CoarseField>
-class LocalCoherenceDeflatedGuesser: public LinearFunction<FineField> {
-private:
-  const std::vector<FineField>   &subspace;
-  const std::vector<CoarseField> &evec_coarse;
-  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)
-    : subspace(_subspace), 
-      evec_coarse(_evec_coarse), 
-      eval_coarse(_eval_coarse)  
-  {
-  }
-  
-  void operator()(const FineField &src,FineField &guess) { 
-    int N = (int)evec_coarse.size();
-    CoarseField src_coarse(evec_coarse[0].Grid());
-    CoarseField guess_coarse(evec_coarse[0].Grid());    guess_coarse = Zero();
-    blockProject(src_coarse,src,subspace);    
-    for (int i=0;i<N;i++) {
-      const CoarseField & tmp = evec_coarse[i];
-      axpy(guess_coarse,TensorRemove(innerProduct(tmp,src_coarse)) / eval_coarse[i],tmp,guess_coarse);
-    }
-    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();
-    }
-  };
-
-  };
-
-
-
-}
-#endif

Grid/algorithms/deflation/MultiRHSBlockCGLinalg.h

@@ -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);

Grid/algorithms/deflation/MultiRHSDeflation.h

@@ -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);

Grid/algorithms/iterative/AdefGeneric.h

@@ -1,542 +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 */
-#ifndef GRID_ALGORITHMS_ITERATIVE_GENERIC_PCG
-#define GRID_ALGORITHMS_ITERATIVE_GENERIC_PCG
-
-  /*
-   * 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);
-
-
-template<class Field>
-class TwoLevelCG : public LinearFunction<Field>
-{
- public:
-  RealD   Tolerance;
-  Integer MaxIterations;
-  GridBase *grid;
-
-  // 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;
-
-  // more most opertor functions
-  TwoLevelCG(RealD tol,
-	     Integer maxit,
-	     LinearOperatorBase<Field>   &FineLinop,
-	     LinearFunction<Field>       &Smoother,
-	     GridBase *fine) : 
-      Tolerance(tol), 
-      MaxIterations(maxit),
-      _FineLinop(FineLinop),
-      _Smoother(Smoother)
-  {
-    grid       = fine;
-  };
-  
-  virtual void operator() (const Field &src, Field &x)
-  {
-    std::cout << GridLogMessage<<"HDCG: fPcg starting single RHS"<<std::endl;
-    RealD f;
-    RealD rtzp,rtz,a,d,b;
-    RealD rptzp;
-
-    /////////////////////////////
-    // Set up history vectors
-    /////////////////////////////
-    int mmax = 5;
-    std::cout << GridLogMessage<<"HDCG: fPcg allocating"<<std::endl;
-    std::vector<Field> p(mmax,grid);
-    std::vector<Field> mmp(mmax,grid);
-    std::vector<RealD> pAp(mmax);
-    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();
-    //////////////////////////
-    // x0 = Vstart -- possibly modify guess
-    //////////////////////////
-    Vstart(x,src);
-
-    // r0 = b -A x0
-    _FineLinop.HermOp(x,mmp[0]);
-    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);
-    rtzp =real(innerProduct(r,z));
-    
-    ///////////////////////////////////////
-    // Solve for Mss mu = P A z and set p = z-mu
-    // 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);
-
-    for (int k=0;k<=MaxIterations;k++){
-    
-      int peri_k  = k % mmax;
-      int peri_kp = (k+1) % mmax;
-
-      rtz=rtzp;
-      M3Timer.Start();
-      d= PcgM3(p[peri_k],mmp[peri_k]);
-      M3Timer.Stop();
-      M3Calls++;
-      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);
-
-      {
-	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
-
-      p[peri_kp]=mu;
-
-      // Standard search direction  p -> z + b p
-      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
-
-      //    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]));
-	RealD beta = -pbApk/pAp[peri_back];
-	axpy(p[peri_kp],beta,p[peri_back],p[peri_kp]);
-      }
-
-      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";
-
-      // 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]);			  
-	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;
-      }
-
-    }
-    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;
-  }
-
-
-
-  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 PcgM2(const Field & in, Field & out) {
-    out=in;
-  }
-
-  virtual RealD PcgM3(const Field & p, Field & mmp){
-    RealD dd;
-    _FineLinop.HermOp(p,mmp);
-    ComplexD dot = innerProduct(p,mmp);
-    dd=real(dot);
-    return dd;
-  }
-
-  /////////////////////////////////////////////////////////////////////
-  // Only Def1 has non-trivial Vout.
-  /////////////////////////////////////////////////////////////////////
-
-};
-  
-
-  
-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;
-  }
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/iterative/AdefMrhs.h

@@ -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);

Grid/algorithms/iterative/BiCGSTAB.h

@@ -1,234 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/BiCGSTAB.h
-
-Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-Author: juettner <juettner@soton.ac.uk>
-Author: David Murphy <djmurphy@mit.edu>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution
-directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef GRID_BICGSTAB_H
-#define GRID_BICGSTAB_H
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////
-// Base classes for iterative processes based on operators
-// single input vec, single output vec.
-/////////////////////////////////////////////////////////////
-
-template <class Field>
-class BiCGSTAB : public OperatorFunction<Field> 
-{
-  public:
-    using OperatorFunction<Field>::operator();
-    
-    bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
-                             // Defaults true.
-    RealD Tolerance;
-    Integer MaxIterations;
-    Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
-  
-    BiCGSTAB(RealD tol, Integer maxit, bool err_on_no_conv = true) : 
-      Tolerance(tol), MaxIterations(maxit), ErrorOnNoConverge(err_on_no_conv){};
-
-    void operator()(LinearOperatorBase<Field>& Linop, const Field& src, Field& psi) 
-    {
-      psi.Checkerboard() = src.Checkerboard();
-      conformable(psi, src);
-
-      RealD cp(0), rho(1), rho_prev(0), alpha(1), beta(0), omega(1);
-      RealD a(0), bo(0), b(0), ssq(0);
-
-      Field p(src);
-      Field r(src);
-      Field rhat(src);
-      Field v(src);
-      Field s(src);
-      Field t(src);
-      Field h(src);
-
-      v = Zero();
-      p = Zero();
-
-      // Initial residual computation & set up
-      RealD guess = norm2(psi);
-      GRID_ASSERT(std::isnan(guess) == 0);
-    
-      Linop.Op(psi, v);
-      b = norm2(v);
-
-      r = src - v;
-      rhat = r;
-      a = norm2(r);
-      ssq = norm2(src);
-
-      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB: guess " << guess << std::endl;
-      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:   src " << ssq << std::endl;
-      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:    mp " << b << std::endl;
-      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB:     r " << a << std::endl;
-
-      RealD rsq = Tolerance * Tolerance * ssq;
-
-      // Check if guess is really REALLY good :)
-      if(a <= rsq){ return; }
-
-      std::cout << GridLogIterative << std::setprecision(8) << "BiCGSTAB: k=0 residual " << a << " target " << rsq << std::endl;
-
-      GridStopWatch LinalgTimer;
-      GridStopWatch InnerTimer;
-      GridStopWatch AxpyNormTimer;
-      GridStopWatch LinearCombTimer;
-      GridStopWatch MatrixTimer;
-      GridStopWatch SolverTimer;
-
-      SolverTimer.Start();
-      int k;
-      for (k = 1; k <= MaxIterations; k++) 
-      {
-        rho_prev = rho;
-
-        LinalgTimer.Start();
-        InnerTimer.Start();
-        ComplexD Crho  = innerProduct(rhat,r);
-        InnerTimer.Stop();
-        rho = Crho.real();
-
-        beta = (rho / rho_prev) * (alpha / omega);
-
-        LinearCombTimer.Start();
-        bo = beta * omega;
-	{
-	  autoView( p_v , p, AcceleratorWrite);
-	  autoView( r_v , r, AcceleratorRead);
-	  autoView( v_v , v, AcceleratorRead);
-	  accelerator_for(ss, p_v.size(), Field::vector_object::Nsimd(),{
-	      coalescedWrite(p_v[ss], beta*p_v(ss) - bo*v_v(ss) + r_v(ss));
-	    });
-	}
-        LinearCombTimer.Stop();
-        LinalgTimer.Stop();
-
-        MatrixTimer.Start();
-        Linop.Op(p,v);
-        MatrixTimer.Stop();
-
-        LinalgTimer.Start();
-        InnerTimer.Start();
-        ComplexD Calpha = innerProduct(rhat,v);
-        InnerTimer.Stop();
-        alpha = rho / Calpha.real();
-
-        LinearCombTimer.Start();
-	{
-	  autoView( p_v , p, AcceleratorRead);
-	  autoView( r_v , r, AcceleratorRead);
-	  autoView( v_v , v, AcceleratorRead);
-	  autoView( psi_v,psi, AcceleratorRead);
-	  autoView( h_v  ,  h, AcceleratorWrite);
-	  autoView( s_v  ,  s, AcceleratorWrite);
-	  accelerator_for(ss, h_v.size(), Field::vector_object::Nsimd(),{
-	      coalescedWrite(h_v[ss], alpha*p_v(ss) + psi_v(ss));
-	    });
-	  accelerator_for(ss, s_v.size(), Field::vector_object::Nsimd(),{
-	      coalescedWrite(s_v[ss], -alpha*v_v(ss) + r_v(ss));
- 	  });
-        }
-        LinearCombTimer.Stop();
-        LinalgTimer.Stop();
-
-        MatrixTimer.Start();
-        Linop.Op(s,t);
-        MatrixTimer.Stop();
-
-        LinalgTimer.Start();
-        InnerTimer.Start();
-        ComplexD Comega = innerProduct(t,s);
-        InnerTimer.Stop();
-        omega = Comega.real() / norm2(t);
-
-        LinearCombTimer.Start();
-	{
-	  autoView( psi_v,psi, AcceleratorWrite);
-	  autoView( r_v , r, AcceleratorWrite);
-	  autoView( h_v , h, AcceleratorRead);
-	  autoView( s_v , s, AcceleratorRead);
-	  autoView( t_v , t, AcceleratorRead);
-	  accelerator_for(ss, psi_v.size(), Field::vector_object::Nsimd(),{
-	      coalescedWrite(psi_v[ss], h_v(ss) + omega * s_v(ss));
-	      coalescedWrite(r_v[ss], -omega * t_v(ss) + s_v(ss));
-	    });
-	}
-        LinearCombTimer.Stop();
-	
-        cp = norm2(r);
-        LinalgTimer.Stop();
-
-        std::cout << GridLogIterative << "BiCGSTAB: Iteration " << k << " residual " << sqrt(cp/ssq) << " target " << Tolerance << std::endl;
-
-        // Stopping condition
-        if(cp <= rsq) 
-        {
-          SolverTimer.Stop();
-          Linop.Op(psi, v);
-          p = v - src;
-
-          RealD srcnorm = sqrt(norm2(src));
-          RealD resnorm = sqrt(norm2(p));
-          RealD true_residual = resnorm / srcnorm;
-
-          std::cout << GridLogMessage << "BiCGSTAB Converged on iteration " << k << std::endl;
-          std::cout << GridLogMessage << "\tComputed residual " << sqrt(cp/ssq) << std::endl;
-          std::cout << GridLogMessage << "\tTrue residual " << true_residual << std::endl;
-          std::cout << GridLogMessage << "\tTarget " << Tolerance << std::endl;
-
-          std::cout << GridLogMessage << "Time breakdown " << std::endl;
-          std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed() << std::endl;
-          std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() << std::endl;
-          std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() << std::endl;
-          std::cout << GridLogMessage << "\tInner      " << InnerTimer.Elapsed() << std::endl;
-          std::cout << GridLogMessage << "\tAxpyNorm   " << AxpyNormTimer.Elapsed() << std::endl;
-          std::cout << GridLogMessage << "\tLinearComb " << LinearCombTimer.Elapsed() << std::endl;
-
-          if(ErrorOnNoConverge){ GRID_ASSERT(true_residual / Tolerance < 10000.0); }
-
-          IterationsToComplete = k;	
-
-          return;
-        }
-      }
-      
-      std::cout << GridLogMessage << "BiCGSTAB did NOT converge" << std::endl;
-
-      if(ErrorOnNoConverge){ GRID_ASSERT(0); }
-      IterationsToComplete = k;
-    }
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/iterative/BiCGSTABMixedPrec.h

@@ -1,159 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: ./lib/algorithms/iterative/BiCGSTABMixedPrec.h
-
-Copyright (C) 2015
-
-Author: Christopher Kelly <ckelly@phys.columbia.edu>
-Author: David Murphy <djmurphy@mit.edu>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef GRID_BICGSTAB_MIXED_PREC_H
-#define GRID_BICGSTAB_MIXED_PREC_H
-
-NAMESPACE_BEGIN(Grid);
-
-// Mixed precision restarted defect correction BiCGSTAB
-template<class FieldD, class FieldF, typename std::enable_if< getPrecision<FieldD>::value == 2, int>::type = 0, typename std::enable_if< getPrecision<FieldF>::value == 1, int>::type = 0> 
-class MixedPrecisionBiCGSTAB : public LinearFunction<FieldD> 
-{
-  public:
-    using LinearFunction<FieldD>::operator();
-    RealD   Tolerance;
-    RealD   InnerTolerance; // Initial tolerance for inner CG. Defaults to Tolerance but can be changed
-    Integer MaxInnerIterations;
-    Integer MaxOuterIterations;
-    GridBase* SinglePrecGrid; // Grid for single-precision fields
-    RealD OuterLoopNormMult; // Stop the outer loop and move to a final double prec solve when the residual is OuterLoopNormMult * Tolerance
-    LinearOperatorBase<FieldF> &Linop_f;
-    LinearOperatorBase<FieldD> &Linop_d;
-
-    Integer TotalInnerIterations; //Number of inner CG iterations
-    Integer TotalOuterIterations; //Number of restarts
-    Integer TotalFinalStepIterations; //Number of CG iterations in final patch-up step
-
-    //Option to speed up *inner single precision* solves using a LinearFunction that produces a guess
-    LinearFunction<FieldF> *guesser;
-    
-    MixedPrecisionBiCGSTAB(RealD tol, Integer maxinnerit, Integer maxouterit, GridBase* _sp_grid, 
-        LinearOperatorBase<FieldF>& _Linop_f, LinearOperatorBase<FieldD>& _Linop_d) : 
-      Linop_f(_Linop_f), Linop_d(_Linop_d), Tolerance(tol), InnerTolerance(tol), MaxInnerIterations(maxinnerit), 
-      MaxOuterIterations(maxouterit), SinglePrecGrid(_sp_grid), OuterLoopNormMult(100.), guesser(NULL) {};
-
-    void useGuesser(LinearFunction<FieldF>& g){
-      guesser = &g;
-    }
-  
-    void operator() (const FieldD& src_d_in, FieldD& sol_d)
-    {
-      TotalInnerIterations = 0;
-    
-      GridStopWatch TotalTimer;
-      TotalTimer.Start();
-      
-      int cb = src_d_in.Checkerboard();
-      sol_d.Checkerboard() = cb;
-      
-      RealD src_norm = norm2(src_d_in);
-      RealD stop = src_norm * Tolerance*Tolerance;
-
-      GridBase* DoublePrecGrid = src_d_in.Grid();
-      FieldD tmp_d(DoublePrecGrid);
-      tmp_d.Checkerboard() = cb;
-      
-      FieldD tmp2_d(DoublePrecGrid);
-      tmp2_d.Checkerboard() = cb;
-      
-      FieldD src_d(DoublePrecGrid);
-      src_d = src_d_in; //source for next inner iteration, computed from residual during operation
-      
-      RealD inner_tol = InnerTolerance;
-      
-      FieldF src_f(SinglePrecGrid);
-      src_f.Checkerboard() = cb;
-      
-      FieldF sol_f(SinglePrecGrid);
-      sol_f.Checkerboard() = cb;
-      
-      BiCGSTAB<FieldF> CG_f(inner_tol, MaxInnerIterations);
-      CG_f.ErrorOnNoConverge = false;
-
-      GridStopWatch InnerCGtimer;
-
-      GridStopWatch PrecChangeTimer;
-      
-      Integer &outer_iter = TotalOuterIterations; //so it will be equal to the final iteration count
-        
-      for(outer_iter = 0; outer_iter < MaxOuterIterations; outer_iter++)
-      {
-        // Compute double precision rsd and also new RHS vector.
-        Linop_d.Op(sol_d, tmp_d);
-        RealD norm = axpy_norm(src_d, -1., tmp_d, src_d_in); //src_d is residual vector
-        
-        std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Outer iteration " << outer_iter << " residual " << norm << " target " << stop << std::endl;
-
-        if(norm < OuterLoopNormMult * stop){
-          std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Outer iteration converged on iteration " << outer_iter << std::endl;
-          break;
-        }
-        while(norm * inner_tol * inner_tol < stop){ inner_tol *= 2; } // inner_tol = sqrt(stop/norm) ??
-
-        PrecChangeTimer.Start();
-        precisionChange(src_f, src_d);
-        PrecChangeTimer.Stop();
-        
-        sol_f = Zero();
-
-        //Optionally improve inner solver guess (eg using known eigenvectors)
-        if(guesser != NULL){ (*guesser)(src_f, sol_f); }
-
-        //Inner CG
-        CG_f.Tolerance = inner_tol;
-        InnerCGtimer.Start();
-        CG_f(Linop_f, src_f, sol_f);
-        InnerCGtimer.Stop();
-        TotalInnerIterations += CG_f.IterationsToComplete;
-        
-        //Convert sol back to double and add to double prec solution
-        PrecChangeTimer.Start();
-        precisionChange(tmp_d, sol_f);
-        PrecChangeTimer.Stop();
-        
-        axpy(sol_d, 1.0, tmp_d, sol_d);
-      }
-      
-      //Final trial CG
-      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Starting final patch-up double-precision solve" << std::endl;
-      
-      BiCGSTAB<FieldD> CG_d(Tolerance, MaxInnerIterations);
-      CG_d(Linop_d, src_d_in, sol_d);
-      TotalFinalStepIterations = CG_d.IterationsToComplete;
-
-      TotalTimer.Stop();
-      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Inner CG iterations " << TotalInnerIterations << " Restarts " << TotalOuterIterations << " Final CG iterations " << TotalFinalStepIterations << std::endl;
-      std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Total time " << TotalTimer.Elapsed() << " Precision change " << PrecChangeTimer.Elapsed() << " Inner CG total " << InnerCGtimer.Elapsed() << std::endl;
-  }
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/iterative/BlockConjugateGradient.h

@@ -1,741 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/BlockConjugateGradient.h
-
-Copyright (C) 2017
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution
-directory
-*************************************************************************************/
-/*  END LEGAL */
-#pragma once
-
-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 };
-
-//////////////////////////////////////////////////////////////////////////
-// Block conjugate gradient. Dimension zero should be the block direction
-//////////////////////////////////////////////////////////////////////////
-template <class Field>
-class BlockConjugateGradient : public OperatorFunction<Field> {
- public:
-
-  typedef typename Field::scalar_type scomplex;
-
-  int blockDim ;
-  int Nblock;
-
-  BlockCGtype CGtype;
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
-                           // Defaults true.
-  RealD Tolerance;
-  Integer MaxIterations;
-  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
-  Integer PrintInterval; //GridLogMessages or Iterative
-  RealD TrueResidual;
-  
-  BlockConjugateGradient(BlockCGtype cgtype,int _Orthog,RealD tol, Integer maxit, bool err_on_no_conv = true)
-    : Tolerance(tol), CGtype(cgtype),   blockDim(_Orthog),  MaxIterations(maxit), ErrorOnNoConverge(err_on_no_conv),PrintInterval(100)
-  {};
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// 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_rr,
-		 Eigen::MatrixXcd &C,
-		 Eigen::MatrixXcd &Cinv,
-		 Field & Q,
-		 const Field & R)
-{
-  int Orthog = blockDim; // First dimension is block dim; this is an assumption
-  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();
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Q = R C^{-1}
-  //
-  // Q_j  = R_i Cinv(i,j) 
-  //
-  // NB maddMatrix conventions are Right multiplication X[j] a[j,i] already
-  ////////////////////////////////////////////////////////////////////////////////////////////////////
-  sliceMulMatrix(Q,Cinv,R,Orthog);
-}
-// see comments above
-void ThinQRfact (Eigen::MatrixXcd &m_rr,
-		 Eigen::MatrixXcd &C,
-		 Eigen::MatrixXcd &Cinv,
-		 std::vector<Field> & Q,
-		 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();
-
-  MulMatrix(Q,Cinv,R);
-}
-
-////////////////////////////////////////////////////////////////////////////////////////////////////
-// Call one of several implementations
-////////////////////////////////////////////////////////////////////////////////////////////////////
-void operator()(LinearOperatorBase<Field> &Linop, const Field &Src, Field &Psi) 
-{
-  if ( CGtype == BlockCGrQ ) {
-    BlockCGrQsolve(Linop,Src,Psi);
-  } else if (CGtype == CGmultiRHS ) {
-    CGmultiRHSsolve(Linop,Src,Psi);
-  } else {
-    GRID_ASSERT(0);
-  }
-}
-virtual void operator()(LinearOperatorBase<Field> &Linop, const std::vector<Field> &Src, std::vector<Field> &Psi) 
-{
-  if ( CGtype == BlockCGrQVec ) {
-    BlockCGrQsolveVec(Linop,Src,Psi);
-  } else {
-    GRID_ASSERT(0);
-  }
-}
-
-////////////////////////////////////////////////////////////////////////////
-// BlockCGrQ implementation:
-//--------------------------
-// X is guess/Solution
-// B is RHS
-// Solve A X_i = B_i    ;        i refers to Nblock index
-////////////////////////////////////////////////////////////////////////////
-void BlockCGrQsolve(LinearOperatorBase<Field> &Linop, const Field &B, Field &X) 
-{
-  int Orthog = blockDim; // First dimension is block dim; this is an assumption
-  Nblock = B.Grid()->_fdimensions[Orthog];
-/* FAKE */
-  Nblock=8;
-  std::cout<<GridLogMessage<<" Block Conjugate Gradient : Orthog "<<Orthog<<" Nblock "<<Nblock<<std::endl;
-
-  X.Checkerboard() = B.Checkerboard();
-  conformable(X, B);
-
-  Field tmp(B);
-  Field Q(B);
-  Field D(B);
-  Field Z(B);
-  Field AD(B);
-
-  Eigen::MatrixXcd m_DZ     = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_M      = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_rr     = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-
-  Eigen::MatrixXcd m_C      = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_Cinv   = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_S      = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_Sinv   = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-
-  Eigen::MatrixXcd m_tmp    = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_tmp1   = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-
-  // Initial residual computation & set up
-  std::vector<RealD> residuals(Nblock);
-  std::vector<RealD> ssq(Nblock);
-
-  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); }
-
-  sliceNorm(residuals,X,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
-
-  /************************************************************************
-   * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
-   ************************************************************************
-   * Dimensions:
-   *
-   *   X,B==(Nferm x Nblock)
-   *   A==(Nferm x Nferm)
-   *  
-   * Nferm = Nspin x Ncolour x Ncomplex x Nlattice_site
-   * 
-   * QC = R = B-AX, D = Q     ; QC => Thin QR factorisation (google it)
-   * for k: 
-   *   Z  = AD
-   *   M  = [D^dag Z]^{-1}
-   *   X  = X + D MC
-   *   QS = Q - ZM
-   *   D  = Q + D S^dag
-   *   C  = S C
-   */
-  ///////////////////////////////////////
-  // Initial block: initial search dir is guess
-  ///////////////////////////////////////
-  std::cout << GridLogMessage<<"BlockCGrQ algorithm initialisation " <<std::endl;
-
-  //1.  QC = R = B-AX, D = Q     ; QC => Thin QR factorisation (google it)
-  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;
-
-  std::cout << GridLogMessage<<"BlockCGrQ computed initial residual and QR fact " <<std::endl;
-
-  ///////////////////////////////////////
-  // Timers
-  ///////////////////////////////////////
-  GridStopWatch sliceInnerTimer;
-  GridStopWatch sliceMaddTimer;
-  GridStopWatch QRTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch SolverTimer;
-  SolverTimer.Start();
-
-  RealD max_resid=0;
-
-  int k;
-  for (k = 1; k <= MaxIterations; k++) {
-
-    //3. Z  = AD
-    MatrixTimer.Start();
-    Linop.HermOp(D, Z);      
-    MatrixTimer.Stop();
-
-    //4. M  = [D^dag Z]^{-1}
-    sliceInnerTimer.Start();
-    sliceInnerProductMatrix(m_DZ,D,Z,Orthog);
-    sliceInnerTimer.Stop();
-    m_M       = m_DZ.inverse();
-    
-    //5. X  = X + D MC
-    m_tmp     = m_M * m_C;
-    sliceMaddTimer.Start();
-    sliceMaddMatrix(X,m_tmp, D,X,Orthog);     
-    sliceMaddTimer.Stop();
-
-    //6. QS = Q - ZM
-    sliceMaddTimer.Start();
-    sliceMaddMatrix(tmp,m_M,Z,Q,Orthog,-1.0);
-    sliceMaddTimer.Stop();
-    QRTimer.Start();
-    ThinQRfact (m_rr, m_S, m_Sinv, Q, tmp);
-    QRTimer.Stop();
-    
-    //7. D  = Q + D S^dag
-    m_tmp = m_S.adjoint();
-
-    sliceMaddTimer.Start();
-    sliceMaddMatrix(D,m_tmp,D,Q,Orthog);
-    sliceMaddTimer.Stop();
-
-    //8. C  = S C
-    m_C = m_S*m_C;
-    
-    /*********************
-     * convergence monitor
-     *********************
-     */
-    m_rr = m_C.adjoint() * m_C;
-
-    max_resid=0;
-    RealD rrsum=0;
-    RealD rr;
-
-    for(int b=0;b<Nblock;b++) {
-      rrsum+=real(m_rr(b,b));
-      rr = real(m_rr(b,b))/ssq[b];
-      if ( rr > max_resid ) max_resid = rr;
-    }
-
-    std::cout << GridLogIterative << "\titeration "<<k<<" rr_sum "<<rrsum<<" ssq_sum "<< sssum
-	      <<" ave "<<std::sqrt(rrsum/sssum) << " max "<< max_resid <<std::endl;
-
-    if ( max_resid < Tolerance*Tolerance ) { 
-
-      SolverTimer.Stop();
-
-      std::cout << GridLogMessage<<"BlockCGrQ converged in "<<k<<" iterations"<<std::endl;
-
-      for(int b=0;b<Nblock;b++){
-	std::cout << GridLogMessage<< "\t\tblock "<<b<<" computed resid "
-		  << std::sqrt(real(m_rr(b,b))/ssq[b])<<std::endl;
-      }
-      std::cout << GridLogMessage<<"\tMax residual is "<<std::sqrt(max_resid)<<std::endl;
-
-      Linop.HermOp(X, AD);
-      AD = AD-B;
-      TrueResidual = std::sqrt(norm2(AD)/norm2(B));
-      std::cout << GridLogMessage <<"\tTrue residual is " << TrueResidual <<std::endl;
-
-      std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
-      std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tInnerProd  " << sliceInnerTimer.Elapsed() <<std::endl;
-      std::cout << GridLogMessage << "\tMaddMatrix " << sliceMaddTimer.Elapsed()  <<std::endl;
-      std::cout << GridLogMessage << "\tThinQRfact " << QRTimer.Elapsed()  <<std::endl;
-	    
-      IterationsToComplete = k;
-      return;
-    }
-
-  }
-
-  std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge "<<k<<" / "<<MaxIterations
-	    <<" residual "<< std::sqrt(max_resid)<< std::endl;
-
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
-  IterationsToComplete = k;
-}
-//////////////////////////////////////////////////////////////////////////
-// multiRHS conjugate gradient. Dimension zero should be the block direction
-// Use this for spread out across nodes
-//////////////////////////////////////////////////////////////////////////
-void CGmultiRHSsolve(LinearOperatorBase<Field> &Linop, const Field &Src, Field &Psi) 
-{
-  int Orthog = blockDim; // First dimension is block dim
-  Nblock = Src.Grid()->_fdimensions[Orthog];
-
-  std::cout<<GridLogMessage<<"MultiRHS Conjugate Gradient : Orthog "<<Orthog<<" Nblock "<<Nblock<<std::endl;
-
-  Psi.Checkerboard() = Src.Checkerboard();
-  conformable(Psi, Src);
-
-  Field P(Src);
-  Field AP(Src);
-  Field R(Src);
-  
-  std::vector<ComplexD> v_pAp(Nblock);
-  std::vector<RealD> v_rr (Nblock);
-  std::vector<RealD> v_rr_inv(Nblock);
-  std::vector<RealD> v_alpha(Nblock);
-  std::vector<RealD> v_beta(Nblock);
-
-  // Initial residual computation & set up
-  std::vector<RealD> residuals(Nblock);
-  std::vector<RealD> ssq(Nblock);
-
-  sliceNorm(ssq,Src,Orthog);
-  RealD sssum=0;
-  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); }
-
-  sliceNorm(residuals,Psi,Orthog);
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
-
-  // Initial search dir is guess
-  Linop.HermOp(Psi, AP);
-
-  R = Src - AP;  
-  P = R;
-  sliceNorm(v_rr,R,Orthog);
-
-  GridStopWatch sliceInnerTimer;
-  GridStopWatch sliceMaddTimer;
-  GridStopWatch sliceNormTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch SolverTimer;
-
-  SolverTimer.Start();
-  int k;
-  for (k = 1; k <= MaxIterations; k++) {
-
-    RealD rrsum=0;
-    for(int b=0;b<Nblock;b++) rrsum+=real(v_rr[b]);
-
-    std::cout << GridLogIterative << "\titeration "<<k<<" rr_sum "<<rrsum<<" ssq_sum "<< sssum
-	      <<" / "<<std::sqrt(rrsum/sssum) <<std::endl;
-
-    MatrixTimer.Start();
-    Linop.HermOp(P, AP);
-    MatrixTimer.Stop();
-
-    // Alpha
-    sliceInnerTimer.Start();
-    sliceInnerProductVector(v_pAp,P,AP,Orthog);
-    sliceInnerTimer.Stop();
-    for(int b=0;b<Nblock;b++){
-      v_alpha[b] = v_rr[b]/real(v_pAp[b]);
-    }
-
-    // Psi, R update
-    sliceMaddTimer.Start();
-    sliceMaddVector(Psi,v_alpha, P,Psi,Orthog);     // add alpha *  P to psi
-    sliceMaddVector(R  ,v_alpha,AP,  R,Orthog,-1.0);// sub alpha * AP to resid
-    sliceMaddTimer.Stop();
-
-    // Beta
-    for(int b=0;b<Nblock;b++){
-      v_rr_inv[b] = 1.0/v_rr[b];
-    }
-    sliceNormTimer.Start();
-    sliceNorm(v_rr,R,Orthog);
-    sliceNormTimer.Stop();
-    for(int b=0;b<Nblock;b++){
-      v_beta[b] = v_rr_inv[b] *v_rr[b];
-    }
-
-    // Search update
-    sliceMaddTimer.Start();
-    sliceMaddVector(P,v_beta,P,R,Orthog);
-    sliceMaddTimer.Stop();
-
-    /*********************
-     * convergence monitor
-     *********************
-     */
-    RealD max_resid=0;
-    for(int b=0;b<Nblock;b++){
-      RealD rr = v_rr[b]/ssq[b];
-      if ( rr > max_resid ) max_resid = rr;
-    }
-    
-    if ( max_resid < Tolerance*Tolerance ) { 
-
-      SolverTimer.Stop();
-
-      std::cout << GridLogMessage<<"MultiRHS solver converged in " <<k<<" iterations"<<std::endl;
-      for(int b=0;b<Nblock;b++){
-	std::cout << GridLogMessage<< "\t\tBlock "<<b<<" computed resid "<< std::sqrt(v_rr[b]/ssq[b])<<std::endl;
-      }
-      std::cout << GridLogMessage<<"\tMax residual is "<<std::sqrt(max_resid)<<std::endl;
-
-      Linop.HermOp(Psi, AP);
-      AP = AP-Src;
-      TrueResidual = std::sqrt(norm2(AP)/norm2(Src));
-      std::cout <<GridLogMessage << "\tTrue residual is " << TrueResidual <<std::endl;
-
-      std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
-      std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tInnerProd  " << sliceInnerTimer.Elapsed() <<std::endl;
-      std::cout << GridLogMessage << "\tNorm       " << sliceNormTimer.Elapsed() <<std::endl;
-      std::cout << GridLogMessage << "\tMaddMatrix " << sliceMaddTimer.Elapsed()  <<std::endl;
-
-
-      IterationsToComplete = k;
-      return;
-    }
-
-  }
-  std::cout << GridLogMessage << "MultiRHSConjugateGradient did NOT converge" << std::endl;
-
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
-  IterationsToComplete = k;
-}
-
-////////////////////////////////////////////////////////////////////////////
-// BlockCGrQvec implementation:
-//--------------------------
-// X is guess/Solution
-// B is RHS
-// Solve A X_i = B_i    ;        i refers to Nblock index
-////////////////////////////////////////////////////////////////////////////
-void BlockCGrQsolveVec(LinearOperatorBase<Field> &Linop, const std::vector<Field> &B, std::vector<Field> &X) 
-{
-  Nblock = B.size();
-  GRID_ASSERT(Nblock == X.size());
-
-  std::cout<<GridLogMessage<<" Block Conjugate Gradient Vec rQ : Nblock "<<Nblock<<std::endl;
-
-  for(int b=0;b<Nblock;b++){ 
-    X[b].Checkerboard() = B[b].Checkerboard();
-    conformable(X[b], B[b]);
-    conformable(X[b], X[0]); 
-  }
-
-  Field Fake(B[0]);
-
-  std::vector<Field> tmp(Nblock,Fake);
-  std::vector<Field>   Q(Nblock,Fake);
-  std::vector<Field>   D(Nblock,Fake);
-  std::vector<Field>   Z(Nblock,Fake);
-  std::vector<Field>  AD(Nblock,Fake);
-
-  Eigen::MatrixXcd m_DZ     = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_M      = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_rr     = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-
-  Eigen::MatrixXcd m_C      = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_Cinv   = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_S      = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-  Eigen::MatrixXcd m_Sinv   = Eigen::MatrixXcd::Zero(Nblock,Nblock);
-
-  Eigen::MatrixXcd m_tmp    = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-  Eigen::MatrixXcd m_tmp1   = Eigen::MatrixXcd::Identity(Nblock,Nblock);
-
-  // Initial residual computation & set up
-  std::vector<RealD> residuals(Nblock);
-  std::vector<RealD> ssq(Nblock);
-
-  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++){ residuals[b] = norm2(X[b]);}
-  for(int b=0;b<Nblock;b++){ GRID_ASSERT(std::isnan(residuals[b])==0); }
-
-  /************************************************************************
-   * Block conjugate gradient rQ (Sebastien Birk Thesis, after Dubrulle 2001)
-   ************************************************************************
-   * Dimensions:
-   *
-   *   X,B==(Nferm x Nblock)
-   *   A==(Nferm x Nferm)
-   *  
-   * Nferm = Nspin x Ncolour x Ncomplex x Nlattice_site
-   * 
-   * QC = R = B-AX, D = Q     ; QC => Thin QR factorisation (google it)
-   * for k: 
-   *   Z  = AD
-   *   M  = [D^dag Z]^{-1}
-   *   X  = X + D MC
-   *   QS = Q - ZM
-   *   D  = Q + D S^dag
-   *   C  = S C
-   */
-  ///////////////////////////////////////
-  // Initial block: initial search dir is guess
-  ///////////////////////////////////////
-  std::cout << GridLogMessage<<"BlockCGrQvec algorithm initialisation " <<std::endl;
-
-  //1.  QC = R = B-AX, D = Q     ; QC => Thin QR factorisation (google it)
-  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);
-
-  for(int b=0;b<Nblock;b++) D[b]=Q[b];
-
-  std::cout << GridLogMessage<<"BlockCGrQ vec computed initial residual and QR fact " <<std::endl;
-
-  ///////////////////////////////////////
-  // Timers
-  ///////////////////////////////////////
-  GridStopWatch sliceInnerTimer;
-  GridStopWatch sliceMaddTimer;
-  GridStopWatch QRTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch SolverTimer;
-  SolverTimer.Start();
-
-  int k;
-  for (k = 1; k <= MaxIterations; k++) {
-
-    //3. Z  = AD
-    MatrixTimer.Start();
-    for(int b=0;b<Nblock;b++) Linop.HermOp(D[b], Z[b]);      
-    MatrixTimer.Stop();
-
-    //4. M  = [D^dag Z]^{-1}
-    sliceInnerTimer.Start();
-    InnerProductMatrix(m_DZ,D,Z);
-    sliceInnerTimer.Stop();
-    m_M       = m_DZ.inverse();
-    
-    //5. X  = X + D MC
-    m_tmp     = m_M * m_C;
-    sliceMaddTimer.Start();
-    MaddMatrix(X,m_tmp, D,X);     
-    sliceMaddTimer.Stop();
-
-    //6. QS = Q - ZM
-    sliceMaddTimer.Start();
-    MaddMatrix(tmp,m_M,Z,Q,-1.0);
-    sliceMaddTimer.Stop();
-    QRTimer.Start();
-    ThinQRfact (m_rr, m_S, m_Sinv, Q, tmp);
-    QRTimer.Stop();
-    
-    //7. D  = Q + D S^dag
-    m_tmp = m_S.adjoint();
-    sliceMaddTimer.Start();
-    MaddMatrix(D,m_tmp,D,Q);
-    sliceMaddTimer.Stop();
-
-    //8. 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 rr;
-
-    for(int b=0;b<Nblock;b++) {
-      rrsum+=real(m_rr(b,b));
-      rr = real(m_rr(b,b))/ssq[b];
-      if ( rr > max_resid ) max_resid = rr;
-    }
-
-    std::cout << GridLogIterative << "\t Block Iteration "<<k<<" ave resid "<< std::sqrt(rrsum/sssum) << " max "<< std::sqrt(max_resid) <<std::endl;
-
-    if ( max_resid < Tolerance*Tolerance ) { 
-
-      SolverTimer.Stop();
-
-      std::cout << GridLogMessage<<"BlockCGrQ converged in "<<k<<" iterations"<<std::endl;
-
-      for(int b=0;b<Nblock;b++){
-	std::cout << GridLogMessage<< "\t\tblock "<<b<<" computed resid "<< std::sqrt(real(m_rr(b,b))/ssq[b])<<std::endl;
-      }
-      std::cout << GridLogMessage<<"\tMax residual is "<<std::sqrt(max_resid)<<std::endl;
-
-      for(int b=0;b<Nblock;b++) Linop.HermOp(X[b], AD[b]);
-      for(int b=0;b<Nblock;b++) AD[b] = AD[b]-B[b];
-      TrueResidual = std::sqrt(normv(AD)/normv(B));
-      std::cout << GridLogMessage << "\tTrue residual is " << TrueResidual <<std::endl;
-
-      std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
-      std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed()     <<std::endl;
-      std::cout << GridLogMessage << "\tInnerProd  " << sliceInnerTimer.Elapsed() <<std::endl;
-      std::cout << GridLogMessage << "\tMaddMatrix " << sliceMaddTimer.Elapsed()  <<std::endl;
-      std::cout << GridLogMessage << "\tThinQRfact " << QRTimer.Elapsed()  <<std::endl;
-	    
-      IterationsToComplete = k;
-      return;
-    }
-
-  }
-  std::cout << GridLogMessage << "BlockConjugateGradient(rQ) did NOT converge" << std::endl;
-
-  if (ErrorOnNoConverge) GRID_ASSERT(0);
-  IterationsToComplete = k;
-}
-
-};
-
-NAMESPACE_END(Grid);
-

Grid/algorithms/iterative/CommunicationAvoidingGeneralisedMinimalResidual.h

@@ -1,248 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/CommunicationAvoidingGeneralisedMinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_COMMUNICATION_AVOIDING_GENERALISED_MINIMAL_RESIDUAL_H
-#define GRID_COMMUNICATION_AVOIDING_GENERALISED_MINIMAL_RESIDUAL_H
-
-namespace Grid {
-
-template<class Field>
-class CommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<Field> {
- public:
-  using OperatorFunction<Field>::operator();
-
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when CAGMRES fails to converge,
-                          // defaults to true
-
-  RealD   Tolerance;
-
-  Integer MaxIterations;
-  Integer RestartLength;
-  Integer MaxNumberOfRestarts;
-  Integer IterationCount; // Number of iterations the CAGMRES took to finish,
-                          // filled in upon completion
-
-  GridStopWatch MatrixTimer;
-  GridStopWatch LinalgTimer;
-  GridStopWatch QrTimer;
-  GridStopWatch CompSolutionTimer;
-
-  Eigen::MatrixXcd H;
-
-  std::vector<ComplexD> y;
-  std::vector<ComplexD> gamma;
-  std::vector<ComplexD> c;
-  std::vector<ComplexD> s;
-
-  CommunicationAvoidingGeneralisedMinimalResidual(RealD   tol,
-                                                  Integer maxit,
-                                                  Integer restart_length,
-                                                  bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , RestartLength(restart_length)
-      , MaxNumberOfRestarts(MaxIterations/RestartLength + ((MaxIterations%RestartLength == 0) ? 0 : 1))
-      , ErrorOnNoConverge(err_on_no_conv)
-      , H(Eigen::MatrixXcd::Zero(RestartLength, RestartLength + 1)) // sizes taken from DD-αAMG code base
-      , y(RestartLength + 1, 0.)
-      , gamma(RestartLength + 1, 0.)
-      , c(RestartLength + 1, 0.)
-      , s(RestartLength + 1, 0.) {};
-
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi) {
-
-    std::cout << GridLogWarning << "This algorithm currently doesn't differ from regular GMRES" << std::endl;
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD cp;
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    Field r(src.Grid());
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "CommunicationAvoidingGeneralisedMinimalResidual: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "CommunicationAvoidingGeneralisedMinimalResidual:   src " << ssq   << std::endl;
-
-    MatrixTimer.Reset();
-    LinalgTimer.Reset();
-    QrTimer.Reset();
-    CompSolutionTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    SolverTimer.Start();
-
-    IterationCount = 0;
-
-    for (int k=0; k<MaxNumberOfRestarts; k++) {
-
-      cp = outerLoopBody(LinOp, src, psi, rsq);
-
-      // Stopping condition
-      if (cp <= rsq) {
-
-        SolverTimer.Stop();
-
-        LinOp.Op(psi,r);
-        axpy(r,-1.0,src,r);
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "CommunicationAvoidingGeneralisedMinimalResidual: Converged on iteration " << IterationCount
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "CAGMRES Time elapsed: Total   " <<       SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "CAGMRES Time elapsed: Matrix  " <<       MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "CAGMRES Time elapsed: Linalg  " <<       LinalgTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "CAGMRES Time elapsed: QR      " <<           QrTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "CAGMRES Time elapsed: CompSol " << CompSolutionTimer.Elapsed() << std::endl;
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "CommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-  }
-
-  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
-
-    RealD cp = 0;
-
-    Field w(src.Grid());
-    Field r(src.Grid());
-
-    // this should probably be made a class member so that it is only allocated once, not in every restart
-    std::vector<Field> v(RestartLength + 1, src.Grid()); for (auto &elem : v) elem = Zero();
-
-    MatrixTimer.Start();
-    LinOp.Op(psi, w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    r = src - w;
-
-    gamma[0] = sqrt(norm2(r));
-
-    ComplexD scale = 1.0/gamma[0];
-    v[0] = scale * r;
-
-    LinalgTimer.Stop();
-
-    for (int i=0; i<RestartLength; i++) {
-
-      IterationCount++;
-
-      arnoldiStep(LinOp, v, w, i);
-
-      qrUpdate(i);
-
-      cp = norm(gamma[i+1]);
-
-      std::cout << GridLogIterative << "CommunicationAvoidingGeneralisedMinimalResidual: Iteration " << IterationCount
-                << " residual " << cp << " target " << rsq << std::endl;
-
-      if ((i == RestartLength - 1) || (IterationCount == MaxIterations) || (cp <= rsq)) {
-
-        computeSolution(v, psi, i);
-
-        return cp;
-      }
-    }
-
-    GRID_ASSERT(0); // Never reached
-    return cp;
-  }
-
-  void arnoldiStep(LinearOperatorBase<Field> &LinOp, std::vector<Field> &v, Field &w, int iter) {
-
-    MatrixTimer.Start();
-    LinOp.Op(v[iter], w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    for (int i = 0; i <= iter; ++i) {
-      H(iter, i) = innerProduct(v[i], w);
-      w = w - ComplexD(H(iter, i)) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = ComplexD(1. / H(iter, iter + 1)) * w;
-    LinalgTimer.Stop();
-  }
-
-  void qrUpdate(int iter) {
-
-    QrTimer.Start();
-    for (int i = 0; i < iter ; ++i) {
-      auto tmp       = -s[i] * ComplexD(H(iter, i)) + c[i] * ComplexD(H(iter, i + 1));
-      H(iter, i)     = conjugate(c[i]) * ComplexD(H(iter, i)) + conjugate(s[i]) * ComplexD(H(iter, i + 1));
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    auto nu     = sqrt(std::norm(H(iter, iter)) + std::norm(H(iter, iter + 1)));
-    c[iter]     = H(iter, iter) / nu;
-    s[iter]     = H(iter, iter + 1) / nu;
-
-    // Apply new Givens rotation
-    H(iter, iter)     = nu;
-    H(iter, iter + 1) = 0.;
-
-    gamma[iter + 1] = -s[iter] * gamma[iter];
-    gamma[iter]     = conjugate(c[iter]) * gamma[iter];
-    QrTimer.Stop();
-  }
-
-  void computeSolution(std::vector<Field> const &v, Field &psi, int iter) {
-
-    CompSolutionTimer.Start();
-    for (int i = iter; i >= 0; i--) {
-      y[i] = gamma[i];
-      for (int k = i + 1; k <= iter; k++)
-        y[i] = y[i] - ComplexD(H(k, i)) * y[k];
-      y[i] = y[i] / ComplexD(H(i, i));
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + v[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/ConjugateGradient.h

@@ -1,377 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/ConjugateGradient.h
-
-Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-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_H
-#define GRID_CONJUGATE_GRADIENT_H
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////
-// Base classes for iterative processes based on operators
-// 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.
-                           // Defaults true.
-  RealD Tolerance;
-  Integer MaxIterations;
-  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
-  RealD TrueResidual;
-  
-  ConjugateGradient(RealD tol, Integer maxit, bool err_on_no_conv = true)
-    : Tolerance(tol),
-      MaxIterations(maxit),
-      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) {
-
-      this->LogBegin();
-
-      GRID_TRACE("ConjugateGradient");
-    GridStopWatch PreambleTimer;
-    GridStopWatch ConstructTimer;
-    GridStopWatch NormTimer;
-    GridStopWatch AssignTimer;
-    PreambleTimer.Start();
-    psi.Checkerboard() = src.Checkerboard();
-
-    conformable(psi, src);
-
-    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();
-
-    // 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);
-    }
-    cp = a;
-    AssignTimer.Stop();
-
-    // Handle trivial case of zero src
-    if (ssq == 0.){
-      psi = Zero();
-      IterationsToComplete = 1;
-      TrueResidual = 0.;
-      return;
-    }
-
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient: guess " << guess << std::endl;
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:   src " << ssq << std::endl;
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:    mp " << d << std::endl;
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:   mmp " << b << std::endl;
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:  cp,r " << cp << std::endl;
-    std::cout << GridLogIterative << std::setprecision(8) << "ConjugateGradient:     p " << a << std::endl;
-
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    // Check if guess is really REALLY good :)
-    if (cp <= rsq) {
-      TrueResidual = std::sqrt(a/ssq);
-      std::cout << GridLogMessage << "ConjugateGradient guess is converged already " << std::endl;
-      IterationsToComplete = 0;	
-      return;
-    }
-
-    std::cout << GridLogIterative << std::setprecision(8)
-              << "ConjugateGradient: k=0 residual " << cp << " target " << rsq << std::endl;
-
-    PreambleTimer.Stop();
-    GridStopWatch LinalgTimer;
-    GridStopWatch InnerTimer;
-    GridStopWatch AxpyNormTimer;
-    GridStopWatch LinearCombTimer;
-    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();
-      Linop.HermOp(p, mmp);
-      MatrixTimer.Stop();
-
-      LinalgTimer.Start();
-
-      InnerTimer.Start();
-      ComplexD dc  = innerProduct(p,mmp);
-      InnerTimer.Stop();
-      d = dc.real();
-      a = c / d;
-
-      AxpyNormTimer.Start();
-      cp = axpy_norm(r, -a, mmp, r);
-      AxpyNormTimer.Stop();
-      b = cp / c;
-
-      LinearCombTimer.Start();
-      {
-	autoView( psi_v , psi, AcceleratorWrite);
-	autoView( p_v   , p,   AcceleratorWrite);
-	autoView( r_v   , r,   AcceleratorWrite);
-	accelerator_for(ss,p_v.size(), Field::vector_object::Nsimd(),{
-	    coalescedWrite(psi_v[ss], a      *  p_v(ss) + psi_v(ss));
-	    coalescedWrite(p_v[ss]  , b      *  p_v(ss) + r_v  (ss));
-	});
-      }
-      LinearCombTimer.Stop();
-      LinalgTimer.Stop();
-      LogIteration(k,a,b);
-
-      IterationTimer.Stop();
-      if ( (k % 500) == 0 ) {
-	std::cout << GridLogMessage << "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 << GridLogDebug << "\tMobius flop rate " << DwfFlops/ usecs<< " Gflops " <<std::endl;
-
-        if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
-
-	IterationsToComplete = k;	
-	TrueResidual = true_residual;
-
-        return;
-      }
-    }
-    // Failed. Calculate true residual before giving up                                                         
-    // Linop.HermOpAndNorm(psi, mmp, d, qq);
-    //    p = mmp - src;
-    //TrueResidual = sqrt(norm2(p)/ssq);
-    //    TrueResidual = 1;
-
-    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;
-
-    if (ErrorOnNoConverge) GRID_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

Grid/algorithms/iterative/ConjugateGradientMixedPrec.h

@@ -1,170 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ConjugateGradientMixedPrec.h
-
-    Copyright (C) 2015
-
-Author: Christopher Kelly <ckelly@phys.columbia.edu>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_CONJUGATE_GRADIENT_MIXED_PREC_H
-#define GRID_CONJUGATE_GRADIENT_MIXED_PREC_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 MixedPrecisionConjugateGradient : 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;
-    GridBase* SinglePrecGrid; //Grid for single-precision fields
-    RealD OuterLoopNormMult; //Stop the outer loop and move to a final double prec solve when the residual is OuterLoopNormMult * Tolerance
-    LinearOperatorBase<FieldF> &Linop_f;
-    LinearOperatorBase<FieldD> &Linop_d;
-
-    Integer TotalInnerIterations; //Number of inner CG iterations
-    Integer TotalOuterIterations; //Number of restarts
-    Integer TotalFinalStepIterations; //Number of CG iterations in final patch-up step
-    RealD TrueResidual;
-
-    //Option to speed up *inner single precision* solves using a LinearFunction that produces a guess
-    LinearFunction<FieldF> *guesser;
-    
-    MixedPrecisionConjugateGradient(RealD tol, 
-				    Integer maxinnerit, 
-				    Integer maxouterit, 
-				    GridBase* _sp_grid, 
-				    LinearOperatorBase<FieldF> &_Linop_f, 
-				    LinearOperatorBase<FieldD> &_Linop_d) :
-      Linop_f(_Linop_f), Linop_d(_Linop_d),
-      Tolerance(tol), InnerTolerance(tol), MaxInnerIterations(maxinnerit), MaxOuterIterations(maxouterit), SinglePrecGrid(_sp_grid),
-      OuterLoopNormMult(100.), guesser(NULL){ };
-
-    void useGuesser(LinearFunction<FieldF> &g){
-      guesser = &g;
-    }
-  
-  void operator() (const FieldD &src_d_in, FieldD &sol_d){
-    std::cout << GridLogMessage << "MixedPrecisionConjugateGradient: Starting mixed precision CG with outer tolerance " << Tolerance << " and inner tolerance " << InnerTolerance << std::endl;
-    TotalInnerIterations = 0;
-	
-    GridStopWatch TotalTimer;
-    TotalTimer.Start();
-    
-    int cb = src_d_in.Checkerboard();
-    sol_d.Checkerboard() = cb;
-    
-    RealD src_norm = norm2(src_d_in);
-    RealD stop = src_norm * Tolerance*Tolerance;
-
-    GridBase* DoublePrecGrid = src_d_in.Grid();
-    FieldD tmp_d(DoublePrecGrid);
-    tmp_d.Checkerboard() = cb;
-    
-    FieldD tmp2_d(DoublePrecGrid);
-    tmp2_d.Checkerboard() = cb;
-    
-    FieldD src_d(DoublePrecGrid);
-    src_d = src_d_in; //source for next inner iteration, computed from residual during operation
-    
-    RealD inner_tol = InnerTolerance;
-    
-    FieldF src_f(SinglePrecGrid);
-    src_f.Checkerboard() = cb;
-    
-    FieldF sol_f(SinglePrecGrid);
-    sol_f.Checkerboard() = cb;
-    
-    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;
-
-    GridStopWatch InnerCGtimer;
-
-    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) ??
-
-      PrecChangeTimer.Start();
-      precisionChange(src_f, src_d, pc_wk_dp_to_sp);
-      PrecChangeTimer.Stop();
-      
-      sol_f = Zero();
-
-      //Optionally improve inner solver guess (eg using known eigenvectors)
-      if(guesser != NULL)
-	(*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);
-      InnerCGtimer.Stop();
-      TotalInnerIterations += CG_f.IterationsToComplete;
-      
-      //Convert sol back to double and add to double prec solution
-      PrecChangeTimer.Start();
-      precisionChange(tmp_d, sol_f, pc_wk_sp_to_dp);
-      PrecChangeTimer.Stop();
-      
-      axpy(sol_d, 1.0, tmp_d, sol_d);
-    }
-    
-    //Final trial CG
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Starting final patch-up double-precision solve"<<std::endl;
-    
-    ConjugateGradient<FieldD> CG_d(Tolerance, MaxInnerIterations);
-    CG_d(Linop_d, src_d_in, sol_d);
-    TotalFinalStepIterations = CG_d.IterationsToComplete;
-    TrueResidual = CG_d.TrueResidual;
-
-    TotalTimer.Stop();
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Inner CG iterations " << TotalInnerIterations << " Restarts " << TotalOuterIterations << " Final CG iterations " << TotalFinalStepIterations << std::endl;
-    std::cout<<GridLogMessage<<"MixedPrecisionConjugateGradient: Total time " << TotalTimer.Elapsed() << " Precision change " << PrecChangeTimer.Elapsed() << " Inner CG total " << InnerCGtimer.Elapsed() << std::endl;
-  }
-};
-
-NAMESPACE_END(Grid);
-
-#endif

Grid/algorithms/iterative/ConjugateGradientMixedPrecBatched.h

@@ -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

Grid/algorithms/iterative/ConjugateGradientMultiShift.h

@@ -1,346 +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>
-
-    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_MULTI_SHIFT_GRADIENT_H
-#define GRID_CONJUGATE_MULTI_SHIFT_GRADIENT_H
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////
-// Base classes for iterative processes based on operators
-// single input vec, single output vec.
-/////////////////////////////////////////////////////////////
-
-template<class Field> 
-class ConjugateGradientMultiShift : public OperatorMultiFunction<Field>,
-				    public OperatorFunction<Field>
-{
-public:                                                
-
-  using OperatorFunction<Field>::operator();
-
-  //  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
-  int verbose;
-  MultiShiftFunction shifts;
-  std::vector<RealD> TrueResidualShift;
-
-  ConjugateGradientMultiShift(Integer maxit, const MultiShiftFunction &_shifts) : 
-    MaxIterations(maxit),
-    shifts(_shifts)
-  { 
-    verbose=1;
-    IterationsToCompleteShift.resize(_shifts.order);
-    TrueResidualShift.resize(_shifts.order);
-  }
-
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &src, Field &psi)
-  {
-    GridBase *grid = src.Grid();
-    int nshift = shifts.order;
-    std::vector<Field> results(nshift,grid);
-    (*this)(Linop,src,results,psi);
-  }
-  void operator() (LinearOperatorBase<Field> &Linop, const Field &src, std::vector<Field> &results, Field &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<Field> &Linop, const Field &src, std::vector<Field> &psi)
-  {
-    GRID_TRACE("ConjugateGradientMultiShift");
-  
-    GridBase *grid = src.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);
-    std::vector<Field>   ps(nshift,grid);// Search directions
-
-    GRID_ASSERT(psi.size()==nshift);
-    GRID_ASSERT(mass.size()==nshift);
-    GRID_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);
-  
-    const int       primary =0;
-  
-    //Primary shift fields CG iteration
-    RealD a,b,c,d;
-    RealD cp,bp,qq; //prev
-  
-    // Matrix mult fields
-    Field r(grid);
-    Field p(grid);
-    Field tmp(grid);
-    Field mmp(grid);
-  
-    // 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);
-
-    // Handle trivial case of zero src.
-    if( cp == 0. ){
-      for(int s=0;s<nshift;s++){
-	psi[s] = Zero();
-	IterationsToCompleteShift[s] = 1;
-	TrueResidualShift[s] = 0.;
-      }
-      return;
-    }
-
-    for(int s=0;s<nshift;s++){
-      rsq[s] = cp * mresidual[s] * mresidual[s];
-      std::cout<<GridLogMessage<<"ConjugateGradientMultiShift: shift "<<s
-	       <<" target resid^2 "<<rsq[s]<<std::endl;
-      ps[s] = src;
-    }
-    // r and p for primary
-    r=src;
-    p=src;
-  
-    //MdagM+m[0]
-    Linop.HermOpAndNorm(p,mmp,d,qq);
-    axpy(mmp,mass[0],p,mmp);
-    RealD rn = norm2(p);
-    d += rn*mass[0];
-  
-    // have verified that inner product of 
-    // p and mmp is equal to d after this since
-    // the d computation is tricky
-    //  qq = real(innerProduct(p,mmp));
-    //  std::cout<<GridLogMessage << "debug equal ?  qq "<<qq<<" d "<< d<<std::endl;
-  
-    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,b,mmp,r);
-  
-    for(int s=0;s<nshift;s++) {
-      axpby(psi[s],0.,-bs[s]*alpha[s],src,src);
-    }
-
-    std::cout << GridLogIterative << "ConjugateGradientMultiShift: initial rn (|src|^2) =" << rn << " qq (|MdagM src|^2) =" << qq << " d ( dot(src, [MdagM + m_0]src) ) =" << d << " c=" << c << std::endl;
-    
-  
-  ///////////////////////////////////////
-  // Timers
-  ///////////////////////////////////////
-  GridStopWatch AXPYTimer;
-  GridStopWatch ShiftTimer;
-  GridStopWatch QRTimer;
-  GridStopWatch MatrixTimer;
-  GridStopWatch SolverTimer;
-  SolverTimer.Start();
-  
-    // Iteration loop
-    int k;
-  
-    for (k=1;k<=MaxIterations;k++){
-    
-      a = c /cp;
-    AXPYTimer.Start();
-      axpy(p,a,p,r);
-    AXPYTimer.Stop();
-    
-      // Note to self - direction ps is iterated seperately
-      // for each shift. Does not appear to have any scope
-      // for avoiding linear algebra in "single" case.
-      // 
-      // However SAME r is used. Could load "r" and update
-      // ALL ps[s]. 2/3 Bandwidth saving
-      // New Kernel: Load r, vector of coeffs, vector of pointers ps
-    AXPYTimer.Start();
-      for(int s=0;s<nshift;s++){
-	if ( ! converged[s] ) { 
-	  if (s==0){
-	    axpy(ps[s],a,ps[s],r);
-	  } else{
-	    RealD as =a *z[s][iz]*bs[s] /(z[s][1-iz]*b);
-	    axpby(ps[s],z[s][iz],as,r,ps[s]);
-	  }
-	}
-      }
-    AXPYTimer.Stop();
-    
-      cp=c;
-    MatrixTimer.Start();  
-    //Linop.HermOpAndNorm(p,mmp,d,qq); // d is used
-    // The below is faster on KNL
-    Linop.HermOp(p,mmp); 
-    d=real(innerProduct(p,mmp));
-    
-    MatrixTimer.Stop();  
-
-    AXPYTimer.Start();
-      axpy(mmp,mass[0],p,mmp);
-    AXPYTimer.Stop();
-      RealD rn = norm2(p);
-      d += rn*mass[0];
-    
-      bp=b;
-      b=-cp/d;
-    
-    AXPYTimer.Start();
-      c=axpy_norm(r,b,mmp,r);
-    AXPYTimer.Stop();
-
-      // 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();
-    
-      for(int s=0;s<nshift;s++){
-	int ss = s;
-	// Scope for optimisation here in case of "single".
-	// Could load psi[0] and pull all ps[s] in.
-	//      if ( single ) ss=primary;
-	// Bandwith saving in single case is Ls * 3 -> 2+Ls, so ~ 3x saving
-	// Pipelined CG gain:
-	//
-	// New Kernel: Load r, vector of coeffs, vector of pointers ps
-	// New Kernel: Load psi[0], vector of coeffs, vector of pointers ps
-	// If can predict the coefficient bs then we can fuse these and avoid write reread cyce
-	//  on ps[s].
-	// Before:  3 x npole  + 3 x npole
-	// After :  2 x npole (ps[s])        => 3x speed up of multishift CG.
-      
-	if( (!converged[s]) ) { 
-	  axpy(psi[ss],-bs[s]*alpha[s],ps[s],psi[ss]);
-	}
-      }
-    
-      // 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<rsq[s]){
-	    if ( ! converged[s] )
-	      std::cout<<GridLogMessage<<"ConjugateGradientMultiShift k="<<k<<" Shift "<<s<<" has converged"<<std::endl;
-	    converged[s]=1;
-	  } else {
-	    all_converged=0;
-	  }
-
-	}
-      }
-    
-      if ( all_converged ){
-
-    SolverTimer.Stop();
-
-
-	std::cout<<GridLogMessage<< "CGMultiShift: All shifts have converged iteration "<<k<<std::endl;
-	std::cout<<GridLogMessage<< "CGMultiShift: Checking solutions"<<std::endl;
-      
-	// Check answers 
-	for(int s=0; s < nshift; s++) { 
-	  Linop.HermOpAndNorm(psi[s],mmp,d,qq);
-	  axpy(tmp,mass[s],psi[s],mmp);
-	  axpy(r,-alpha[s],src,tmp);
-	  RealD rn = norm2(r);
-	  RealD cn = norm2(src);
-	  TrueResidualShift[s] = std::sqrt(rn/cn);
-	  std::cout<<GridLogMessage<<"CGMultiShift: shift["<<s<<"] true residual "<< TrueResidualShift[s] <<std::endl;
-	}
-
-      std::cout << GridLogMessage << "Time Breakdown "<<std::endl;
-      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 << "\tShift    " << ShiftTimer.Elapsed()     <<std::endl;
-
-      IterationsToComplete = k;	
-
-	return;
-      }
-
-   
-    }
-    // ugly hack
-    std::cout<<GridLogMessage<<"CG multi shift did not converge"<<std::endl;
-    //  GRID_ASSERT(0);
-  }
-
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/ConjugateGradientMultiShiftCleanup.h

@@ -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);
-

Grid/algorithms/iterative/ConjugateGradientMultiShiftMixedPrec.h

@@ -1,416 +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 */
-#ifndef GRID_CONJUGATE_GRADIENT_MULTI_SHIFT_MIXEDPREC_H
-#define GRID_CONJUGATE_GRADIENT_MULTI_SHIFT_MIXEDPREC_H
-
-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
-
-//Linop to add shift to input linop, used in cleanup CG
-namespace ConjugateGradientMultiShiftMixedPrecSupport{
-template<typename Field>
-class ShiftedLinop: public LinearOperatorBase<Field>{
-public:
-  LinearOperatorBase<Field> &linop_base;
-  RealD shift;
-
-  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 Op     (const Field &in, Field &out){ GRID_ASSERT(0); }
-  void AdjOp  (const Field &in, Field &out){ GRID_ASSERT(0); }
-
-  void HermOp(const Field &in, Field &out){
-    linop_base.HermOp(in, out);
-    axpy(out, shift, 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);
-  }
-};
-};
-
-
-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 ConjugateGradientMultiShiftMixedPrec : 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
-
-  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)
-  { 
-    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("ConjugateGradientMultiShiftMixedPrec");
-    GridBase *DoublePrecGrid = src_d.Grid();
-
-    precisionChangeWorkspace pc_wk_s_to_d(DoublePrecGrid,SinglePrecGrid);
-    precisionChangeWorkspace pc_wk_d_to_s(SinglePrecGrid,DoublePrecGrid);
-    
-    ////////////////////////////////////////////////////////////////////////
-    // 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<FieldD> ps_d(nshift, DoublePrecGrid);// Search directions (double precision)
-
-    FieldD tmp_d(DoublePrecGrid);
-    FieldD r_d(DoublePrecGrid);
-    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();
-	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<<"ConjugateGradientMultiShiftMixedPrec: shift "<< s <<" target resid "<<rsq[s]<<std::endl;
-      ps_d[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, 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);
-    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);
-    }
-  
-    ///////////////////////////////////////
-    // 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); 
-
-      for(int s=0;s<nshift;s++){
-	if ( ! converged[s] ) { 
-	  if (s==0){
-	    axpy(ps_d[s],a,ps_d[s],r_d);
-	  } else{
-	    RealD as =a *z[s][iz]*bs[s] /(z[s][1-iz]*b);
-	    axpby(ps_d[s],z[s][iz],as,r_d,ps_d[s]);
-	  }
-	}
-      }
-      AXPYTimer.Stop();
-
-      PrecChangeTimer.Start();
-      precisionChange(p_f, p_d, pc_wk_d_to_s); //get back single prec search direction for linop
-      PrecChangeTimer.Stop();
-
-      cp=c;
-      MatrixTimer.Start();  
-      Linop_f.HermOp(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);
-      AXPYTimer.Stop();
-      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 double precision solutions
-      AXPYTimer.Start();
-      for(int s=0;s<nshift;s++){
-	int ss = s;
-	if( (!converged[s]) ) { 
-	  axpy(psi_d[ss],-bs[s]*alpha[s],ps_d[s],psi_d[ss]);
-	}
-      }
-
-      //Perform reliable update if necessary; otherwise update residual from single-prec mmp
-      c = axpy_norm(r_d,b,mmp_d,r_d);
-
-      AXPYTimer.Stop();
-
-      if(k % ReliableUpdateFreq == 0){
-	RealD c_old = c;
-	//Replace r with true residual
-	MatrixTimer.Start();  
-	Linop_d.HermOp(psi_d[0],mmp_d); 
-	MatrixTimer.Stop();  
-
-	AXPYTimer.Start();
-	axpy(mmp_d,mass[0],psi_d[0],mmp_d);
-
-	c = 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;
-      }
-    
-      // 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<<"ConjugateGradientMultiShiftMixedPrec k="<<k<<" Shift "<<s<<" has converged"<<std::endl;
-	    converged[s]=1;
-	  } else {
-	    all_converged=0;
-	  }
-
-	}
-      }
-
-      if ( all_converged || k == MaxIterationsMshift-1){
-
-	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;
-	}
-	
-	// 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<<"ConjugateGradientMultiShiftMixedPrec: 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<<"ConjugateGradientMultiShiftMixedPrec: 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 << "ConjugateGradientMultiShiftMixedPrec: 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);
-#endif

Grid/algorithms/iterative/ConjugateGradientReliableUpdate.h

@@ -1,277 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ConjugateGradientReliableUpdate.h
-
-    Copyright (C) 2015
-
-Author: Christopher Kelly <ckelly@phys.columbia.edu>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_CONJUGATE_GRADIENT_RELIABLE_UPDATE_H
-#define GRID_CONJUGATE_GRADIENT_RELIABLE_UPDATE_H
-
-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 ConjugateGradientReliableUpdate : public LinearFunction<FieldD> {
-public:
-  bool ErrorOnNoConverge;  // throw an GRID_ASSERT when the CG fails to converge.
-  // Defaults true.
-  RealD Tolerance;
-  Integer MaxIterations;
-  Integer IterationsToComplete; //Number of iterations the CG took to finish. Filled in upon completion
-  Integer ReliableUpdatesPerformed;
-
-  bool DoFinalCleanup; //Final DP cleanup, defaults to true
-  Integer IterationsToCleanup; //Final DP cleanup step iterations
-    
-  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
-
-  //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;
-  RealD fallback_transition_tol;
-
-    
-  ConjugateGradientReliableUpdate(RealD tol, Integer maxit, RealD _delta, GridBase* _sp_grid, LinearOperatorBase<FieldF> &_Linop_f, LinearOperatorBase<FieldD> &_Linop_d, bool err_on_no_conv = true)
-    : Tolerance(tol),
-      MaxIterations(maxit),
-      Delta(_delta),
-      Linop_f(_Linop_f),
-      Linop_d(_Linop_d),
-      SinglePrecGrid(_sp_grid),
-      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;
-    fallback_transition_tol = _fallback_transition_tol;      
-  }
-    
-  void operator()(const FieldD &src, FieldD &psi) {
-    GRID_TRACE("ConjugateGradientReliableUpdate");
-    LinearOperatorBase<FieldF> *Linop_f_use = &Linop_f;
-    bool using_fallback = false;
-      
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD cp, c, a, d, b, ssq, qq, b_pred;
-
-    FieldD p(src);
-    FieldD mmp(src);
-    FieldD r(src);
-
-    // Initial residual computation & set up
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-    
-    Linop_d.HermOpAndNorm(psi, mmp, d, b);
-    
-    r = src - mmp;
-    p = r;
-
-    a = norm2(p);
-    cp = a;
-    ssq = norm2(src);
-
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate: guess " << guess << std::endl;
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate:   src " << ssq << std::endl;
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate:    mp " << d << std::endl;
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate:   mmp " << b << std::endl;
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate:  cp,r " << cp << std::endl;
-    std::cout << GridLogIterative << std::setprecision(4) << "ConjugateGradientReliableUpdate:     p " << a << std::endl;
-
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    // Check if guess is really REALLY good :)
-    if (cp <= rsq) {
-      std::cout << GridLogMessage << "ConjugateGradientReliableUpdate guess was REALLY good\n";
-      std::cout << GridLogMessage << "\tComputed residual " << std::sqrt(cp / ssq)<<std::endl;
-      return;
-    }
-
-    //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);
-
-    FieldF psi_f(r_f);
-    psi_f = Zero();
-
-    FieldF p_f(r_f);
-    FieldF mmp_f(r_f);
-
-    RealD MaxResidSinceLastRelUp = cp; //initial residual    
-    
-    std::cout << GridLogIterative << std::setprecision(4)
-	      << "ConjugateGradient: k=0 residual " << cp << " target " << rsq << std::endl;
-
-    GridStopWatch LinalgTimer;
-    GridStopWatch MatrixTimer;
-    GridStopWatch SolverTimer;
-    GridStopWatch PrecChangeTimer;
-    
-    SolverTimer.Start();
-    int k = 0;
-    int l = 0;
-    
-    for (k = 1; k <= MaxIterations; k++) {
-      c = cp;
-
-      MatrixTimer.Start();
-      Linop_f_use->HermOpAndNorm(p_f, mmp_f, d, qq);
-      MatrixTimer.Stop();
-
-      LinalgTimer.Start();
-
-      a = c / d;
-      b_pred = a * (a * qq - d) / c;
-
-      cp = axpy_norm(r_f, -a, mmp_f, r_f);
-      b = cp / c;
-
-      // Fuse these loops ; should be really easy
-      psi_f = a * p_f + psi_f;
-      //p_f = p_f * b + r_f;
-
-      LinalgTimer.Stop();
-
-      std::cout << GridLogIterative << "ConjugateGradientReliableUpdate: Iteration " << k
-		<< " residual " << cp << " target " << rsq << std::endl;
-      std::cout << GridLogDebug << "a = "<< a << " b_pred = "<< b_pred << "  b = "<< b << std::endl;
-      std::cout << GridLogDebug << "qq = "<< qq << " d = "<< d << "  c = "<< c << std::endl;
-
-      if(cp > MaxResidSinceLastRelUp){
-	std::cout << GridLogIterative << "ConjugateGradientReliableUpdate: updating MaxResidSinceLastRelUp : " << MaxResidSinceLastRelUp << " -> " << cp << std::endl;
-	MaxResidSinceLastRelUp = cp;
-      }
-	  
-      // 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();
-	psi = psi + mmp;
-	
-	
-	SolverTimer.Stop();
-	Linop_d.HermOpAndNorm(psi, mmp, d, qq);
-	p = mmp - src;
-
-	RealD srcnorm = std::sqrt(norm2(src));
-	RealD resnorm = std::sqrt(norm2(p));
-	RealD true_residual = resnorm / srcnorm;
-
-	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate Converged on iteration " << k << " after " << l << " reliable updates" << std::endl;
-	std::cout << GridLogMessage << "\tComputed residual " << std::sqrt(cp / ssq)<<std::endl;
-	std::cout << GridLogMessage << "\tTrue residual " << true_residual<<std::endl;
-	std::cout << GridLogMessage << "\tTarget " << Tolerance << std::endl;
-
-	std::cout << GridLogMessage << "Time breakdown "<<std::endl;
-	std::cout << GridLogMessage << "\tElapsed    " << SolverTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tMatrix     " << MatrixTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tLinalg     " << LinalgTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tPrecChange " << PrecChangeTimer.Elapsed() <<std::endl;
-	std::cout << GridLogMessage << "\tPrecChange avg time " << PrecChangeTimer.Elapsed()/(2*l+1) <<std::endl;
-
-	
-	IterationsToComplete = k;	
-	ReliableUpdatesPerformed = l;
-	  
-	if(DoFinalCleanup){
-	  //Do a final CG to cleanup
-	  std::cout << GridLogMessage << "ConjugateGradientReliableUpdate performing final cleanup.\n";
-	  ConjugateGradient<FieldD> CG(Tolerance,MaxIterations);
-	  CG.ErrorOnNoConverge = ErrorOnNoConverge;
-	  CG(Linop_d,src,psi);
-	  IterationsToCleanup = CG.IterationsToComplete;
-	}
-	else if (ErrorOnNoConverge) GRID_ASSERT(true_residual / Tolerance < 10000.0);
-
-	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate complete.\n";
-	return;
-      }
-      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();
-	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();
-	cp = norm2(r);
-	MaxResidSinceLastRelUp = cp;
-
-	b = cp/c;
-	  
-	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate new residual " << cp << std::endl;
-	  
-	l = l+1;
-      }
-
-      p_f = p_f * b + r_f; //update search vector after reliable update appears to help convergence
-
-      if(!using_fallback && Linop_fallback != NULL && cp < fallback_transition_tol){
-	std::cout << GridLogMessage << "ConjugateGradientReliableUpdate switching to fallback linear operator on iteration " << k << " at residual " << cp << std::endl;
-	Linop_f_use = Linop_fallback;
-	using_fallback = true;
-      }
-
-	
-    }
-    std::cout << GridLogMessage << "ConjugateGradientReliableUpdate did NOT converge"
-	      << std::endl;
-      
-    if (ErrorOnNoConverge) GRID_ASSERT(0);
-    IterationsToComplete = k;
-    ReliableUpdatesPerformed = l;      
-  }    
-};
-
-
-NAMESPACE_END(Grid);
-
-
-
-#endif

Grid/algorithms/iterative/ConjugateResidual.h

@@ -1,113 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ConjugateResidual.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_CONJUGATE_RESIDUAL_H
-#define GRID_CONJUGATE_RESIDUAL_H
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////
-// Base classes for iterative processes based on operators
-// single input vec, single output vec.
-/////////////////////////////////////////////////////////////
-
-template<class Field> 
-class ConjugateResidual : public OperatorFunction<Field> {
-public:                                                
-  using OperatorFunction<Field>::operator();
-
-  RealD   Tolerance;
-  Integer MaxIterations;
-  int verbose;
-
-  ConjugateResidual(RealD tol,Integer maxit) : Tolerance(tol), MaxIterations(maxit) { 
-    verbose=0;
-  };
-
-  void operator() (LinearOperatorBase<Field> &Linop,const Field &src, Field &psi){
-
-    RealD a, b; // c, d;
-    RealD cp, ssq,rsq;
-      
-    RealD rAr, rAAr, rArp;
-    RealD pAp, pAAp;
-
-    GridBase *grid = src.Grid();
-    psi=Zero();
-    Field r(grid),  p(grid), Ap(grid), Ar(grid);
-      
-    r=src;
-    p=src;
-
-    Linop.HermOpAndNorm(p,Ap,pAp,pAAp);
-    Linop.HermOpAndNorm(r,Ar,rAr,rAAr);
-
-    cp =norm2(r);
-    ssq=norm2(src);
-    rsq=Tolerance*Tolerance*ssq;
-
-    if (verbose) std::cout<<GridLogMessage<<"ConjugateResidual: iteration " <<0<<" residual "<<cp<< " target"<< rsq<<std::endl;
-
-    for(int k=1;k<MaxIterations;k++){
-
-      a = rAr/pAAp;
-
-      axpy(psi,a,p,psi);
-
-      cp = axpy_norm(r,-a,Ap,r);
-
-      rArp=rAr;
-
-      Linop.HermOpAndNorm(r,Ar,rAr,rAAr);
-
-      b   =rAr/rArp;
- 
-      axpy(p,b,p,r);
-      pAAp=axpy_norm(Ap,b,Ap,Ar);
-	
-      if(verbose) std::cout<<GridLogMessage<<"ConjugateResidual: iteration " <<k<<" residual "<<cp<< " target"<< rsq<<std::endl;
-
-      if(cp<rsq) {
-	Linop.HermOp(psi,Ap);
-	axpy(r,-1.0,src,Ap);
-	RealD true_resid = norm2(r)/ssq;
-	std::cout<<GridLogMessage<<"ConjugateResidual: Converged on iteration " <<k
-		 << " computed residual "<<std::sqrt(cp/ssq)
-		 << " true residual "<<std::sqrt(true_resid)
-		 << " target "       <<Tolerance <<std::endl;
-	return;
-      }
-
-    }
-
-    std::cout<<GridLogMessage<<"ConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
-  }
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/FlexibleCommunicationAvoidingGeneralisedMinimalResidual.h

@@ -1,258 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/FlexibleCommunicationAvoidingGeneralisedMinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_FLEXIBLE_COMMUNICATION_AVOIDING_GENERALISED_MINIMAL_RESIDUAL_H
-#define GRID_FLEXIBLE_COMMUNICATION_AVOIDING_GENERALISED_MINIMAL_RESIDUAL_H
-
-namespace Grid {
-
-template<class Field>
-class FlexibleCommunicationAvoidingGeneralisedMinimalResidual : public OperatorFunction<Field> {
- public:
-  using OperatorFunction<Field>::operator();
-
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FCAGMRES fails to converge,
-                          // defaults to true
-
-  RealD   Tolerance;
-
-  Integer MaxIterations;
-  Integer RestartLength;
-  Integer MaxNumberOfRestarts;
-  Integer IterationCount; // Number of iterations the FCAGMRES took to finish,
-                          // filled in upon completion
-
-  GridStopWatch MatrixTimer;
-  GridStopWatch PrecTimer;
-  GridStopWatch LinalgTimer;
-  GridStopWatch QrTimer;
-  GridStopWatch CompSolutionTimer;
-
-  Eigen::MatrixXcd H;
-
-  std::vector<ComplexD> y;
-  std::vector<ComplexD> gamma;
-  std::vector<ComplexD> c;
-  std::vector<ComplexD> s;
-
-  LinearFunction<Field> &Preconditioner;
-
-  FlexibleCommunicationAvoidingGeneralisedMinimalResidual(RealD   tol,
-                                                          Integer maxit,
-                                                          LinearFunction<Field> &Prec,
-                                                          Integer restart_length,
-                                                          bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , RestartLength(restart_length)
-      , MaxNumberOfRestarts(MaxIterations/RestartLength + ((MaxIterations%RestartLength == 0) ? 0 : 1))
-      , ErrorOnNoConverge(err_on_no_conv)
-      , H(Eigen::MatrixXcd::Zero(RestartLength, RestartLength + 1)) // sizes taken from DD-αAMG code base
-      , y(RestartLength + 1, 0.)
-      , gamma(RestartLength + 1, 0.)
-      , c(RestartLength + 1, 0.)
-      , s(RestartLength + 1, 0.)
-      , Preconditioner(Prec) {};
-
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi) {
-
-    std::cout << GridLogWarning << "This algorithm currently doesn't differ from regular FGMRES" << std::endl;
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD cp;
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    Field r(src.Grid());
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual:   src " << ssq   << std::endl;
-
-    PrecTimer.Reset();
-    MatrixTimer.Reset();
-    LinalgTimer.Reset();
-    QrTimer.Reset();
-    CompSolutionTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    SolverTimer.Start();
-
-    IterationCount = 0;
-
-    for (int k=0; k<MaxNumberOfRestarts; k++) {
-
-      cp = outerLoopBody(LinOp, src, psi, rsq);
-
-      // Stopping condition
-      if (cp <= rsq) {
-
-        SolverTimer.Stop();
-
-        LinOp.Op(psi,r);
-        axpy(r,-1.0,src,r);
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual: Converged on iteration " << IterationCount
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: Total   " <<       SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: Precon  " <<         PrecTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: Matrix  " <<       MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: Linalg  " <<       LinalgTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: QR      " <<           QrTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FCAGMRES Time elapsed: CompSol " << CompSolutionTimer.Elapsed() << std::endl;
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual did NOT converge" << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-  }
-
-  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
-
-    RealD cp = 0;
-
-    Field w(src.Grid());
-    Field r(src.Grid());
-
-    // these should probably be made class members so that they are only allocated once, not in every restart
-    std::vector<Field> v(RestartLength + 1, src.Grid()); for (auto &elem : v) elem = Zero();
-    std::vector<Field> z(RestartLength + 1, src.Grid()); for (auto &elem : z) elem = Zero();
-
-    MatrixTimer.Start();
-    LinOp.Op(psi, w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    r = src - w;
-
-    gamma[0] = sqrt(norm2(r));
-
-    v[0] = (1. / gamma[0]) * r;
-    LinalgTimer.Stop();
-
-    for (int i=0; i<RestartLength; i++) {
-
-      IterationCount++;
-
-      arnoldiStep(LinOp, v, z, w, i);
-
-      qrUpdate(i);
-
-      cp = norm(gamma[i+1]);
-
-      std::cout << GridLogIterative << "FlexibleCommunicationAvoidingGeneralisedMinimalResidual: Iteration " << IterationCount
-                << " residual " << cp << " target " << rsq << std::endl;
-
-      if ((i == RestartLength - 1) || (IterationCount == MaxIterations) || (cp <= rsq)) {
-
-        computeSolution(z, psi, i);
-
-        return cp;
-      }
-    }
-
-    GRID_ASSERT(0); // Never reached
-    return cp;
-  }
-
-  void arnoldiStep(LinearOperatorBase<Field> &LinOp, std::vector<Field> &v, std::vector<Field> &z, Field &w, int iter) {
-
-    PrecTimer.Start();
-    Preconditioner(v[iter], z[iter]);
-    PrecTimer.Stop();
-
-    MatrixTimer.Start();
-    LinOp.Op(z[iter], w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    for (int i = 0; i <= iter; ++i) {
-      H(iter, i) = innerProduct(v[i], w);
-      w = w - ComplexD(H(iter, i)) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = ComplexD(1. / H(iter, iter + 1)) * w;
-    LinalgTimer.Stop();
-  }
-
-  void qrUpdate(int iter) {
-
-    QrTimer.Start();
-    for (int i = 0; i < iter ; ++i) {
-      auto tmp       = -s[i] * ComplexD(H(iter, i)) + c[i] * ComplexD(H(iter, i + 1));
-      H(iter, i)     = conjugate(c[i]) * ComplexD(H(iter, i)) + conjugate(s[i]) * ComplexD(H(iter, i + 1));
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    auto nu = sqrt(std::norm(H(iter, iter)) + std::norm(H(iter, iter + 1)));
-    c[iter]     = H(iter, iter) / nu;
-    s[iter]     = H(iter, iter + 1) / nu;
-
-    // Apply new Givens rotation
-    H(iter, iter)     = nu;
-    H(iter, iter + 1) = 0.;
-
-    gamma[iter + 1] = -s[iter] * gamma[iter];
-    gamma[iter]     = conjugate(c[iter]) * gamma[iter];
-    QrTimer.Stop();
-  }
-
-  void computeSolution(std::vector<Field> const &z, Field &psi, int iter) {
-
-    CompSolutionTimer.Start();
-    for (int i = iter; i >= 0; i--) {
-      y[i] = gamma[i];
-      for (int k = i + 1; k <= iter; k++)
-        y[i] = y[i] - ComplexD(H(k, i)) * y[k];
-      y[i] = y[i] / ComplexD(H(i, i));
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + z[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/FlexibleGeneralisedMinimalResidual.h

@@ -1,256 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/FlexibleGeneralisedMinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_FLEXIBLE_GENERALISED_MINIMAL_RESIDUAL_H
-#define GRID_FLEXIBLE_GENERALISED_MINIMAL_RESIDUAL_H
-
-namespace Grid {
-
-template<class Field>
-class FlexibleGeneralisedMinimalResidual : public OperatorFunction<Field> {
- public:
-  using OperatorFunction<Field>::operator();
-
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when FGMRES fails to converge,
-                          // defaults to true
-
-  RealD   Tolerance;
-
-  Integer MaxIterations;
-  Integer RestartLength;
-  Integer MaxNumberOfRestarts;
-  Integer IterationCount; // Number of iterations the FGMRES took to finish,
-                          // filled in upon completion
-
-  GridStopWatch MatrixTimer;
-  GridStopWatch PrecTimer;
-  GridStopWatch LinalgTimer;
-  GridStopWatch QrTimer;
-  GridStopWatch CompSolutionTimer;
-
-  Eigen::MatrixXcd H;
-
-  std::vector<ComplexD> y;
-  std::vector<ComplexD> gamma;
-  std::vector<ComplexD> c;
-  std::vector<ComplexD> s;
-
-  LinearFunction<Field> &Preconditioner;
-
-  FlexibleGeneralisedMinimalResidual(RealD   tol,
-                                     Integer maxit,
-                                     LinearFunction<Field> &Prec,
-                                     Integer restart_length,
-                                     bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , RestartLength(restart_length)
-      , MaxNumberOfRestarts(MaxIterations/RestartLength + ((MaxIterations%RestartLength == 0) ? 0 : 1))
-      , ErrorOnNoConverge(err_on_no_conv)
-      , H(Eigen::MatrixXcd::Zero(RestartLength, RestartLength + 1)) // sizes taken from DD-αAMG code base
-      , y(RestartLength + 1, 0.)
-      , gamma(RestartLength + 1, 0.)
-      , c(RestartLength + 1, 0.)
-      , s(RestartLength + 1, 0.)
-      , Preconditioner(Prec) {};
-
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi) {
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD cp;
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    Field r(src.Grid());
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "FlexibleGeneralisedMinimalResidual: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "FlexibleGeneralisedMinimalResidual:   src " << ssq   << std::endl;
-
-    PrecTimer.Reset();
-    MatrixTimer.Reset();
-    LinalgTimer.Reset();
-    QrTimer.Reset();
-    CompSolutionTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    SolverTimer.Start();
-
-    IterationCount = 0;
-
-    for (int k=0; k<MaxNumberOfRestarts; k++) {
-
-      cp = outerLoopBody(LinOp, src, psi, rsq);
-
-      // Stopping condition
-      if (cp <= rsq) {
-
-        SolverTimer.Stop();
-
-        LinOp.Op(psi,r);
-        axpy(r,-1.0,src,r);
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "FlexibleGeneralisedMinimalResidual: Converged on iteration " << IterationCount
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "FGMRES Time elapsed: Total   " <<       SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FGMRES Time elapsed: Precon  " <<         PrecTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FGMRES Time elapsed: Matrix  " <<       MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FGMRES Time elapsed: Linalg  " <<       LinalgTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FGMRES Time elapsed: QR      " <<           QrTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "FGMRES Time elapsed: CompSol " << CompSolutionTimer.Elapsed() << std::endl;
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "FlexibleGeneralisedMinimalResidual did NOT converge" << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-  }
-
-  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
-
-    RealD cp = 0;
-
-    Field w(src.Grid());
-    Field r(src.Grid());
-
-    // these should probably be made class members so that they are only allocated once, not in every restart
-    std::vector<Field> v(RestartLength + 1, src.Grid()); for (auto &elem : v) elem = Zero();
-    std::vector<Field> z(RestartLength + 1, src.Grid()); for (auto &elem : z) elem = Zero();
-
-    MatrixTimer.Start();
-    LinOp.Op(psi, w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    r = src - w;
-
-    gamma[0] = sqrt(norm2(r));
-
-    v[0] = (1. / gamma[0]) * r;
-    LinalgTimer.Stop();
-
-    for (int i=0; i<RestartLength; i++) {
-
-      IterationCount++;
-
-      arnoldiStep(LinOp, v, z, w, i);
-
-      qrUpdate(i);
-
-      cp = norm(gamma[i+1]);
-
-      std::cout << GridLogIterative << "FlexibleGeneralisedMinimalResidual: Iteration " << IterationCount
-                << " residual " << cp << " target " << rsq << std::endl;
-
-      if ((i == RestartLength - 1) || (IterationCount == MaxIterations) || (cp <= rsq)) {
-
-        computeSolution(z, psi, i);
-
-        return cp;
-      }
-    }
-
-    GRID_ASSERT(0); // Never reached
-    return cp;
-  }
-
-  void arnoldiStep(LinearOperatorBase<Field> &LinOp, std::vector<Field> &v, std::vector<Field> &z, Field &w, int iter) {
-
-    PrecTimer.Start();
-    Preconditioner(v[iter], z[iter]);
-    PrecTimer.Stop();
-
-    MatrixTimer.Start();
-    LinOp.Op(z[iter], w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    for (int i = 0; i <= iter; ++i) {
-      H(iter, i) = innerProduct(v[i], w);
-      w = w - ComplexD(H(iter, i)) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = ComplexD(1. / H(iter, iter + 1)) * w;
-    LinalgTimer.Stop();
-  }
-
-  void qrUpdate(int iter) {
-
-    QrTimer.Start();
-    for (int i = 0; i < iter ; ++i) {
-      auto tmp       = -s[i] * ComplexD(H(iter, i)) + c[i] * ComplexD(H(iter, i + 1));
-      H(iter, i)     = conjugate(c[i]) * ComplexD(H(iter, i)) + conjugate(s[i]) * ComplexD(H(iter, i + 1));
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    auto nu = sqrt(std::norm(H(iter, iter)) + std::norm(H(iter, iter + 1)));
-    c[iter]     = H(iter, iter) / nu;
-    s[iter]     = H(iter, iter + 1) / nu;
-
-    // Apply new Givens rotation
-    H(iter, iter)     = nu;
-    H(iter, iter + 1) = 0.;
-
-    gamma[iter + 1] = -s[iter] * gamma[iter];
-    gamma[iter]     = conjugate(c[iter]) * gamma[iter];
-    QrTimer.Stop();
-  }
-
-  void computeSolution(std::vector<Field> const &z, Field &psi, int iter) {
-
-    CompSolutionTimer.Start();
-    for (int i = iter; i >= 0; i--) {
-      y[i] = gamma[i];
-      for (int k = i + 1; k <= iter; k++)
-        y[i] = y[i] - ComplexD(H(k, i)) * y[k];
-      y[i] = y[i] / ComplexD(H(i, i));
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + z[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/GCRCoefficients.h

@@ -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);

Grid/algorithms/iterative/GeneralisedMinimalResidual.h

@@ -1,244 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/GeneralisedMinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_GENERALISED_MINIMAL_RESIDUAL_H
-#define GRID_GENERALISED_MINIMAL_RESIDUAL_H
-
-namespace Grid {
-
-template<class Field>
-class GeneralisedMinimalResidual : public OperatorFunction<Field> {
- public:
-  using OperatorFunction<Field>::operator();
-
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when GMRES fails to converge,
-                          // defaults to true
-
-  RealD   Tolerance;
-
-  Integer MaxIterations;
-  Integer RestartLength;
-  Integer MaxNumberOfRestarts;
-  Integer IterationCount; // Number of iterations the GMRES took to finish,
-                          // filled in upon completion
-
-  GridStopWatch MatrixTimer;
-  GridStopWatch LinalgTimer;
-  GridStopWatch QrTimer;
-  GridStopWatch CompSolutionTimer;
-
-  Eigen::MatrixXcd H;
-
-  std::vector<ComplexD> y;
-  std::vector<ComplexD> gamma;
-  std::vector<ComplexD> c;
-  std::vector<ComplexD> s;
-
-  GeneralisedMinimalResidual(RealD   tol,
-                             Integer maxit,
-                             Integer restart_length,
-                             bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , RestartLength(restart_length)
-      , MaxNumberOfRestarts(MaxIterations/RestartLength + ((MaxIterations%RestartLength == 0) ? 0 : 1))
-      , ErrorOnNoConverge(err_on_no_conv)
-      , H(Eigen::MatrixXcd::Zero(RestartLength, RestartLength + 1)) // sizes taken from DD-αAMG code base
-      , y(RestartLength + 1, 0.)
-      , gamma(RestartLength + 1, 0.)
-      , c(RestartLength + 1, 0.)
-      , s(RestartLength + 1, 0.) {};
-
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi) {
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD cp;
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    Field r(src.Grid());
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "GeneralisedMinimalResidual: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "GeneralisedMinimalResidual:   src " << ssq   << std::endl;
-
-    MatrixTimer.Reset();
-    LinalgTimer.Reset();
-    QrTimer.Reset();
-    CompSolutionTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    SolverTimer.Start();
-
-    IterationCount = 0;
-
-    for (int k=0; k<MaxNumberOfRestarts; k++) {
-
-      cp = outerLoopBody(LinOp, src, psi, rsq);
-
-      // Stopping condition
-      if (cp <= rsq) {
-
-        SolverTimer.Stop();
-
-        LinOp.Op(psi,r);
-        axpy(r,-1.0,src,r);
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "GeneralisedMinimalResidual: Converged on iteration " << IterationCount
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "GMRES Time elapsed: Total   " <<       SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "GMRES Time elapsed: Matrix  " <<       MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "GMRES Time elapsed: Linalg  " <<       LinalgTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "GMRES Time elapsed: QR      " <<           QrTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "GMRES Time elapsed: CompSol " << CompSolutionTimer.Elapsed() << std::endl;
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "GeneralisedMinimalResidual did NOT converge" << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-  }
-
-  RealD outerLoopBody(LinearOperatorBase<Field> &LinOp, const Field &src, Field &psi, RealD rsq) {
-
-    RealD cp = 0;
-
-    Field w(src.Grid());
-    Field r(src.Grid());
-
-    // this should probably be made a class member so that it is only allocated once, not in every restart
-    std::vector<Field> v(RestartLength + 1, src.Grid()); for (auto &elem : v) elem = Zero();
-
-    MatrixTimer.Start();
-    LinOp.Op(psi, w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    r = src - w;
-
-    gamma[0] = sqrt(norm2(r));
-
-    v[0] = (1. / gamma[0]) * r;
-    LinalgTimer.Stop();
-
-    for (int i=0; i<RestartLength; i++) {
-
-      IterationCount++;
-
-      arnoldiStep(LinOp, v, w, i);
-
-      qrUpdate(i);
-
-      cp = norm(gamma[i+1]);
-
-      std::cout << GridLogIterative << "GeneralisedMinimalResidual: Iteration " << IterationCount
-                << " residual " << cp << " target " << rsq << std::endl;
-
-      if ((i == RestartLength - 1) || (IterationCount == MaxIterations) || (cp <= rsq)) {
-
-        computeSolution(v, psi, i);
-
-        return cp;
-      }
-    }
-
-    GRID_ASSERT(0); // Never reached
-    return cp;
-  }
-
-  void arnoldiStep(LinearOperatorBase<Field> &LinOp, std::vector<Field> &v, Field &w, int iter) {
-
-    MatrixTimer.Start();
-    LinOp.Op(v[iter], w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    for (int i = 0; i <= iter; ++i) {
-      H(iter, i) = innerProduct(v[i], w);
-      w = w - ComplexD(H(iter, i)) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = ComplexD(1. / H(iter, iter + 1)) * w;
-    LinalgTimer.Stop();
-  }
-
-  void qrUpdate(int iter) {
-
-    QrTimer.Start();
-    for (int i = 0; i < iter ; ++i) {
-      auto tmp       = -s[i] * ComplexD(H(iter, i)) + c[i] * ComplexD(H(iter, i + 1));
-      H(iter, i)     = conjugate(c[i]) * ComplexD(H(iter, i)) + conjugate(s[i]) * ComplexD(H(iter, i + 1));
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    auto nu = sqrt(std::norm(H(iter, iter)) + std::norm(H(iter, iter + 1)));
-    c[iter]     = H(iter, iter) / nu;
-    s[iter]     = H(iter, iter + 1) / nu;
-
-    // Apply new Givens rotation
-    H(iter, iter)     = nu;
-    H(iter, iter + 1) = 0.;
-
-    gamma[iter + 1] = -s[iter] * gamma[iter];
-    gamma[iter]     = conjugate(c[iter]) * gamma[iter];
-    QrTimer.Stop();
-  }
-
-  void computeSolution(std::vector<Field> const &v, Field &psi, int iter) {
-
-    CompSolutionTimer.Start();
-    for (int i = iter; i >= 0; i--) {
-      y[i] = gamma[i];
-      for (int k = i + 1; k <= iter; k++)
-        y[i] = y[i] - ComplexD(H(k, i)) * y[k];
-      y[i] = y[i] / ComplexD(H(i, i));
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + v[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/ImplicitlyRestartedLanczos.h

@@ -1,741 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/ImplicitlyRestartedLanczos.h
-
-    Copyright (C) 2015
-
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-Author: Chulwoo Jung <chulwoo@bnl.gov>
-Author: Christoph Lehner <clehner@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 */
-#ifndef GRID_BIRL_H
-#define GRID_BIRL_H
-
-#include <string.h> //memset
-//#include <zlib.h>
-#include <sys/stat.h>
-
-NAMESPACE_BEGIN(Grid); 
-
-/////////////////////////////////////////////////////////////
-// Implicitly restarted lanczos
-/////////////////////////////////////////////////////////////
-template<class Field> class ImplicitlyRestartedLanczosTester 
-{
- public:
-  virtual int TestConvergence(int j,RealD resid,Field &evec, RealD &eval,RealD evalMaxApprox)=0;
-  virtual int ReconstructEval(int j,RealD resid,Field &evec, RealD &eval,RealD evalMaxApprox)=0;
-};
-
-enum IRLdiagonalisation { 
-  IRLdiagonaliseWithDSTEGR,
-  IRLdiagonaliseWithQR,
-  IRLdiagonaliseWithEigen
-};
-
-template<class Field> class ImplicitlyRestartedLanczosHermOpTester  : public ImplicitlyRestartedLanczosTester<Field>
-{
- public:
-
-  LinearFunction<Field>       &_HermOp;
-  ImplicitlyRestartedLanczosHermOpTester(LinearFunction<Field> &HermOp) : _HermOp(HermOp)  {  };
-  int ReconstructEval(int j,RealD resid,Field &B, RealD &eval,RealD evalMaxApprox)
-  {
-    return TestConvergence(j,resid,B,eval,evalMaxApprox);
-  }
-  int TestConvergence(int j,RealD eresid,Field &B, RealD &eval,RealD evalMaxApprox)
-  {
-    Field v(B);
-    RealD eval_poly = eval;
-    // Apply operator
-    _HermOp(B,v);
-
-    RealD vnum = real(innerProduct(B,v)); // HermOp.
-    RealD vden = norm2(B);
-    RealD vv0  = norm2(v);
-    eval   = vnum/vden;
-    v -= eval*B;
-
-    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;
-
-    return conv;
-  }
-};
-
-template<class Field> 
-class ImplicitlyRestartedLanczos {
- private:
-  const RealD small = 1.0e-8;
-  int MaxIter;
-  int MinRestart; // Minimum number of restarts; only check for convergence after
-  int Nstop;   // Number of evecs checked for convergence
-  int Nk;      // Number of converged sought
-  //  int Np;      // Np -- Number of spare vecs in krylov space //  == Nm - Nk
-  int Nm;      // Nm -- total number of vectors
-  IRLdiagonalisation diagonalisation;
-  int orth_period;
-    
-  RealD OrthoTime;
-  RealD eresid, betastp;
-  ////////////////////////////////
-  // Embedded objects
-  ////////////////////////////////
-  LinearFunction<Field>       &_PolyOp;
-  LinearFunction<Field>       &_HermOp;
-  ImplicitlyRestartedLanczosTester<Field> &_Tester;
-  // Default tester provided (we need a ref to something in default case)
-  ImplicitlyRestartedLanczosHermOpTester<Field> SimpleTester;
-  /////////////////////////
-  // Constructor
-  /////////////////////////
-  
-public:       
-
-  //////////////////////////////////////////////////////////////////
-  // PAB:
-  //////////////////////////////////////////////////////////////////
-  // Too many options  & knobs. 
-  // Eliminate:
-  //   orth_period
-  //   betastp
-  //   MinRestart
-  //
-  // Do we really need orth_period
-  // What is the theoretical basis & guarantees of betastp ?
-  // Nstop=Nk viable?
-  // MinRestart avoidable with new convergence test?
-  // Could cut to PolyOp, HermOp, Tester, Nk, Nm, resid, maxiter (+diagonalisation)
-  // HermOp could be eliminated if we dropped the Power method for max eval.
-  // -- also: The eval, eval2, eval2_copy stuff is still unnecessarily unclear
-  //////////////////////////////////////////////////////////////////
- ImplicitlyRestartedLanczos(LinearFunction<Field> & PolyOp,
-			    LinearFunction<Field> & HermOp,
-			    ImplicitlyRestartedLanczosTester<Field> & Tester,
-			    int _Nstop, // sought vecs
-			    int _Nk, // sought vecs
-			    int _Nm, // spare vecs
-			    RealD _eresid, // resid in lmdue deficit 
-			    int _MaxIter, // Max iterations
-			    RealD _betastp=0.0, // if beta(k) < betastp: converged
-			    int _MinRestart=0, int _orth_period = 1,
-			    IRLdiagonalisation _diagonalisation= IRLdiagonaliseWithEigen) :
-    SimpleTester(HermOp), _PolyOp(PolyOp),      _HermOp(HermOp), _Tester(Tester),
-    Nstop(_Nstop)  ,      Nk(_Nk),      Nm(_Nm),
-    eresid(_eresid),      betastp(_betastp),
-    MaxIter(_MaxIter)  ,      MinRestart(_MinRestart),
-    orth_period(_orth_period), diagonalisation(_diagonalisation)  { };
-
-    ImplicitlyRestartedLanczos(LinearFunction<Field> & PolyOp,
-			       LinearFunction<Field> & HermOp,
-			       int _Nstop, // sought vecs
-			       int _Nk, // sought vecs
-			       int _Nm, // spare vecs
-			       RealD _eresid, // resid in lmdue deficit 
-			       int _MaxIter, // Max iterations
-			       RealD _betastp=0.0, // if beta(k) < betastp: converged
-			       int _MinRestart=0, int _orth_period = 1,
-			       IRLdiagonalisation _diagonalisation= IRLdiagonaliseWithEigen) :
-    SimpleTester(HermOp),  _PolyOp(PolyOp),      _HermOp(HermOp), _Tester(SimpleTester),
-    Nstop(_Nstop)  ,      Nk(_Nk),      Nm(_Nm),
-    eresid(_eresid),      betastp(_betastp),
-    MaxIter(_MaxIter)  ,      MinRestart(_MinRestart),
-    orth_period(_orth_period), diagonalisation(_diagonalisation)  { };
-
-  ////////////////////////////////
-  // Helpers
-  ////////////////////////////////
-  template<typename T>  static RealD normalise(T& v) 
-  {
-    RealD nn = norm2(v);
-    nn = std::sqrt(nn);
-    v = v * (1.0/nn);
-    return nn;
-  }
-
-  void orthogonalize(Field& w, std::vector<Field>& evec,int k)
-  {
-    OrthoTime-=usecond()/1e6;
-    basisOrthogonalize(evec,w,k);
-    normalise(w);
-    OrthoTime+=usecond()/1e6;
-  }
-
-/* Rudy Arthur's thesis pp.137
-------------------------
-Require: M > K P = M − K †
-Compute the factorization AVM = VM HM + fM eM 
-repeat
-  Q=I
-  for i = 1,...,P do
-    QiRi =HM −θiI Q = QQi
-    H M = Q †i H M Q i
-  end for
-  βK =HM(K+1,K) σK =Q(M,K)
-  r=vK+1βK +rσK
-  VK =VM(1:M)Q(1:M,1:K)
-  HK =HM(1:K,1:K)
-  →AVK =VKHK +fKe†K † Extend to an M = K + P step factorization AVM = VMHM + fMeM
-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());
-    
-    //    GridLogIRL.TimingMode(1);
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-    std::cout << GridLogIRL <<" ImplicitlyRestartedLanczos::calc() starting iteration 0 /  "<< MaxIter<< std::endl;
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-    std::cout << GridLogIRL <<" -- seek   Nk    = " << Nk    <<" vectors"<< std::endl;
-    std::cout << GridLogIRL <<" -- accept Nstop = " << Nstop <<" vectors"<< std::endl;
-    std::cout << GridLogIRL <<" -- total  Nm    = " << Nm    <<" vectors"<< std::endl;
-    std::cout << GridLogIRL <<" -- size of eval = " << eval.size() << std::endl;
-    std::cout << GridLogIRL <<" -- size of evec = " << evec.size() << std::endl;
-    if ( diagonalisation == IRLdiagonaliseWithDSTEGR ) {
-      std::cout << GridLogIRL << "Diagonalisation is DSTEGR "<<std::endl;
-    } else if ( diagonalisation == IRLdiagonaliseWithQR ) { 
-      std::cout << GridLogIRL << "Diagonalisation is QR "<<std::endl;
-    }  else if ( diagonalisation == IRLdiagonaliseWithEigen ) { 
-      std::cout << GridLogIRL << "Diagonalisation is Eigen "<<std::endl;
-    }
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-	
-    GRID_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;
-    {
-      auto src_n = src;
-      auto tmp = src;
-      std::cout << GridLogIRL << " IRL source norm " << norm2(src) << std::endl;
-      const int _MAX_ITER_IRL_MEVAPP_ = 50;
-      for (int i=0;i<_MAX_ITER_IRL_MEVAPP_;i++) {
-	normalise(src_n);
-	_HermOp(src_n,tmp);
-	//	std::cout << GridLogMessage<< tmp<<std::endl; exit(0);
-	//	std::cout << GridLogIRL << " _HermOp " << norm2(tmp) << std::endl;
-//	RealD vnum = real(innerProduct(src_n,tmp)); // HermOp.
-	RealD vnum = real(innerProduct(tmp,tmp)); // HermOp^2.
-	RealD vden = norm2(src_n);
-	RealD na = std::sqrt(vnum/vden);
-	if (fabs(evalMaxApprox/na - 1.0) < 0.0001)
-	  i=_MAX_ITER_IRL_MEVAPP_;
-	evalMaxApprox = na;
-	std::cout << GridLogIRL << " Approximation of largest eigenvalue: " << evalMaxApprox << std::endl;
-	src_n = tmp;
-      }
-    }
-    std::cout << GridLogIRL << " Final evalMaxApprox  " << evalMaxApprox << std::endl;
-	
-    std::vector<RealD> lme(Nm);  
-    std::vector<RealD> lme2(Nm);
-    std::vector<RealD> eval2(Nm);
-    std::vector<RealD> eval2_copy(Nm);
-    Eigen::MatrixXd Qt = Eigen::MatrixXd::Zero(Nm,Nm);
-
-    Field f(grid);
-    Field v(grid);
-    int k1 = 1;
-    int k2 = Nk;
-    RealD beta_k;
-
-    Nconv = 0;
-  
-    // Set initial vector
-    evec[0] = src;
-    normalise(evec[0]);
-	
-    // Initial Nk steps
-    OrthoTime=0.;
-    for(int k=0; k<Nk; ++k) step(eval,lme,evec,f,Nm,k);
-    std::cout<<GridLogIRL <<"Initial "<< Nk <<"steps done "<<std::endl;
-    std::cout<<GridLogIRL <<"Initial steps:OrthoTime "<<OrthoTime<< "seconds"<<std::endl;
-
-    //////////////////////////////////
-    // Restarting loop begins
-    //////////////////////////////////
-    int iter;
-    for(iter = 0; iter<MaxIter; ++iter){
-      
-      OrthoTime=0.;
-
-      std::cout<< GridLogMessage <<" **********************"<< std::endl;
-      std::cout<< GridLogMessage <<" Restart iteration = "<< iter << std::endl;
-      std::cout<< GridLogMessage <<" **********************"<< std::endl;
-
-      std::cout<<GridLogIRL <<" running "<<Nm-Nk <<" steps: "<<std::endl;
-      for(int k=Nk; k<Nm; ++k) step(eval,lme,evec,f,Nm,k);
-      f *= lme[Nm-1];
-
-      std::cout<<GridLogIRL <<" "<<Nm-Nk <<" steps done "<<std::endl;
-      std::cout<<GridLogIRL <<"Initial steps:OrthoTime "<<OrthoTime<< "seconds"<<std::endl;
-	  
-      //////////////////////////////////
-      // getting eigenvalues
-      //////////////////////////////////
-      for(int k=0; k<Nm; ++k){
-	eval2[k] = eval[k+k1-1];
-	lme2[k] = lme[k+k1-1];
-      }
-      Qt = Eigen::MatrixXd::Identity(Nm,Nm);
-      diagonalize(eval2,lme2,Nm,Nm,Qt,grid);
-      std::cout<<GridLogIRL <<" diagonalized "<<std::endl;
-
-      //////////////////////////////////
-      // sorting
-      //////////////////////////////////
-      eval2_copy = eval2;
-      std::partial_sort(eval2.begin(),eval2.begin()+Nm,eval2.end(),std::greater<RealD>());
-      std::cout<<GridLogIRL <<" evals sorted "<<std::endl;
-      const int chunk=8;
-      for(int io=0; io<k2;io+=chunk){
-	std::cout<<GridLogIRL << "eval "<< std::setw(3) << io ;
-	for(int ii=0;ii<chunk;ii++){
-	  if ( (io+ii)<k2 )
-	    std::cout<< " "<< std::setw(12)<< eval2[io+ii];
-	}
-	std::cout << std::endl;
-      }
-
-      //////////////////////////////////
-      // Implicitly shifted QR transformations
-      //////////////////////////////////
-      Qt = Eigen::MatrixXd::Identity(Nm,Nm);
-      for(int ip=k2; ip<Nm; ++ip){ 
-	QR_decomp(eval,lme,Nm,Nm,Qt,eval2[ip],k1,Nm);
-      }
-      std::cout<<GridLogIRL <<"QR decomposed "<<std::endl;
-
-      GRID_ASSERT(k2<Nm);      GRID_ASSERT(k2<Nm);      GRID_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;
-      
-      ////////////////////////////////////////////////////
-      // Compressed vector f and beta(k2)
-      ////////////////////////////////////////////////////
-      f *= Qt(k2-1,Nm-1);
-      f += lme[k2-1] * evec[k2];
-      beta_k = norm2(f);
-      beta_k = std::sqrt(beta_k);
-      std::cout<<GridLogIRL<<" beta(k) = "<<beta_k<<std::endl;
-	  
-      RealD betar = 1.0/beta_k;
-      evec[k2] = betar * f;
-      lme[k2-1] = beta_k;
-	  
-      ////////////////////////////////////////////////////
-      // Convergence test
-      ////////////////////////////////////////////////////
-      for(int k=0; k<Nm; ++k){    
-	eval2[k] = eval[k];
-	lme2[k] = lme[k];
-      }
-      Qt = Eigen::MatrixXd::Identity(Nm,Nm);
-      diagonalize(eval2,lme2,Nk,Nm,Qt,grid);
-      std::cout<<GridLogIRL <<" Diagonalized "<<std::endl;
-	  
-      Nconv = 0;
-      if (iter >= MinRestart) {
-
-	std::cout << GridLogIRL << "Test convergence: rotate subset of vectors to test convergence " << std::endl;
-
-	Field B(grid); B.Checkerboard() = evec[0].Checkerboard();
-
-	//  power of two search pattern;  not every evalue in eval2 is assessed.
-	int allconv =1;
-	for(int jj = 1; jj<=Nstop; jj*=2){
-	  int j = Nstop-jj;
-	  RealD e = eval2_copy[j]; // Discard the evalue
-	  basisRotateJ(B,evec,Qt,j,0,Nk,Nm);	    
-	  if( !_Tester.TestConvergence(j,eresid,B,e,evalMaxApprox) ) {
-	    allconv=0;
-	  }
-	}
-	// Do evec[0] for good measure
-	{ 
-	  int j=0;
-	  RealD e = eval2_copy[0]; 
-	  basisRotateJ(B,evec,Qt,j,0,Nk,Nm);	    
-	  if( !_Tester.TestConvergence(j,eresid,B,e,evalMaxApprox) ) allconv=0;
-	}
-	if ( allconv ) Nconv = Nstop;
-
-	// test if we converged, if so, terminate
-	std::cout<<GridLogIRL<<" #modes converged: >= "<<Nconv<<"/"<<Nstop<<std::endl;
-	//	if( Nconv>=Nstop || beta_k < betastp){
-	if( Nconv>=Nstop){
-	  goto converged;
-	}
-	  
-      } else {
-	std::cout << GridLogIRL << "iter < MinRestart: do not yet test for convergence\n";
-      } // end of iter loop
-    }
-
-    std::cout<<GridLogError<<"\n NOT converged.\n";
-    abort();
-	
-  converged:
-    {
-      Field B(grid); B.Checkerboard() = evec[0].Checkerboard();
-      basisRotate(evec,Qt,0,Nk,0,Nk,Nm);	    
-      std::cout << GridLogIRL << " Rotated basis"<<std::endl;
-      Nconv=0;
-      //////////////////////////////////////////////////////////////////////
-      // Full final convergence test; unconditionally applied
-      //////////////////////////////////////////////////////////////////////
-      for(int j = 0; j<=Nk; j++){
-	B=evec[j];
-	if( _Tester.ReconstructEval(j,eresid,B,eval2[j],evalMaxApprox) ) {
-	  Nconv++;
-	}
-      }
-
-      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
-      basisSortInPlace(evec,eval,reverse);
-      
-    }
-       
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-    std::cout << GridLogIRL << "ImplicitlyRestartedLanczos CONVERGED ; Summary :\n";
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-    std::cout << GridLogIRL << " -- Iterations  = "<< iter   << "\n";
-    std::cout << GridLogIRL << " -- beta(k)     = "<< beta_k << "\n";
-    std::cout << GridLogIRL << " -- Nconv       = "<< Nconv  << "\n";
-    std::cout << GridLogIRL <<"**************************************************************************"<< std::endl;
-  }
-
- private:
-/* Saad PP. 195
-1. Choose an initial vector v1 of 2-norm unity. Set β1 ≡ 0, v0 ≡ 0
-2. For k = 1,2,...,m Do:
-3. wk:=Avk - b_k v_{k-1}      
-4. ak:=(wk,vk)       // 
-5. wk:=wk-akvk       // wk orthog vk 
-6. bk+1 := ||wk||_2. If b_k+1 = 0 then Stop
-7. vk+1 := wk/b_k+1
-8. EndDo
- */
-  void step(std::vector<RealD>& lmd,
-	    std::vector<RealD>& lme, 
-	    std::vector<Field>& evec,
-	    Field& w,int Nm,int k)
-  {
-    std::cout<<GridLogDebug << "Lanczos step " <<k<<std::endl;
-    const RealD tiny = 1.0e-20;
-    GRID_ASSERT( k< Nm );
-
-    GridStopWatch gsw_op,gsw_o;
-
-    Field& evec_k = evec[k];
-
-    _PolyOp(evec_k,w);    std::cout<<GridLogDebug << "PolyOp" <<std::endl;
-
-    if(k>0) w -= lme[k-1] * evec[k-1];
-
-    ComplexD zalph = innerProduct(evec_k,w);
-    RealD     alph = real(zalph);
-
-    w = w - alph * evec_k;
-
-    RealD beta = normalise(w); 
-
-    lmd[k] = alph;
-    lme[k] = beta;
-
-    if ( (k>0) && ( (k % orth_period) == 0 )) {
-      std::cout<<GridLogDebug << "Orthogonalising " <<k<<std::endl;
-      orthogonalize(w,evec,k); // orthonormalise
-      std::cout<<GridLogDebug << "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;
-    if ( beta < tiny ) 
-      std::cout<<GridLogIRL << " beta is tiny "<<beta<<std::endl;
-
-    std::cout<<GridLogDebug << "Lanczos step complete " <<k<<std::endl;
-  }
-
-  void diagonalize_Eigen(std::vector<RealD>& lmd, std::vector<RealD>& lme, 
-			 int Nk, int Nm,  
-			 Eigen::MatrixXd & Qt, // Nm x Nm
-			 GridBase *grid)
-  {
-    Eigen::MatrixXd TriDiag = Eigen::MatrixXd::Zero(Nk,Nk);
-
-    for(int i=0;i<Nk;i++)   TriDiag(i,i)   = lmd[i];
-    for(int i=0;i<Nk-1;i++) TriDiag(i,i+1) = lme[i];
-    for(int i=0;i<Nk-1;i++) TriDiag(i+1,i) = lme[i];
-    
-    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> eigensolver(TriDiag);
-
-    for (int i = 0; i < Nk; i++) {
-      lmd[Nk-1-i] = eigensolver.eigenvalues()(i);
-    }
-    for (int i = 0; i < Nk; i++) {
-      for (int j = 0; j < Nk; j++) {
-	Qt(Nk-1-i,j) = eigensolver.eigenvectors()(j,i);
-      }
-    }
-  }
-
-  ///////////////////////////////////////////////////////////////////////////
-  // File could end here if settle on Eigen ??? !!!
-  ///////////////////////////////////////////////////////////////////////////
-  void QR_decomp(std::vector<RealD>& lmd,   // Nm 
-		 std::vector<RealD>& lme,   // Nm 
-		 int Nk, int Nm,            // Nk, Nm
-		 Eigen::MatrixXd& Qt,       // Nm x Nm matrix
-		 RealD Dsh, int kmin, int kmax)
-  {
-    int k = kmin-1;
-    RealD x;
-    
-    RealD Fden = 1.0/hypot(lmd[k]-Dsh,lme[k]);
-    RealD c = ( lmd[k] -Dsh) *Fden;
-    RealD s = -lme[k] *Fden;
-      
-    RealD tmpa1 = lmd[k];
-    RealD tmpa2 = lmd[k+1];
-    RealD tmpb  = lme[k];
-
-    lmd[k]   = c*c*tmpa1 +s*s*tmpa2 -2.0*c*s*tmpb;
-    lmd[k+1] = s*s*tmpa1 +c*c*tmpa2 +2.0*c*s*tmpb;
-    lme[k]   = c*s*(tmpa1-tmpa2) +(c*c-s*s)*tmpb;
-    x        =-s*lme[k+1];
-    lme[k+1] = c*lme[k+1];
-      
-    for(int i=0; i<Nk; ++i){
-      RealD Qtmp1 = Qt(k,i);
-      RealD Qtmp2 = Qt(k+1,i);
-      Qt(k,i)  = c*Qtmp1 - s*Qtmp2;
-      Qt(k+1,i)= s*Qtmp1 + c*Qtmp2; 
-    }
-
-    // Givens transformations
-    for(int k = kmin; k < kmax-1; ++k){
-      
-      RealD Fden = 1.0/hypot(x,lme[k-1]);
-      RealD c = lme[k-1]*Fden;
-      RealD s = - x*Fden;
-	
-      RealD tmpa1 = lmd[k];
-      RealD tmpa2 = lmd[k+1];
-      RealD tmpb  = lme[k];
-
-      lmd[k]   = c*c*tmpa1 +s*s*tmpa2 -2.0*c*s*tmpb;
-      lmd[k+1] = s*s*tmpa1 +c*c*tmpa2 +2.0*c*s*tmpb;
-      lme[k]   = c*s*(tmpa1-tmpa2) +(c*c-s*s)*tmpb;
-      lme[k-1] = c*lme[k-1] -s*x;
-
-      if(k != kmax-2){
-	x = -s*lme[k+1];
-	lme[k+1] = c*lme[k+1];
-      }
-
-      for(int i=0; i<Nk; ++i){
-	RealD Qtmp1 = Qt(k,i);
-	RealD Qtmp2 = Qt(k+1,i);
-	Qt(k,i)     = c*Qtmp1 -s*Qtmp2;
-	Qt(k+1,i)   = s*Qtmp1 +c*Qtmp2;
-      }
-    }
-  }
-
-  void diagonalize(std::vector<RealD>& lmd, std::vector<RealD>& lme, 
-		   int Nk, int Nm,   
-		   Eigen::MatrixXd & Qt,
-		   GridBase *grid)
-  {
-    Qt = Eigen::MatrixXd::Identity(Nm,Nm);
-    if ( diagonalisation == IRLdiagonaliseWithDSTEGR ) {
-      diagonalize_lapack(lmd,lme,Nk,Nm,Qt,grid);
-    } else if ( diagonalisation == IRLdiagonaliseWithQR ) { 
-      diagonalize_QR(lmd,lme,Nk,Nm,Qt,grid);
-    }  else if ( diagonalisation == IRLdiagonaliseWithEigen ) { 
-      diagonalize_Eigen(lmd,lme,Nk,Nm,Qt,grid);
-    } else { 
-      GRID_ASSERT(0);
-    }
-  }
-
-#ifdef USE_LAPACK
-void LAPACK_dstegr(char *jobz, char *range, int *n, double *d, double *e,
-                   double *vl, double *vu, int *il, int *iu, double *abstol,
-                   int *m, double *w, double *z, int *ldz, int *isuppz,
-                   double *work, int *lwork, int *iwork, int *liwork,
-                   int *info);
-#endif
-
-void diagonalize_lapack(std::vector<RealD>& lmd,
-			std::vector<RealD>& lme, 
-			int Nk, int Nm,  
-			Eigen::MatrixXd& Qt,
-			GridBase *grid)
-{
-#ifdef USE_LAPACK
-  const int size = Nm;
-  int NN = Nk;
-  double evals_tmp[NN];
-  double evec_tmp[NN][NN];
-  memset(evec_tmp[0],0,sizeof(double)*NN*NN);
-  double DD[NN];
-  double EE[NN];
-  for (int i = 0; i< NN; i++) {
-    for (int j = i - 1; j <= i + 1; j++) {
-      if ( j < NN && j >= 0 ) {
-	if (i==j) DD[i] = lmd[i];
-	if (i==j) evals_tmp[i] = lmd[i];
-	if (j==(i-1)) EE[j] = lme[j];
-      }
-    }
-  }
-  int evals_found;
-  int lwork = ( (18*NN) > (1+4*NN+NN*NN)? (18*NN):(1+4*NN+NN*NN)) ;
-  int liwork =  3+NN*10 ;
-  int iwork[liwork];
-  double work[lwork];
-  int isuppz[2*NN];
-  char jobz = 'V'; // calculate evals & evecs
-  char range = 'I'; // calculate all evals
-  //    char range = 'A'; // calculate all evals
-  char uplo = 'U'; // refer to upper half of original matrix
-  char compz = 'I'; // Compute eigenvectors of tridiagonal matrix
-  int ifail[NN];
-  int info;
-  int total = grid->_Nprocessors;
-  int node  = grid->_processor;
-  int interval = (NN/total)+1;
-  double vl = 0.0, vu = 0.0;
-  int il = interval*node+1 , iu = interval*(node+1);
-  if (iu > NN)  iu=NN;
-  double tol = 0.0;
-  if (1) {
-    memset(evals_tmp,0,sizeof(double)*NN);
-    if ( il <= NN){
-      LAPACK_dstegr(&jobz, &range, &NN,
-		    (double*)DD, (double*)EE,
-		    &vl, &vu, &il, &iu, // these four are ignored if second parameteris 'A'
-		    &tol, // tolerance
-		    &evals_found, evals_tmp, (double*)evec_tmp, &NN,
-		    isuppz,
-		    work, &lwork, iwork, &liwork,
-		    &info);
-      for (int i = iu-1; i>= il-1; i--){
-	evals_tmp[i] = evals_tmp[i - (il-1)];
-	if (il>1) evals_tmp[i-(il-1)]=0.;
-	for (int j = 0; j< NN; j++){
-	  evec_tmp[i][j] = evec_tmp[i - (il-1)][j];
-	  if (il>1) evec_tmp[i-(il-1)][j]=0.;
-	}
-      }
-    }
-    {
-      grid->GlobalSumVector(evals_tmp,NN);
-      grid->GlobalSumVector((double*)evec_tmp,NN*NN);
-    }
-  } 
-  // Safer to sort instead of just reversing it, 
-  // but the document of the routine says evals are sorted in increasing order. 
-  // qr gives evals in decreasing order.
-  for(int i=0;i<NN;i++){
-    lmd [NN-1-i]=evals_tmp[i];
-    for(int j=0;j<NN;j++){
-      Qt((NN-1-i),j)=evec_tmp[i][j];
-    }
-  }
-#else 
-  GRID_ASSERT(0);
-#endif
-}
-
-void diagonalize_QR(std::vector<RealD>& lmd, std::vector<RealD>& lme, 
-		    int Nk, int Nm,   
-		    Eigen::MatrixXd & Qt,
-		    GridBase *grid)
-{
-  int QRiter = 100*Nm;
-  int kmin = 1;
-  int kmax = Nk;
-  
-  // (this should be more sophisticated)
-  for(int iter=0; iter<QRiter; ++iter){
-    
-    // determination of 2x2 leading submatrix
-    RealD dsub = lmd[kmax-1]-lmd[kmax-2];
-    RealD dd = std::sqrt(dsub*dsub + 4.0*lme[kmax-2]*lme[kmax-2]);
-    RealD Dsh = 0.5*(lmd[kmax-2]+lmd[kmax-1] +dd*(dsub/fabs(dsub)));
-    // (Dsh: shift)
-    
-    // transformation
-    QR_decomp(lmd,lme,Nk,Nm,Qt,Dsh,kmin,kmax); // Nk, Nm
-    
-    // Convergence criterion (redef of kmin and kamx)
-    for(int j=kmax-1; j>= kmin; --j){
-      RealD dds = fabs(lmd[j-1])+fabs(lmd[j]);
-      if(fabs(lme[j-1])+dds > dds){
-	kmax = j+1;
-	goto continued;
-      }
-    }
-    QRiter = iter;
-    return;
-    
-  continued:
-    for(int j=0; j<kmax-1; ++j){
-      RealD dds = fabs(lmd[j])+fabs(lmd[j+1]);
-      if(fabs(lme[j])+dds > dds){
-	kmin = j+1;
-	break;
-      }
-    }
-  }
-  std::cout << GridLogError << "[QL method] Error - Too many iteration: "<<QRiter<<"\n";
-  abort();
-}
-};
-
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/LocalCoherenceLanczos.h

@@ -1,454 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/LocalCoherenceLanczos.h
-
-    Copyright (C) 2015
-
-Author: Christoph Lehner <clehner@bnl.gov>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_LOCAL_COHERENCE_IRL_H
-#define GRID_LOCAL_COHERENCE_IRL_H
-
-NAMESPACE_BEGIN(Grid); 
-
-struct LanczosParams : Serializable {
-public:
-  GRID_SERIALIZABLE_CLASS_MEMBERS(LanczosParams,
-				  ChebyParams, Cheby,/*Chebyshev*/
-				  int, Nstop,    /*Vecs in Lanczos must converge Nstop < Nk < Nm*/
-				  int, Nk,       /*Vecs in Lanczos seek converge*/
-				  int, Nm,       /*Total vecs in Lanczos include restart*/
-				  RealD, resid,  /*residual*/
- 				  int, MaxIt, 
-				  RealD, betastp,  /* ? */
-				  int, MinRes);    // Must restart
-};
-
-//This class is the input parameter class for some testing programs
-struct LocalCoherenceLanczosParams : Serializable {
-public:
-  GRID_SERIALIZABLE_CLASS_MEMBERS(LocalCoherenceLanczosParams,
-				  bool, saveEvecs,
-				  bool, doFine,
-				  bool, doFineRead,
-				  bool, doCoarse,
-	       			  bool, doCoarseRead,
-				  LanczosParams, FineParams,
-				  LanczosParams, CoarseParams,
-				  ChebyParams,   Smoother,
-				  RealD        , coarse_relax_tol,
-				  std::vector<int>, blockSize,
-				  std::string, config,
-				  std::vector < ComplexD  >, omega,
-				  RealD, mass,
-				  RealD, M5);
-};
-
-// Duplicate functionality; ProjectedFunctionHermOp could be used with the trivial function
-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
-  typedef Lattice<Fobj>          FineField;
-
-  LinearOperatorBase<FineField> &_Linop;
-  std::vector<FineField>        &subspace;
-
-  ProjectedHermOp(LinearOperatorBase<FineField>& linop, std::vector<FineField> & _subspace) : 
-    _Linop(linop), subspace(_subspace)
-  {  
-    GRID_ASSERT(subspace.size() >0);
-  };
-
-  void operator()(const CoarseField& in, CoarseField& out) {
-    GridBase *FineGrid = subspace[0].Grid();    
-    int   checkerboard = subspace[0].Checkerboard();
-
-    FineField fin (FineGrid);     fin.Checkerboard()= checkerboard;
-    FineField fout(FineGrid);   fout.Checkerboard() = checkerboard;
-
-    blockPromote(in,fin,subspace);       std::cout<<GridLogIRL<<"ProjectedHermop : Promote to fine"<<std::endl;
-    _Linop.HermOp(fin,fout);                   std::cout<<GridLogIRL<<"ProjectedHermop : HermOp (fine) "<<std::endl;
-    blockProject(out,fout,subspace);     std::cout<<GridLogIRL<<"ProjectedHermop : Project to coarse "<<std::endl;
-  }
-};
-
-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
-  typedef Lattice<Fobj>          FineField;
-
-
-  OperatorFunction<FineField>   & _poly;
-  LinearOperatorBase<FineField> &_Linop;
-  std::vector<FineField>        &subspace;
-
-  ProjectedFunctionHermOp(OperatorFunction<FineField> & poly,
-			  LinearOperatorBase<FineField>& linop, 
-			  std::vector<FineField> & _subspace) :
-    _poly(poly),
-    _Linop(linop),
-    subspace(_subspace)
-  {  };
-
-  void operator()(const CoarseField& in, CoarseField& out) {
-
-    GridBase *FineGrid = subspace[0].Grid();    
-    int   checkerboard = subspace[0].Checkerboard();
-
-    FineField fin (FineGrid); fin.Checkerboard() =checkerboard;
-    FineField fout(FineGrid);fout.Checkerboard() =checkerboard;
-    
-    blockPromote(in,fin,subspace);             std::cout<<GridLogIRL<<"ProjectedFunctionHermop : Promote to fine"<<std::endl;
-    _poly(_Linop,fin,fout);                    std::cout<<GridLogIRL<<"ProjectedFunctionHermop : Poly "<<std::endl;
-    blockProject(out,fout,subspace);           std::cout<<GridLogIRL<<"ProjectedFunctionHermop : Project to coarse "<<std::endl;
-  }
-};
-
-template<class Fobj,class CComplex,int nbasis>
-class ImplicitlyRestartedLanczosSmoothedTester  : public ImplicitlyRestartedLanczosTester<Lattice<iVector<CComplex,nbasis > > >
-{
-public:
-  typedef iVector<CComplex,nbasis >           CoarseSiteVector;
-  typedef Lattice<CoarseSiteVector>           CoarseField;
-  typedef Lattice<CComplex>   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<Fobj>          FineField;
-
-  LinearFunction<CoarseField> & _Poly;
-  OperatorFunction<FineField>   & _smoother;
-  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) 
-    : _smoother(smoother), _Linop(Linop), _Poly(Poly), _subspace(subspace),
-      _coarse_relax_tol(coarse_relax_tol), _largestEvalIdxForReport(largestEvalIdxForReport)
-  {    };
-
-  //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);
-    RealD eval_poly = eval;
-
-    // Apply operator
-    _Poly(B,v);
-
-    RealD vnum = real(innerProduct(B,v)); // HermOp.
-    RealD vden = norm2(B);
-    RealD vv0  = norm2(v);
-    eval   = vnum/vden;
-    v -= eval*B;
-
-    RealD vv = norm2(v) / ::pow(evalMaxApprox,2.0);
-
-    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
-	     <<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)  
-  {
-    evalMaxApprox = 1.0; //cf above
-    GridBase *FineGrid = _subspace[0].Grid();    
-    int checkerboard   = _subspace[0].Checkerboard();
-    FineField fB(FineGrid);fB.Checkerboard() =checkerboard;
-    FineField fv(FineGrid);fv.Checkerboard() =checkerboard;
-
-    blockPromote(B,fv,_subspace);  
-    
-    _smoother(_Linop,fv,fB); 
-
-    RealD eval_poly = eval;
-    _Linop.HermOp(fB,fv);
-
-    RealD vnum = real(innerProduct(fB,fv)); // HermOp.
-    RealD vden = norm2(fB);
-    RealD vv0  = norm2(fv);
-    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
-	     <<std::endl;
-    if( (vv<eresid*eresid) ) return 1;
-    return 0;
-  }
-};
-
-////////////////////////////////////////////
-// Make serializable Lanczos params
-////////////////////////////////////////////
-template<class Fobj,class CComplex,int nbasis>
-class LocalCoherenceLanczos 
-{
-public:
-  typedef iVector<CComplex,nbasis >           CoarseSiteVector;
-  typedef Lattice<CComplex>                   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<CoarseSiteVector>           CoarseField;
-  typedef Lattice<Fobj>                       FineField;
-
-protected:
-  GridBase *_CoarseGrid;
-  GridBase *_FineGrid;
-  int _checkerboard;
-  LinearOperatorBase<FineField>                 & _FineOp;
-  
-  std::vector<RealD>                              &evals_fine;
-  std::vector<RealD>                              &evals_coarse; 
-  std::vector<FineField>                          &subspace;
-  std::vector<CoarseField>                        &evec_coarse;
-
-private:
-  std::vector<RealD>                              _evals_fine;
-  std::vector<RealD>                              _evals_coarse; 
-  std::vector<FineField>                          _subspace;
-  std::vector<CoarseField>                        _evec_coarse;
-
-public:
-
-  LocalCoherenceLanczos(GridBase *FineGrid,
-			GridBase *CoarseGrid,
-			LinearOperatorBase<FineField> &FineOp,
-			int checkerboard) :
-    _CoarseGrid(CoarseGrid),
-    _FineGrid(FineGrid),
-    _FineOp(FineOp),
-    _checkerboard(checkerboard),
-    evals_fine  (_evals_fine),
-    evals_coarse(_evals_coarse),
-    subspace    (_subspace),
-    evec_coarse(_evec_coarse)
-  {
-    evals_fine.resize(0);
-    evals_coarse.resize(0);
-  };
-  //////////////////////////////////////////////////////////////////////////
-  // Alternate constructore, external storage for use by Hadrons module
-  //////////////////////////////////////////////////////////////////////////
-  LocalCoherenceLanczos(GridBase *FineGrid,
-			GridBase *CoarseGrid,
-			LinearOperatorBase<FineField> &FineOp,
-			int checkerboard,
-			std::vector<FineField>   &ext_subspace,
-			std::vector<CoarseField> &ext_coarse,
-			std::vector<RealD>       &ext_eval_fine,
-			std::vector<RealD>       &ext_eval_coarse
-			) :
-    _CoarseGrid(CoarseGrid),
-    _FineGrid(FineGrid),
-    _FineOp(FineOp),
-    _checkerboard(checkerboard),
-    evals_fine  (ext_eval_fine), 
-    evals_coarse(ext_eval_coarse),
-    subspace    (ext_subspace),
-    evec_coarse (ext_coarse)
-  {
-    evals_fine.resize(0);
-    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;
-    blockOrthogonalise(InnerProd,subspace);
-    std::cout << GridLogMessage <<" Gramm-Schmidt pass 2"<<std::endl;
-    blockOrthogonalise(InnerProd,subspace);
-  };
-
-  template<typename T>  static RealD normalise(T& v) 
-  {
-    RealD nn = norm2(v);
-    nn = ::sqrt(nn);
-    v = v * (1.0/nn);
-    return nn;
-  }
-  /*
-  void fakeFine(void)
-  {
-    int Nk = nbasis;
-    subspace.resize(Nk,_FineGrid);
-    subspace[0]=1.0;
-    subspace[0].Checkerboard()=_checkerboard;
-    normalise(subspace[0]);
-    PlainHermOp<FineField>    Op(_FineOp);
-    for(int k=1;k<Nk;k++){
-      subspace[k].Checkerboard()=_checkerboard;
-      Op(subspace[k-1],subspace[k]);
-      normalise(subspace[k]);
-    }
-  }
-  */
-
-  void testFine(RealD resid) 
-  {
-    GRID_ASSERT(evals_fine.size() == nbasis);
-    GRID_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);
-    }
-  }
-
-  //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);
-    //////////////////////////////////////////////////////////////////////////////////////////////////
-    // create a smoother and see if we can get a cheap convergence test and smooth inside the IRL
-    //////////////////////////////////////////////////////////////////////////////////////////////////
-    Chebyshev<FineField>                          ChebySmooth(cheby_smooth);
-    ProjectedFunctionHermOp<Fobj,CComplex,nbasis> ChebyOp (ChebySmooth,_FineOp,subspace);
-    ImplicitlyRestartedLanczosSmoothedTester<Fobj,CComplex,nbasis> ChebySmoothTester(ChebyOp,ChebySmooth,_FineOp,subspace,relax);
-
-    for(int k=0;k<evec_coarse.size();k++){
-      if ( k < nbasis ) { 
-	assert(ChebySmoothTester.ReconstructEval(k,resid,evec_coarse[k],evals_coarse[k],1.0)==1);
-      } else { 
-	assert(ChebySmoothTester.ReconstructEval(k,resid*relax,evec_coarse[k],evals_coarse[k],1.0)==1);
-      }
-    }
-  }
-
-  void calcFine(ChebyParams cheby_parms,int Nstop,int Nk,int Nm,RealD resid, 
-		RealD MaxIt, RealD betastp, int MinRes)
-  {
-    GRID_ASSERT(nbasis<=Nm);
-    Chebyshev<FineField>      Cheby(cheby_parms);
-    FunctionHermOp<FineField> ChebyOp(Cheby,_FineOp);
-    PlainHermOp<FineField>    Op(_FineOp);
-
-    evals_fine.resize(Nm);
-    subspace.resize(Nm,_FineGrid);
-
-    ImplicitlyRestartedLanczos<FineField> IRL(ChebyOp,Op,Nstop,Nk,Nm,resid,MaxIt,betastp,MinRes);
-
-    FineField src(_FineGrid); 
-    typedef typename FineField::scalar_type Scalar;
-    // src=1.0; 
-    src=Scalar(1.0); 
-    src.Checkerboard() = _checkerboard;
-
-    int Nconv;
-    IRL.calc(evals_fine,subspace,src,Nconv,false);
-    
-    // Shrink down to number saved
-    GRID_ASSERT(Nstop>=nbasis);
-    GRID_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
-    //////////////////////////////////////////////////////////////////////////////////////////////////
-    // 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); 
-
-    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);
-    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);
-#endif

Grid/algorithms/iterative/MinimalResidual.h

@@ -1,157 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/MinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_MINIMAL_RESIDUAL_H
-#define GRID_MINIMAL_RESIDUAL_H
-
-namespace Grid {
-
-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.
-                          // Defaults true.
-  RealD   Tolerance;
-  Integer MaxIterations;
-  RealD   overRelaxParam;
-  Integer IterationsToComplete; // Number of iterations the MR took to finish.
-                                // Filled in upon completion
-
-  MinimalResidual(RealD tol, Integer maxit, Real ovrelparam = 1.0, bool err_on_no_conv = true)
-    : Tolerance(tol), MaxIterations(maxit), overRelaxParam(ovrelparam), ErrorOnNoConverge(err_on_no_conv){};
-
-  void operator()(LinearOperatorBase<Field> &Linop, const Field &src, Field &psi) {
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    ComplexD a, c;
-    RealD    d;
-
-    Field Mr(src);
-    Field r(src);
-
-    // Initial residual computation & set up
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    Linop.Op(psi, Mr);
-
-    r = src - Mr;
-
-    RealD cp = norm2(r);
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "MinimalResidual: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "MinimalResidual:   src " << ssq << std::endl;
-    std::cout << GridLogIterative << "MinimalResidual:  cp,r " << cp << std::endl;
-
-    if (cp <= rsq) {
-      return;
-    }
-
-    std::cout << GridLogIterative << "MinimalResidual: k=0 residual " << cp << " target " << rsq << std::endl;
-
-    GridStopWatch LinalgTimer;
-    GridStopWatch MatrixTimer;
-    GridStopWatch SolverTimer;
-
-    SolverTimer.Start();
-    int k;
-    for (k = 1; k <= MaxIterations; k++) {
-
-      MatrixTimer.Start();
-      Linop.Op(r, Mr);
-      MatrixTimer.Stop();
-
-      LinalgTimer.Start();
-
-      c = innerProduct(Mr, r);
-
-      d = norm2(Mr);
-
-      a = c / d;
-
-      a = a * overRelaxParam;
-
-      psi = psi + r * a;
-
-      r = r - Mr * a;
-
-      cp = norm2(r);
-
-      LinalgTimer.Stop();
-
-      std::cout << GridLogIterative << "MinimalResidual: Iteration " << k
-                << " residual " << cp << " target " << rsq << std::endl;
-      std::cout << GridLogDebug << "a = " << a << " c = " << c << " d = " << d << std::endl;
-
-      // Stopping condition
-      if (cp <= rsq) {
-        SolverTimer.Stop();
-
-        Linop.Op(psi, Mr);
-        r = src - Mr;
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "MinimalResidual Converged on iteration " << k
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "MR Time elapsed: Total   " << SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MR Time elapsed: Matrix  " << MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MR Time elapsed: Linalg  " << LinalgTimer.Elapsed() << std::endl;
-
-        if (ErrorOnNoConverge)
-          GRID_ASSERT(true_residual / Tolerance < 10000.0);
-
-        IterationsToComplete = k;
-
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "MinimalResidual did NOT converge"
-              << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-
-    IterationsToComplete = k;
-  }
-};
-} // namespace Grid
-#endif

Grid/algorithms/iterative/MixedPrecisionFlexibleGeneralisedMinimalResidual.h

@@ -1,276 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithms/iterative/MixedPrecisionFlexibleGeneralisedMinimalResidual.h
-
-Copyright (C) 2015
-
-Author: Daniel Richtmann <daniel.richtmann@ur.de>
-
-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_MIXED_PRECISION_FLEXIBLE_GENERALISED_MINIMAL_RESIDUAL_H
-#define GRID_MIXED_PRECISION_FLEXIBLE_GENERALISED_MINIMAL_RESIDUAL_H
-
-namespace 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 MixedPrecisionFlexibleGeneralisedMinimalResidual : public OperatorFunction<FieldD> {
- public:
-
-  using OperatorFunction<FieldD>::operator();
-
-  bool ErrorOnNoConverge; // Throw an GRID_ASSERT when MPFGMRES fails to converge,
-                          // defaults to true
-
-  RealD   Tolerance;
-
-  Integer MaxIterations;
-  Integer RestartLength;
-  Integer MaxNumberOfRestarts;
-  Integer IterationCount; // Number of iterations the MPFGMRES took to finish,
-                          // filled in upon completion
-
-  GridStopWatch MatrixTimer;
-  GridStopWatch PrecTimer;
-  GridStopWatch LinalgTimer;
-  GridStopWatch QrTimer;
-  GridStopWatch CompSolutionTimer;
-  GridStopWatch ChangePrecTimer;
-
-  Eigen::MatrixXcd H;
-
-  std::vector<ComplexD> y;
-  std::vector<ComplexD> gamma;
-  std::vector<ComplexD> c;
-  std::vector<ComplexD> s;
-
-  GridBase* SinglePrecGrid;
-
-  LinearFunction<FieldF> &Preconditioner;
-
-  MixedPrecisionFlexibleGeneralisedMinimalResidual(RealD   tol,
-                                                   Integer maxit,
-                                                   GridBase * sp_grid,
-                                                   LinearFunction<FieldF> &Prec,
-                                                   Integer restart_length,
-                                                   bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , RestartLength(restart_length)
-      , MaxNumberOfRestarts(MaxIterations/RestartLength + ((MaxIterations%RestartLength == 0) ? 0 : 1))
-      , ErrorOnNoConverge(err_on_no_conv)
-      , H(Eigen::MatrixXcd::Zero(RestartLength, RestartLength + 1)) // sizes taken from DD-αAMG code base
-      , y(RestartLength + 1, 0.)
-      , gamma(RestartLength + 1, 0.)
-      , c(RestartLength + 1, 0.)
-      , s(RestartLength + 1, 0.)
-      , SinglePrecGrid(sp_grid)
-      , Preconditioner(Prec) {};
-
-  void operator()(LinearOperatorBase<FieldD> &LinOp, const FieldD &src, FieldD &psi) {
-
-    psi.Checkerboard() = src.Checkerboard();
-    conformable(psi, src);
-
-    RealD guess = norm2(psi);
-    GRID_ASSERT(std::isnan(guess) == 0);
-
-    RealD cp;
-    RealD ssq = norm2(src);
-    RealD rsq = Tolerance * Tolerance * ssq;
-
-    FieldD r(src.Grid());
-
-    std::cout << std::setprecision(4) << std::scientific;
-    std::cout << GridLogIterative << "MPFGMRES: guess " << guess << std::endl;
-    std::cout << GridLogIterative << "MPFGMRES:   src " << ssq   << std::endl;
-
-    PrecTimer.Reset();
-    MatrixTimer.Reset();
-    LinalgTimer.Reset();
-    QrTimer.Reset();
-    CompSolutionTimer.Reset();
-    ChangePrecTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    SolverTimer.Start();
-
-    IterationCount = 0;
-
-    for (int k=0; k<MaxNumberOfRestarts; k++) {
-
-      cp = outerLoopBody(LinOp, src, psi, rsq);
-
-      // Stopping condition
-      if (cp <= rsq) {
-
-        SolverTimer.Stop();
-
-        LinOp.Op(psi,r);
-        axpy(r,-1.0,src,r);
-
-        RealD srcnorm       = sqrt(ssq);
-        RealD resnorm       = sqrt(norm2(r));
-        RealD true_residual = resnorm / srcnorm;
-
-        std::cout << GridLogMessage        << "MPFGMRES: Converged on iteration " << IterationCount
-                  << " computed residual " << sqrt(cp / ssq)
-                  << " true residual "     << true_residual
-                  << " target "            << Tolerance << std::endl;
-
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: Total      " <<       SolverTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: Precon     " <<         PrecTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: Matrix     " <<       MatrixTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: Linalg     " <<       LinalgTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: QR         " <<           QrTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: CompSol    " << CompSolutionTimer.Elapsed() << std::endl;
-        std::cout << GridLogMessage << "MPFGMRES Time elapsed: PrecChange " <<   ChangePrecTimer.Elapsed() << std::endl;
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "MPFGMRES did NOT converge" << std::endl;
-
-    if (ErrorOnNoConverge)
-      GRID_ASSERT(0);
-  }
-
-  RealD outerLoopBody(LinearOperatorBase<FieldD> &LinOp, const FieldD &src, FieldD &psi, RealD rsq) {
-
-    RealD cp = 0;
-
-    FieldD w(src.Grid());
-    FieldD r(src.Grid());
-
-    // these should probably be made class members so that they are only allocated once, not in every restart
-    std::vector<FieldD> v(RestartLength + 1, src.Grid()); for (auto &elem : v) elem = Zero();
-    std::vector<FieldD> z(RestartLength + 1, src.Grid()); for (auto &elem : z) elem = Zero();
-
-    MatrixTimer.Start();
-    LinOp.Op(psi, w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    r = src - w;
-
-    gamma[0] = sqrt(norm2(r));
-
-    v[0] = (1. / gamma[0]) * r;
-    LinalgTimer.Stop();
-
-    for (int i=0; i<RestartLength; i++) {
-
-      IterationCount++;
-
-      arnoldiStep(LinOp, v, z, w, i);
-
-      qrUpdate(i);
-
-      cp = norm(gamma[i+1]);
-
-      std::cout << GridLogIterative << "MPFGMRES: Iteration " << IterationCount
-                << " residual " << cp << " target " << rsq << std::endl;
-
-      if ((i == RestartLength - 1) || (IterationCount == MaxIterations) || (cp <= rsq)) {
-
-        computeSolution(z, psi, i);
-
-        return cp;
-      }
-    }
-
-    GRID_ASSERT(0); // Never reached
-    return cp;
-  }
-
-  void arnoldiStep(LinearOperatorBase<FieldD> &LinOp, std::vector<FieldD> &v, std::vector<FieldD> &z, FieldD &w, int iter) {
-
-    FieldF v_f(SinglePrecGrid);
-    FieldF z_f(SinglePrecGrid);
-
-    ChangePrecTimer.Start();
-    precisionChange(v_f, v[iter]);
-    precisionChange(z_f, z[iter]);
-    ChangePrecTimer.Stop();
-
-    PrecTimer.Start();
-    Preconditioner(v_f, z_f);
-    PrecTimer.Stop();
-
-    ChangePrecTimer.Start();
-    precisionChange(z[iter], z_f);
-    ChangePrecTimer.Stop();
-
-    MatrixTimer.Start();
-    LinOp.Op(z[iter], w);
-    MatrixTimer.Stop();
-
-    LinalgTimer.Start();
-    for (int i = 0; i <= iter; ++i) {
-      H(iter, i) = innerProduct(v[i], w);
-      w = w - ComplexD(H(iter, i)) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = ComplexD(1. / H(iter, iter + 1)) * w;
-    LinalgTimer.Stop();
-  }
-
-  void qrUpdate(int iter) {
-
-    QrTimer.Start();
-    for (int i = 0; i < iter ; ++i) {
-      auto tmp       = -s[i] * ComplexD(H(iter, i)) + c[i] * ComplexD(H(iter, i + 1));
-      H(iter, i)     = conjugate(c[i]) * ComplexD(H(iter, i)) + conjugate(s[i]) * ComplexD(H(iter, i + 1));
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    auto nu = sqrt(std::norm(H(iter, iter)) + std::norm(H(iter, iter + 1)));
-    c[iter]     = H(iter, iter) / nu;
-    s[iter]     = H(iter, iter + 1) / nu;
-
-    // Apply new Givens rotation
-    H(iter, iter)     = nu;
-    H(iter, iter + 1) = 0.;
-
-    gamma[iter + 1] = -s[iter] * gamma[iter];
-    gamma[iter]     = conjugate(c[iter]) * gamma[iter];
-    QrTimer.Stop();
-  }
-
-  void computeSolution(std::vector<FieldD> const &z, FieldD &psi, int iter) {
-
-    CompSolutionTimer.Start();
-    for (int i = iter; i >= 0; i--) {
-      y[i] = gamma[i];
-      for (int k = i + 1; k <= iter; k++)
-        y[i] = y[i] - ComplexD(H(k, i)) * y[k];
-      y[i] = y[i] / ComplexD(H(i, i));
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + z[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/NormalEquations.h

@@ -1,138 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/NormalEquations.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 */
-#ifndef GRID_NORMAL_EQUATIONS_H
-#define GRID_NORMAL_EQUATIONS_H
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// Take a matrix and form an NE solver calling a Herm solver
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field> class NormalEquations : public LinearFunction<Field>{
-private:
-  SparseMatrixBase<Field> & _Matrix;
-  OperatorFunction<Field> & _HermitianSolver;
-  LinearFunction<Field>   & _Guess;
-public:
-
-  /////////////////////////////////////////////////////
-  // Wrap the usual normal equations trick
-  /////////////////////////////////////////////////////
- NormalEquations(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver,
-		 LinearFunction<Field> &Guess) 
-   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
-
-  void operator() (const Field &in, Field &out){
- 
-    Field src(in.Grid());
-    Field tmp(in.Grid());
-
-    MdagMLinearOperator<SparseMatrixBase<Field>,Field> MdagMOp(_Matrix);
-    _Matrix.Mdag(in,src);
-    _Guess(src,out);
-    _HermitianSolver(MdagMOp,src,out);  // Mdag M out = Mdag in
-
-  }     
-};
-
-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> {
-private:
-  LinearOperatorBase<Field> & _Matrix;
-  OperatorFunction<Field> & _HermitianSolver;
-  LinearFunction<Field>   & _Guess;
-public:
-
-  /////////////////////////////////////////////////////
-  // Wrap the usual normal equations trick
-  /////////////////////////////////////////////////////
- HPDSolver(LinearOperatorBase<Field> &Matrix,
-	   OperatorFunction<Field> &HermitianSolver,
-	   LinearFunction<Field> &Guess) 
-   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
-
-  void operator() (const Field &in, Field &out){
- 
-    _Guess(in,out);
-    _HermitianSolver(_Matrix,in,out);  //M out = in
-
-  }     
-};
-
-
-template<class Field> class MdagMSolver : public LinearFunction<Field> {
-private:
-  SparseMatrixBase<Field> & _Matrix;
-  OperatorFunction<Field> & _HermitianSolver;
-  LinearFunction<Field>   & _Guess;
-public:
-
-  /////////////////////////////////////////////////////
-  // Wrap the usual normal equations trick
-  /////////////////////////////////////////////////////
- MdagMSolver(SparseMatrixBase<Field> &Matrix, OperatorFunction<Field> &HermitianSolver,
-	     LinearFunction<Field> &Guess) 
-   :  _Matrix(Matrix), _HermitianSolver(HermitianSolver), _Guess(Guess) {}; 
-
-  void operator() (const Field &in, Field &out){
- 
-    MdagMLinearOperator<SparseMatrixBase<Field>,Field> MdagMOp(_Matrix);
-    _Guess(in,out);
-
-    _HermitianSolver(MdagMOp,in,out);  // Mdag M out = Mdag in
-
-  }     
-};
-
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/PowerMethod.h

@@ -1,111 +0,0 @@
-#pragma once
-namespace Grid {
-template<class Field> class PowerMethod  
-{ 
- public: 
-
-  template<typename T>  static RealD normalise(T& v) 
-  {
-    RealD nn = norm2(v);
-    nn = sqrt(nn);
-    v = v * (1.0/nn);
-    return nn;
-  }
-
-  RealD operator()(LinearOperatorBase<Field> &HermOp, const Field &src) 
-  { 
-    GridBase *grid = src.Grid(); 
-    
-    // quickly get an idea of the largest eigenvalue to more properly normalize the residuum 
-    RealD evalMaxApprox = 0.0; 
-    auto src_n = src; 
-    auto tmp = src; 
-    const int _MAX_ITER_EST_ = 200; 
-
-    for (int i=0;i<_MAX_ITER_EST_;i++) { 
-      
-      normalise(src_n); 
-      HermOp.HermOp(src_n,tmp); 
-      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; 
-      //      } 
-      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;
-  }
-};
-}

Grid/algorithms/iterative/PowerSpectrum.h

@@ -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;
-  };
-};
-  
-}

Grid/algorithms/iterative/PrecConjugateResidual.h

@@ -1,119 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/PrecConjugateResidual.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 */
-#ifndef GRID_PREC_CONJUGATE_RESIDUAL_H
-#define GRID_PREC_CONJUGATE_RESIDUAL_H
-
-NAMESPACE_BEGIN(Grid);
-
-/////////////////////////////////////////////////////////////
-// Base classes for iterative processes based on operators
-// single input vec, single output vec.
-/////////////////////////////////////////////////////////////
-
-template<class Field> 
-class PrecConjugateResidual : public OperatorFunction<Field> {
-public:                                                
-  RealD   Tolerance;
-  Integer MaxIterations;
-  int verbose;
-  LinearFunction<Field> &Preconditioner;
-
-  PrecConjugateResidual(RealD tol,Integer maxit,LinearFunction<Field> &Prec) : Tolerance(tol), MaxIterations(maxit),      Preconditioner(Prec)
-  { 
-    verbose=1;
-  };
-
-  void operator() (LinearOperatorBase<Field> &Linop,const Field &src, Field &psi){
-
-    RealD a, b, c, d;
-    RealD cp, ssq,rsq;
-      
-    RealD rAr, rAAr, rArp;
-    RealD pAp, pAAp;
-
-    GridBase *grid = src.Grid();
-    Field r(grid),  p(grid), Ap(grid), Ar(grid), z(grid);
-      
-    psi=zero;
-    r  = src;
-    Preconditioner(r,p);
-
-      
-
-    Linop.HermOpAndNorm(p,Ap,pAp,pAAp);
-    Ar=Ap;
-    rAr=pAp;
-    rAAr=pAAp;
-
-    cp =norm2(r);
-    ssq=norm2(src);
-    rsq=Tolerance*Tolerance*ssq;
-
-    if (verbose) std::cout<<GridLogMessage<<"PrecConjugateResidual: iteration " <<0<<" residual "<<cp<< " target"<< rsq<<std::endl;
-
-    for(int k=0;k<MaxIterations;k++){
-
-
-      Preconditioner(Ap,z);
-      RealD rq= real(innerProduct(Ap,z)); 
-
-      a = rAr/rq;
-
-      axpy(psi,a,p,psi);
-      cp = axpy_norm(r,-a,z,r);
-
-      rArp=rAr;
-
-      Linop.HermOpAndNorm(r,Ar,rAr,rAAr);
-
-      b   =rAr/rArp;
- 
-      axpy(p,b,p,r);
-      pAAp=axpy_norm(Ap,b,Ap,Ar);
-	
-      if(verbose) std::cout<<GridLogMessage<<"PrecConjugateResidual: iteration " <<k<<" residual "<<cp<< " target"<< rsq<<std::endl;
-
-      if(cp<rsq) {
-	Linop.HermOp(psi,Ap);
-	axpy(r,-1.0,src,Ap);
-	RealD true_resid = norm2(r)/ssq;
-	std::cout<<GridLogMessage<<"PrecConjugateResidual: Converged on iteration " <<k
-		 << " computed residual "<<sqrt(cp/ssq)
-		 << " true residual "<<sqrt(true_resid)
-		 << " target "       <<Tolerance <<std::endl;
-	return;
-      }
-
-    }
-
-    std::cout<<GridLogMessage<<"PrecConjugateResidual did NOT converge"<<std::endl;
-    GRID_ASSERT(0);
-  }
-};
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/PrecGeneralisedConjugateResidual.h

@@ -1,75 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid
-
-    Source file: ./lib/algorithms/iterative/PrecGeneralisedConjugateResidual.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef GRID_PREC_GCR_H
-#define GRID_PREC_GCR_H
-#include <Grid/algorithms/iterative/PrecGeneralisedConjugateResidualNonHermitian.h>
-
-NAMESPACE_BEGIN(Grid);
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-// Hermitian spelling of PrecGeneralisedConjugateResidualNonHermitian.
-//
-// The algorithm is the same; only the operator entry point differs.  The solver
-// drives Linop.Op(), while a caller of this class means "invert HermOp", so the
-// operator is wrapped in HermOpAdaptor.  The wrap is what makes the two classes
-// one: for an operator whose Op() already IS its HermOp() (HermitianLinearOperator,
-// Gamma5R5HermitianLinearOperator, HermOpAdaptor) it changes nothing, and for one
-// where they differ (MdagMLinearOperator: Op()=M, HermOp()=MdagM) it preserves the
-// Hermitian meaning the caller asked for.
-//
-// A non-zero initial guess is respected.  Callers that guarantee x0 = 0 can call
-// SetZeroGuess(1) to skip the first r0 = src - A x0 apply.
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-template<class Field>
-class PrecGeneralisedConjugateResidual : public LinearFunction<Field> {
-  // Declaration order is initialisation order: the adaptor is complete before
-  // the solver binds its reference to it.
-  HermOpAdaptor<Field>                                HermLinop;
-  PrecGeneralisedConjugateResidualNonHermitian<Field> GCR;
-public:
-  using LinearFunction<Field>::operator();
-
-  PrecGeneralisedConjugateResidual(RealD tol,Integer maxit,LinearOperatorBase<Field> &Linop,
-                                   LinearFunction<Field> &Prec,int mmax,int nstep)
-    : HermLinop(Linop),
-      GCR(tol,maxit,HermLinop,Prec,mmax,nstep) {};
-
-  void operator() (const Field &src, Field &psi) { GCR(src,psi); };
-
-  void Name(std::string n)                       { GCR.Name(n); };
-  void Level(int n)                              { GCR.Level(n); };
-  void SetZeroGuess(int z)                       { GCR.SetZeroGuess(z); };
-  int  Steps(void) const                         { return GCR.Steps(); };
-  void LogCoefficients(int l)                    { GCR.LogCoefficients(l); };
-  void SetCoefficientRecorder(GCRCoefficients *r){ GCR.SetCoefficientRecorder(r); };
-  void ReleaseHistory(void)                      { GCR.ReleaseHistory(); };
-};
-
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/iterative/PrecGeneralisedConjugateResidualNonHermitian.h

@@ -1,358 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/PrecGeneralisedConjugateResidual.h
-
-    Copyright (C) 2015
-
-Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#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.
-//INTERNATIONAL JOURNAL OF NUMERICAL ANALYSIS AND MODELING
-//Computing and Information Volume 2, Number 2, Pages 147-161
-//NB. Likely not original reference since they are focussing on a preconditioner variant.
-//    but VPGCR was nicely written up in their paper
-///////////////////////////////////////////////////////////////////////////////////////////////////////
-NAMESPACE_BEGIN(Grid);
-
-#define GCRLogLevel std::cout << GridLogMessage <<std::string(level,'\t')<< name<<" "
-
-template<class Field>
-class PrecGeneralisedConjugateResidualNonHermitian : public LinearFunction<Field> {
-public:
-  using LinearFunction<Field>::operator();
-
-  PrecGeneralisedConjugateResidualNonHermitian(RealD tol,Integer maxit,LinearOperatorBase<Field> &_Linop,LinearFunction<Field> &Prec,int _mmax,int _nstep) :
-    Tolerance(tol),
-    MaxIterations(maxit),
-    mmax(_mmax),
-    nstep(_nstep),
-    Preconditioner(Prec),
-    Linop(_Linop)
-  {
-    Level(1);
-    verbose=1;
-    trivial_prec = Preconditioner.isTrivial();
-  };
-
-  // 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; };
-
-  // Steps taken by the last solve.
-  int  Steps(void) const { return steps; };
-
-  // 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.
-  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.
-  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; };
-
-private:
-  RealD   Tolerance;
-  RealD   SSQ;
-  Integer MaxIterations;
-  int verbose;
-  int mmax;
-  int nstep;
-  int steps;
-  int level;
-  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;
-  int  LogCoeffs = 0;
-  int  trivial_prec;      // Preconditioner is the identity: p == r, copies fold away
-  GCRCoefficients *Recorder = nullptr;
-
-  LinearFunction<Field>     &Preconditioner;
-  LinearOperatorBase<Field> &Linop;
-
-public:
-
-  void operator() (const Field &src, Field &psi){
-
-    //    psi=Zero();
-    RealD cp, ssq,rsq;
-    ssq=norm2(src);
-    SSQ=ssq;
-    rsq=Tolerance*Tolerance*ssq;
-      
-    Field r(src.Grid());
-
-    PrecTimer.Reset();
-    MatTimer.Reset();
-    LinalgTimer.Reset();
-
-    GridStopWatch SolverTimer;
-    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;
-
-      if(cp<rsq) {
-
-	SolverTimer.Stop();
-
-	Linop.Op(psi,r);
-	axpy(r,-1.0,src,r);
-	RealD tr = norm2(r);
-	GCRLogLevel<<"PGCR: Converged on iteration " <<steps
-		 << " computed residual "<<sqrt(cp/ssq)
-		 << " true residual "    <<sqrt(tr/ssq)
-		 << " target "           <<Tolerance <<std::endl;
-
-	GCRLogLevel<<"PGCR Time elapsed: Total  "<< SolverTimer.Elapsed() <<std::endl;
-	return;
-      }
-
-    }
-    GCRLogLevel<<"Variable Preconditioned GCR did not converge"<<std::endl;
-    //    GRID_ASSERT(0);
-  }
-
-private:
-  RealD GCRnStep(const Field &src, Field &psi,RealD rsq){
-
-    RealD cp;
-    ComplexD a, b;
-    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 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;
-    }
-      
-    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.
-    //////////////////////////////////
-    // The residual is READ through rp and only materialised in r when it is
-    // first written, at the k=0 update.  On a zero-guess first cycle r0 IS src,
-    // so no copy is made; a restart cycle computes r and rp points at it.
-    const Field *rp = &src;
-    GRID_ASSERT(nstep>=1);   // psi is first written at k=0; see zero_start below
-    int zero_start = (ZeroGuess && FirstCycle);
-    if ( !zero_start ) {
-      MatTimer.Start();
-      Linop.Op(psi,Az);
-      MatTimer.Stop();
-      LinalgTimer.Start();
-      r=src-Az;
-      LinalgTimer.Stop();
-      rp = &r;
-    }
-    FirstCycle=0;
-
-    /////////////////////
-    // p = Prec(r)
-    /////////////////////
-
-    // p[0] = Prec(r), q[0] = A p[0], written straight into the history slots.
-    // This copy is forced even for a trivial preconditioner: p[0] is history and
-    // must survive while the residual evolves.
-    PrecTimer.Start();
-    Preconditioner(*rp,p[0]);
-    PrecTimer.Stop();
-
-    MatTimer.Start();
-    Linop.Op(p[0],q[0]);
-    MatTimer.Stop();
-
-    LinalgTimer.Start();
-
-    qq[0]= norm2(q[0]);
-
-    cp =norm2(*rp);
-    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;
-      int peri_k = k %mmax;
-      int peri_kp= kp%mmax;
-
-      LinalgTimer.Start();
-      rq= innerProduct(q[peri_k],*rp); // what if rAr not real?
-      a = rq/qq[peri_k];
-      if ( Recorder ) Recorder->RecordA(k,a);
-
-      // On a zero-guess first step psi is still unwritten, and the update would
-      // be a*p added to zero: assign it instead, so psi is never zeroed.
-      if ( zero_start && (k==0) ) psi = a*p[peri_k];
-      else                        axpy(psi,a,p[peri_k],psi);
-
-#ifdef GRID_GCR_RESIDUAL_RECURRENCE
-      // |r - a q|^2 = |r|^2 - |<q,r>|^2/|q|^2 with a = <q,r>/|q|^2, so the new
-      // residual norm follows from scalars already in hand and the reduction in
-      // axpy_norm is not needed.  cp then DRIFTS rather than being measured; the
-      // true residual is recomputed at restart and at convergence, which bounds
-      // the exposure.  The drift only matters for an instance driven to a tight
-      // tolerance -- the outer solver -- and there it is the same computed-vs-true
-      // residual gap that CG lives with; the smoother and coarse instances run at
-      // fixed work or loose tolerance and are indifferent to it.
-      // Explicit re/im: ComplexD is thrust::complex under HIP.
-      axpy(r,-a,q[peri_k],*rp);
-      cp = cp - (real(rq)*real(rq)+imag(rq)*imag(rq))/qq[peri_k];
-      if ( cp < 0.0 ) cp = 0.0;          // drift can undershoot; keeps the log finite
-#else
-      cp = axpy_norm(r,-a,q[peri_k],*rp);
-#endif
-      rp = &r;   // the residual now lives in r; src is untouched from here on
-      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;
-
-      if((k==nstep-1)||(cp<rsq)){
-	return cp;
-      }
-
-      // New direction written straight into its history slot: p = Prec(r), q = A p.
-      // For a trivial preconditioner p[kp] would only be a copy of the residual,
-      // so the operator is applied to the residual directly and the copy folds
-      // into the orthogonalisation pass below.
-      if ( trivial_prec ) {
-        MatTimer.Start();
-        Linop.Op(*rp,q[peri_kp]);
-        MatTimer.Stop();
-      } else {
-        PrecTimer.Start();
-        Preconditioner(*rp,p[peri_kp]);
-        PrecTimer.Stop();
-        MatTimer.Start();
-        Linop.Op(p[peri_kp],q[peri_kp]);
-        MatTimer.Stop();
-      }
-
-      LinalgTimer.Start();
-
-      int northog = ((kp)>(mmax-1))?(mmax-1):(kp);  // if more than mmax done, we orthog all mmax history.
-      std::ostringstream bs;
-
-      // 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);
-      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);
-      // axpyMultiNorm returns |q|^2 from the update pass, so qq is complete here:
-      // a separate norm2 would be a second reduction and a second GlobalSum.
-      if ( northog ) {
-        if ( trivial_prec ) axpyMultiFrom(p[peri_kp],*rp,bcoef,pwin);
-        else                axpyMulti(p[peri_kp],bcoef,pwin);
-        qq[peri_kp]=axpyMultiNorm(q[peri_kp],bcoef,qwin);
-      } else {
-        if ( trivial_prec ) p[peri_kp] = *rp;   // no pass to fold the copy into
-        qq[peri_kp]=norm2(q[peri_kp]);
-      }
-      if ( LogCoeffs && northog ) {
-        GCRLogLevel<<"coeff["<<k<<"]"<<bs.str()<<std::endl;
-      }
-      LinalgTimer.Stop();
-    }
-    GRID_ASSERT(0); // never reached
-    return cp;
-  }
-};
-NAMESPACE_END(Grid);
-
-#undef GCRLogLevel
-#endif

Grid/algorithms/iterative/QuasiMinimalResidual.h

@@ -1,371 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/algorithmsf/iterative/QuasiMinimalResidual.h
-
-Copyright (C) 2019
-
-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
-
-NAMESPACE_BEGIN(Grid);
-
-template<class Field> 
-RealD innerG5ProductReal(Field &l, Field &r)
-{
-  Gamma G5(Gamma::Algebra::Gamma5);
-  Field tmp(l.Grid());
-  //  tmp = G5*r;
-  G5R5(tmp,r);
-  ComplexD ip =innerProduct(l,tmp);
-  std::cout << "innerProductRealG5R5 "<<ip<<std::endl;
-  return ip.real();
-}
-
-template<class Field>
-class QuasiMinimalResidual : public OperatorFunction<Field> {
- public:
-  using OperatorFunction<Field>::operator();
-
-  bool ErrorOnNoConverge; 
-  RealD   Tolerance;
-  Integer MaxIterations;
-  Integer IterationCount;
-
-  QuasiMinimalResidual(RealD   tol,
-		       Integer maxit,
-		       bool    err_on_no_conv = true)
-      : Tolerance(tol)
-      , MaxIterations(maxit)
-      , ErrorOnNoConverge(err_on_no_conv) 
-  {};
-
-#if 1
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &b, Field &x) 
-  {
-    RealD resid;
-    IterationCount=0;
-
-    RealD  rho, rho_1, xi, gamma, gamma_1, theta, theta_1;
-    RealD  eta, delta, ep, beta; 
-
-    GridBase *Grid = b.Grid();
-    Field r(Grid), d(Grid), s(Grid);
-    Field v(Grid), w(Grid), y(Grid),  z(Grid);
-    Field v_tld(Grid), w_tld(Grid), y_tld(Grid), z_tld(Grid);
-    Field p(Grid), q(Grid), p_tld(Grid);
-
-    Real normb = norm2(b);
-
-    LinOp.Op(x,r); r = b - r;
-
-    GRID_ASSERT(normb> 0.0);
-
-    resid = norm2(r)/normb;
-    if (resid <= Tolerance) {
-      return;
-    }
-
-    v_tld = r;
-    y = v_tld;
-    rho = norm2(y);
-
-    // Take Gamma5 conjugate
-    //    Gamma G5(Gamma::Algebra::Gamma5);
-    //    G5R5(w_tld,r);
-    //    w_tld = G5* v_tld;
-    w_tld=v_tld;
-    z = w_tld;
-    xi = norm2(z);
-
-    gamma = 1.0;
-    eta   = -1.0;
-    theta = 0.0;
-
-    for (int i = 1; i <= MaxIterations; i++) {
-
-      // Breakdown tests
-      GRID_ASSERT( rho != 0.0);
-      GRID_ASSERT( xi  != 0.0);
-
-      v = (1. / rho) * v_tld;
-      y = (1. / rho) * y;
-
-      w = (1. / xi) * w_tld;
-      z = (1. / xi) * z;
-
-      ComplexD Zdelta = innerProduct(z, y); // Complex?
-      std::cout << "Zdelta "<<Zdelta<<std::endl;
-      delta = Zdelta.real();
-
-      y_tld = y; 
-      z_tld = z;
-
-      if (i > 1) {
-	p = y_tld - (xi  * delta / ep) * p;
-	q = z_tld - (rho * delta / ep) * q;
-      } else {
-	p = y_tld;
-	q = z_tld;
-      }
-
-      LinOp.Op(p,p_tld);      //     p_tld = A * p;
-      ComplexD Zep = innerProduct(q, p_tld);
-      ep=Zep.real();
-      std::cout << "Zep "<<Zep <<std::endl;
-      // Complex Audit
-      GRID_ASSERT(abs(ep)>0);
-
-      beta = ep / delta;
-      GRID_ASSERT(abs(beta)>0);
-
-      v_tld = p_tld - beta * v;
-      y = v_tld;
-
-      rho_1 = rho;
-      rho   = norm2(y);
-      LinOp.AdjOp(q,w_tld);
-      w_tld = w_tld - beta * w;
-      z = w_tld;
-
-      xi = norm2(z);
-
-      gamma_1 = gamma;
-      theta_1 = theta;
-
-      theta   = rho / (gamma_1 * beta);
-      gamma   = 1.0 / sqrt(1.0 + theta * theta);
-      std::cout << "theta "<<theta<<std::endl;
-      std::cout << "gamma "<<gamma<<std::endl;
-
-      GRID_ASSERT(abs(gamma)> 0.0);
-
-      eta = -eta * rho_1 * gamma* gamma / (beta * gamma_1 * gamma_1);
-
-      if (i > 1) {
-	d = eta * p + (theta_1 * theta_1 * gamma * gamma) * d;
-	s = eta * p_tld + (theta_1 * theta_1 * gamma * gamma) * s;
-      } else {
-	d = eta * p;
-	s = eta * p_tld;
-      }
-
-      x =x+d;                            // update approximation vector
-      r =r-s;                            // compute residual
-
-      if ((resid = norm2(r) / normb) <= Tolerance) {
-	return;
-      }
-      std::cout << "Iteration "<<i<<" resid " << resid<<std::endl;
-    }
-    GRID_ASSERT(0);
-    return;                            // no convergence
-  }
-#else
-  // QMRg5 SMP thesis
-  void operator()(LinearOperatorBase<Field> &LinOp, const Field &b, Field &x) 
-  {
-    // Real scalars
-    GridBase *grid = b.Grid();
-
-    Field    r(grid);
-    Field    p_m(grid), p_m_minus_1(grid), p_m_minus_2(grid);
-    Field    v_m(grid), v_m_minus_1(grid), v_m_plus_1(grid);
-    Field    tmp(grid);
-
-    RealD    w;
-    RealD    z1, z2;
-    RealD    delta_m, delta_m_minus_1;
-    RealD    c_m_plus_1, c_m, c_m_minus_1;
-    RealD    s_m_plus_1, s_m, s_m_minus_1;
-    RealD    alpha, beta, gamma, epsilon;
-    RealD    mu, nu, rho, theta, xi, chi;
-    RealD    mod2r, mod2b;
-    RealD    tau2, target2;
-
-    mod2b=norm2(b);
-
-    /////////////////////////
-    // Initial residual
-    /////////////////////////
-    LinOp.Op(x,tmp);
-    r = b - tmp;
-
-    /////////////////////////
-    // \mu = \rho = |r_0|
-    /////////////////////////
-    mod2r = norm2(r);
-    rho = sqrt( mod2r);
-    mu=rho;
-    
-    std::cout << "QuasiMinimalResidual rho "<< rho<<std::endl;
-    /////////////////////////
-    // Zero negative history
-    /////////////////////////
-    v_m_plus_1  = Zero();
-    v_m_minus_1 = Zero();
-    p_m_minus_1 = Zero();
-    p_m_minus_2 = Zero();
-
-    // v0
-    v_m = (1.0/rho)*r;
-
-    /////////////////////////
-    // Initial coeffs
-    /////////////////////////
-    delta_m_minus_1 = 1.0;
-    c_m_minus_1     = 1.0;
-    c_m             = 1.0;
-    s_m_minus_1     = 0.0;
-    s_m             = 0.0;
-
-    /////////////////////////
-    // Set up convergence check
-    /////////////////////////
-    tau2    = mod2r;
-    target2 = mod2b * Tolerance*Tolerance;
- 
-    for(int iter = 0 ; iter < MaxIterations; iter++){
-
-      /////////////////////////
-      // \delta_m = (v_m, \gamma_5 v_m) 
-      /////////////////////////
-      delta_m = innerG5ProductReal(v_m,v_m);
-      std::cout << "QuasiMinimalResidual delta_m "<< delta_m<<std::endl;
-
-      /////////////////////////
-      // tmp = A v_m
-      /////////////////////////
-      LinOp.Op(v_m,tmp);
-
-      /////////////////////////
-      // \alpha = (v_m, \gamma_5 temp) / \delta_m 
-      /////////////////////////
-      alpha = innerG5ProductReal(v_m,tmp);
-      alpha = alpha/delta_m ;
-      std::cout << "QuasiMinimalResidual alpha "<< alpha<<std::endl;
-
-      /////////////////////////
-      // \beta = \rho \delta_m / \delta_{m-1}
-      /////////////////////////
-      beta = rho * delta_m / delta_m_minus_1;
-      std::cout << "QuasiMinimalResidual beta "<< beta<<std::endl;
-
-      /////////////////////////
-      // \tilde{v}_{m+1} = temp - \alpha v_m - \beta v_{m-1}
-      /////////////////////////
-      v_m_plus_1 = tmp - alpha*v_m - beta*v_m_minus_1;
-
-      ///////////////////////////////
-      // \rho = || \tilde{v}_{m+1} ||
-      ///////////////////////////////
-      rho = sqrt( norm2(v_m_plus_1) );
-      std::cout << "QuasiMinimalResidual rho "<< rho<<std::endl;
-
-      ///////////////////////////////
-      //      v_{m+1} = \tilde{v}_{m+1}
-      ///////////////////////////////
-      v_m_plus_1 = (1.0 / rho) * v_m_plus_1;
-
-      ////////////////////////////////
-      // QMR recurrence coefficients.
-      ////////////////////////////////
-      theta      = s_m_minus_1 * beta;
-      gamma      = c_m_minus_1 * beta;
-      epsilon    =  c_m * gamma + s_m * alpha;
-      xi         = -s_m * gamma + c_m * alpha;
-      nu         = sqrt( xi*xi + rho*rho );
-      c_m_plus_1 = fabs(xi) / nu;
-      if ( xi == 0.0 ) {
-	s_m_plus_1 = 1.0;
-      } else {
-	s_m_plus_1 = c_m_plus_1 * rho / xi;
-      }
-      chi = c_m_plus_1 * xi + s_m_plus_1 * rho;
-
-      std::cout << "QuasiMinimalResidual coeffs "<< theta <<" "<<gamma<<" "<< epsilon<<" "<< xi<<" "<< nu<<std::endl;
-      std::cout << "QuasiMinimalResidual coeffs "<< chi   <<std::endl;
-
-      ////////////////////////////////
-      //p_m=(v_m - \epsilon p_{m-1} - \theta p_{m-2}) / \chi
-      ////////////////////////////////
-      p_m = (1.0/chi) * v_m - (epsilon/chi) * p_m_minus_1 - (theta/chi) * p_m_minus_2;
-
-      ////////////////////////////////////////////////////////////////
-      //      \psi = \psi + c_{m+1} \mu p_m	
-      ////////////////////////////////////////////////////////////////
-      x = x + ( c_m_plus_1 * mu ) * p_m;
-
-      ////////////////////////////////////////
-      //
-      ////////////////////////////////////////
-      mu              = -s_m_plus_1 * mu;
-      delta_m_minus_1 = delta_m;
-      c_m_minus_1     = c_m;
-      c_m             = c_m_plus_1;
-      s_m_minus_1     = s_m;
-      s_m             = s_m_plus_1;
-
-      ////////////////////////////////////
-      // Could use pointer swizzle games.
-      ////////////////////////////////////
-      v_m_minus_1 = v_m;
-      v_m         = v_m_plus_1;
-      p_m_minus_2 = p_m_minus_1;
-      p_m_minus_1 = p_m;
-
-
-      /////////////////////////////////////
-      // Convergence checks
-      /////////////////////////////////////
-      z1 = RealD(iter+1.0);
-      z2 = z1 + 1.0;
-      tau2 = tau2 *( z2 / z1 ) * s_m * s_m;
-      std::cout << " QuasiMinimumResidual iteration "<< iter<<std::endl;
-      std::cout << " QuasiMinimumResidual tau bound "<< tau2<<std::endl;
-
-      // Compute true residual
-      mod2r = tau2;
-      if ( 1 || (tau2 < (100.0 * target2)) ) {
-	LinOp.Op(x,tmp);
-	r = b - tmp;
-	mod2r = norm2(r);
-	std::cout << " QuasiMinimumResidual true residual is "<< mod2r<<std::endl;
-      }
-
-
-      if ( mod2r < target2 ) { 
-
-	std::cout << " QuasiMinimumResidual has converged"<<std::endl;
-	return;
-
-      }
-
-    }
-
-
-  }
-#endif
-};
-
-NAMESPACE_END(Grid);

Grid/algorithms/iterative/SchurRedBlack.h

@@ -1,732 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/SchurRedBlack.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 */
-#ifndef GRID_SCHUR_RED_BLACK_H
-#define GRID_SCHUR_RED_BLACK_H
-
-
-  /*
-   * 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                    )
-   * L^{-d}  = ( 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 psi = eta
-   ***********************
-   *Odd
-   * i)                 D_oo psi_o =  L^{-1}  eta_o
-   *                        eta_o' = (D_oo)^dag (eta_o - Moe Mee^{-1} eta_e)
-   *
-   * Wilson:
-   *      (D_oo)^{\dag} D_oo psi_o = (D_oo)^dag L^{-1}  eta_o
-   * Stag:
-   *      D_oo psi_o = L^{-1}  eta =    (eta_o - Moe Mee^{-1} eta_e)
-   *
-   * L^-1 eta_o= (1              0 ) (e
-   *             (-MoeMee^{-1}   1 )   
-   *
-   *Even
-   * ii)  Mee psi_e + Meo psi_o = src_e
-   *
-   *   => sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-   *
-   * 
-   * TODO: Other options:
-   * 
-   * a) change checkerboards for Schur e<->o
-   *
-   * Left precon by Moo^-1
-   * b) Doo^{dag} M_oo^-dag Moo^-1 Doo psi_0 =  (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)
-   *
-   * Right precon by Moo^-1
-   * 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 {
-
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Use base class to share code
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Take a matrix and form a Red Black solver calling a Herm solver
-  // Use of RB info prevents making SchurRedBlackSolve conform to standard interface
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  template<class Field> class SchurRedBlackBase {
-  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
-  public:
-
-    SchurRedBlackBase(OperatorFunction<Field> &HermitianRBSolver, const bool initSubGuess = false,
-        const bool _solnAsInitGuess = false)  :
-    _HermitianRBSolver(HermitianRBSolver),
-    useSolnAsInitGuess(_solnAsInitGuess)
-    { 
-      CBfactorise = 0;
-      subtractGuess(initSubGuess);
-    };
-    void subtractGuess(const bool initSubGuess)
-    {
-      subGuess = initSubGuess;
-    }
-    bool isSubtractGuess(void)
-    {
-      return subGuess;
-    }
-
-    /////////////////////////////////////////////////////////////
-    // Shared code
-    /////////////////////////////////////////////////////////////
-    void operator() (Matrix & _Matrix,const Field &in, Field &out){
-      ZeroGuesser<Field> guess;
-      (*this)(_Matrix,in,out,guess);
-    }
-    void operator()(Matrix &_Matrix, const std::vector<Field> &in, std::vector<Field> &out) 
-    {
-      ZeroGuesser<Field> guess;
-      (*this)(_Matrix,in,out,guess);
-    }
-
-    void RedBlackSource(Matrix &_Matrix, const std::vector<Field> &in, std::vector<Field> &src_o) 
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      Field tmp(grid);
-      int nblock = in.size();
-      for(int b=0;b<nblock;b++){
-	RedBlackSource(_Matrix,in[b],tmp,src_o[b]);
-      }
-    }
-    // James can write his own deflated guesser
-    // with optimised code for the inner products
-    //    RedBlackSolveSplitGrid();
-    //    RedBlackSolve(_Matrix,src_o,sol_o); 
-
-    void RedBlackSolution(Matrix &_Matrix, const std::vector<Field> &in, const std::vector<Field> &sol_o, std::vector<Field> &out)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      Field tmp(grid);
-      int nblock = in.size();
-      for(int b=0;b<nblock;b++) {
-	pickCheckerboard(Even,tmp,in[b]);
-	RedBlackSolution(_Matrix,sol_o[b],tmp,out[b]);
-      }
-    }
-
-    template<class Guesser>
-    void operator()(Matrix &_Matrix, const std::vector<Field> &in, std::vector<Field> &out,Guesser &guess) 
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-      int nblock = in.size();
-
-      std::vector<Field> src_o(nblock,grid);
-      std::vector<Field> sol_o(nblock,grid);
-      
-      std::vector<Field> guess_save;
-
-      Field resid(fgrid);
-      Field tmp(grid);
-
-      ////////////////////////////////////////////////
-      // Prepare RedBlack source
-      ////////////////////////////////////////////////
-      RedBlackSource(_Matrix,in,src_o);
-	//      for(int b=0;b<nblock;b++){
-	//	RedBlackSource(_Matrix,in[b],tmp,src_o[b]);
-	//      }
-      
-      ////////////////////////////////////////////////
-      // Make the guesses
-      ////////////////////////////////////////////////
-      if ( subGuess ) guess_save.resize(nblock,grid);
-
-      
-      if(useSolnAsInitGuess) {
-        for(int b=0;b<nblock;b++){
-          pickCheckerboard(Odd, sol_o[b], out[b]);
-        }
-      } else {
-        guess(src_o, sol_o); 
-      }
-
-	    if ( subGuess ) { 
-        for(int b=0;b<nblock;b++){
-          guess_save[b] = sol_o[b];
-        }
-      }
-      //////////////////////////////////////////////////////////////
-      // Call the block solver
-      //////////////////////////////////////////////////////////////
-      std::cout<<GridLogMessage << "SchurRedBlackBase calling the solver for "<<nblock<<" RHS" <<std::endl;
-      RedBlackSolve(_Matrix,src_o,sol_o);
-
-      ////////////////////////////////////////////////
-      // A2A boolean behavioural control & reconstruct other checkerboard
-      ////////////////////////////////////////////////
-      for(int b=0;b<nblock;b++) {
-
-	if (subGuess)   sol_o[b] = sol_o[b] - guess_save[b];
-
-	///////// Needs even source //////////////
-	pickCheckerboard(Even,tmp,in[b]);
-	RedBlackSolution(_Matrix,sol_o[b],tmp,out[b]);
-
-	/////////////////////////////////////////////////
-	// Check unprec residual if possible
-	/////////////////////////////////////////////////
-	if ( ! subGuess ) {
-	  _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;
-	} else {
-	  std::cout<<GridLogMessage<< "SchurRedBlackBase Guess subtracted after solve["<<b<<"] " << std::endl;
-	}
-
-      }
-    }
-    template<class Guesser>
-    void operator() (Matrix & _Matrix,const Field &in, Field &out,Guesser &guess){
-
-      // FIXME CGdiagonalMee not implemented virtual function
-      // FIXME use CBfactorise to control schur decomp
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      Field resid(fgrid);
-      Field src_o(grid);
-      Field src_e(grid);
-      Field sol_o(grid);
-
-      ////////////////////////////////////////////////
-      // RedBlack source
-      ////////////////////////////////////////////////
-      RedBlackSource(_Matrix,in,src_e,src_o);
-
-      ////////////////////////////////
-      // Construct the guess
-      ////////////////////////////////
-      if(useSolnAsInitGuess) {
-        pickCheckerboard(Odd, sol_o, out);
-      } else {
-        guess(src_o,sol_o);
-      }
-
-      Field  guess_save(grid);
-      guess_save = sol_o;
-
-      //////////////////////////////////////////////////////////////
-      // Call the red-black solver
-      //////////////////////////////////////////////////////////////
-      RedBlackSolve(_Matrix,src_o,sol_o);
-
-      ////////////////////////////////////////////////
-      // Fionn A2A boolean behavioural control
-      ////////////////////////////////////////////////
-      if (subGuess)      sol_o= sol_o-guess_save;
-
-      ///////////////////////////////////////////////////
-      // RedBlack solution needs the even source
-      ///////////////////////////////////////////////////
-      RedBlackSolution(_Matrix,sol_o,src_e,out);
-
-      // Verify the unprec residual
-      if ( ! subGuess ) {
-        _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;
-      } else {
-        std::cout << GridLogMessage << "SchurRedBlackBase Guess subtracted after solve." << std::endl;
-      }
-    }     
-    
-    /////////////////////////////////////////////////////////////
-    // Override in derived. 
-    /////////////////////////////////////////////////////////////
-    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;
-    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)=0;
-
-  };
-
-  template<class Field> class SchurRedBlackStaggeredSolve : public SchurRedBlackBase<Field> {
-  public:
-    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-    SchurRedBlackStaggeredSolve(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 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.Mooee(tmp,src_o); // Extra factor of "m" in source from dumb choice of matrix norm.
-    }
-    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e_c,Field &sol)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      Field   tmp(grid);
-      Field   sol_e(grid);
-      Field   src_e(grid);
-
-      src_e = src_e_c; // Const correctness
-
-      ///////////////////////////////////////////////////
-      // 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);
-     
-      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)
-    {
-      SchurStaggeredOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
-    };
-    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
-    {
-      SchurStaggeredOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o); 
-    }
-  };
-  template<class Field> using SchurRedBlackStagSolve = SchurRedBlackStaggeredSolve<Field>;
-
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Site diagonal has Mooee on it.
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  template<class Field> class SchurRedBlackDiagMooeeSolve : public SchurRedBlackBase<Field> {
-  public:
-    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-    SchurRedBlackDiagMooeeSolve(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 = 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);     
-
-      // get the right MpcDag
-      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      _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);
-      Field  src_e_i(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);
-     
-      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)
-    {
-      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  GRID_ASSERT(sol_o.Checkerboard()==Odd);
-    };
-    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
-    {
-      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o); 
-    }
-  };
-
-  template<class Field> class NonHermitianSchurRedBlackDiagMooeeSolve : public SchurRedBlackBase<Field> 
-  {
-    public:
-      typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-      NonHermitianSchurRedBlackDiagMooeeSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
-          const bool _solnAsInitGuess = false)  
-      : SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
-
-      //////////////////////////////////////////////////////
-      // Override RedBlack specialisation
-      //////////////////////////////////////////////////////
-      virtual void RedBlackSource(Matrix& _Matrix, const Field& src, Field& src_e, Field& src_o)
-      {
-        GridBase* grid  = _Matrix.RedBlackGrid();
-        GridBase* fgrid = _Matrix.Grid();
-
-        Field  tmp(grid);
-        Field Mtmp(grid);
-
-        pickCheckerboard(Even, src_e, src);
-        pickCheckerboard(Odd , src_o, src);
-
-        /////////////////////////////////////////////////////
-        // src_o = Mdag * (source_o - Moe MeeInv source_e)
-        /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  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);
-        Field src_e_i(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 );
-       
-        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)
-      {
-        NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
-        this->_HermitianRBSolver(_OpEO, src_o, sol_o);  GRID_ASSERT(sol_o.Checkerboard() == Odd);
-      }
-
-      virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o, std::vector<Field>& sol_o)
-      {
-        NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
-        this->_HermitianRBSolver(_OpEO, src_o, sol_o); 
-      }
-  };
-
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  // Site diagonal is identity, 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
-  //=> psi = MeeInv phi
-  ///////////////////////////////////////////////////////////////////////////////////////////////////////
-  template<class Field> class SchurRedBlackDiagTwoSolve : public SchurRedBlackBase<Field> {
-  public:
-    typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-    /////////////////////////////////////////////////////
-    // Wrap the usual normal equations Schur trick
-    /////////////////////////////////////////////////////
-  SchurRedBlackDiagTwoSolve(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();
-
-      SchurDiagTwoOperator<Matrix,Field> _HermOpEO(_Matrix);
-      
-      Field   tmp(grid);
-      Field  Mtmp(grid);
-
-      pickCheckerboard(Even,src_e,src);
-      pickCheckerboard(Odd ,src_o,src);
-    
-      /////////////////////////////////////////////////////
-      // src_o = Mdag * (source_o - Moe MeeInv source_e)
-      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     GRID_ASSERT(  tmp.Checkerboard() ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      GRID_ASSERT( Mtmp.Checkerboard() ==Odd);     
-      tmp=src_o-Mtmp;                  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   sol_o_i(grid);
-      Field   tmp(grid);
-      Field   sol_e(grid);
-
-      ////////////////////////////////////////////////
-      // MooeeInv due to pecond
-      ////////////////////////////////////////////////
-      _Matrix.MooeeInv(sol_o,tmp);
-      sol_o_i = tmp;
-
-      ///////////////////////////////////////////////////
-      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o_i,tmp);    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_i);  GRID_ASSERT(  sol_o_i.Checkerboard() ==Odd );
-    };
-
-    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
-    {
-      SchurDiagTwoOperator<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)
-    {
-      SchurDiagTwoOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o); 
-    }
-  };
-
-  template<class Field> class NonHermitianSchurRedBlackDiagTwoSolve : public SchurRedBlackBase<Field> 
-  {
-    public:
-      typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
-
-      /////////////////////////////////////////////////////
-      // Wrap the usual normal equations Schur trick
-      /////////////////////////////////////////////////////
-      NonHermitianSchurRedBlackDiagTwoSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
-          const bool _solnAsInitGuess = false)  
-      : SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
-
-      virtual void RedBlackSource(Matrix& _Matrix, const Field& src, Field& src_e, Field& src_o)
-      {
-        GridBase* grid  = _Matrix.RedBlackGrid();
-        GridBase* fgrid = _Matrix.Grid();
-
-        Field  tmp(grid);
-        Field Mtmp(grid);
-
-        pickCheckerboard(Even, src_e, src);
-        pickCheckerboard(Odd , src_o, src);
-      
-        /////////////////////////////////////////////////////
-        // src_o = Mdag * (source_o - Moe MeeInv source_e)
-        /////////////////////////////////////////////////////
-        _Matrix.MooeeInv(src_e, tmp);   GRID_ASSERT(   tmp.Checkerboard() == Even );
-        _Matrix.Meooe   (tmp, Mtmp);    GRID_ASSERT(  Mtmp.Checkerboard() == Odd  );     
-        src_o -= Mtmp;                  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 sol_o_i(grid);
-        Field     tmp(grid);
-        Field   sol_e(grid);
-
-        ////////////////////////////////////////////////
-        // MooeeInv due to pecond
-        ////////////////////////////////////////////////
-        _Matrix.MooeeInv(sol_o, tmp);
-        sol_o_i = tmp;
-
-        ///////////////////////////////////////////////////
-        // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-        ///////////////////////////////////////////////////
-        _Matrix.Meooe(sol_o_i, tmp);    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_i);  GRID_ASSERT( sol_o_i.Checkerboard() == Odd  );
-      };
-
-      virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
-      {
-        NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
-        this->_HermitianRBSolver(_OpEO, src_o, sol_o);
-      };
-
-      virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o,  std::vector<Field>& sol_o)
-      {
-        NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
-        this->_HermitianRBSolver(_OpEO, src_o, sol_o); 
-      }
-  };
-}
-
-#endif

Grid/algorithms/multigrid/Aggregates.h

@@ -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);
-

Grid/algorithms/multigrid/BlockCyclic.h

@@ -1,234 +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.  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);

Grid/algorithms/multigrid/BlockCyclicRedistribute.h

@@ -1,287 +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);

Grid/algorithms/multigrid/BlockCyclicSchurInverse.h

@@ -1,450 +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);

Grid/algorithms/multigrid/BlockCyclicSumma.h

@@ -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);

Grid/algorithms/multigrid/CoarsenedMatrix.h

@@ -1,837 +0,0 @@
-/*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/CoarsenedMatrix.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 */
-#ifndef  GRID_ALGORITHM_COARSENED_MATRIX_H
-#define  GRID_ALGORITHM_COARSENED_MATRIX_H
-
-#include <Grid/qcd/QCD.h> // needed for Dagger(Yes|No), Inverse(Yes|No)
-
-NAMESPACE_BEGIN(Grid);
-
-template<class vobj,class CComplex>
-inline void blockMaskedInnerProduct(Lattice<CComplex> &CoarseInner,
-				    const Lattice<decltype(innerProduct(vobj(),vobj()))> &FineMask,
-				    const Lattice<vobj> &fineX,
-				    const Lattice<vobj> &fineY)
-{
-  typedef decltype(innerProduct(vobj(),vobj())) dotp;
-
-  GridBase *coarse(CoarseInner.Grid());
-  GridBase *fine  (fineX.Grid());
-
-  Lattice<dotp> fine_inner(fine); fine_inner.Checkerboard() = fineX.Checkerboard();
-  Lattice<dotp> fine_inner_msk(fine);
-
-  // Multiply could be fused with innerProduct
-  // Single block sum kernel could do both masks.
-  fine_inner = localInnerProduct(fineX,fineY);
-  mult(fine_inner_msk, fine_inner,FineMask);
-  blockSum(CoarseInner,fine_inner_msk);
-}
-
-// Fine Object == (per site) type of fine field
-// nbasis      == number of deflation vectors
-template<class Fobj,class CComplex,int nbasis>
-class CoarsenedMatrix : public CheckerBoardedSparseMatrixBase<Lattice<iVector<CComplex,nbasis > > >  {
-public:
-    
-  typedef iVector<CComplex,nbasis >           siteVector;
-  typedef Lattice<CComplex >                  CoarseComplexField;
-  typedef Lattice<siteVector>                 CoarseVector;
-  typedef Lattice<iMatrix<CComplex,nbasis > > CoarseMatrix;
-  typedef iMatrix<CComplex,nbasis >  Cobj;
-  typedef Lattice< CComplex >   CoarseScalar; // used for inner products on fine field
-  typedef Lattice<Fobj >        FineField;
-  typedef CoarseVector FermionField;
-
-  // enrich interface, use default implementation as in FermionOperator ///////
-  void Dminus(CoarseVector const& in, CoarseVector& out) { out = in; }
-  void DminusDag(CoarseVector const& in, CoarseVector& out) { out = in; }
-  void ImportPhysicalFermionSource(CoarseVector const& input, CoarseVector& imported) { imported = input; }
-  void ImportUnphysicalFermion(CoarseVector const& input, CoarseVector& imported) { imported = input; }
-  void ExportPhysicalFermionSolution(CoarseVector const& solution, CoarseVector& exported) { exported = solution; };
-  void ExportPhysicalFermionSource(CoarseVector const& solution, CoarseVector& exported) { exported = solution; };
-
-  ////////////////////
-  // Data members
-  ////////////////////
-  Geometry         geom;
-  GridBase *       _grid; 
-  GridBase*        _cbgrid;
-  int hermitian;
-
-  CartesianStencil<siteVector,siteVector,DefaultImplParams> Stencil; 
-  CartesianStencil<siteVector,siteVector,DefaultImplParams> StencilEven;
-  CartesianStencil<siteVector,siteVector,DefaultImplParams> StencilOdd;
-
-  std::vector<CoarseMatrix> A;
-  std::vector<CoarseMatrix> Aeven;
-  std::vector<CoarseMatrix> Aodd;
-
-  CoarseMatrix AselfInv;
-  CoarseMatrix AselfInvEven;
-  CoarseMatrix AselfInvOdd;
-
-  deviceVector<RealD> dag_factor;
-
-  ///////////////////////
-  // Interface
-  ///////////////////////
-  GridBase * Grid(void)         { return _grid; };   // this is all the linalg routines need to know
-  GridBase * RedBlackGrid()     { return _cbgrid; };
-
-  int ConstEE() { return 0; }
-
-  void M (const CoarseVector &in, CoarseVector &out)
-  {
-    conformable(_grid,in.Grid());
-    conformable(in.Grid(),out.Grid());
-    out.Checkerboard() = in.Checkerboard();
-
-    SimpleCompressor<siteVector> compressor;
-
-    Stencil.HaloExchange(in,compressor);
-    autoView( in_v , in, AcceleratorRead);
-    autoView( out_v , out, AcceleratorWrite);
-    autoView( Stencil_v  , Stencil, AcceleratorRead);
-    int npoint = geom.npoint;
-    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]);
-    }
-    Aview *Aview_p = & AcceleratorViewContainer[0];
-
-    const int Nsimd = CComplex::Nsimd();
-    typedef decltype(coalescedRead(in_v[0])) calcVector;
-    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-
-    int osites=Grid()->oSites();
-
-    accelerator_for(sss, Grid()->oSites()*nbasis, Nsimd, {
-      int ss = sss/nbasis;
-      int b  = sss%nbasis;
-      calcComplex res = Zero();
-      calcVector nbr;
-      int ptype;
-      StencilEntry *SE;
-
-      for(int point=0;point<npoint;point++){
-
-	SE=Stencil_v.GetEntry(ptype,point,ss);
-	  
-	if(SE->_is_local) { 
-	  nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-	} else {
-	  nbr = coalescedRead(Stencil_v.CommBuf()[SE->_offset]);
-	}
-	acceleratorSynchronise();
-
-	for(int bb=0;bb<nbasis;bb++) {
-	  res = res + coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
-	}
-      }
-      coalescedWrite(out_v[ss](b),res);
-      });
-
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
-  };
-
-  void Mdag (const CoarseVector &in, CoarseVector &out)
-  {
-    if(hermitian) {
-      // corresponds to Petrov-Galerkin coarsening
-      return M(in,out);
-    } else {
-      // corresponds to Galerkin coarsening
-      return MdagNonHermitian(in, out);
-    }
-  };
-
-  void MdagNonHermitian(const CoarseVector &in, CoarseVector &out)
-  {
-    conformable(_grid,in.Grid());
-    conformable(in.Grid(),out.Grid());
-    out.Checkerboard() = in.Checkerboard();
-
-    SimpleCompressor<siteVector> compressor;
-
-    Stencil.HaloExchange(in,compressor);
-    autoView( in_v , in, AcceleratorRead);
-    autoView( out_v , out, AcceleratorWrite);
-    autoView( Stencil_v  , Stencil, AcceleratorRead);
-    int npoint = geom.npoint;
-    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]);
-    }
-    Aview *Aview_p = & AcceleratorViewContainer[0];
-
-    const int Nsimd = CComplex::Nsimd();
-    typedef decltype(coalescedRead(in_v[0])) calcVector;
-    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-
-    int osites=Grid()->oSites();
-
-    deviceVector<int> points(geom.npoint);
-    for(int p=0; p<geom.npoint; p++) { 
-      acceleratorPut(points[p],geom.points_dagger[p]);
-    }
-    auto points_p = &points[0];
-
-    RealD* dag_factor_p = &dag_factor[0];
-
-    accelerator_for(sss, Grid()->oSites()*nbasis, Nsimd, {
-      int ss = sss/nbasis;
-      int b  = sss%nbasis;
-      calcComplex res = Zero();
-      calcVector nbr;
-      int ptype;
-      StencilEntry *SE;
-
-      for(int p=0;p<npoint;p++){
-        int point = points_p[p];
-
-	SE=Stencil_v.GetEntry(ptype,point,ss);
-
-	if(SE->_is_local) {
-	  nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-	} else {
-	  nbr = coalescedRead(Stencil_v.CommBuf()[SE->_offset]);
-	}
-	acceleratorSynchronise();
-
-	for(int bb=0;bb<nbasis;bb++) {
-	  res = res + dag_factor_p[b*nbasis+bb]*coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
-	}
-      }
-      coalescedWrite(out_v[ss](b),res);
-      });
-
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
-  }
-
-  void MdirComms(const CoarseVector &in)
-  {
-    SimpleCompressor<siteVector> compressor;
-    Stencil.HaloExchange(in,compressor);
-  }
-  void MdirCalc(const CoarseVector &in, CoarseVector &out, int point)
-  {
-    conformable(_grid,in.Grid());
-    conformable(_grid,out.Grid());
-    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]);
-    }
-    Aview *Aview_p = & AcceleratorViewContainer[0];
-
-    autoView( out_v , out, AcceleratorWrite);
-    autoView( in_v  , in, AcceleratorRead);
-    autoView( Stencil_v  , Stencil, AcceleratorRead);
-
-    const int Nsimd = CComplex::Nsimd();
-    typedef decltype(coalescedRead(in_v[0])) calcVector;
-    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-
-    accelerator_for(sss, Grid()->oSites()*nbasis, Nsimd, {
-      int ss = sss/nbasis;
-      int b  = sss%nbasis;
-      calcComplex res = Zero();
-      calcVector nbr;
-      int ptype;
-      StencilEntry *SE;
-
-      SE=Stencil_v.GetEntry(ptype,point,ss);
-	  
-      if(SE->_is_local) { 
-	nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-      } else {
-	nbr = coalescedRead(Stencil_v.CommBuf()[SE->_offset]);
-      }
-      acceleratorSynchronise();
-
-      for(int bb=0;bb<nbasis;bb++) {
-	res = res + coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
-      }
-      coalescedWrite(out_v[ss](b),res);
-    });
-    for(int p=0;p<geom.npoint;p++) hAcceleratorViewContainer[p].ViewClose();
-  }
-  void MdirAll(const CoarseVector &in,std::vector<CoarseVector> &out)
-  {
-    this->MdirComms(in);
-    int ndir=geom.npoint-1;
-    if ((out.size()!=ndir)&&(out.size()!=ndir+1)) { 
-      std::cout <<"MdirAll out size "<< out.size()<<std::endl;
-      std::cout <<"MdirAll ndir "<< ndir<<std::endl;
-      GRID_ASSERT(0);
-    }
-    for(int p=0;p<ndir;p++){
-      MdirCalc(in,out[p],p);
-    }
-  };
-  void Mdir(const CoarseVector &in, CoarseVector &out, int dir, int disp){
-
-    this->MdirComms(in);
-
-    MdirCalc(in,out,geom.point(dir,disp));
-  };
-
-  void Mdiag(const CoarseVector &in, CoarseVector &out)
-  {
-    int point=geom.npoint-1;
-    MdirCalc(in, out, point); // No comms
-  };
-
-  void Mooee(const CoarseVector &in, CoarseVector &out) {
-    MooeeInternal(in, out, DaggerNo, InverseNo);
-  }
-
-  void MooeeInv(const CoarseVector &in, CoarseVector &out) {
-    MooeeInternal(in, out, DaggerNo, InverseYes);
-  }
-
-  void MooeeDag(const CoarseVector &in, CoarseVector &out) {
-    MooeeInternal(in, out, DaggerYes, InverseNo);
-  }
-
-  void MooeeInvDag(const CoarseVector &in, CoarseVector &out) {
-    MooeeInternal(in, out, DaggerYes, InverseYes);
-  }
-
-  void Meooe(const CoarseVector &in, CoarseVector &out) {
-    if(in.Checkerboard() == Odd) {
-      DhopEO(in, out, DaggerNo);
-    } else {
-      DhopOE(in, out, DaggerNo);
-    }
-  }
-
-  void MeooeDag(const CoarseVector &in, CoarseVector &out) {
-    if(in.Checkerboard() == Odd) {
-      DhopEO(in, out, DaggerYes);
-    } else {
-      DhopOE(in, out, DaggerYes);
-    }
-  }
-
-  void Dhop(const CoarseVector &in, CoarseVector &out, int dag) {
-    conformable(in.Grid(), _grid); // verifies full grid
-    conformable(in.Grid(), out.Grid());
-
-    out.Checkerboard() = in.Checkerboard();
-
-    DhopInternal(Stencil, A, in, out, dag);
-  }
-
-  void DhopOE(const CoarseVector &in, CoarseVector &out, int dag) {
-    conformable(in.Grid(), _cbgrid);    // verifies half grid
-    conformable(in.Grid(), out.Grid()); // drops the cb check
-
-    GRID_ASSERT(in.Checkerboard() == Even);
-    out.Checkerboard() = Odd;
-
-    DhopInternal(StencilEven, Aodd, in, out, dag);
-  }
-
-  void DhopEO(const CoarseVector &in, CoarseVector &out, int dag) {
-    conformable(in.Grid(), _cbgrid);    // verifies half grid
-    conformable(in.Grid(), out.Grid()); // drops the cb check
-
-    GRID_ASSERT(in.Checkerboard() == Odd);
-    out.Checkerboard() = Even;
-
-    DhopInternal(StencilOdd, Aeven, in, out, dag);
-  }
-
-  void MooeeInternal(const CoarseVector &in, CoarseVector &out, int dag, int inv) {
-    out.Checkerboard() = in.Checkerboard();
-    GRID_ASSERT(in.Checkerboard() == Odd || in.Checkerboard() == Even);
-
-    CoarseMatrix *Aself = nullptr;
-    if(in.Grid()->_isCheckerBoarded) {
-      if(in.Checkerboard() == Odd) {
-        Aself = (inv) ? &AselfInvOdd : &Aodd[geom.npoint-1];
-        DselfInternal(StencilOdd, *Aself, in, out, dag);
-      } else {
-        Aself = (inv) ? &AselfInvEven : &Aeven[geom.npoint-1];
-        DselfInternal(StencilEven, *Aself, in, out, dag);
-      }
-    } else {
-      Aself = (inv) ? &AselfInv : &A[geom.npoint-1];
-      DselfInternal(Stencil, *Aself, in, out, dag);
-    }
-    GRID_ASSERT(Aself != nullptr);
-  }
-
-  void DselfInternal(CartesianStencil<siteVector,siteVector,DefaultImplParams> &st, CoarseMatrix &a,
-                       const CoarseVector &in, CoarseVector &out, int dag) {
-    int point = geom.npoint-1;
-    autoView( out_v, out, AcceleratorWrite);
-    autoView( in_v,  in,  AcceleratorRead);
-    autoView( st_v,  st,  AcceleratorRead);
-    autoView( a_v,   a,   AcceleratorRead);
-
-    const int Nsimd = CComplex::Nsimd();
-    typedef decltype(coalescedRead(in_v[0])) calcVector;
-    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-
-    RealD* dag_factor_p = &dag_factor[0];
-
-    if(dag) {
-      accelerator_for(sss, in.Grid()->oSites()*nbasis, Nsimd, {
-        int ss = sss/nbasis;
-        int b  = sss%nbasis;
-        calcComplex res = Zero();
-        calcVector nbr;
-        int ptype;
-        StencilEntry *SE;
-
-        SE=st_v.GetEntry(ptype,point,ss);
-
-        if(SE->_is_local) {
-          nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-        } else {
-          nbr = coalescedRead(st_v.CommBuf()[SE->_offset]);
-        }
-        acceleratorSynchronise();
-
-        for(int bb=0;bb<nbasis;bb++) {
-          res = res + dag_factor_p[b*nbasis+bb]*coalescedRead(a_v[ss](b,bb))*nbr(bb);
-        }
-        coalescedWrite(out_v[ss](b),res);
-      });
-    } else {
-      accelerator_for(sss, in.Grid()->oSites()*nbasis, Nsimd, {
-        int ss = sss/nbasis;
-        int b  = sss%nbasis;
-        calcComplex res = Zero();
-        calcVector nbr;
-        int ptype;
-        StencilEntry *SE;
-
-        SE=st_v.GetEntry(ptype,point,ss);
-
-        if(SE->_is_local) {
-          nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-        } else {
-          nbr = coalescedRead(st_v.CommBuf()[SE->_offset]);
-        }
-        acceleratorSynchronise();
-
-        for(int bb=0;bb<nbasis;bb++) {
-          res = res + coalescedRead(a_v[ss](b,bb))*nbr(bb);
-        }
-        coalescedWrite(out_v[ss](b),res);
-      });
-    }
-  }
-
-  void DhopInternal(CartesianStencil<siteVector,siteVector,DefaultImplParams> &st, std::vector<CoarseMatrix> &a,
-                    const CoarseVector &in, CoarseVector &out, int dag) {
-    SimpleCompressor<siteVector> compressor;
-
-    st.HaloExchange(in,compressor);
-    autoView( in_v,  in,  AcceleratorRead);
-    autoView( out_v, out, AcceleratorWrite);
-    autoView( st_v , st,  AcceleratorRead);
-    typedef LatticeView<Cobj> Aview;
-
-    // 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);
-    }
-    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]);
-    }
-    Aview *Aview_p = & AcceleratorViewContainer[0];
-
-    const int Nsimd = CComplex::Nsimd();
-    typedef decltype(coalescedRead(in_v[0])) calcVector;
-    typedef decltype(coalescedRead(in_v[0](0))) calcComplex;
-
-    RealD* dag_factor_p = &dag_factor[0];
-
-    if(dag) {
-      accelerator_for(sss, in.Grid()->oSites()*nbasis, Nsimd, {
-        int ss = sss/nbasis;
-        int b  = sss%nbasis;
-        calcComplex res = Zero();
-        calcVector nbr;
-        int ptype;
-        StencilEntry *SE;
-
-        for(int p=0;p<npoint;p++){
-          int point = points_p[p];
-          SE=st_v.GetEntry(ptype,point,ss);
-
-          if(SE->_is_local) {
-            nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-          } else {
-            nbr = coalescedRead(st_v.CommBuf()[SE->_offset]);
-          }
-          acceleratorSynchronise();
-
-          for(int bb=0;bb<nbasis;bb++) {
-            res = res + dag_factor_p[b*nbasis+bb]*coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
-          }
-        }
-        coalescedWrite(out_v[ss](b),res);
-      });
-    } else {
-      accelerator_for(sss, in.Grid()->oSites()*nbasis, Nsimd, {
-        int ss = sss/nbasis;
-        int b  = sss%nbasis;
-        calcComplex res = Zero();
-        calcVector nbr;
-        int ptype;
-        StencilEntry *SE;
-
-        for(int p=0;p<npoint;p++){
-          int point = points_p[p];
-          SE=st_v.GetEntry(ptype,point,ss);
-
-          if(SE->_is_local) {
-            nbr = coalescedReadPermute(in_v[SE->_offset],ptype,SE->_permute);
-          } else {
-            nbr = coalescedRead(st_v.CommBuf()[SE->_offset]);
-          }
-          acceleratorSynchronise();
-
-          for(int bb=0;bb<nbasis;bb++) {
-            res = res + coalescedRead(Aview_p[point][ss](b,bb))*nbr(bb);
-          }
-        }
-        coalescedWrite(out_v[ss](b),res);
-      });
-    }
-
-    for(int p=0;p<npoint;p++) hAcceleratorViewContainer[p].ViewClose();
-  }
-  
-  CoarsenedMatrix(GridCartesian &CoarseGrid, int hermitian_=0) 	:
-    _grid(&CoarseGrid),
-    _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),
-    A(geom.npoint,&CoarseGrid),
-    Aeven(geom.npoint,_cbgrid),
-    Aodd(geom.npoint,_cbgrid),
-    AselfInv(&CoarseGrid),
-    AselfInvEven(_cbgrid),
-    AselfInvOdd(_cbgrid),
-    dag_factor(nbasis*nbasis)
-  {
-    fillFactor();
-  };
-
-  CoarsenedMatrix(GridCartesian &CoarseGrid, GridRedBlackCartesian &CoarseRBGrid, int hermitian_=0) 	:
-
-    _grid(&CoarseGrid),
-    _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),
-    A(geom.npoint,&CoarseGrid),
-    Aeven(geom.npoint,&CoarseRBGrid),
-    Aodd(geom.npoint,&CoarseRBGrid),
-    AselfInv(&CoarseGrid),
-    AselfInvEven(&CoarseRBGrid),
-    AselfInvOdd(&CoarseRBGrid),
-    dag_factor(nbasis*nbasis)
-  {
-    fillFactor();
-  };
-
-  void fillFactor() {
-    Eigen::MatrixXd dag_factor_eigen = Eigen::MatrixXd::Ones(nbasis, nbasis);
-    if(!hermitian) {
-      const int nb = nbasis/2;
-      dag_factor_eigen.block(0,nb,nb,nb) *= -1.0;
-      dag_factor_eigen.block(nb,0,nb,nb) *= -1.0;
-    }
-
-    // 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);
-    });
-    acceleratorCopyToDevice(&h_dag_factor[0],&dag_factor[0],dag_factor.size()*sizeof(RealD));
-  }
-
-  void CoarsenOperator(GridBase *FineGrid,LinearOperatorBase<Lattice<Fobj> > &linop,
-		       Aggregation<Fobj,CComplex,nbasis> & Subspace)
-  {
-    typedef Lattice<typename Fobj::tensor_reduced> FineComplexField;
-    typedef typename Fobj::scalar_type scalar_type;
-
-    std::cout << GridLogMessage<< "CoarsenMatrix "<< std::endl;
-
-    FineComplexField one(FineGrid); one=scalar_type(1.0,0.0);
-    FineComplexField zero(FineGrid); zero=scalar_type(0.0,0.0);
-
-    std::vector<FineComplexField> masks(geom.npoint,FineGrid);
-    FineComplexField imask(FineGrid); // contributions from within this block
-    FineComplexField omask(FineGrid); // contributions from outwith this block
-
-    FineComplexField evenmask(FineGrid);
-    FineComplexField oddmask(FineGrid); 
-
-    FineField     phi(FineGrid);
-    FineField     tmp(FineGrid);
-    FineField     zz(FineGrid); zz=Zero();
-    FineField    Mphi(FineGrid);
-    FineField    Mphie(FineGrid);
-    FineField    Mphio(FineGrid);
-    std::vector<FineField>     Mphi_p(geom.npoint,FineGrid);
-
-    Lattice<iScalar<vInteger> > coor (FineGrid);
-    Lattice<iScalar<vInteger> > bcoor(FineGrid);
-    Lattice<iScalar<vInteger> > bcb  (FineGrid); bcb = Zero();
-
-    CoarseVector iProj(Grid()); 
-    CoarseVector oProj(Grid()); 
-    CoarseVector SelfProj(Grid()); 
-    CoarseComplexField iZProj(Grid()); 
-    CoarseComplexField oZProj(Grid()); 
-
-    CoarseScalar InnerProd(Grid()); 
-
-    std::cout << GridLogMessage<< "CoarsenMatrix Orthog "<< std::endl;
-    // Orthogonalise the subblocks over the basis
-    blockOrthogonalise(InnerProd,Subspace.subspace);
-
-    // Compute the matrix elements of linop between this orthonormal
-    // set of vectors.
-    std::cout << GridLogMessage<< "CoarsenMatrix masks "<< std::endl;
-    int self_stencil=-1;
-    for(int p=0;p<geom.npoint;p++)
-    { 
-      int dir   = geom.directions[p];
-      int disp  = geom.displacements[p];
-      A[p]=Zero();
-      if( geom.displacements[p]==0){
-	self_stencil=p;
-      }
-
-      Integer block=(FineGrid->_rdimensions[dir])/(Grid()->_rdimensions[dir]);
-
-      LatticeCoordinate(coor,dir);
-
-      ///////////////////////////////////////////////////////
-      // Work out even and odd block checkerboarding for fast diagonal term
-      ///////////////////////////////////////////////////////
-      if ( disp==1 ) {
-	bcb   = bcb + div(coor,block);
-      }
-	
-      if ( disp==0 ) {
-	  masks[p]= Zero();
-      } else if ( disp==1 ) {
-	masks[p] = where(mod(coor,block)==(block-1),one,zero);
-      } else if ( disp==-1 ) {
-	masks[p] = where(mod(coor,block)==(Integer)0,one,zero);
-      }
-    }
-    evenmask = where(mod(bcb,2)==(Integer)0,one,zero);
-    oddmask  = one-evenmask;
-
-    GRID_ASSERT(self_stencil!=-1);
-
-    for(int i=0;i<nbasis;i++){
-
-      phi=Subspace.subspace[i];
-
-      std::cout << GridLogMessage<< "CoarsenMatrix vector "<<i << std::endl;
-      linop.OpDirAll(phi,Mphi_p);
-      linop.OpDiag  (phi,Mphi_p[geom.npoint-1]);
-
-      for(int p=0;p<geom.npoint;p++){ 
-
-	Mphi = Mphi_p[p];
-
-	int dir   = geom.directions[p];
-	int disp  = geom.displacements[p];
-
-	if ( (disp==-1) || (!hermitian ) ) {
-
-	  ////////////////////////////////////////////////////////////////////////
-	  // Pick out contributions coming from this cell and neighbour cell
-	  ////////////////////////////////////////////////////////////////////////
-	  omask = masks[p];
-	  imask = one-omask;
-	
-	  for(int j=0;j<nbasis;j++){
-	    
-	    blockMaskedInnerProduct(oZProj,omask,Subspace.subspace[j],Mphi);
-	    
-	    autoView( iZProj_v , iZProj, AcceleratorRead) ;
-	    autoView( oZProj_v , oZProj, AcceleratorRead) ;
-	    autoView( A_p     ,  A[p], AcceleratorWrite);
-	    autoView( A_self  , A[self_stencil], AcceleratorWrite);
-
-	    accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{ coalescedWrite(A_p[ss](j,i),oZProj_v(ss)); });
-	    if ( hermitian && (disp==-1) ) {
-	      for(int pp=0;pp<geom.npoint;pp++){// Find the opposite link and set <j|A|i> = <i|A|j>*
-		int dirp   = geom.directions[pp];
-		int dispp  = geom.displacements[pp];
-		if ( (dirp==dir) && (dispp==1) ){
-		  auto sft = conjugate(Cshift(oZProj,dir,1));
-		  autoView( sft_v    ,  sft  , AcceleratorWrite);
-		  autoView( A_pp     ,  A[pp], AcceleratorWrite);
-		  accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{ coalescedWrite(A_pp[ss](i,j),sft_v(ss)); });
-		}
-	      }
-	    }
-
-	  }
-	}
-      }
-
-      ///////////////////////////////////////////
-      // Faster alternate self coupling.. use hermiticity to save 2x
-      ///////////////////////////////////////////
-      {
-	mult(tmp,phi,evenmask);  linop.Op(tmp,Mphie);
-	mult(tmp,phi,oddmask );  linop.Op(tmp,Mphio);
-
-	{
-	  autoView( tmp_      , tmp, AcceleratorWrite);
-	  autoView( evenmask_ , evenmask, AcceleratorRead);
-	  autoView( oddmask_  ,  oddmask, AcceleratorRead);
-	  autoView( Mphie_    ,  Mphie, AcceleratorRead);
-	  autoView( Mphio_    ,  Mphio, AcceleratorRead);
-	  accelerator_for(ss, FineGrid->oSites(), Fobj::Nsimd(),{ 
-	      coalescedWrite(tmp_[ss],evenmask_(ss)*Mphie_(ss) + oddmask_(ss)*Mphio_(ss));
-	    });
-	}
-
-	blockProject(SelfProj,tmp,Subspace.subspace);
-
-	autoView( SelfProj_ , SelfProj, AcceleratorRead);
-	autoView( A_self  , A[self_stencil], AcceleratorWrite);
-
-	accelerator_for(ss, Grid()->oSites(), Fobj::Nsimd(),{
-	  for(int j=0;j<nbasis;j++){
-	    coalescedWrite(A_self[ss](j,i), SelfProj_(ss)(j));
-	  }
-	});
-
-      }
-    }
-    if(hermitian) {
-      std::cout << GridLogMessage << " ForceHermitian, new code "<<std::endl;
-    }
-
-    InvertSelfStencilLink(); std::cout << GridLogMessage << "Coarse self link inverted" << std::endl;
-    FillHalfCbs(); std::cout << GridLogMessage << "Coarse half checkerboards filled" << std::endl;
-  }
-
-  void InvertSelfStencilLink() {
-    std::cout << GridLogDebug << "CoarsenedMatrix::InvertSelfStencilLink" << std::endl;
-    int localVolume = Grid()->lSites();
-
-    typedef typename Cobj::scalar_object scalar_object;
-
-    autoView(Aself_v,    A[geom.npoint-1], CpuRead);
-    autoView(AselfInv_v, AselfInv,         CpuWrite);
-    thread_for(site, localVolume, { // NOTE: Not able to bring this to GPU because of Eigen + peek/poke
-      Eigen::MatrixXcd selfLinkEigen    = Eigen::MatrixXcd::Zero(nbasis, nbasis);
-      Eigen::MatrixXcd selfLinkInvEigen = Eigen::MatrixXcd::Zero(nbasis, nbasis);
-
-      scalar_object selfLink    = Zero();
-      scalar_object selfLinkInv = Zero();
-
-      Coordinate lcoor;
-
-      Grid()->LocalIndexToLocalCoor(site, lcoor);
-      peekLocalSite(selfLink, Aself_v, lcoor);
-
-      for (int i = 0; i < nbasis; ++i)
-        for (int j = 0; j < nbasis; ++j)
-          selfLinkEigen(i, j) = static_cast<ComplexD>(TensorRemove(selfLink(i, j)));
-
-      selfLinkInvEigen = selfLinkEigen.inverse();
-
-      for(int i = 0; i < nbasis; ++i)
-        for(int j = 0; j < nbasis; ++j)
-          selfLinkInv(i, j) = selfLinkInvEigen(i, j);
-
-      pokeLocalSite(selfLinkInv, AselfInv_v, lcoor);
-    });
-  }
-
-  void FillHalfCbs() {
-    std::cout << GridLogDebug << "CoarsenedMatrix::FillHalfCbs" << std::endl;
-    for(int p = 0; p < geom.npoint; ++p) {
-      pickCheckerboard(Even, Aeven[p], A[p]);
-      pickCheckerboard(Odd, Aodd[p], A[p]);
-    }
-    pickCheckerboard(Even, AselfInvEven, AselfInv);
-    pickCheckerboard(Odd, AselfInvOdd, AselfInv);
-  }
-};
-
-NAMESPACE_END(Grid);
-#endif

Grid/algorithms/multigrid/DenseCoarseMatrix.h

@@ -1,912 +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 coarsened operator.
-//
-//  - 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();
-    {
-      CheckMrhsSlices(Op);    // the batched apply keeps its slices apart
-      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];
-
-    // Every slice carries the same vector; slice 0 is the answer.  The
-    // slices are not a check here -- see CheckMrhsSlices, which does that
-    // once on a field chosen for the purpose.
-    Field min(mgrid), mout(mgrid);
-    for(int r=0;r<nr;r++) InsertSliceFast(in,min,r,0);
-    Op.M(min,mout);
-    ExtractSliceFast(out,mout,0,0);
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // Do the multiRHS slices stay independent?  Slice r carries (r+1) times
-  // one RANDOM field, so linearity says the results scale likewise, and a
-  // slot reading another slot's data is an O(1) error.
-  //
-  // The field is random on purpose.  Run on the output of the inverse, as
-  // this check once was, it measures the cancellation in A applied to
-  // A^-1 x instead: at the production point that is 1.3e-4 in an fp32
-  // sector with an fp32 inversion, so the check then fires on any change
-  // of summation order while saying nothing about slice independence.
-  // Once per import, not per apply.
-  ////////////////////////////////////////////////////////////////////
-  template<class CoarseOp>
-  void CheckMrhsSlices(CoarseOp &Op)
-  {
-    if ( Op.Grid() == grid ) return;               // single rhs: nothing to mix
-
-    GridBase *mgrid = Op.Grid();
-    GRID_ASSERT(mgrid->_ndimension == nd+1);
-    int nr = mgrid->_fdimensions[0];
-    if ( nr < 2 ) return;
-
-    Field in(grid);
-    GridParallelRNG rng(grid); rng.SeedFixedIntegers(std::vector<int>({7,8,9,10}));
-    random(rng,in);
-
-    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);
-
-    Field s0(grid);
-    ExtractSliceFast(s0,mout,0,0);
-    RealD worst=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)*s0;
-      RealD rel = std::sqrt(norm2(d)/norm2(sr));
-      worst = std::max(worst,rel);
-      const RealD otol = (sizeof(CoarseScalar)==sizeof(ComplexF)) ? 1.0e-4 : 1.0e-6;
-      if ( rel >= otol ) {
-        std::cout << GridLogMessage << "DenseCoarseMatrix: mrhs slice "<<r
-                  <<" inconsistent with slice 0, rel "<<rel<<std::endl;
-      }
-      GRID_ASSERT( rel < otol );
-    }
-    std::cout << GridLogMessage << "DenseCoarseMatrix: mrhs slices independent to "
-              << worst << " over " << nr << " right hand sides" << std::endl;
-  }
-
-  ////////////////////////////////////////////////////////////////////
-  // 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];
-      // ExtractMatrix hands back the unpadded matrix field, which is what the
-      // unpadded coordinates below index.
-      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);

Grid/algorithms/multigrid/Geometry.h

@@ -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);

Grid/algorithms/multigrid/HDCGMultiGrid.h

@@ -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 (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 MultiGeneralCoarsenedOperator<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);

Grid/algorithms/multigrid/HDCGMultiGridParams.h

@@ -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);

Grid/algorithms/multigrid/MrhsMultiGrid.h

@@ -1,433 +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) {
-    GRID_TRACE("MGCoarseVcycle");
-    CoarseField vec1(in.Grid());
-    CoarseField vec2(in.Grid());
-    CoarseCoarseField CCsrc(_CoarseCoarseMrhs);
-    CoarseCoarseField CCsol(_CoarseCoarseMrhs);
-    // The cycle starts from x0 = in, one unit-step Richardson iteration ahead of
-    // a zero start; measured, it pays for its apply by cutting Couter steps 22%.
-    // x0 is never materialised in out: the operator is applied to in directly and
-    // the copy folds into the add that lands the coarse-coarse correction.
-    {
-      GRID_TRACE("MGCoarseResidual");
-      _CoarseOp.Op(in,vec1);  sub(vec1,in,vec1);
-    }
-    // restrict, through the mixed blockProject: D+1 coarse in, D+1 cc out
-    {
-      GRID_TRACE("MGCCProject");
-      _Projector.blockProject(vec1,CCsrc);
-    }
-    {
-      GRID_TRACE("MGCCSolve");
-      _CoarseCoarseSolve(CCsrc,CCsol);
-    }
-    {
-      GRID_TRACE("MGCCPromote");
-      _Projector.blockPromote(vec1,CCsol);
-      add(out,in,vec1);
-    }
-    {
-      GRID_TRACE("MGCoarseResidual2");
-      _CoarseOp.Op(out,vec1);  sub(vec1,in,vec1);
-    }
-    {
-      GRID_TRACE("MGCoarseSmooth");
-      _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);
-    // x0 = in, never materialised in out: the operator is applied to in directly
-    // and the copy folds into the add that lands the coarse correction.
-    {
-      GRID_TRACE("MGFineResidual");
-      for(int r=0;r<nrhs;r++){ _FineOperator.Op(in[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],in[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);

Grid/algorithms/multigrid/MrhsPreconditioner.h

@@ -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);

Grid/algorithms/multigrid/MrhsPromotedOperator.h

@@ -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);

Grid/algorithms/multigrid/MultiGrid.h

@@ -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/GeneralCoarsenedMatrixMultiRHS.h>
-// DEPRECATED: the superseded coarse operators and the Aggregation-based
-// single-RHS ADEF-2.  Nothing in the library uses them; the PVdagM and HDCG
-// chains are on MultiGeneralCoarsenedOperator (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.

Grid/algorithms/multigrid/MultiGridIO.h

@@ -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);

Grid/algorithms/multigrid/PVdagMMultiGrid.h

@@ -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 MultiGeneralCoarsenedOperator<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 MultiGeneralCoarsenedOperator<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 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);