Merge branch 'release/ISC-freeze-2'

.gitignore

@@ -83,7 +83,6 @@ ltmain.sh
 .Trashes
 ehthumbs.db
 Thumbs.db
-.dirstamp
 
 # build directory #
 ###################
@@ -98,8 +97,11 @@ build.sh
 
 # Eigen source #
 ################
-Grid/Eigen
+lib/Eigen/*
-Eigen/*
+
+# FFTW source #
+################
+lib/fftw/*
 
 # libtool macros #
 ##################
@@ -110,7 +112,21 @@ m4/libtool.m4
 ################
 gh-pages/
 
+# Buck files #
+##############
+.buck*
+buck-out
+BUCK
+make-bin-BUCK.sh
+
 # generated sources #
 #####################
-Grid/qcd/spin/gamma-gen/*.h
+lib/qcd/spin/gamma-gen/*.h
-Grid/qcd/spin/gamma-gen/*.cc
+lib/qcd/spin/gamma-gen/*.cc
+lib/version.h
+
+# vs code editor files #
+########################
+.vscode/
+.vscode/settings.json
+settings.json

.travis.yml

@@ -9,11 +9,6 @@ matrix:
     - os:        osx
       osx_image: xcode8.3
       compiler: clang
-      env: PREC=single
-    - os:        osx
-      osx_image: xcode8.3
-      compiler: clang
-      env: PREC=double
       
 before_install:
     - export GRIDDIR=`pwd`
@@ -21,7 +16,7 @@ before_install:
     - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then export PATH="${GRIDDIR}/clang/bin:${PATH}"; fi
     - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then export LD_LIBRARY_PATH="${GRIDDIR}/clang/lib:${LD_LIBRARY_PATH}"; fi
     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi
-    - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libmpc openssl; fi
+    - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install libmpc; fi
     
 install:
     - export CWD=`pwd`
@@ -38,7 +33,6 @@ install:
     - which $CXX
     - $CXX --version
     - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export LDFLAGS='-L/usr/local/lib'; fi
-    - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then export EXTRACONF='--with-openssl=/usr/local/opt/openssl'; fi
     
 script:
     - ./bootstrap.sh
@@ -55,7 +49,12 @@ script:
     - make -j4
     - make install
     - cd $CWD/build
-    - ../configure --enable-precision=$PREC --enable-simd=SSE4 --enable-comms=none --with-lime=$CWD/build/lime/install ${EXTRACONF}
+    - ../configure --enable-precision=single --enable-simd=SSE4 --enable-comms=none --with-lime=$CWD/build/lime/install
     - make -j4 
     - ./benchmarks/Benchmark_dwf --threads 1 --debug-signals
+    - echo make clean
+    - ../configure --enable-precision=double --enable-simd=SSE4 --enable-comms=none --with-lime=$CWD/build/lime/install
+    - make -j4
+    - ./benchmarks/Benchmark_dwf --threads 1 --debug-signals
     - make check
+

Grid/algorithms/iterative/CommunicationAvoidingGeneralisedMinimalResidual.h

@@ -1,244 +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:
-  bool ErrorOnNoConverge; // Throw an 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<std::complex<double>> y;
-  std::vector<std::complex<double>> gamma;
-  std::vector<std::complex<double>> c;
-  std::vector<std::complex<double>> 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);
-    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)
-      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 = std::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;
-      }
-    }
-
-    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 - H(iter, i) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = (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] * H(iter, i) + c[i] * H(iter, i + 1);
-      H(iter, i)     = std::conj(c[i]) * H(iter, i) + std::conj(s[i]) * H(iter, i + 1);
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    ComplexD 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]     = std::conj(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] - H(k, i) * y[k];
-      y[i] = y[i] / H(i, i);
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + v[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/FlexibleCommunicationAvoidingGeneralisedMinimalResidual.h

@@ -1,256 +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:
-  bool ErrorOnNoConverge; // Throw an 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<std::complex<double>> y;
-  std::vector<std::complex<double>> gamma;
-  std::vector<std::complex<double>> c;
-  std::vector<std::complex<double>> 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);
-    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)
-      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 = std::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;
-      }
-    }
-
-    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 - H(iter, i) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = (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] * H(iter, i) + c[i] * H(iter, i + 1);
-      H(iter, i)     = std::conj(c[i]) * H(iter, i) + std::conj(s[i]) * H(iter, i + 1);
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    ComplexD 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]     = std::conj(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] - H(k, i) * y[k];
-      y[i] = y[i] / 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,254 +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:
-  bool ErrorOnNoConverge; // Throw an 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<std::complex<double>> y;
-  std::vector<std::complex<double>> gamma;
-  std::vector<std::complex<double>> c;
-  std::vector<std::complex<double>> 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);
-    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)
-      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 = std::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;
-      }
-    }
-
-    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 - H(iter, i) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = (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] * H(iter, i) + c[i] * H(iter, i + 1);
-      H(iter, i)     = std::conj(c[i]) * H(iter, i) + std::conj(s[i]) * H(iter, i + 1);
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    ComplexD 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]     = std::conj(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] - H(k, i) * y[k];
-      y[i] = y[i] / H(i, i);
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + z[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/GeneralisedMinimalResidual.h

@@ -1,242 +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:
-  bool ErrorOnNoConverge; // Throw an 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<std::complex<double>> y;
-  std::vector<std::complex<double>> gamma;
-  std::vector<std::complex<double>> c;
-  std::vector<std::complex<double>> 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);
-    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)
-      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 = std::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;
-      }
-    }
-
-    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 - H(iter, i) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = (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] * H(iter, i) + c[i] * H(iter, i + 1);
-      H(iter, i)     = std::conj(c[i]) * H(iter, i) + std::conj(s[i]) * H(iter, i + 1);
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    ComplexD 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]     = std::conj(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] - H(k, i) * y[k];
-      y[i] = y[i] / H(i, i);
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + v[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/MinimalResidual.h

@@ -1,156 +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:
-  bool ErrorOnNoConverge; // throw an 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);
-
-    Complex a, c;
-    Real    d;
-
-    Field Mr(src);
-    Field r(src);
-
-    // Initial residual computation & set up
-    RealD guess = norm2(psi);
-    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:    mp " << d << 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)
-          assert(true_residual / Tolerance < 10000.0);
-
-        IterationsToComplete = k;
-
-        return;
-      }
-    }
-
-    std::cout << GridLogMessage << "MinimalResidual did NOT converge"
-              << std::endl;
-
-    if (ErrorOnNoConverge)
-      assert(0);
-
-    IterationsToComplete = k;
-  }
-};
-} // namespace Grid
-#endif

Grid/algorithms/iterative/MixedPrecisionFlexibleGeneralisedMinimalResidual.h

@@ -1,273 +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:
-  bool ErrorOnNoConverge; // Throw an 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<std::complex<double>> y;
-  std::vector<std::complex<double>> gamma;
-  std::vector<std::complex<double>> c;
-  std::vector<std::complex<double>> 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);
-    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)
-      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 = std::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;
-      }
-    }
-
-    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 - H(iter, i) * v[i];
-    }
-
-    H(iter, iter + 1) = sqrt(norm2(w));
-    v[iter + 1] = (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] * H(iter, i) + c[i] * H(iter, i + 1);
-      H(iter, i)     = std::conj(c[i]) * H(iter, i) + std::conj(s[i]) * H(iter, i + 1);
-      H(iter, i + 1) = tmp;
-    }
-
-    // Compute new Givens Rotation
-    ComplexD 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]     = std::conj(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] - H(k, i) * y[k];
-      y[i] = y[i] / H(i, i);
-    }
-
-    for (int i = 0; i <= iter; i++)
-      psi = psi + z[i] * y[i];
-    CompSolutionTimer.Stop();
-  }
-};
-}
-#endif

Grid/algorithms/iterative/SchurRedBlack.h

@@ -1,473 +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;
-  public:
-
-    SchurRedBlackBase(OperatorFunction<Field> &HermitianRBSolver, const bool initSubGuess = false)  :
-    _HermitianRBSolver(HermitianRBSolver) 
-    { 
-      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);
-    }
-
-    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
-      ////////////////////////////////////////////////
-      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);
-
-      for(int b=0;b<nblock;b++){
-	guess(src_o[b],sol_o[b]); 
-
-	if ( subGuess ) { 
-	  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
-      ////////////////////////////////
-      Field   tmp(grid);
-      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. Not virtual as template methods
-    /////////////////////////////////////////////////////////////
-    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) 
-      :    SchurRedBlackBase<Field> (HermitianRBSolver,initSubGuess) 
-    {
-    }
-
-    //////////////////////////////////////////////////////
-    // 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);     assert(  tmp.checkerboard ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.checkerboard ==Odd);     
-      tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
-
-      _Matrix.Mooee(tmp,src_o); // Extra factor of "m" in source from dumb choice of matrix norm.
-    }
-    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);        assert(  tmp.checkerboard   ==Even);
-      src_e = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-      _Matrix.MooeeInv(src_e,sol_e);   assert(  sol_e.checkerboard ==Even);
-     
-      setCheckerboard(sol,sol_e); assert(  sol_e.checkerboard ==Even);
-      setCheckerboard(sol,sol_o); assert(  sol_o.checkerboard ==Odd );
-    }
-    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
-    {
-      SchurStaggeredOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  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)  
-      : SchurRedBlackBase<Field> (HermitianRBSolver,initSubGuess) {};
-
-
-    //////////////////////////////////////////////////////
-    // Override RedBlack specialisation
-    //////////////////////////////////////////////////////
-    virtual void RedBlackSource(Matrix & _Matrix,const Field &src, Field &src_e,Field &src_o)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      Field   tmp(grid);
-      Field  Mtmp(grid);
-
-      pickCheckerboard(Even,src_e,src);
-      pickCheckerboard(Odd ,src_o,src);
-
-      /////////////////////////////////////////////////////
-      // src_o = Mdag * (source_o - Moe MeeInv source_e)
-      /////////////////////////////////////////////////////
-      _Matrix.MooeeInv(src_e,tmp);     assert(  tmp.checkerboard ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.checkerboard ==Odd);     
-      tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
-
-      // get the right MpcDag
-      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.checkerboard ==Odd);       
-
-    }
-    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      Field   tmp(grid);
-      Field  sol_e(grid);
-      Field  src_e_i(grid);
-      ///////////////////////////////////////////////////
-      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o,tmp);          assert(  tmp.checkerboard   ==Even);
-      src_e_i = src_e-tmp;               assert(  src_e_i.checkerboard ==Even);
-      _Matrix.MooeeInv(src_e_i,sol_e);   assert(  sol_e.checkerboard ==Even);
-     
-      setCheckerboard(sol,sol_e); assert(  sol_e.checkerboard ==Even);
-      setCheckerboard(sol,sol_o); assert(  sol_o.checkerboard ==Odd );
-    }
-    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
-    {
-      SchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
-      this->_HermitianRBSolver(_HermOpEO,src_o,sol_o);  assert(sol_o.checkerboard==Odd);
-    };
-    virtual void RedBlackSolve   (Matrix & _Matrix,const std::vector<Field> &src_o,  std::vector<Field> &sol_o)
-    {
-      SchurDiagMooeeOperator<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)  
-    : SchurRedBlackBase<Field>(HermitianRBSolver,initSubGuess) {};
-
-    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);     assert(  tmp.checkerboard ==Even);
-      _Matrix.Meooe   (tmp,Mtmp);      assert( Mtmp.checkerboard ==Odd);     
-      tmp=src_o-Mtmp;                  assert(  tmp.checkerboard ==Odd);     
-
-      // get the right MpcDag
-      _HermOpEO.MpcDag(tmp,src_o);     assert(src_o.checkerboard ==Odd);       
-    }
-
-    virtual void RedBlackSolution(Matrix & _Matrix,const Field &sol_o, const Field &src_e,Field &sol)
-    {
-      GridBase *grid = _Matrix.RedBlackGrid();
-      GridBase *fgrid= _Matrix.Grid();
-
-      Field   sol_o_i(grid);
-      Field   tmp(grid);
-      Field   sol_e(grid);
-
-      ////////////////////////////////////////////////
-      // MooeeInv due to pecond
-      ////////////////////////////////////////////////
-      _Matrix.MooeeInv(sol_o,tmp);
-      sol_o_i = tmp;
-
-      ///////////////////////////////////////////////////
-      // sol_e = M_ee^-1 * ( src_e - Meo sol_o )...
-      ///////////////////////////////////////////////////
-      _Matrix.Meooe(sol_o_i,tmp);    assert(  tmp.checkerboard   ==Even);
-      tmp = src_e-tmp;               assert(  src_e.checkerboard ==Even);
-      _Matrix.MooeeInv(tmp,sol_e);   assert(  sol_e.checkerboard ==Even);
-     
-      setCheckerboard(sol,sol_e);    assert(  sol_e.checkerboard ==Even);
-      setCheckerboard(sol,sol_o_i);  assert(  sol_o_i.checkerboard ==Odd );
-    };
-
-    virtual void RedBlackSolve   (Matrix & _Matrix,const Field &src_o, Field &sol_o)
-    {
-      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); 
-    }
-  };
-}
-#endif

Grid/parallelIO/BinaryIO.cc

@@ -1,3 +0,0 @@
-#include <Grid/GridCore.h>
-
-int Grid::BinaryIO::latticeWriteMaxRetry = -1;

Grid/qcd/action/fermion/FourierAcceleratedPV.h

@@ -1,237 +0,0 @@
-
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/qcd/action/fermion/FourierAcceleratedPV.h
-
-    Copyright (C) 2015
-
-Author: Christoph Lehner (lifted with permission by Peter Boyle, brought back to Grid)
-Author: Peter Boyle <pabobyle@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 Grid {
-namespace QCD {
-
-  template<typename M>
-    void get_real_const_bc(M& m, RealD& _b, RealD& _c) {
-    ComplexD b,c;
-    b=m.bs[0];
-    c=m.cs[0];
-    std::cout << GridLogMessage << "b=" << b << ", c=" << c << std::endl;
-    for (size_t i=1;i<m.bs.size();i++) {
-      assert(m.bs[i] == b);
-      assert(m.cs[i] == c);
-    }
-    assert(b.imag() == 0.0);
-    assert(c.imag() == 0.0);
-    _b = b.real();
-    _c = c.real();
-  }
-
-
-template<typename Vi, typename M, typename G>
-class FourierAcceleratedPV {
- public:
-
-  ConjugateGradient<Vi> &cg;
-  M& dwfPV;
-  G& Umu;
-  GridCartesian* grid5D;
-  GridRedBlackCartesian* gridRB5D;
-  int group_in_s;
-
-  FourierAcceleratedPV(M& _dwfPV, G& _Umu, ConjugateGradient<Vi> &_cg, int _group_in_s = 2) 
-   : dwfPV(_dwfPV), Umu(_Umu), cg(_cg), group_in_s(_group_in_s) 
-  {
-    assert( dwfPV.FermionGrid()->_fdimensions[0] % (2*group_in_s) == 0);
-    grid5D = QCD::SpaceTimeGrid::makeFiveDimGrid(2*group_in_s, (GridCartesian*)Umu._grid);
-    gridRB5D = QCD::SpaceTimeGrid::makeFiveDimRedBlackGrid(2*group_in_s, (GridCartesian*)Umu._grid);
-  }
-
-  void rotatePV(const Vi& _src, Vi& dst, bool forward) const {
-
-    GridStopWatch gsw1, gsw2;
-
-    typedef typename Vi::scalar_type Coeff_t;
-    int Ls = dst._grid->_fdimensions[0];
-
-    Vi _tmp(dst._grid);
-    double phase = M_PI / (double)Ls;
-    Coeff_t bzero(0.0,0.0);
-
-    FFT theFFT((GridCartesian*)dst._grid);
-
-    if (!forward) {
-      gsw1.Start();
-      for (int s=0;s<Ls;s++) {
-	Coeff_t a(::cos(phase*s),-::sin(phase*s));
-	axpby_ssp(_tmp,a,_src,bzero,_src,s,s);
-      }
-      gsw1.Stop();
-
-      gsw2.Start();
-      theFFT.FFT_dim(dst,_tmp,0,FFT::forward);
-      gsw2.Stop();
-
-    } else {
-
-      gsw2.Start();
-      theFFT.FFT_dim(_tmp,_src,0,FFT::backward);
-      gsw2.Stop();
-
-      gsw1.Start();
-      for (int s=0;s<Ls;s++) {
-	Coeff_t a(::cos(phase*s),::sin(phase*s));
-	axpby_ssp(dst,a,_tmp,bzero,_tmp,s,s);
-      }
-      gsw1.Stop();
-    }
-
-    std::cout << GridLogMessage << "Timing rotatePV: " << gsw1.Elapsed() << ", " << gsw2.Elapsed() << std::endl;
-
-  }
-
-  void pvInv(const Vi& _src, Vi& _dst) const {
-
-    std::cout << GridLogMessage << "Fourier-Accelerated Outer Pauli Villars"<<std::endl;
-
-    typedef typename Vi::scalar_type Coeff_t;
-    int Ls = _dst._grid->_fdimensions[0];
-
-    GridStopWatch gswT;
-    gswT.Start();
-
-    RealD b,c;
-    get_real_const_bc(dwfPV,b,c);
-    RealD M5 = dwfPV.M5;
-    
-    // U(true) Rightinv TMinv U(false) = Minv
-
-    Vi _src_diag(_dst._grid);
-    Vi _src_diag_slice(dwfPV.GaugeGrid());
-    Vi _dst_diag_slice(dwfPV.GaugeGrid());
-    Vi _src_diag_slices(grid5D);
-    Vi _dst_diag_slices(grid5D);
-    Vi _dst_diag(_dst._grid);
-
-    rotatePV(_src,_src_diag,false);
-
-    // now do TM solves
-    Gamma G5(Gamma::Algebra::Gamma5);
-
-    GridStopWatch gswA, gswB;
-
-    gswA.Start();
-
-    typedef typename M::Impl_t Impl;
-    //WilsonTMFermion<Impl> tm(x.Umu,*x.UGridF,*x.UrbGridF,0.0,0.0,solver_outer.parent.par.wparams_f);
-    std::vector<RealD> vmass(grid5D->_fdimensions[0],0.0);
-    std::vector<RealD> vmu(grid5D->_fdimensions[0],0.0);
-
-    WilsonTMFermion5D<Impl> tm(Umu,*grid5D,*gridRB5D,
-			   *(GridCartesian*)dwfPV.GaugeGrid(),
-			   *(GridRedBlackCartesian*)dwfPV.GaugeRedBlackGrid(),
-			   vmass,vmu);
-    
-    //SchurRedBlackDiagTwoSolve<Vi> sol(cg);
-    SchurRedBlackDiagMooeeSolve<Vi> sol(cg); // same performance as DiagTwo
-    gswA.Stop();
-
-    gswB.Start();
-
-    for (int sgroup=0;sgroup<Ls/2/group_in_s;sgroup++) {
-
-      for (int sidx=0;sidx<group_in_s;sidx++) {
-
-	int s = sgroup*group_in_s + sidx;
-	int sprime = Ls-s-1;
-
-	RealD phase = M_PI / (RealD)Ls * (2.0 * s + 1.0);
-	RealD cosp = ::cos(phase);
-	RealD sinp = ::sin(phase);
-	RealD denom = b*b + c*c + 2.0*b*c*cosp;
-	RealD mass = -(b*b*M5 + c*(1.0 - cosp + c*M5) + b*(-1.0 + cosp + 2.0*c*cosp*M5))/denom;
-	RealD mu = (b+c)*sinp/denom;
-
-	vmass[2*sidx + 0] = mass;
-	vmass[2*sidx + 1] = mass;
-	vmu[2*sidx + 0] = mu;
-	vmu[2*sidx + 1] = -mu;
-
-      }
-
-      tm.update(vmass,vmu);
-
-      for (int sidx=0;sidx<group_in_s;sidx++) {
-
-	int s = sgroup*group_in_s + sidx;
-	int sprime = Ls-s-1;
-
-	ExtractSlice(_src_diag_slice,_src_diag,s,0);
-	InsertSlice(_src_diag_slice,_src_diag_slices,2*sidx + 0,0);
-
-	ExtractSlice(_src_diag_slice,_src_diag,sprime,0);
-	InsertSlice(_src_diag_slice,_src_diag_slices,2*sidx + 1,0);
-
-      }
-
-      GridStopWatch gsw;
-      gsw.Start();
-      _dst_diag_slices = zero; // zero guess
-      sol(tm,_src_diag_slices,_dst_diag_slices);
-      gsw.Stop();
-      std::cout << GridLogMessage << "Solve[sgroup=" << sgroup << "] completed in " << gsw.Elapsed() << ", " << gswA.Elapsed() << std::endl;
-
-      for (int sidx=0;sidx<group_in_s;sidx++) {
-
-	int s = sgroup*group_in_s + sidx;
-	int sprime = Ls-s-1;
-
-	RealD phase = M_PI / (RealD)Ls * (2.0 * s + 1.0);
-	RealD cosp = ::cos(phase);
-	RealD sinp = ::sin(phase);
-
-	// now rotate with inverse of
-	Coeff_t pA = b + c*cosp;
-	Coeff_t pB = - Coeff_t(0.0,1.0)*c*sinp;
-	Coeff_t pABden = pA*pA - pB*pB;
-	// (pA + pB * G5) * (pA - pB*G5) = (pA^2 - pB^2)
-      
-	ExtractSlice(_dst_diag_slice,_dst_diag_slices,2*sidx + 0,0);
-	_dst_diag_slice = (pA/pABden) * _dst_diag_slice - (pB/pABden) * (G5 * _dst_diag_slice);
-	InsertSlice(_dst_diag_slice,_dst_diag,s,0);
-	
-	ExtractSlice(_dst_diag_slice,_dst_diag_slices,2*sidx + 1,0);
-	_dst_diag_slice = (pA/pABden) * _dst_diag_slice + (pB/pABden) * (G5 * _dst_diag_slice);
-	InsertSlice(_dst_diag_slice,_dst_diag,sprime,0);
-      }
-    }
-    gswB.Stop();
-
-    rotatePV(_dst_diag,_dst,true);
-
-    gswT.Stop();
-    std::cout << GridLogMessage << "PV completed in " << gswT.Elapsed() << " (Setup: " << gswA.Elapsed() << ", s-loop: " << gswB.Elapsed() << ")" << std::endl;
-  }
-
-};
-}}

Grid/qcd/action/fermion/MADWF.h

@@ -1,193 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/algorithms/iterative/MADWF.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
-
-namespace Grid {
-namespace QCD {
-
-template <class Fieldi, class Fieldo,IfNotSame<Fieldi,Fieldo> X=0>
-inline void convert(const Fieldi &from,Fieldo &to) 
-{
-  precisionChange(to,from);
-}
-template <class Fieldi, class Fieldo,IfSame<Fieldi,Fieldo> X=0>
-inline void convert(const Fieldi &from,Fieldo &to) 
-{
-  to=from;
-}
-
-template<class Matrixo,class Matrixi,class PVinverter,class SchurSolver, class Guesser> 
-class MADWF 
-{
- private:
-  typedef typename Matrixo::FermionField FermionFieldo;
-  typedef typename Matrixi::FermionField FermionFieldi;
-
-  PVinverter  & PauliVillarsSolvero;// For the outer field
-  SchurSolver & SchurSolveri;       // For the inner approx field
-  Guesser     & Guesseri;           // To deflate the inner approx solves
-
-  Matrixo & Mato;                   // Action object for outer
-  Matrixi & Mati;                   // Action object for inner
-
-  RealD target_resid;
-  int   maxiter;
- public:
-
-  MADWF(Matrixo &_Mato,
-	Matrixi &_Mati, 
-	PVinverter &_PauliVillarsSolvero, 
-	SchurSolver &_SchurSolveri,
-	Guesser & _Guesseri,
-	RealD resid,
-	int _maxiter) :
-
-  Mato(_Mato),Mati(_Mati),
-    SchurSolveri(_SchurSolveri),
-    PauliVillarsSolvero(_PauliVillarsSolvero),Guesseri(_Guesseri)
-  {   
-    target_resid=resid;
-    maxiter     =_maxiter; 
-  };
-
-  void operator() (const FermionFieldo &src4,FermionFieldo &sol5)
-  {
-    std::cout << GridLogMessage<< " ************************************************" << std::endl;
-    std::cout << GridLogMessage<< "  MADWF-like algorithm                           " << std::endl;
-    std::cout << GridLogMessage<< " ************************************************" << std::endl;
-
-    FermionFieldi    c0i(Mati.GaugeGrid()); // 4d 
-    FermionFieldi    y0i(Mati.GaugeGrid()); // 4d
-    FermionFieldo    c0 (Mato.GaugeGrid()); // 4d 
-    FermionFieldo    y0 (Mato.GaugeGrid()); // 4d
-
-    FermionFieldo    A(Mato.FermionGrid()); // Temporary outer
-    FermionFieldo    B(Mato.FermionGrid()); // Temporary outer
-    FermionFieldo    b(Mato.FermionGrid()); // 5d source
-
-    FermionFieldo    c(Mato.FermionGrid()); // PVinv source; reused so store
-    FermionFieldo    defect(Mato.FermionGrid()); // 5d source
-
-    FermionFieldi   ci(Mati.FermionGrid()); 
-    FermionFieldi   yi(Mati.FermionGrid()); 
-    FermionFieldi   xi(Mati.FermionGrid()); 
-    FermionFieldi srci(Mati.FermionGrid()); 
-    FermionFieldi   Ai(Mati.FermionGrid()); 
-
-    RealD m=Mati.Mass();
-
-    ///////////////////////////////////////
-    //Import source, include Dminus factors
-    ///////////////////////////////////////
-    Mato.ImportPhysicalFermionSource(src4,b); 
-    std::cout << GridLogMessage << " src4 " <<norm2(src4)<<std::endl;
-    std::cout << GridLogMessage << " b    " <<norm2(b)<<std::endl;
-
-    defect = b;
-    sol5=zero;
-    for (int i=0;i<maxiter;i++) {
-
-      ///////////////////////////////////////
-      // Set up c0 from current defect
-      ///////////////////////////////////////
-      PauliVillarsSolvero(Mato,defect,A);
-      Mato.Pdag(A,c);
-      ExtractSlice(c0, c, 0 , 0);
-
-      ////////////////////////////////////////////////
-      // Solve the inner system with surface term c0
-      ////////////////////////////////////////////////
-      ci = zero;  
-      convert(c0,c0i); // Possible precison change
-      InsertSlice(c0i,ci,0, 0);
-
-      // Dwm P y = Dwm x = D(1) P (c0,0,0,0)^T
-      Mati.P(ci,Ai);
-      Mati.SetMass(1.0);      Mati.M(Ai,srci);      Mati.SetMass(m);
-      SchurSolveri(Mati,srci,xi,Guesseri); 
-      Mati.Pdag(xi,yi);
-      ExtractSlice(y0i, yi, 0 , 0);
-      convert(y0i,y0); // Possible precision change
-
-      //////////////////////////////////////
-      // Propagate solution back to outer system
-      // Build Pdag PV^-1 Dm P [-sol4,c2,c3... cL]
-      //////////////////////////////////////
-      c0 = - y0;
-      InsertSlice(c0, c, 0   , 0);
-
-      /////////////////////////////
-      // Reconstruct the bulk solution Pdag PV^-1 Dm P 
-      /////////////////////////////
-      Mato.P(c,B);
-      Mato.M(B,A);
-      PauliVillarsSolvero(Mato,A,B);
-      Mato.Pdag(B,A);
-
-      //////////////////////////////
-      // Reinsert surface prop
-      //////////////////////////////
-      InsertSlice(y0,A,0,0);
-
-      //////////////////////////////
-      // Convert from y back to x 
-      //////////////////////////////
-      Mato.P(A,B);
-
-      //         sol5' = sol5 + M^-1 defect
-      //               = sol5 + M^-1 src - M^-1 M sol5  ...
-      sol5 = sol5 + B;
-      std::cout << GridLogMessage << "***************************************" <<std::endl;
-      std::cout << GridLogMessage << " Sol5 update "<<std::endl;
-      std::cout << GridLogMessage << "***************************************" <<std::endl;
-      std::cout << GridLogMessage << " Sol5 now "<<norm2(sol5)<<std::endl;
-      std::cout << GridLogMessage << " delta    "<<norm2(B)<<std::endl;
-
-       // New defect  = b - M sol5
-       Mato.M(sol5,A);
-       defect = b - A;
-
-       std::cout << GridLogMessage << " defect   "<<norm2(defect)<<std::endl;
-
-       double resid = ::sqrt(norm2(defect) / norm2(b));
-       std::cout << GridLogMessage << "Residual " << i << ": " << resid  << std::endl;
-       std::cout << GridLogMessage << "***************************************" <<std::endl;
-
-       if (resid < target_resid) {
-	 return;
-       }
-    }
-
-    std::cout << GridLogMessage << "MADWF : Exceeded maxiter "<<std::endl;
-    assert(0);
-
-  }
-
-};
-
-}}

Grid/qcd/action/fermion/PauliVillarsInverters.h

@@ -1,95 +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 */
-#pragma once
-
-namespace Grid {
-namespace QCD {
-
-template<class Field>
-class PauliVillarsSolverUnprec
-{
- public:
-  ConjugateGradient<Field> & CG;
-  PauliVillarsSolverUnprec(  ConjugateGradient<Field> &_CG) : CG(_CG){};
-
-  template<class Matrix>
-  void operator() (Matrix &_Matrix,const Field &src,Field &sol)
-  {
-    RealD m = _Matrix.Mass();
-    Field A  (_Matrix.FermionGrid());
-
-    MdagMLinearOperator<Matrix,Field> HermOp(_Matrix);
-
-    _Matrix.SetMass(1.0);
-    _Matrix.Mdag(src,A);
-    CG(HermOp,A,sol);
-    _Matrix.SetMass(m);
-  };
-};
-
-template<class Field,class SchurSolverType>
-class PauliVillarsSolverRBprec
-{
- public:
-  SchurSolverType & SchurSolver;
-  PauliVillarsSolverRBprec( SchurSolverType &_SchurSolver) : SchurSolver(_SchurSolver){};
-
-  template<class Matrix>
-  void operator() (Matrix &_Matrix,const Field &src,Field &sol)
-  {
-    RealD m = _Matrix.Mass();
-    Field A  (_Matrix.FermionGrid());
-
-    _Matrix.SetMass(1.0);
-    SchurSolver(_Matrix,src,sol);
-    _Matrix.SetMass(m);
-  };
-};
-
-template<class Field,class GaugeField>
-class PauliVillarsSolverFourierAccel
-{
- public:
-  GaugeField      & Umu;
-  ConjugateGradient<Field> & CG;
-
-  PauliVillarsSolverFourierAccel(GaugeField &_Umu,ConjugateGradient<Field> &_CG) :  Umu(_Umu), CG(_CG)
-  {
-  };
-
-  template<class Matrix>
-  void operator() (Matrix &_Matrix,const Field &src,Field &sol)
-  {
-    FourierAcceleratedPV<Field, Matrix, typename Matrix::GaugeField > faPV(_Matrix,Umu,CG) ;
-    faPV.pvInv(src,sol);
-  };
-};
-
-
-}
-}

Grid/qcd/action/fermion/Reconstruct5Dprop.h

@@ -1,135 +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 */
-#pragma once
-
-namespace Grid {
-namespace QCD {
-
-template<class Field,class PVinverter> class Reconstruct5DfromPhysical {
- private:
-  PVinverter & PauliVillarsSolver;
- public:
-
- /////////////////////////////////////////////////////
- // First cut works, 10 Oct 2018.
- //
- // Must form a plan to get this into production for Zmobius acceleration
- // of the Mobius exact AMA corrections.
- //
- // TODO : understand absence of contact term in eqns in Hantao's thesis
- //        sol4 is contact term subtracted, but thesis & Brower's paper suggests not.
- //
- // Step 1: Localise PV inverse in a routine. [DONE]
- // Step 2: Schur based PV inverse            [DONE]
- // Step 3: Fourier accelerated PV inverse    [DONE]
- //
- /////////////////////////////////////////////////////
- 
-  Reconstruct5DfromPhysical(PVinverter &_PauliVillarsSolver) 
-    : PauliVillarsSolver(_PauliVillarsSolver) 
-  { 
-  };
-
-
-   template<class Matrix>
-   void PV(Matrix &_Matrix,const Field &src,Field &sol)
-   {
-     RealD m = _Matrix.Mass();
-     _Matrix.SetMass(1.0);
-     _Matrix.M(src,sol);
-     _Matrix.SetMass(m);
-   }
-   template<class Matrix>
-   void PVdag(Matrix &_Matrix,const Field &src,Field &sol)
-   {
-     RealD m = _Matrix.Mass();
-     _Matrix.SetMass(1.0);
-     _Matrix.Mdag(src,sol);
-     _Matrix.SetMass(m);
-   }
-  template<class Matrix>
-  void operator() (Matrix & _Matrix,const Field &sol4,const Field &src4, Field &sol5){
-
-    int Ls =  _Matrix.Ls;
-
-    Field psi4(_Matrix.GaugeGrid());
-    Field psi(_Matrix.FermionGrid());
-    Field A  (_Matrix.FermionGrid());
-    Field B  (_Matrix.FermionGrid());
-    Field c  (_Matrix.FermionGrid());
-
-    typedef typename Matrix::Coeff_t Coeff_t;
-
-    std::cout << GridLogMessage<< " ************************************************" << std::endl;
-    std::cout << GridLogMessage<< " Reconstruct5Dprop: c.f. MADWF algorithm         " << std::endl;
-    std::cout << GridLogMessage<< " ************************************************" << std::endl;
-
-    ///////////////////////////////////////
-    //Import source, include Dminus factors
-    ///////////////////////////////////////
-    _Matrix.ImportPhysicalFermionSource(src4,B); 
-
-    ///////////////////////////////////////
-    // Set up c from src4
-    ///////////////////////////////////////
-    PauliVillarsSolver(_Matrix,B,A);
-    _Matrix.Pdag(A,c);
-
-    //////////////////////////////////////
-    // Build Pdag PV^-1 Dm P [-sol4,c2,c3... cL]
-    //////////////////////////////////////
-    psi4 = - sol4;
-    InsertSlice(psi4, psi, 0   , 0);
-    for (int s=1;s<Ls;s++) {
-      ExtractSlice(psi4,c,s,0);
-       InsertSlice(psi4,psi,s,0);
-    }
-
-    /////////////////////////////
-    // Pdag PV^-1 Dm P 
-    /////////////////////////////
-    _Matrix.P(psi,B);
-    _Matrix.M(B,A);
-    PauliVillarsSolver(_Matrix,A,B);
-    _Matrix.Pdag(B,A);
-
-    //////////////////////////////
-    // Reinsert surface prop
-    //////////////////////////////
-    InsertSlice(sol4,A,0,0);
-
-    //////////////////////////////
-    // Convert from y back to x 
-    //////////////////////////////
-    _Matrix.P(A,sol5);
-    
-  }
-};
-
-}
-}

Grid/qcd/action/fermion/WilsonTMFermion5D.h

@@ -1,155 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/qcd/action/fermion/WilsonTMFermion5D.h
-
-    Copyright (C) 2015
-
-Author: paboyle <paboyle@ph.ed.ac.uk> ; NB Christoph did similar in GPT
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
-#pragma once 
-
-#include <Grid/qcd/action/fermion/FermionCore.h>
-#include <Grid/qcd/action/fermion/WilsonFermion.h>
-
-
-namespace Grid {
-
-  namespace QCD {
-    
-    template<class Impl>
-      class WilsonTMFermion5D : public WilsonFermion5D<Impl>
-      {
-      public:
-	INHERIT_IMPL_TYPES(Impl);
-      public:
-
-	virtual void   Instantiatable(void) {};
-
-	// Constructors
-        WilsonTMFermion5D(GaugeField &_Umu,
-			  GridCartesian         &Fgrid,
-			  GridRedBlackCartesian &Frbgrid, 
-			  GridCartesian         &Ugrid,
-			  GridRedBlackCartesian &Urbgrid, 
-			  const std::vector<RealD> _mass,
-			  const std::vector<RealD> _mu,
-			  const ImplParams &p= ImplParams()
-			  ) :
-	WilsonFermion5D<Impl>(_Umu,
-			      Fgrid,
-			      Frbgrid,
-			      Ugrid,
-			      Urbgrid,
-			      4.0,p)
-	
-	  {
-	    update(_mass,_mu);
-	  }
-
-	virtual void Meooe(const FermionField &in, FermionField &out) {
-	  if (in.checkerboard == Odd) {
-	    this->DhopEO(in, out, DaggerNo);
-	  } else {
-	    this->DhopOE(in, out, DaggerNo);
-	  }
-	}
-
-	virtual void MeooeDag(const FermionField &in, FermionField &out) {
-	  if (in.checkerboard == Odd) {
-	    this->DhopEO(in, out, DaggerYes);
-	  } else {
-	    this->DhopOE(in, out, DaggerYes);
-	  }
-	}	
-	
-	// allow override for twisted mass and clover
-	virtual void Mooee(const FermionField &in, FermionField &out) {
-	  out.checkerboard = in.checkerboard;
-	  //axpibg5x(out,in,a,b); // out = a*in + b*i*G5*in
-	  for (int s=0;s<(int)this->mass.size();s++) {
-	    ComplexD a = 4.0+this->mass[s];
-	    ComplexD b(0.0,this->mu[s]);
-	    axpbg5y_ssp(out,a,in,b,in,s,s);
-	  }
-	}
-
-	virtual void MooeeDag(const FermionField &in, FermionField &out) {
-	  out.checkerboard = in.checkerboard;
-	  for (int s=0;s<(int)this->mass.size();s++) {
-	    ComplexD a = 4.0+this->mass[s];
-	    ComplexD b(0.0,-this->mu[s]);
-	    axpbg5y_ssp(out,a,in,b,in,s,s);
-	  }
-	}
-	virtual void MooeeInv(const FermionField &in, FermionField &out) {
-	  for (int s=0;s<(int)this->mass.size();s++) {
-	    RealD m    = this->mass[s];
-	    RealD tm   = this->mu[s];
-	    RealD mtil = 4.0+this->mass[s];
-	    RealD sq   = mtil*mtil+tm*tm;
-	    ComplexD a    = mtil/sq;
-	    ComplexD b(0.0, -tm /sq);
-	    axpbg5y_ssp(out,a,in,b,in,s,s);
-	  }
-	}
-	virtual void MooeeInvDag(const FermionField &in, FermionField &out) {
-	  for (int s=0;s<(int)this->mass.size();s++) {
-	    RealD m    = this->mass[s];
-	    RealD tm   = this->mu[s];
-	    RealD mtil = 4.0+this->mass[s];
-	    RealD sq   = mtil*mtil+tm*tm;
-	    ComplexD a    = mtil/sq;
-	    ComplexD b(0.0,tm /sq);
-	    axpbg5y_ssp(out,a,in,b,in,s,s);
-	  }
-	}
-
-	virtual RealD M(const FermionField &in, FermionField &out) {
-	  out.checkerboard = in.checkerboard;
-	  this->Dhop(in, out, DaggerNo);
-	  FermionField tmp(out._grid);
-	  for (int s=0;s<(int)this->mass.size();s++) {
-	    ComplexD a = 4.0+this->mass[s];
-	    ComplexD b(0.0,this->mu[s]);
-	    axpbg5y_ssp(tmp,a,in,b,in,s,s);
-	  }
-	  return axpy_norm(out, 1.0, tmp, out);
-	}
-	
-	// needed for fast PV
-	void update(const std::vector<RealD>& _mass, const std::vector<RealD>& _mu) {
-	  assert(_mass.size() == _mu.size());
-	  assert(_mass.size() == this->FermionGrid()->_fdimensions[0]);
-	  this->mass = _mass;
-	  this->mu = _mu;
-	}
-	
-      private:
-	std::vector<RealD> mu;
-	std::vector<RealD> mass;
-	
-      };
-   
-    typedef WilsonTMFermion5D<WilsonImplF> WilsonTMFermion5DF; 
-    typedef WilsonTMFermion5D<WilsonImplD> WilsonTMFermion5DD; 
-
-}}

Grid/qcd/action/gauge/Photon.h

@@ -1,330 +0,0 @@
-/*************************************************************************************
- 
- Grid physics library, www.github.com/paboyle/Grid
- 
- Source file: ./lib/qcd/action/gauge/Photon.h
- 
-Copyright (C) 2015-2018
- 
- Author: Peter Boyle <paboyle@ph.ed.ac.uk>
- Author: Antonin Portelli <antonin.portelli@me.com>
- Author: James Harrison <J.Harrison@soton.ac.uk>
- 
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
- 
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along
- with this program; if not, write to the Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- 
- See the full license in the file "LICENSE" in the top level distribution directory
- *************************************************************************************/
-/*  END LEGAL */
-#ifndef QCD_PHOTON_ACTION_H
-#define QCD_PHOTON_ACTION_H
-
-namespace Grid{
-namespace QCD{
-
-  template <class S>
-  class QedGImpl
-  {
-  public:
-    typedef S Simd;
-    
-    template <typename vtype>
-    using iImplGaugeLink  = iScalar<iScalar<iScalar<vtype>>>;
-    template <typename vtype>
-    using iImplGaugeField = iVector<iScalar<iScalar<vtype>>, Nd>;
-    
-    typedef iImplGaugeLink<Simd>  SiteLink;
-    typedef iImplGaugeField<Simd> SiteField;
-    typedef SiteLink              SiteComplex;
-    
-    typedef Lattice<SiteLink>  LinkField;
-    typedef Lattice<SiteField> Field;
-    typedef Field              ComplexField;
-  };
-  
-  typedef QedGImpl<vComplex> QedGImplR;
-  
-  template <class GImpl>
-  class Photon
-  {
-  public:
-    INHERIT_GIMPL_TYPES(GImpl);
-    typedef typename SiteGaugeLink::scalar_object ScalarSite;
-    typedef typename ScalarSite::scalar_type      ScalarComplex;
-    GRID_SERIALIZABLE_ENUM(Gauge, undef, feynman, 1, coulomb, 2, landau, 3);
-    GRID_SERIALIZABLE_ENUM(ZmScheme, undef, qedL, 1, qedTL, 2);
-  public:
-    Photon(GridBase *grid, Gauge gauge, ZmScheme zmScheme, std::vector<Real> improvement);
-    Photon(GridBase *grid, Gauge gauge, ZmScheme zmScheme);
-    virtual ~Photon(void) = default;
-    void FreePropagator(const GaugeField &in, GaugeField &out);
-    void MomentumSpacePropagator(const GaugeField &in, GaugeField &out);
-    void StochasticWeight(GaugeLinkField &weight);
-    void StochasticField(GaugeField &out, GridParallelRNG &rng);
-    void StochasticField(GaugeField &out, GridParallelRNG &rng,
-                         const GaugeLinkField &weight);
-    void UnitField(GaugeField &out);
-  private:
-    void makeSpatialNorm(LatticeInteger &spNrm);
-    void makeKHat(std::vector<GaugeLinkField> &khat);
-    void makeInvKHatSquared(GaugeLinkField &out);
-    void zmSub(GaugeLinkField &out);
-    void transverseProjectSpatial(GaugeField &out);
-    void gaugeTransform(GaugeField &out);
-  private:
-    GridBase          *grid_;
-    Gauge             gauge_;
-    ZmScheme          zmScheme_;
-    std::vector<Real> improvement_;
-  };
-
-  typedef Photon<QedGImplR>  PhotonR;
-  
-  template<class GImpl>
-  Photon<GImpl>::Photon(GridBase *grid, Gauge gauge, ZmScheme zmScheme,
-                        std::vector<Real> improvements)
-  : grid_(grid), gauge_(gauge), zmScheme_(zmScheme), improvement_(improvements)
-  {}
-
-  template<class GImpl>
-  Photon<GImpl>::Photon(GridBase *grid, Gauge gauge, ZmScheme zmScheme)
-  : Photon(grid, gauge, zmScheme, std::vector<Real>())
-  {}
-
-  template<class GImpl>
-  void Photon<GImpl>::FreePropagator(const GaugeField &in, GaugeField &out)
-  {
-    FFT        theFFT(dynamic_cast<GridCartesian *>(grid_));
-    GaugeField in_k(grid_);
-    GaugeField prop_k(grid_);
-    
-    theFFT.FFT_all_dim(in_k, in, FFT::forward);
-    MomentumSpacePropagator(prop_k, in_k);
-    theFFT.FFT_all_dim(out, prop_k, FFT::backward);
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::makeSpatialNorm(LatticeInteger &spNrm)
-  {
-    LatticeInteger   coor(grid_);
-    std::vector<int> l = grid_->FullDimensions();
-
-    spNrm = zero;
-    for(int mu = 0; mu < grid_->Nd() - 1; mu++)
-    {
-      LatticeCoordinate(coor, mu);
-      coor  = where(coor < Integer(l[mu]/2), coor, coor - Integer(l[mu]));
-      spNrm = spNrm + coor*coor;
-    }
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::makeKHat(std::vector<GaugeLinkField> &khat)
-  {
-    const unsigned int nd = grid_->Nd();
-    std::vector<int>   l  = grid_->FullDimensions();
-    Complex            ci(0., 1.);
-
-    khat.resize(nd, grid_);
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-      Real piL = M_PI/l[mu];
-
-      LatticeCoordinate(khat[mu], mu);
-      khat[mu] = exp(piL*ci*khat[mu])*2.*sin(piL*khat[mu]);
-    }
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::makeInvKHatSquared(GaugeLinkField &out)
-  {
-    std::vector<GaugeLinkField> khat;
-    GaugeLinkField              lone(grid_);
-    const unsigned int          nd = grid_->Nd();
-    std::vector<int>            zm(nd, 0);
-    ScalarSite                  one = ScalarComplex(1., 0.), z = ScalarComplex(0., 0.);
-    
-    out = zero;
-    makeKHat(khat);
-    for(int mu = 0; mu < nd; mu++)
-    {
-      out = out + khat[mu]*conjugate(khat[mu]);
-    }
-    lone = ScalarComplex(1., 0.);
-    pokeSite(one, out, zm);
-    out = lone/out;
-    pokeSite(z, out, zm);
-  }
-  
-  template<class GImpl>
-  void Photon<GImpl>::zmSub(GaugeLinkField &out)
-  {
-    switch (zmScheme_)
-    {
-      case ZmScheme::qedTL:
-      {
-        std::vector<int> zm(grid_->Nd(), 0);
-        ScalarSite       z = ScalarComplex(0., 0.);
-        
-        pokeSite(z, out, zm);
-        break;
-      }
-      case ZmScheme::qedL:
-      {
-        LatticeInteger spNrm(grid_);
-
-        makeSpatialNorm(spNrm);
-        out = where(spNrm == Integer(0), 0.*out, out);
-        for(int i = 0; i < improvement_.size(); i++)
-        {
-          Real f = sqrt(improvement_[i] + 1);
-          out = where(spNrm == Integer(i + 1), f*out, out);
-        }
-        break;
-      }
-      default:
-        assert(0);
-        break;
-    }
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::transverseProjectSpatial(GaugeField &out)
-  {
-    const unsigned int          nd = grid_->Nd();
-    GaugeLinkField              invKHat(grid_), cst(grid_), spdiv(grid_);
-    LatticeInteger              spNrm(grid_);
-    std::vector<GaugeLinkField> khat, a(nd, grid_), aProj(nd, grid_);
-
-    invKHat = zero;
-    makeSpatialNorm(spNrm);
-    makeKHat(khat);
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-      a[mu] = peekLorentz(out, mu);
-      if (mu < nd - 1)
-      {
-        invKHat += khat[mu]*conjugate(khat[mu]);
-      }
-    }
-    cst     = ScalarComplex(1., 0.);
-    invKHat = where(spNrm == Integer(0), cst, invKHat);
-    invKHat = cst/invKHat;
-    cst     = zero;
-    invKHat = where(spNrm == Integer(0), cst, invKHat);
-    spdiv   = zero;
-    for (unsigned int nu = 0; nu < nd - 1; ++nu)
-    {
-      spdiv += conjugate(khat[nu])*a[nu];
-    }
-    spdiv *= invKHat;
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-      aProj[mu] = a[mu] - khat[mu]*spdiv;
-      pokeLorentz(out, aProj[mu], mu);
-    }
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::gaugeTransform(GaugeField &out)
-  {
-    switch (gauge_)
-    {
-      case Gauge::feynman:
-        break;
-      case Gauge::coulomb:
-        transverseProjectSpatial(out);
-        break;
-      case Gauge::landau:
-        assert(0);
-        break;
-      default:
-        assert(0);
-        break;
-    }
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::MomentumSpacePropagator(const GaugeField &in,
-                                              GaugeField &out)
-  {
-    LatticeComplex momProp(grid_);
-    
-    makeInvKHatSquared(momProp);
-    zmSub(momProp);
-    
-    out = in*momProp;
-  }
-  
-  template<class GImpl>
-  void Photon<GImpl>::StochasticWeight(GaugeLinkField &weight)
-  {
-    const unsigned int nd  = grid_->Nd();
-    std::vector<int>   l   = grid_->FullDimensions();
-    Integer            vol = 1;
-
-    for(unsigned int mu = 0; mu < nd; mu++)
-    {
-      vol = vol*l[mu];
-    }
-    makeInvKHatSquared(weight);
-    weight = sqrt(vol)*sqrt(weight);
-    zmSub(weight);
-  }
-  
-  template<class GImpl>
-  void Photon<GImpl>::StochasticField(GaugeField &out, GridParallelRNG &rng)
-  {
-    GaugeLinkField weight(grid_);
-    
-    StochasticWeight(weight);
-    StochasticField(out, rng, weight);
-  }
-  
-  template<class GImpl>
-  void Photon<GImpl>::StochasticField(GaugeField &out, GridParallelRNG &rng,
-                                      const GaugeLinkField &weight)
-  {
-    const unsigned int nd = grid_->Nd();
-    GaugeLinkField     r(grid_);
-    GaugeField         aTilde(grid_);
-    FFT                fft(dynamic_cast<GridCartesian *>(grid_));
-    
-    for(unsigned int mu = 0; mu < nd; mu++)
-    {
-      gaussian(rng, r);
-      r = weight*r;
-      pokeLorentz(aTilde, r, mu);
-    }
-    gaugeTransform(aTilde);
-    fft.FFT_all_dim(out, aTilde, FFT::backward);
-    out = real(out);
-  }
-
-  template<class GImpl>
-  void Photon<GImpl>::UnitField(GaugeField &out)
-  {
-    const unsigned int nd = grid_->Nd();
-    GaugeLinkField     r(grid_);
-    
-    r = ScalarComplex(1., 0.);
-    for(unsigned int mu = 0; mu < nd; mu++)
-    {
-      pokeLorentz(out, r, mu);
-    }
-    out = real(out);
-  }
-  
-}}
-#endif

Grid/util/Sha.h

@@ -1,99 +0,0 @@
-   /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/util/Sha.h
-
-    Copyright (C) 2018
-
-    Author: Peter Boyle
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
-extern "C" {
-#include <openssl/sha.h>
-}
-#ifdef USE_IPP
-#include "ipp.h"
-#endif
-
-#pragma once
-
-class GridChecksum
-{
-public:
-  static inline uint32_t crc32(const void *data, size_t bytes)
-  {
-    return ::crc32(0L,(unsigned char *)data,bytes);
-  }
-
-#ifdef USE_IPP
-  static inline uint32_t crc32c(const void* data, size_t bytes)
-  {
-      uint32_t crc32c = ~(uint32_t)0;
-      ippsCRC32C_8u(reinterpret_cast<const unsigned char *>(data), bytes, &crc32c);
-      ippsSwapBytes_32u_I(&crc32c, 1);
-  
-      return ~crc32c;
-  }
-#endif
-
-  template <typename T>
-  static inline std::string sha256_string(const std::vector<T> &hash)
-  {
-    std::stringstream sha;
-    std::string       s;
-
-    for(unsigned int i = 0; i < hash.size(); i++) 
-    { 
-        sha << std::hex << static_cast<unsigned int>(hash[i]);
-    }
-    s = sha.str();
-
-    return s;
-  }
-  static inline std::vector<unsigned char> sha256(const void *data,size_t bytes)
-  {
-    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
-    SHA256_CTX sha256;
-    SHA256_Init  (&sha256);
-    SHA256_Update(&sha256, data,bytes);
-    SHA256_Final (&hash[0], &sha256);
-    return hash;
-  }
-  static inline std::vector<int> sha256_seeds(const std::string &s)
-  {
-    std::vector<int> seeds;
-    std::vector<unsigned char> uchars = sha256((void *)s.c_str(),s.size());
-    for(int i=0;i<uchars.size();i++) seeds.push_back(uchars[i]);
-    return seeds;
-  }
-};
-
-/*
-int main(int argc,char **argv)
-{
-  std::string s("The quick brown fox jumps over the lazy dog");
-  auto csum = GridChecksum::sha256_seeds(s);
-  std::cout << "SHA256 sum is 0x";
-  for(int i=0;i<csum.size;i++) { 
-    std::cout << std::hex << csum[i];
-  }
-  std::cout << std::endl;
-}
-*/

Hadrons/A2AMatrix.hpp

@@ -1,768 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/A2AMatrix.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef A2A_Matrix_hpp_
-#define A2A_Matrix_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/TimerArray.hpp>
-#include <Grid/Eigen/unsupported/CXX11/Tensor>
-#ifdef USE_MKL
-#include "mkl.h"
-#include "mkl_cblas.h"
-#endif
-
-#ifndef HADRONS_A2AM_NAME 
-#define HADRONS_A2AM_NAME "a2aMatrix"
-#endif
-
-#ifndef HADRONS_A2AM_IO_TYPE
-#define HADRONS_A2AM_IO_TYPE ComplexF
-#endif
-
-#define HADRONS_A2AM_PARALLEL_IO
-
-BEGIN_HADRONS_NAMESPACE
-
-// general A2A matrix set based on Eigen tensors and Grid-allocated memory
-// Dimensions:
-//   0 - ext - external field (momentum, EM field, ...)
-//   1 - str - spin-color structure
-//   2 - t   - timeslice
-//   3 - i   - left  A2A mode index
-//   4 - j   - right A2A mode index
-template <typename T>
-using A2AMatrixSet = Eigen::TensorMap<Eigen::Tensor<T, 5, Eigen::RowMajor>>;
-
-template <typename T>
-using A2AMatrix = Eigen::Matrix<T, -1, -1, Eigen::RowMajor>;
-
-template <typename T>
-using A2AMatrixMap = Eigen::Map<A2AMatrix<T>>;
-
-template <typename T>
-using A2AMatrixTr = Eigen::Matrix<T, -1, -1, Eigen::ColMajor>;
-
-/******************************************************************************
- *                      Abstract class for A2A kernels                        *
- ******************************************************************************/
-template <typename T, typename Field>
-class A2AKernel
-{
-public:
-    A2AKernel(void) = default;
-    virtual ~A2AKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const Field *left, const Field *right,
-                          const unsigned int orthogDim, double &time) = 0;
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej) = 0;
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej) = 0;
-};
-
-/******************************************************************************
- *                  Class to handle A2A matrix block HDF5 I/O                 *
- ******************************************************************************/
-template <typename T>
-class A2AMatrixIo
-{
-public:
-    // constructors
-    A2AMatrixIo(void) = default;
-    A2AMatrixIo(std::string filename, std::string dataname, 
-                const unsigned int nt, const unsigned int ni = 0,
-                const unsigned int nj = 0);
-    // destructor
-    ~A2AMatrixIo(void) = default;
-    // access
-    unsigned int getNi(void) const;
-    unsigned int getNj(void) const;
-    unsigned int getNt(void) const;
-    size_t       getSize(void) const;
-    // file allocation
-    template <typename MetadataType>
-    void initFile(const MetadataType &d, const unsigned int chunkSize);
-    // block I/O
-    void saveBlock(const T *data, const unsigned int i, const unsigned int j,
-                   const unsigned int blockSizei, const unsigned int blockSizej);
-    void saveBlock(const A2AMatrixSet<T> &m, const unsigned int ext, const unsigned int str,
-                   const unsigned int i, const unsigned int j);
-    template <template <class> class Vec, typename VecT>
-    void load(Vec<VecT> &v, double *tRead = nullptr, const bool useCache = true);
-private:
-    std::string  filename_{""}, dataname_{""};
-    unsigned int nt_{0}, ni_{0}, nj_{0};
-};
-
-/******************************************************************************
- *                  Wrapper for A2A matrix block computation                  *
- ******************************************************************************/
-template <typename T, typename Field, typename MetadataType, typename TIo = T>
-class A2AMatrixBlockComputation
-{
-private:
-    struct IoHelper
-    {
-        A2AMatrixIo<TIo> io;
-        MetadataType     md;
-        unsigned int     e, s, i, j;
-    };
-    typedef std::function<std::string(const unsigned int, const unsigned int)>  FilenameFn;
-    typedef std::function<MetadataType(const unsigned int, const unsigned int)> MetadataFn;
-public:
-    // constructor
-    A2AMatrixBlockComputation(GridBase *grid,
-                              const unsigned int orthogDim,
-                              const unsigned int next,
-                              const unsigned int nstr,
-                              const unsigned int blockSize,
-                              const unsigned int cacheBlockSize,
-                              TimerArray *tArray = nullptr);
-    // execution
-    void execute(const std::vector<Field> &left, 
-                 const std::vector<Field> &right,
-                 A2AKernel<T, Field> &kernel,
-                 const FilenameFn &ionameFn,
-                 const FilenameFn &filenameFn,
-                 const MetadataFn &metadataFn);
-private:
-    // I/O handler
-    void saveBlock(const A2AMatrixSet<TIo> &m, IoHelper &h);
-private:
-    TimerArray            *tArray_;
-    GridBase              *grid_;
-    unsigned int          orthogDim_, nt_, next_, nstr_, blockSize_, cacheBlockSize_;
-    Vector<T>             mCache_;
-    Vector<TIo>           mBuf_;
-    std::vector<IoHelper> nodeIo_;
-};
-
-/******************************************************************************
- *                       A2A matrix contraction kernels                       *
- ******************************************************************************/
-class A2AContraction
-{
-public:
-    // accTrMul(acc, a, b): acc += tr(a*b)
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void accTrMul(C &acc, const MatLeft &a, const MatRight &b)
-    {
-        if ((MatLeft::Options == Eigen::RowMajor) and
-            (MatRight::Options == Eigen::ColMajor))
-        {
-            parallel_for (unsigned int r = 0; r < a.rows(); ++r)
-            {
-                C tmp;
-#ifdef USE_MKL
-                dotuRow(tmp, r, a, b);
-#else
-                tmp = a.row(r).conjugate().dot(b.col(r));
-#endif
-                parallel_critical
-                {
-                    acc += tmp;
-                }
-            }
-        }
-        else
-        {
-            parallel_for (unsigned int c = 0; c < a.cols(); ++c)
-            {
-                C tmp;
-#ifdef USE_MKL 
-                dotuCol(tmp, c, a, b);
-#else
-                tmp = a.col(c).conjugate().dot(b.row(c));
-#endif
-                parallel_critical
-                {
-                    acc += tmp;
-                }
-            }
-        }
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline double accTrMulFlops(const MatLeft &a, const MatRight &b)
-    {
-        double n = a.rows()*a.cols();
-
-        return 8.*n;
-    }
-
-    // mul(res, a, b): res = a*b
-#ifdef USE_MKL
-    template <template <class, int...> class Mat, int... Opts>
-    static inline void mul(Mat<ComplexD, Opts...> &res, 
-                           const Mat<ComplexD, Opts...> &a, 
-                           const Mat<ComplexD, Opts...> &b)
-    {
-        static const ComplexD one(1., 0.), zero(0., 0.);
-
-        if ((res.rows() != a.rows()) or (res.cols() != b.cols()))
-        {
-            res.resize(a.rows(), b.cols());
-        }
-        if (Mat<ComplexD, Opts...>::Options == Eigen::RowMajor)
-        {
-            cblas_zgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.cols(), b.data(), b.cols(), &zero,
-                        res.data(), res.cols());
-        }
-        else if (Mat<ComplexD, Opts...>::Options == Eigen::ColMajor)
-        {
-            cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.rows(), b.data(), b.rows(), &zero,
-                        res.data(), res.rows());
-        }
-    }
-
-    template <template <class, int...> class Mat, int... Opts>
-    static inline void mul(Mat<ComplexF, Opts...> &res, 
-                           const Mat<ComplexF, Opts...> &a, 
-                           const Mat<ComplexF, Opts...> &b)
-    {
-        static const ComplexF one(1., 0.), zero(0., 0.);
-
-        if ((res.rows() != a.rows()) or (res.cols() != b.cols()))
-        {
-            res.resize(a.rows(), b.cols());
-        }
-        if (Mat<ComplexF, Opts...>::Options == Eigen::RowMajor)
-        {
-            cblas_cgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.cols(), b.data(), b.cols(), &zero,
-                        res.data(), res.cols());
-        }
-        else if (Mat<ComplexF, Opts...>::Options == Eigen::ColMajor)
-        {
-            cblas_cgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, a.rows(), b.cols(),
-                        a.cols(), &one, a.data(), a.rows(), b.data(), b.rows(), &zero,
-                        res.data(), res.rows());
-        }
-    }
-#else
-    template <typename Mat>
-    static inline void mul(Mat &res, const Mat &a, const Mat &b)
-    {
-        res = a*b;
-    }
-#endif
-    template <typename Mat>
-    static inline double mulFlops(const Mat &a, const Mat &b)
-    {
-        double nr = a.rows(), nc = a.cols();
-
-        return nr*nr*(6.*nc + 2.*(nc - 1.));
-    }
-private:
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void makeDotRowPt(C * &aPt, unsigned int &aInc, C * &bPt, 
-                                    unsigned int &bInc, const unsigned int aRow, 
-                                    const MatLeft &a, const MatRight &b)
-    {
-        if (MatLeft::Options == Eigen::RowMajor)
-        {
-            aPt  = a.data() + aRow*a.cols();
-            aInc = 1;
-        }
-        else if (MatLeft::Options == Eigen::ColMajor)
-        {
-            aPt  = a.data() + aRow;
-            aInc = a.rows();
-        }
-        if (MatRight::Options == Eigen::RowMajor)
-        {
-            bPt  = b.data() + aRow;
-            bInc = b.cols();
-        }
-        else if (MatRight::Options == Eigen::ColMajor)
-        {
-            bPt  = b.data() + aRow*b.rows();
-            bInc = 1;
-        }
-    }
-
-#ifdef USE_MKL
-    template <typename C, typename MatLeft, typename MatRight>
-    static inline void makeDotColPt(C * &aPt, unsigned int &aInc, C * &bPt, 
-                                    unsigned int &bInc, const unsigned int aCol, 
-                                    const MatLeft &a, const MatRight &b)
-    {
-        if (MatLeft::Options == Eigen::RowMajor)
-        {
-            aPt  = a.data() + aCol;
-            aInc = a.cols();
-        }
-        else if (MatLeft::Options == Eigen::ColMajor)
-        {
-            aPt  = a.data() + aCol*a.rows();
-            aInc = 1;
-        }
-        if (MatRight::Options == Eigen::RowMajor)
-        {
-            bPt  = b.data() + aCol*b.cols();
-            bInc = 1;
-        }
-        else if (MatRight::Options == Eigen::ColMajor)
-        {
-            bPt  = b.data() + aCol;
-            bInc = b.rows();
-        }
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuRow(ComplexF &res, const unsigned int aRow,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexF *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotRowPt(aPt, aInc, bPt, bInc, aRow, a, b);
-        cblas_cdotu_sub(a.cols(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuCol(ComplexF &res, const unsigned int aCol,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexF *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotColPt(aPt, aInc, bPt, bInc, aCol, a, b);
-        cblas_cdotu_sub(a.rows(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuRow(ComplexD &res, const unsigned int aRow,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexD *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotRowPt(aPt, aInc, bPt, bInc, aRow, a, b);
-        cblas_zdotu_sub(a.cols(), aPt, aInc, bPt, bInc, &res);
-    }
-
-    template <typename MatLeft, typename MatRight>
-    static inline void dotuCol(ComplexD &res, const unsigned int aCol,
-                               const MatLeft &a, const MatRight &b)
-    {
-        const ComplexD *aPt, *bPt;
-        unsigned int   aInc, bInc;
-
-        makeDotColPt(aPt, aInc, bPt, bInc, aCol, a, b);
-        cblas_zdotu_sub(a.rows(), aPt, aInc, bPt, bInc, &res);
-    }
-#endif
-};
-
-/******************************************************************************
- *                     A2AMatrixIo template implementation                    *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T>
-A2AMatrixIo<T>::A2AMatrixIo(std::string filename, std::string dataname, 
-                            const unsigned int nt, const unsigned int ni,
-                            const unsigned int nj)
-: filename_(filename), dataname_(dataname)
-, nt_(nt), ni_(ni), nj_(nj)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNt(void) const
-{
-    return nt_;
-}
-
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNi(void) const
-{
-    return ni_;
-}
-
-template <typename T>
-unsigned int A2AMatrixIo<T>::getNj(void) const
-{
-    return nj_;
-}
-
-template <typename T>
-size_t A2AMatrixIo<T>::getSize(void) const
-{
-    return nt_*ni_*nj_*sizeof(T);
-}
-
-// file allocation /////////////////////////////////////////////////////////////
-template <typename T>
-template <typename MetadataType>
-void A2AMatrixIo<T>::initFile(const MetadataType &d, const unsigned int chunkSize)
-{
-#ifdef HAVE_HDF5
-    std::vector<hsize_t>    dim = {static_cast<hsize_t>(nt_), 
-                                   static_cast<hsize_t>(ni_), 
-                                   static_cast<hsize_t>(nj_)},
-                            chunk = {static_cast<hsize_t>(nt_), 
-                                     static_cast<hsize_t>(chunkSize), 
-                                     static_cast<hsize_t>(chunkSize)};
-    H5NS::DataSpace         dataspace(dim.size(), dim.data());
-    H5NS::DataSet           dataset;
-    H5NS::DSetCreatPropList plist;
-    
-    // create empty file just with metadata
-    {
-        Hdf5Writer writer(filename_);
-        write(writer, dataname_, d);
-    }
-
-    // create the dataset
-    Hdf5Reader reader(filename_, false);
-
-    push(reader, dataname_);
-    auto &group = reader.getGroup();
-    plist.setChunk(chunk.size(), chunk.data());
-    plist.setFletcher32();
-    dataset = group.createDataSet(HADRONS_A2AM_NAME, Hdf5Type<T>::type(), dataspace, plist);
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-// block I/O ///////////////////////////////////////////////////////////////////
-template <typename T>
-void A2AMatrixIo<T>::saveBlock(const T *data, 
-                               const unsigned int i, 
-                               const unsigned int j,
-                               const unsigned int blockSizei,
-                               const unsigned int blockSizej)
-{
-#ifdef HAVE_HDF5
-    Hdf5Reader           reader(filename_, false);
-    std::vector<hsize_t> count = {nt_, blockSizei, blockSizej},
-                         offset = {0, static_cast<hsize_t>(i),
-                                   static_cast<hsize_t>(j)},
-                         stride = {1, 1, 1},
-                         block  = {1, 1, 1}; 
-    H5NS::DataSpace      memspace(count.size(), count.data()), dataspace;
-    H5NS::DataSet        dataset;
-    size_t               shift;
-
-    push(reader, dataname_);
-    auto &group = reader.getGroup();
-    dataset     = group.openDataSet(HADRONS_A2AM_NAME);
-    dataspace   = dataset.getSpace();
-    dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data(),
-                              stride.data(), block.data());
-    dataset.write(data, Hdf5Type<T>::type(), memspace, dataspace);
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-template <typename T>
-void A2AMatrixIo<T>::saveBlock(const A2AMatrixSet<T> &m,
-                               const unsigned int ext, const unsigned int str,
-                               const unsigned int i, const unsigned int j)
-{
-    unsigned int blockSizei = m.dimension(3);
-    unsigned int blockSizej = m.dimension(4);
-    unsigned int nstr       = m.dimension(1);
-    size_t       offset     = (ext*nstr + str)*nt_*blockSizei*blockSizej;
-
-    saveBlock(m.data() + offset, i, j, blockSizei, blockSizej);
-}
-
-template <typename T>
-template <template <class> class Vec, typename VecT>
-void A2AMatrixIo<T>::load(Vec<VecT> &v, double *tRead, const bool useCache)
-{
-#ifdef HAVE_HDF5
-    Hdf5Reader           reader(filename_);
-    std::vector<hsize_t> hdim;
-    H5NS::DataSet        dataset;
-    H5NS::DataSpace      dataspace;
-    H5NS::CompType       datatype;
-    
-    push(reader, dataname_);
-    auto &group = reader.getGroup();
-    dataset     = group.openDataSet(HADRONS_A2AM_NAME);
-    datatype    = dataset.getCompType();
-    dataspace   = dataset.getSpace();
-    hdim.resize(dataspace.getSimpleExtentNdims());
-    dataspace.getSimpleExtentDims(hdim.data());
-    if ((nt_*ni_*nj_ != 0) and
-        ((hdim[0] != nt_) or (hdim[1] != ni_) or (hdim[2] != nj_)))
-    {
-        HADRONS_ERROR(Size, "all-to-all matrix size mismatch (got "
-            + std::to_string(hdim[0]) + "x" + std::to_string(hdim[1]) + "x"
-            + std::to_string(hdim[2]) + ", expected "
-            + std::to_string(nt_) + "x" + std::to_string(ni_) + "x"
-            + std::to_string(nj_));
-    }
-    else if (ni_*nj_ == 0)
-    {
-        if (hdim[0] != nt_)
-        {
-            HADRONS_ERROR(Size, "all-to-all time size mismatch (got "
-                + std::to_string(hdim[0]) + ", expected "
-                + std::to_string(nt_) + ")");
-        }
-        ni_ = hdim[1];
-        nj_ = hdim[2];
-    }
-
-    if (useCache)
-    {
-        std::vector<T> buf(nt_*ni_*nj_);
-        T              *pt;
-
-        dataset.read(buf.data(), datatype);
-        pt = buf.data();
-        for (unsigned int t = 0; t < nt_; ++t)
-        {
-            A2AMatrixMap<T> bufMap(pt, ni_, nj_);
-
-            v[t]  = bufMap.template cast<VecT>();
-            pt   += ni_*nj_;
-        }
-    }
-    // if useCache = false, do I/O timeslice per timeslice (much slower)
-    else
-    {
-        A2AMatrix<T>         buf(ni_, nj_);
-        std::vector<hsize_t> count    = {1, static_cast<hsize_t>(ni_),
-                                        static_cast<hsize_t>(nj_)},
-                             stride   = {1, 1, 1},
-                             block    = {1, 1, 1},
-                             memCount = {static_cast<hsize_t>(ni_),
-                                         static_cast<hsize_t>(nj_)};
-        H5NS::DataSpace      memspace(memCount.size(), memCount.data());
-
-        std::cout << "Loading timeslice";
-        std::cout.flush();
-        *tRead = 0.;
-        for (unsigned int tp1 = nt_; tp1 > 0; --tp1)
-        {
-            unsigned int         t      = tp1 - 1;
-            std::vector<hsize_t> offset = {static_cast<hsize_t>(t), 0, 0};
-            
-            if (t % 10 == 0)
-            {
-                std::cout << " " << t;
-                std::cout.flush();
-            }
-            dataspace.selectHyperslab(H5S_SELECT_SET, count.data(), offset.data(),
-                                      stride.data(), block.data());
-            if (tRead) *tRead -= usecond();    
-            dataset.read(buf.data(), datatype, memspace, dataspace);
-            if (tRead) *tRead += usecond();
-            v[t] = buf.template cast<VecT>();
-        }
-        std::cout << std::endl;
-    }
-#else
-    HADRONS_ERROR(Implementation, "all-to-all matrix I/O needs HDF5 library");
-#endif
-}
-
-/******************************************************************************
- *               A2AMatrixBlockComputation template implementation            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::A2AMatrixBlockComputation(GridBase *grid,
-                            const unsigned int orthogDim,
-                            const unsigned int next, 
-                            const unsigned int nstr,
-                            const unsigned int blockSize, 
-                            const unsigned int cacheBlockSize,
-                            TimerArray *tArray)
-: grid_(grid), nt_(grid->GlobalDimensions()[orthogDim]), orthogDim_(orthogDim)
-, next_(next), nstr_(nstr), blockSize_(blockSize), cacheBlockSize_(cacheBlockSize)
-, tArray_(tArray)
-{
-    mCache_.resize(nt_*next_*nstr_*cacheBlockSize_*cacheBlockSize_);
-    mBuf_.resize(nt_*next_*nstr_*blockSize_*blockSize_);
-}
-
-#define START_TIMER(name) if (tArray_) tArray_->startTimer(name)
-#define STOP_TIMER(name)  if (tArray_) tArray_->stopTimer(name)
-#define GET_TIMER(name)   ((tArray_ != nullptr) ? tArray_->getDTimer(name) : 0.)
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-void A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::execute(const std::vector<Field> &left, const std::vector<Field> &right,
-          A2AKernel<T, Field> &kernel, const FilenameFn &ionameFn,
-          const FilenameFn &filenameFn, const MetadataFn &metadataFn)
-{
-    //////////////////////////////////////////////////////////////////////////
-    // i,j   is first  loop over blockSize_ factors
-    // ii,jj is second loop over cacheBlockSize_ factors for high perf contractions
-    // iii,jjj are loops within cacheBlock
-    // Total index is sum of these  i+ii+iii etc...
-    //////////////////////////////////////////////////////////////////////////
-    int    N_i = left.size();
-    int    N_j = right.size();
-    double flops, bytes, t_kernel;
-    double nodes = grid_->NodeCount();
-    
-    int NBlock_i = N_i/blockSize_ + (((N_i % blockSize_) != 0) ? 1 : 0);
-    int NBlock_j = N_j/blockSize_ + (((N_j % blockSize_) != 0) ? 1 : 0);
-
-    for(int i=0;i<N_i;i+=blockSize_)
-    for(int j=0;j<N_j;j+=blockSize_)
-    {
-        // Get the W and V vectors for this block^2 set of terms
-        int N_ii = MIN(N_i-i,blockSize_);
-        int N_jj = MIN(N_j-j,blockSize_);
-        A2AMatrixSet<TIo> mBlock(mBuf_.data(), next_, nstr_, nt_, N_ii, N_jj);
-
-        LOG(Message) << "All-to-all matrix block " 
-                     << j/blockSize_ + NBlock_j*i/blockSize_ + 1 
-                     << "/" << NBlock_i*NBlock_j << " [" << i <<" .. " 
-                     << i+N_ii-1 << ", " << j <<" .. " << j+N_jj-1 << "]" 
-                     << std::endl;
-        // Series of cache blocked chunks of the contractions within this block
-        flops    = 0.0;
-        bytes    = 0.0;
-        t_kernel = 0.0;
-        for(int ii=0;ii<N_ii;ii+=cacheBlockSize_)
-        for(int jj=0;jj<N_jj;jj+=cacheBlockSize_)
-        {
-            double t;
-            int N_iii = MIN(N_ii-ii,cacheBlockSize_);
-            int N_jjj = MIN(N_jj-jj,cacheBlockSize_);
-            A2AMatrixSet<T> mCacheBlock(mCache_.data(), next_, nstr_, nt_, N_iii, N_jjj);
-
-            START_TIMER("kernel");
-            kernel(mCacheBlock, &left[i+ii], &right[j+jj], orthogDim_, t);
-            STOP_TIMER("kernel");
-            t_kernel += t;
-            flops    += kernel.flops(N_iii, N_jjj);
-            bytes    += kernel.bytes(N_iii, N_jjj);
-
-            START_TIMER("cache copy");
-            parallel_for_nest5(int e =0;e<next_;e++)
-            for(int s =0;s< nstr_;s++)
-            for(int t =0;t< nt_;t++)
-            for(int iii=0;iii< N_iii;iii++)
-            for(int jjj=0;jjj< N_jjj;jjj++)
-            {
-                mBlock(e,s,t,ii+iii,jj+jjj) = mCacheBlock(e,s,t,iii,jjj);
-            }
-            STOP_TIMER("cache copy");
-        }
-
-        // perf
-        LOG(Message) << "Kernel perf " << flops/t_kernel/1.0e3/nodes 
-                     << " Gflop/s/node " << std::endl;
-        LOG(Message) << "Kernel perf " << bytes/t_kernel*1.0e6/1024/1024/1024/nodes 
-                     << " GB/s/node "  << std::endl;
-
-        // IO
-        double       blockSize, ioTime;
-        unsigned int myRank = grid_->ThisRank(), nRank  = grid_->RankCount();
-    
-        LOG(Message) << "Writing block to disk" << std::endl;
-        ioTime = -GET_TIMER("IO: write block");
-        START_TIMER("IO: total");
-        makeFileDir(filenameFn(0, 0), grid_);
-#ifdef HADRONS_A2AM_PARALLEL_IO
-        grid_->Barrier();
-        // make task list for current node
-        nodeIo_.clear();
-        for(int f = myRank; f < next_*nstr_; f += nRank)
-        {
-            IoHelper h;
-
-            h.i  = i;
-            h.j  = j;
-            h.e  = f/nstr_;
-            h.s  = f % nstr_;
-            h.io = A2AMatrixIo<TIo>(filenameFn(h.e, h.s), 
-                                    ionameFn(h.e, h.s), nt_, N_i, N_j);
-            h.md = metadataFn(h.e, h.s);
-            nodeIo_.push_back(h);
-        }
-        // parallel IO
-        for (auto &h: nodeIo_)
-        {
-            saveBlock(mBlock, h);
-        }
-        grid_->Barrier();
-#else
-        // serial IO, for testing purposes only
-        for(int e = 0; e < next_; e++)
-        for(int s = 0; s < nstr_; s++)
-        {
-            IoHelper h;
-
-            h.i  = i;
-            h.j  = j;
-            h.e  = e;
-            h.s  = s;
-            h.io = A2AMatrixIo<TIo>(filenameFn(h.e, h.s), 
-                                    ionameFn(h.e, h.s), nt_, N_i, N_j);
-            h.md = metadataFn(h.e, h.s);
-            saveBlock(mfBlock, h);
-        }
-#endif
-        STOP_TIMER("IO: total");
-        blockSize  = static_cast<double>(next_*nstr_*nt_*N_ii*N_jj*sizeof(TIo));
-        ioTime    += GET_TIMER("IO: write block");
-        LOG(Message) << "HDF5 IO done " << sizeString(blockSize) << " in "
-                     << ioTime  << " us (" 
-                     << blockSize/ioTime*1.0e6/1024/1024
-                     << " MB/s)" << std::endl;
-    }
-}
-
-// I/O handler /////////////////////////////////////////////////////////////////
-template <typename T, typename Field, typename MetadataType, typename TIo>
-void A2AMatrixBlockComputation<T, Field, MetadataType, TIo>
-::saveBlock(const A2AMatrixSet<TIo> &m, IoHelper &h)
-{
-    if ((h.i == 0) and (h.j == 0))
-    {
-        START_TIMER("IO: file creation");
-        h.io.initFile(h.md, blockSize_);
-        STOP_TIMER("IO: file creation");
-    }
-    START_TIMER("IO: write block");
-    h.io.saveBlock(m, h.e, h.s, h.i, h.j);
-    STOP_TIMER("IO: write block");
-}
-
-#undef START_TIMER
-#undef STOP_TIMER
-#undef GET_TIMER
-
-END_HADRONS_NAMESPACE
-
-#endif // A2A_Matrix_hpp_

Hadrons/A2AVectors.hpp

@@ -1,342 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/A2AVectors.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: fionnoh <fionnoh@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef A2A_Vectors_hpp_
-#define A2A_Vectors_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Environment.hpp>
-#include <Hadrons/Solver.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                 Class to generate V & W all-to-all vectors                 *
- ******************************************************************************/
-template <typename FImpl>
-class A2AVectorsSchurDiagTwo
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    SOLVER_TYPE_ALIASES(FImpl,);
-public:
-    A2AVectorsSchurDiagTwo(FMat &action, Solver &solver);
-    virtual ~A2AVectorsSchurDiagTwo(void) = default;
-    void makeLowModeV(FermionField &vout, 
-                      const FermionField &evec, const Real &eval);
-    void makeLowModeV5D(FermionField &vout_4d, FermionField &vout_5d, 
-                        const FermionField &evec, const Real &eval);
-    void makeLowModeW(FermionField &wout, 
-                      const FermionField &evec, const Real &eval);
-    void makeLowModeW5D(FermionField &wout_4d, FermionField &wout_5d, 
-                        const FermionField &evec, const Real &eval);
-    void makeHighModeV(FermionField &vout, const FermionField &noise);
-    void makeHighModeV5D(FermionField &vout_4d, FermionField &vout_5d, 
-                         const FermionField &noise_5d);
-    void makeHighModeW(FermionField &wout, const FermionField &noise);
-    void makeHighModeW5D(FermionField &vout_5d, FermionField &wout_5d, 
-                         const FermionField &noise_5d);
-private:
-    FMat                                     &action_;
-    Solver                                   &solver_;
-    GridBase                                 *fGrid_, *frbGrid_, *gGrid_;
-    bool                                     is5d_;
-    FermionField                             src_o_, sol_e_, sol_o_, tmp_, tmp5_;
-    SchurDiagTwoOperator<FMat, FermionField> op_;
-};
-
-/******************************************************************************
- *                  Methods for V & W all-to-all vectors I/O                  *
- ******************************************************************************/
-class A2AVectorsIo
-{
-public:
-    struct Record: Serializable
-    {
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Record,
-                                        unsigned int, index);
-        Record(void): index(0) {}
-    };
-public:
-    template <typename Field>
-    static void write(const std::string fileStem, std::vector<Field> &vec, 
-                      const bool multiFile, const int trajectory = -1);
-    template <typename Field>
-    static void read(std::vector<Field> &vec, const std::string fileStem,
-                     const bool multiFile, const int trajectory = -1);
-private:
-    static inline std::string vecFilename(const std::string stem, const int traj, 
-                                          const bool multiFile)
-    {
-        std::string t = (traj < 0) ? "" : ("." + std::to_string(traj));
-
-        if (multiFile)
-        {
-            return stem + t;
-        }
-        else
-        {
-            return stem + t + ".bin";
-        }
-    }
-};
-
-/******************************************************************************
- *               A2AVectorsSchurDiagTwo template implementation               *
- ******************************************************************************/
-template <typename FImpl>
-A2AVectorsSchurDiagTwo<FImpl>::A2AVectorsSchurDiagTwo(FMat &action, Solver &solver)
-: action_(action)
-, solver_(solver)
-, fGrid_(action_.FermionGrid())
-, frbGrid_(action_.FermionRedBlackGrid())
-, gGrid_(action_.GaugeGrid())
-, src_o_(frbGrid_)
-, sol_e_(frbGrid_)
-, sol_o_(frbGrid_)
-, tmp_(frbGrid_)
-, tmp5_(fGrid_)
-, op_(action_)
-{}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeV(FermionField &vout, const FermionField &evec, const Real &eval)
-{
-    src_o_ = evec;
-    src_o_.checkerboard = Odd;
-    pickCheckerboard(Even, sol_e_, vout);
-    pickCheckerboard(Odd, sol_o_, vout);
-
-    /////////////////////////////////////////////////////
-    // v_ie = -(1/eval_i) * MeeInv Meo MooInv evec_i
-    /////////////////////////////////////////////////////
-    action_.MooeeInv(src_o_, tmp_);
-    assert(tmp_.checkerboard == Odd);
-    action_.Meooe(tmp_, sol_e_);
-    assert(sol_e_.checkerboard == Even);
-    action_.MooeeInv(sol_e_, tmp_);
-    assert(tmp_.checkerboard == Even);
-    sol_e_ = (-1.0 / eval) * tmp_;
-    assert(sol_e_.checkerboard == Even);
-
-    /////////////////////////////////////////////////////
-    // v_io = (1/eval_i) * MooInv evec_i
-    /////////////////////////////////////////////////////
-    action_.MooeeInv(src_o_, tmp_);
-    assert(tmp_.checkerboard == Odd);
-    sol_o_ = (1.0 / eval) * tmp_;
-    assert(sol_o_.checkerboard == Odd);
-    setCheckerboard(vout, sol_e_);
-    assert(sol_e_.checkerboard == Even);
-    setCheckerboard(vout, sol_o_);
-    assert(sol_o_.checkerboard == Odd);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeV5D(FermionField &vout_4d, FermionField &vout_5d, const FermionField &evec, const Real &eval)
-{
-    makeLowModeV(vout_5d, evec, eval);
-    action_.ExportPhysicalFermionSolution(vout_5d, vout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeW(FermionField &wout, const FermionField &evec, const Real &eval)
-{
-    src_o_ = evec;
-    src_o_.checkerboard = Odd;
-    pickCheckerboard(Even, sol_e_, wout);
-    pickCheckerboard(Odd, sol_o_, wout);
-
-    /////////////////////////////////////////////////////
-    // w_ie = - MeeInvDag MoeDag Doo evec_i
-    /////////////////////////////////////////////////////
-    op_.Mpc(src_o_, tmp_);
-    assert(tmp_.checkerboard == Odd);
-    action_.MeooeDag(tmp_, sol_e_);
-    assert(sol_e_.checkerboard == Even);
-    action_.MooeeInvDag(sol_e_, tmp_);
-    assert(tmp_.checkerboard == Even);
-    sol_e_ = (-1.0) * tmp_;
-
-    /////////////////////////////////////////////////////
-    // w_io = Doo evec_i
-    /////////////////////////////////////////////////////
-    op_.Mpc(src_o_, sol_o_);
-    assert(sol_o_.checkerboard == Odd);
-    setCheckerboard(wout, sol_e_);
-    assert(sol_e_.checkerboard == Even);
-    setCheckerboard(wout, sol_o_);
-    assert(sol_o_.checkerboard == Odd);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeLowModeW5D(FermionField &wout_4d, 
-                                                   FermionField &wout_5d, 
-                                                   const FermionField &evec, 
-                                                   const Real &eval)
-{
-    makeLowModeW(tmp5_, evec, eval);
-    action_.DminusDag(tmp5_, wout_5d);
-    action_.ExportPhysicalFermionSource(wout_5d, wout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeV(FermionField &vout, 
-                                                  const FermionField &noise)
-{
-    solver_(vout, noise);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeV5D(FermionField &vout_4d, 
-                                                    FermionField &vout_5d, 
-                                                    const FermionField &noise)
-{
-    if (noise._grid->Dimensions() == fGrid_->Dimensions() - 1)
-    {
-        action_.ImportPhysicalFermionSource(noise, tmp5_);
-    }
-    else
-    {
-        tmp5_ = noise;
-    }
-    makeHighModeV(vout_5d, tmp5_);
-    action_.ExportPhysicalFermionSolution(vout_5d, vout_4d);
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeW(FermionField &wout, 
-                                                  const FermionField &noise)
-{
-    wout = noise;
-}
-
-template <typename FImpl>
-void A2AVectorsSchurDiagTwo<FImpl>::makeHighModeW5D(FermionField &wout_4d, 
-                                                    FermionField &wout_5d, 
-                                                    const FermionField &noise)
-{
-    if (noise._grid->Dimensions() == fGrid_->Dimensions() - 1)
-    {
-        action_.ImportUnphysicalFermion(noise, wout_5d);
-        wout_4d = noise;
-    }
-    else
-    {
-        wout_5d = noise;
-        action_.ExportPhysicalFermionSource(wout_5d, wout_4d);
-    }
-}
-
-/******************************************************************************
- *               all-to-all vectors I/O template implementation               *
- ******************************************************************************/
-template <typename Field>
-void A2AVectorsIo::write(const std::string fileStem, std::vector<Field> &vec, 
-                         const bool multiFile, const int trajectory)
-{
-    Record       record;
-    GridBase     *grid = vec[0]._grid;
-    ScidacWriter binWriter(grid->IsBoss());
-    std::string  filename = vecFilename(fileStem, trajectory, multiFile);
-
-    if (multiFile)
-    {
-        std::string fullFilename;
-
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            fullFilename = filename + "/elem" + std::to_string(i) + ".bin";
-
-            LOG(Message) << "Writing vector " << i << std::endl;
-            makeFileDir(fullFilename, grid);
-            binWriter.open(fullFilename);
-            record.index = i;
-            binWriter.writeScidacFieldRecord(vec[i], record);
-            binWriter.close();
-        }
-    }
-    else
-    {
-        makeFileDir(filename, grid);
-        binWriter.open(filename);
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            LOG(Message) << "Writing vector " << i << std::endl;
-            record.index = i;
-            binWriter.writeScidacFieldRecord(vec[i], record);
-        }
-        binWriter.close();
-    }
-}
-
-template <typename Field>
-void A2AVectorsIo::read(std::vector<Field> &vec, const std::string fileStem, 
-                        const bool multiFile, const int trajectory)
-{
-    Record       record;
-    ScidacReader binReader;
-    std::string  filename = vecFilename(fileStem, trajectory, multiFile);
-
-    if (multiFile)
-    {
-        std::string fullFilename;
-
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            fullFilename = filename + "/elem" + std::to_string(i) + ".bin";
-
-            LOG(Message) << "Reading vector " << i << std::endl;
-            binReader.open(fullFilename);
-            binReader.readScidacFieldRecord(vec[i], record);
-            binReader.close();
-            if (record.index != i)
-            {
-                HADRONS_ERROR(Io, "vector index mismatch");
-            }
-        }
-    }
-    else
-    {
-        binReader.open(filename);
-        for (unsigned int i = 0; i < vec.size(); ++i)
-        {
-            LOG(Message) << "Reading vector " << i << std::endl;
-            binReader.readScidacFieldRecord(vec[i], record);
-            if (record.index != i)
-            {
-                HADRONS_ERROR(Io, "vector index mismatch");
-            }
-        }
-        binReader.close();
-    }
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // A2A_Vectors_hpp_

Hadrons/DilutedNoise.hpp

@@ -1,249 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/DilutedNoise.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_DilutedNoise_hpp_
-#define Hadrons_DilutedNoise_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                   Abstract container for diluted noise                     *
- ******************************************************************************/
-template <typename FImpl>
-class DilutedNoise
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    DilutedNoise(GridCartesian *g);
-    DilutedNoise(GridCartesian *g, const unsigned int nNoise);
-    virtual ~DilutedNoise(void) = default;
-    // access
-    std::vector<FermionField> &       getNoise(void);
-    const std::vector<FermionField> & getNoise(void) const;
-    const FermionField &              operator[](const unsigned int i) const;
-    FermionField &                    operator[](const unsigned int i);
-    void                              resize(const unsigned int nNoise);
-    unsigned int                      size(void) const;
-    GridCartesian                     *getGrid(void) const;
-    // generate noise (pure virtual)
-    virtual void generateNoise(GridParallelRNG &rng) = 0;
-private:
-    std::vector<FermionField> noise_;
-    GridCartesian             *grid_;
-    unsigned int              nNoise_;
-};
-
-template <typename FImpl>
-class TimeDilutedSpinColorDiagonalNoise: public DilutedNoise<FImpl>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    TimeDilutedSpinColorDiagonalNoise(GridCartesian *g);
-    virtual ~TimeDilutedSpinColorDiagonalNoise(void) = default;
-    // generate noise
-    virtual void generateNoise(GridParallelRNG &rng);
-private:
-    unsigned int nt_;
-};
-
-template <typename FImpl>
-class FullVolumeSpinColorDiagonalNoise: public DilutedNoise<FImpl>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    // constructor/destructor
-    FullVolumeSpinColorDiagonalNoise(GridCartesian *g, unsigned int n_src);
-    virtual ~FullVolumeSpinColorDiagonalNoise(void) = default;
-    // generate noise
-    virtual void generateNoise(GridParallelRNG &rng);
-private:
-    unsigned int nSrc_;
-};
-
-
-/******************************************************************************
- *                    DilutedNoise template implementation                    *
- ******************************************************************************/
-template <typename FImpl>
-DilutedNoise<FImpl>::DilutedNoise(GridCartesian *g)
-: grid_(g)
-{}
-
-template <typename FImpl>
-DilutedNoise<FImpl>::DilutedNoise(GridCartesian *g,
-                                  const unsigned int nNoise)
-: DilutedNoise(g)
-{
-    resize(nNoise);
-}
-
-template <typename FImpl>
-std::vector<typename DilutedNoise<FImpl>::FermionField> & DilutedNoise<FImpl>::
-getNoise(void)
-{
-    return noise_;
-}
-
-template <typename FImpl>
-const std::vector<typename DilutedNoise<FImpl>::FermionField> & DilutedNoise<FImpl>::
-getNoise(void) const
-{
-    return noise_;
-}
-
-template <typename FImpl>
-const typename DilutedNoise<FImpl>::FermionField & 
-DilutedNoise<FImpl>::operator[](const unsigned int i) const
-{
-    return noise_[i];
-}
-
-template <typename FImpl>
-typename DilutedNoise<FImpl>::FermionField & 
-DilutedNoise<FImpl>::operator[](const unsigned int i)
-{
-    return noise_[i];
-}
-
-template <typename FImpl>
-void DilutedNoise<FImpl>::resize(const unsigned int nNoise)
-{
-    nNoise_ = nNoise;
-    noise_.resize(nNoise, grid_);
-}
-
-template <typename FImpl>
-unsigned int DilutedNoise<FImpl>::size(void) const
-{  
-    return noise_.size();
-}
-
-template <typename FImpl>
-GridCartesian * DilutedNoise<FImpl>::getGrid(void) const
-{
-    return grid_;
-}
-
-/******************************************************************************
- *        TimeDilutedSpinColorDiagonalNoise template implementation           *
- ******************************************************************************/
-template <typename FImpl>
-TimeDilutedSpinColorDiagonalNoise<FImpl>::
-TimeDilutedSpinColorDiagonalNoise(GridCartesian *g)
-: DilutedNoise<FImpl>(g)
-{
-    nt_ = this->getGrid()->GlobalDimensions().back();
-    this->resize(nt_*Ns*FImpl::Dimension);
-}
-
-template <typename FImpl>
-void TimeDilutedSpinColorDiagonalNoise<FImpl>::generateNoise(GridParallelRNG &rng)
-{
-    typedef decltype(peekColour((*this)[0], 0)) SpinField;
-
-    auto                       &noise = *this;
-    auto                       g      = this->getGrid();
-    auto                       nd     = g->GlobalDimensions().size();
-    auto                       nc     = FImpl::Dimension;
-    Complex                    shift(1., 1.);
-    Lattice<iScalar<vInteger>> tLat(g);
-    LatticeComplex             eta(g), etaCut(g);
-    SpinField                  etas(g);
-    unsigned int               i = 0;
-
-    LatticeCoordinate(tLat, nd - 1);
-    bernoulli(rng, eta);
-    eta = (2.*eta - shift)*(1./::sqrt(2.));
-    for (unsigned int t = 0; t < nt_; ++t)
-    {
-        etaCut = where((tLat == t), eta, 0.*eta);
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-            etas = zero;
-            pokeSpin(etas, etaCut, s);
-            for (unsigned int c = 0; c < nc; ++c)
-            {
-                noise[i] = zero;
-                pokeColour(noise[i], etas, c);
-                i++;
-            }
-        }
-    }
-}
-
-/******************************************************************************
- *        FullVolumeSpinColorDiagonalNoise template implementation           *
- ******************************************************************************/
-template <typename FImpl>
-FullVolumeSpinColorDiagonalNoise<FImpl>::
-FullVolumeSpinColorDiagonalNoise(GridCartesian *g, unsigned int nSrc)
-: DilutedNoise<FImpl>(g, nSrc*Ns*FImpl::Dimension), nSrc_(nSrc)
-{}
-
-template <typename FImpl>
-void FullVolumeSpinColorDiagonalNoise<FImpl>::generateNoise(GridParallelRNG &rng)
-{
-    typedef decltype(peekColour((*this)[0], 0)) SpinField;
-
-    auto                       &noise = *this;
-    auto                       g      = this->getGrid();
-    auto                       nd     = g->GlobalDimensions().size();
-    auto                       nc     = FImpl::Dimension;
-    Complex                    shift(1., 1.);
-    LatticeComplex             eta(g);
-    SpinField                  etas(g);
-    unsigned int               i = 0;
-
-    bernoulli(rng, eta);
-    eta = (2.*eta - shift)*(1./::sqrt(2.));
-    for (unsigned int n = 0; n < nSrc_; ++n)
-    {
-        for (unsigned int s = 0; s < Ns; ++s)
-        {
-            etas = zero;
-            pokeSpin(etas, eta, s);
-            for (unsigned int c = 0; c < nc; ++c)
-            {
-                noise[i] = zero;
-                pokeColour(noise[i], etas, c);
-                i++;
-            }
-        }
-    }
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_DilutedNoise_hpp_

Hadrons/DiskVector.hpp

@@ -1,442 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/DiskVector.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_DiskVector_hpp_
-#define Hadrons_DiskVector_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-#include <deque>
-#include <sys/stat.h>
-#include <ftw.h>
-#include <unistd.h>
-
-#ifdef DV_DEBUG
-#define DV_DEBUG_MSG(dv, stream) LOG(Debug) << "diskvector " << (dv) << ": " << stream << std::endl
-#else
-#define DV_DEBUG_MSG(dv, stream)
-#endif
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                           Abstract base class                              *
- ******************************************************************************/
-template <typename T>
-class DiskVectorBase
-{
-public:
-    typedef T ObjectType;
-
-    // helper for read/write vector access
-    class RwAccessHelper
-    {
-    public:
-        RwAccessHelper(DiskVectorBase<T> &master, const unsigned int i)
-        : master_(master), cmaster_(master), i_(i) {}
-
-        // operator=: somebody is trying to store a vector element
-        // write to cache and tag as modified
-        T &operator=(const T &obj) const
-        {
-            auto &cache    = *master_.cachePtr_;
-            auto &modified = *master_.modifiedPtr_;
-            auto &index    = *master_.indexPtr_;
-
-            DV_DEBUG_MSG(&master_, "writing to " << i_);
-            master_.cacheInsert(i_, obj);
-            modified[index.at(i_)] = true;
-            
-            return cache[index.at(i_)];
-        }
-
-        // implicit cast to const object reference and redirection
-        // to the const operator[] for read-only operations
-        operator const T&() const
-        {
-            return cmaster_[i_];
-        }
-    private:
-        DiskVectorBase<T>       &master_;
-        const DiskVectorBase<T> &cmaster_;
-        const unsigned int      i_;
-    };
-public:
-    DiskVectorBase(const std::string dirname, const unsigned int size = 0,
-                   const unsigned int cacheSize = 1, const bool clean = true);
-    DiskVectorBase(DiskVectorBase<T> &&v) = default;
-    virtual ~DiskVectorBase(void);
-    const T & operator[](const unsigned int i) const;
-    RwAccessHelper operator[](const unsigned int i);
-    double hitRatio(void) const;
-    void resetStat(void);
-private:
-    virtual void load(T &obj, const std::string filename) const = 0;
-    virtual void save(const std::string filename, const T &obj) const = 0;
-    virtual std::string filename(const unsigned int i) const;
-    void evict(void) const;
-    void fetch(const unsigned int i) const;
-    void cacheInsert(const unsigned int i, const T &obj) const;
-    void clean(void);
-private:
-    std::string                                           dirname_;
-    unsigned int                                          size_, cacheSize_;
-    double                                                access_{0.}, hit_{0.};
-    bool                                                  clean_;
-    // using pointers to allow modifications when class is const
-    // semantic: const means data unmodified, but cache modification allowed
-    std::unique_ptr<std::vector<T>>                       cachePtr_;
-    std::unique_ptr<std::vector<bool>>                    modifiedPtr_;
-    std::unique_ptr<std::map<unsigned int, unsigned int>> indexPtr_;
-    std::unique_ptr<std::stack<unsigned int>>             freePtr_;
-    std::unique_ptr<std::deque<unsigned int>>             loadsPtr_;                
-};
-
-/******************************************************************************
- *                   Specialisation for serialisable classes                  *
- ******************************************************************************/
-template <typename T, typename Reader, typename Writer>
-class SerializableDiskVector: public DiskVectorBase<T>
-{
-public:
-    using DiskVectorBase<T>::DiskVectorBase;
-private:
-    virtual void load(T &obj, const std::string filename) const
-    {
-        Reader reader(filename);
-
-        read(reader, basename(filename), obj);
-    }
-
-    virtual void save(const std::string filename, const T &obj) const
-    {
-        Writer writer(filename);
-
-        write(writer, basename(filename), obj);
-    }
-};
-
-/******************************************************************************
- *                      Specialisation for Eigen matrices                     *
- ******************************************************************************/
-template <typename T>
-using EigenDiskVectorMat = A2AMatrix<T>;
-
-template <typename T>
-class EigenDiskVector: public DiskVectorBase<EigenDiskVectorMat<T>>
-{
-public:
-    using DiskVectorBase<EigenDiskVectorMat<T>>::DiskVectorBase;
-    typedef EigenDiskVectorMat<T> Matrix;
-public:
-    T operator()(const unsigned int i, const Eigen::Index j,
-                 const Eigen::Index k) const
-    {
-        return (*this)[i](j, k);
-    }
-private:
-    virtual void load(EigenDiskVectorMat<T> &obj, const std::string filename) const
-    {
-        std::ifstream f(filename, std::ios::binary);
-        uint32_t      crc, check;
-        Eigen::Index  nRow, nCol;
-        size_t        matSize;
-        double        tRead, tHash;
-
-        f.read(reinterpret_cast<char *>(&crc), sizeof(crc));
-        f.read(reinterpret_cast<char *>(&nRow), sizeof(nRow));
-        f.read(reinterpret_cast<char *>(&nCol), sizeof(nCol));
-        obj.resize(nRow, nCol);
-        matSize = nRow*nCol*sizeof(T);
-        tRead  = -usecond();
-        f.read(reinterpret_cast<char *>(obj.data()), matSize);
-        tRead += usecond();
-        tHash  = -usecond();
-#ifdef USE_IPP
-        check  = GridChecksum::crc32c(obj.data(), matSize);
-#else
-        check  = GridChecksum::crc32(obj.data(), matSize);
-#endif
-        tHash += usecond();
-        DV_DEBUG_MSG(this, "Eigen read " << tRead/1.0e6 << " sec " << matSize/tRead*1.0e6/1024/1024 << " MB/s");
-        DV_DEBUG_MSG(this, "Eigen crc32 " << std::hex << check << std::dec 
-                     << " " << tHash/1.0e6 << " sec " << matSize/tHash*1.0e6/1024/1024 << " MB/s");
-        if (crc != check)
-        {
-            HADRONS_ERROR(Io, "checksum failed")
-        }
-    }
-
-    virtual void save(const std::string filename, const EigenDiskVectorMat<T> &obj) const
-    {
-        std::ofstream f(filename, std::ios::binary);
-        uint32_t      crc;
-        Eigen::Index  nRow, nCol;
-        size_t        matSize;
-        double        tWrite, tHash;
-        
-        nRow    = obj.rows();
-        nCol    = obj.cols();
-        matSize = nRow*nCol*sizeof(T);
-        tHash   = -usecond();
-#ifdef USE_IPP
-        crc     = GridChecksum::crc32c(obj.data(), matSize);
-#else
-        crc     = GridChecksum::crc32(obj.data(), matSize);
-#endif
-        tHash  += usecond();
-        f.write(reinterpret_cast<char *>(&crc), sizeof(crc));
-        f.write(reinterpret_cast<char *>(&nRow), sizeof(nRow));
-        f.write(reinterpret_cast<char *>(&nCol), sizeof(nCol));
-        tWrite = -usecond();
-        f.write(reinterpret_cast<const char *>(obj.data()), matSize);
-        tWrite += usecond();
-        DV_DEBUG_MSG(this, "Eigen write " << tWrite/1.0e6 << " sec " << matSize/tWrite*1.0e6/1024/1024 << " MB/s");
-        DV_DEBUG_MSG(this, "Eigen crc32 " << std::hex << crc << std::dec
-                     << " " << tHash/1.0e6 << " sec " << matSize/tHash*1.0e6/1024/1024 << " MB/s");
-    }
-};
-
-/******************************************************************************
- *                       DiskVectorBase implementation                         *
- ******************************************************************************/
-template <typename T>
-DiskVectorBase<T>::DiskVectorBase(const std::string dirname, 
-                                  const unsigned int size,
-                                  const unsigned int cacheSize,
-                                  const bool clean)
-: dirname_(dirname), size_(size), cacheSize_(cacheSize), clean_(clean)
-, cachePtr_(new std::vector<T>(size))
-, modifiedPtr_(new std::vector<bool>(size, false))
-, indexPtr_(new std::map<unsigned int, unsigned int>())
-, freePtr_(new std::stack<unsigned int>)
-, loadsPtr_(new std::deque<unsigned int>())
-{
-    struct stat s;
-
-    if(stat(dirname.c_str(), &s) == 0)
-    {
-        HADRONS_ERROR(Io, "directory '" + dirname + "' already exists")
-    }
-    mkdir(dirname);
-    for (unsigned int i = 0; i < cacheSize_; ++i)
-    {
-        freePtr_->push(i);
-    }
-}
-
-template <typename T>
-DiskVectorBase<T>::~DiskVectorBase(void)
-{
-    if (clean_)
-    {
-        clean();
-    }
-}
-
-template <typename T>
-const T & DiskVectorBase<T>::operator[](const unsigned int i) const
-{
-    auto &cache   = *cachePtr_;
-    auto &index   = *indexPtr_;
-    auto &freeInd = *freePtr_;
-    auto &loads   = *loadsPtr_;
-
-    DV_DEBUG_MSG(this, "accessing " << i << " (RO)");
-
-    if (i >= size_)
-    {
-        HADRONS_ERROR(Size, "index out of range");
-    }
-    const_cast<double &>(access_)++;
-    if (index.find(i) == index.end())
-    {
-        // cache miss
-        DV_DEBUG_MSG(this, "cache miss");
-        fetch(i);
-    }
-    else
-    {
-        DV_DEBUG_MSG(this, "cache hit");
-
-        auto pos = std::find(loads.begin(), loads.end(), i);
-
-        const_cast<double &>(hit_)++;
-        loads.erase(pos);
-        loads.push_back(i);
-    }
-
-#ifdef DV_DEBUG
-    std::string msg;
-
-    for (auto &p: loads)
-    {
-        msg += std::to_string(p) + " ";
-    }
-    DV_DEBUG_MSG(this, "in cache: " << msg);
-#endif
-
-    return cache[index.at(i)];
-}
-
-template <typename T>
-typename DiskVectorBase<T>::RwAccessHelper DiskVectorBase<T>::operator[](const unsigned int i)
-{
-    DV_DEBUG_MSG(this, "accessing " << i << " (RW)");
-
-    if (i >= size_)
-    {
-        HADRONS_ERROR(Size, "index out of range");
-    }
-
-    return RwAccessHelper(*this, i);
-}
-
-template <typename T>
-double DiskVectorBase<T>::hitRatio(void) const
-{
-    return hit_/access_;
-}
-
-template <typename T>
-void DiskVectorBase<T>::resetStat(void)
-{
-    access_ = 0.;
-    hit_    = 0.;
-}
-
-template <typename T>
-std::string DiskVectorBase<T>::filename(const unsigned int i) const
-{
-    return dirname_ + "/elem_" + std::to_string(i);
-}
-
-template <typename T>
-void DiskVectorBase<T>::evict(void) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    if (index.size() >= cacheSize_)
-    {
-        unsigned int i = loads.front();
-        
-        DV_DEBUG_MSG(this, "evicting " << i);
-        if (modified[index.at(i)])
-        {
-            DV_DEBUG_MSG(this, "element " << i << " modified, saving to disk");
-            save(filename(i), cache[index.at(i)]);
-        }
-        freeInd.push(index.at(i));
-        index.erase(i);
-        loads.pop_front();
-    }
-}
-
-template <typename T>
-void DiskVectorBase<T>::fetch(const unsigned int i) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    struct stat s;
-
-    DV_DEBUG_MSG(this, "loading " << i << " from disk");
-
-    evict();
-    
-    if(stat(filename(i).c_str(), &s) != 0)
-    {
-        HADRONS_ERROR(Io, "disk vector element " + std::to_string(i) + " uninitialised");
-    }
-    index[i] = freeInd.top();
-    freeInd.pop();
-    load(cache[index.at(i)], filename(i));
-    loads.push_back(i);
-    modified[index.at(i)] = false;
-}
-
-template <typename T>
-void DiskVectorBase<T>::cacheInsert(const unsigned int i, const T &obj) const
-{
-    auto &cache    = *cachePtr_;
-    auto &modified = *modifiedPtr_;
-    auto &index    = *indexPtr_;
-    auto &freeInd  = *freePtr_;
-    auto &loads    = *loadsPtr_;
-
-    evict();
-    index[i] = freeInd.top();
-    freeInd.pop();
-    cache[index.at(i)] = obj;
-    loads.push_back(i);
-    modified[index.at(i)] = false;
-
-#ifdef DV_DEBUG
-    std::string msg;
-
-    for (auto &p: loads)
-    {
-        msg += std::to_string(p) + " ";
-    }
-    DV_DEBUG_MSG(this, "in cache: " << msg);
-#endif
-}
-
-#ifdef DV_DEBUG
-#undef DV_DEBUG_MSG
-#endif
-
-template <typename T>
-void DiskVectorBase<T>::clean(void)
-{
-    auto unlink = [](const char *fpath, const struct stat *sb, 
-                     int typeflag, struct FTW *ftwbuf)
-    {
-        int rv = remove(fpath);
-
-        if (rv)
-        {
-            HADRONS_ERROR(Io, "cannot remove '" + std::string(fpath) + "': "
-                          + std::string(std::strerror(errno)));
-        }
-
-        return rv;
-    };
-
-    nftw(dirname_.c_str(), unlink, 64, FTW_DEPTH | FTW_PHYS);
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_DiskVector_hpp_

Hadrons/EigenPack.hpp

@@ -1,414 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/EigenPack.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_EigenPack_hpp_
-#define Hadrons_EigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Grid/algorithms/iterative/Deflation.h>
-#include <Grid/algorithms/iterative/LocalCoherenceLanczos.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-// Lanczos type
-#ifndef HADRONS_DEFAULT_LANCZOS_NBASIS
-#define HADRONS_DEFAULT_LANCZOS_NBASIS 60
-#endif
-
-#define HADRONS_DUMP_EP_METADATA(record) \
-LOG(Message) << "Eigenpack metadata:" << std::endl;\
-LOG(Message) << "* operator" << std::endl;\
-LOG(Message) << (record).operatorXml << std::endl;\
-LOG(Message) << "* solver" << std::endl;\
-LOG(Message) << (record).solverXml << std::endl;
-
-struct PackRecord
-{
-    std::string operatorXml, solverXml;
-};
-
-struct VecRecord: Serializable
-{
-    GRID_SERIALIZABLE_CLASS_MEMBERS(VecRecord,
-                                    unsigned int, index,
-                                    double,       eval);
-    VecRecord(void): index(0), eval(0.) {}
-};
-
-namespace EigenPackIo
-{
-    inline void readHeader(PackRecord &record, ScidacReader &binReader)
-    {
-        std::string recordXml;
-
-        binReader.readLimeObject(recordXml, SCIDAC_FILE_XML);
-        XmlReader xmlReader(recordXml, true, "eigenPackPar");
-        xmlReader.push();
-        xmlReader.readCurrentSubtree(record.operatorXml);
-        xmlReader.nextElement();
-        xmlReader.readCurrentSubtree(record.solverXml);
-    }
-
-    template <typename T, typename TIo = T>
-    void readElement(T &evec, RealD &eval, const unsigned int index,
-                     ScidacReader &binReader, TIo *ioBuf = nullptr)
-    {
-        VecRecord vecRecord;
-
-        LOG(Message) << "Reading eigenvector " << index << std::endl;
-        if (ioBuf == nullptr)
-        {
-            binReader.readScidacFieldRecord(evec, vecRecord);
-        }
-        else
-        {
-            binReader.readScidacFieldRecord(*ioBuf, vecRecord);
-            precisionChange(evec, *ioBuf);
-        }
-        if (vecRecord.index != index)
-        {
-            HADRONS_ERROR(Io, "Eigenvector " + std::to_string(index) + " has a"
-                            + " wrong index (expected " + std::to_string(vecRecord.index) 
-                            + ")");
-        }
-        eval = vecRecord.eval;
-    }
-
-    template <typename T, typename TIo = T>
-    static void readPack(std::vector<T> &evec, std::vector<RealD> &eval,
-                         PackRecord &record, const std::string filename, 
-                         const unsigned int size, bool multiFile, 
-                         GridBase *gridIo = nullptr)
-    {
-        std::unique_ptr<TIo> ioBuf{nullptr};
-        ScidacReader         binReader;
-
-        if (typeHash<T>() != typeHash<TIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-            ioBuf.reset(new TIo(gridIo));
-        }
-        if (multiFile)
-        {
-            std::string fullFilename;
-
-            for(int k = 0; k < size; ++k) 
-            {
-                fullFilename = filename + "/v" + std::to_string(k) + ".bin";
-                binReader.open(fullFilename);
-                readHeader(record, binReader);
-                readElement(evec[k], eval[k], k, binReader, ioBuf.get());
-                binReader.close();
-            }
-        }
-        else
-        {
-            binReader.open(filename);
-            readHeader(record, binReader);
-            for(int k = 0; k < size; ++k) 
-            {
-                readElement(evec[k], eval[k], k, binReader, ioBuf.get());
-            }
-            binReader.close();
-        }
-    }
-
-    inline void writeHeader(ScidacWriter &binWriter, PackRecord &record)
-    {
-        XmlWriter xmlWriter("", "eigenPackPar");
-
-        xmlWriter.pushXmlString(record.operatorXml);
-        xmlWriter.pushXmlString(record.solverXml);
-        binWriter.writeLimeObject(1, 1, xmlWriter, "parameters", SCIDAC_FILE_XML);
-    }
-
-    template <typename T, typename TIo = T>
-    void writeElement(ScidacWriter &binWriter, T &evec, RealD &eval, 
-                      const unsigned int index, TIo *ioBuf, 
-                      T *testBuf = nullptr)
-    {
-        VecRecord vecRecord;
-
-        LOG(Message) << "Writing eigenvector " << index << std::endl;
-        vecRecord.eval  = eval;
-        vecRecord.index = index;
-        if ((ioBuf == nullptr) || (testBuf == nullptr))
-        {
-            binWriter.writeScidacFieldRecord(evec, vecRecord, DEFAULT_ASCII_PREC);
-        }
-        else
-        {
-            precisionChange(*ioBuf, evec);
-            precisionChange(*testBuf, *ioBuf);
-            *testBuf -= evec;
-            LOG(Message) << "Precision diff norm^2 " << norm2(*testBuf) << std::endl;
-            binWriter.writeScidacFieldRecord(*ioBuf, vecRecord, DEFAULT_ASCII_PREC);
-        }   
-    }
-    
-    template <typename T, typename TIo = T>
-    static void writePack(const std::string filename, std::vector<T> &evec, 
-                          std::vector<RealD> &eval, PackRecord &record, 
-                          const unsigned int size, bool multiFile, 
-                          GridBase *gridIo = nullptr)
-    {
-        GridBase             *grid = evec[0]._grid;
-        std::unique_ptr<TIo> ioBuf{nullptr}; 
-        std::unique_ptr<T>   testBuf{nullptr};
-        ScidacWriter         binWriter(grid->IsBoss());
-
-        if (typeHash<T>() != typeHash<TIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-            ioBuf.reset(new TIo(gridIo));
-            testBuf.reset(new T(grid));
-        }
-        if (multiFile)
-        {
-            std::string fullFilename;
-
-            for(int k = 0; k < size; ++k) 
-            {
-                fullFilename = filename + "/v" + std::to_string(k) + ".bin";
-
-                makeFileDir(fullFilename, grid);
-                binWriter.open(fullFilename);
-                writeHeader(binWriter, record);
-                writeElement(binWriter, evec[k], eval[k], k, ioBuf.get(), testBuf.get());
-                binWriter.close();
-            }
-        }
-        else
-        {
-            makeFileDir(filename, grid);
-            binWriter.open(filename);
-            writeHeader(binWriter, record);
-            for(int k = 0; k < size; ++k) 
-            {
-                writeElement(binWriter, evec[k], eval[k], k, ioBuf.get(), testBuf.get());
-            }
-            binWriter.close();
-        }
-    }
-}
-
-template <typename F>
-class BaseEigenPack
-{
-public:
-    typedef F Field;
-public:
-    std::vector<RealD> eval;
-    std::vector<F>     evec;
-    PackRecord         record;
-public:
-    BaseEigenPack(void)          = default;
-    BaseEigenPack(const size_t size, GridBase *grid)
-    {
-        resize(size, grid);
-    }
-    virtual ~BaseEigenPack(void) = default;
-    void resize(const size_t size, GridBase *grid)
-    {
-        eval.resize(size);
-        evec.resize(size, grid);
-    }
-};
-
-template <typename F, typename FIo = F>
-class EigenPack: public BaseEigenPack<F>
-{
-public:
-    typedef F   Field;
-    typedef FIo FieldIo;
-public:
-    EigenPack(void)          = default;
-    virtual ~EigenPack(void) = default;
-
-    EigenPack(const size_t size, GridBase *grid, GridBase *gridIo = nullptr)
-    : BaseEigenPack<F>(size, grid)
-    {
-        if (typeHash<F>() != typeHash<FIo>())
-        {
-            if (gridIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "I/O type different from vector type but null I/O grid passed");
-            }
-        }
-        gridIo_ = gridIo;
-    }
-
-    virtual void read(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::readPack<F, FIo>(this->evec, this->eval, this->record, 
-                                      evecFilename(fileStem, traj, multiFile), 
-                                      this->evec.size(), multiFile, gridIo_);
-        HADRONS_DUMP_EP_METADATA(this->record);
-    }
-
-    virtual void write(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::writePack<F, FIo>(evecFilename(fileStem, traj, multiFile), 
-                                       this->evec, this->eval, this->record, 
-                                       this->evec.size(), multiFile, gridIo_);
-    }
-protected:
-    std::string evecFilename(const std::string stem, const int traj, const bool multiFile)
-    {
-        std::string t = (traj < 0) ? "" : ("." + std::to_string(traj));
-
-        if (multiFile)
-        {
-            return stem + t;
-        }
-        else
-        {
-            return stem + t + ".bin";
-        }
-    }
-protected:
-    GridBase *gridIo_;
-};
-
-template <typename FineF, typename CoarseF, 
-          typename FineFIo = FineF, typename CoarseFIo = CoarseF>
-class CoarseEigenPack: public EigenPack<FineF, FineFIo>
-{
-public:
-    typedef CoarseF CoarseField;         
-    std::vector<CoarseF> evecCoarse;
-    std::vector<RealD>   evalCoarse;
-public:
-    CoarseEigenPack(void)          = default;
-    virtual ~CoarseEigenPack(void) = default;
-
-    CoarseEigenPack(const size_t sizeFine, const size_t sizeCoarse, 
-                    GridBase *gridFine, GridBase *gridCoarse,
-                    GridBase *gridFineIo = nullptr, 
-                    GridBase *gridCoarseIo = nullptr)
-    {
-        if (typeHash<FineF>() != typeHash<FineFIo>())
-        {
-            if (gridFineIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "Fine I/O type different from vector type but null fine I/O grid passed");
-            }
-        }
-        if (typeHash<CoarseF>() != typeHash<CoarseFIo>())
-        {
-            if (gridCoarseIo == nullptr)
-            {
-                HADRONS_ERROR(Definition, 
-                              "Coarse I/O type different from vector type but null coarse I/O grid passed");
-            }
-        }
-        this->gridIo_ = gridFineIo;
-        gridCoarseIo_ = gridCoarseIo;
-        resize(sizeFine, sizeCoarse, gridFine, gridCoarse);
-    }
-
-    void resize(const size_t sizeFine, const size_t sizeCoarse, 
-                GridBase *gridFine, GridBase *gridCoarse)
-    {
-        EigenPack<FineF, FineFIo>::resize(sizeFine, gridFine);
-        evalCoarse.resize(sizeCoarse);
-        evecCoarse.resize(sizeCoarse, gridCoarse);
-    }
-
-    void readFine(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPack<FineF, FineFIo>::read(fileStem + "_fine", multiFile, traj);
-    }
-
-    void readCoarse(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        PackRecord dummy;
-
-        EigenPackIo::readPack<CoarseF, CoarseFIo>(evecCoarse, evalCoarse, dummy, 
-                              this->evecFilename(fileStem + "_coarse", traj, multiFile), 
-                              evecCoarse.size(), multiFile, gridCoarseIo_);
-    }
-
-    virtual void read(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        readFine(fileStem, multiFile, traj);
-        readCoarse(fileStem, multiFile, traj);
-    }
-
-    void writeFine(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPack<FineF, FineFIo>::write(fileStem + "_fine", multiFile, traj);
-    }
-
-    void writeCoarse(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        EigenPackIo::writePack<CoarseF, CoarseFIo>(this->evecFilename(fileStem + "_coarse", traj, multiFile), 
-                                                   evecCoarse, evalCoarse, this->record, 
-                                                   evecCoarse.size(), multiFile, gridCoarseIo_);
-    }
-    
-    virtual void write(const std::string fileStem, const bool multiFile, const int traj = -1)
-    {
-        writeFine(fileStem, multiFile, traj);
-        writeCoarse(fileStem, multiFile, traj);
-    }
-private:
-    GridBase *gridCoarseIo_;
-};
-
-template <typename FImpl>
-using BaseFermionEigenPack = BaseEigenPack<typename FImpl::FermionField>;
-
-template <typename FImpl, typename FImplIo = FImpl>
-using FermionEigenPack = EigenPack<typename FImpl::FermionField, typename FImplIo::FermionField>;
-
-template <typename FImpl, int nBasis, typename FImplIo = FImpl>
-using CoarseFermionEigenPack = CoarseEigenPack<
-    typename FImpl::FermionField,
-    typename LocalCoherenceLanczos<typename FImpl::SiteSpinor, 
-                                   typename FImpl::SiteComplex, 
-                                   nBasis>::CoarseField,
-    typename FImplIo::FermionField,
-    typename LocalCoherenceLanczos<typename FImplIo::SiteSpinor, 
-                                   typename FImplIo::SiteComplex, 
-                                   nBasis>::CoarseField>;
-
-#undef HADRONS_DUMP_EP_METADATA
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_EigenPack_hpp_

Hadrons/Environment.hpp

@@ -1,585 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Environment.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Environment_hpp_
-#define Hadrons_Environment_hpp_
-
-#include <Hadrons/Global.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Global environment                                 *
- ******************************************************************************/
-class Object
-{
-public:
-    Object(void) = default;
-    virtual ~Object(void) = default;
-};
-
-template <typename T>
-class Holder: public Object
-{
-public:
-    Holder(void) = default;
-    Holder(T *pt);
-    virtual ~Holder(void) = default;
-    T &       get(void) const;
-    T *       getPt(void) const;
-    void      reset(T *pt);
-private:
-    std::unique_ptr<T> objPt_{nullptr};
-};
-
-#define DEFINE_ENV_ALIAS \
-inline Environment & env(void) const\
-{\
-    return Environment::getInstance();\
-}
-
-#define DEFINE_ENV_LAMBDA \
-auto env = [](void)->Environment &{return Environment::getInstance();}
-
-class Environment
-{
-    SINGLETON(Environment);
-public:
-    typedef SITE_SIZE_TYPE                         Size;
-    typedef std::unique_ptr<GridCartesian>         GridPt;
-    typedef std::unique_ptr<GridRedBlackCartesian> GridRbPt;
-    typedef std::unique_ptr<GridParallelRNG>       RngPt;
-    enum class Storage {object, cache, temporary};
-private:
-    struct ObjInfo
-    {
-        Size                    size{0};
-        Storage                 storage{Storage::object};
-        unsigned int            Ls{0};
-        const std::type_info    *type{nullptr}, *derivedType{nullptr};
-        std::string             name;
-        int                     module{-1};
-        std::unique_ptr<Object> data{nullptr};
-    };
-    typedef std::pair<size_t, unsigned int>     FineGridKey;
-    typedef std::pair<size_t, std::vector<int>> CoarseGridKey;
-public:
-    // grids
-    template <typename VType = vComplex>
-    void                    createGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    void                    createCoarseGrid(const std::vector<int> &blockSize,
-                                             const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridCartesian *         getGrid(void);
-    template <typename VType = vComplex>
-    GridRedBlackCartesian * getRbGrid(void);
-    template <typename VType = vComplex>
-    GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize);
-    template <typename VType = vComplex>
-    GridCartesian *         getGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridRedBlackCartesian * getRbGrid(const unsigned int Ls);
-    template <typename VType = vComplex>
-    GridCartesian *         getCoarseGrid(const std::vector<int> &blockSize,
-                                          const unsigned int Ls);
-    std::vector<int>        getDim(void) const;
-    int                     getDim(const unsigned int mu) const;
-    unsigned int            getNd(void) const;
-    double                  getVolume(void) const;
-    // random number generator
-    GridParallelRNG *       get4dRng(void) const;
-    // general memory management
-    void                    addObject(const std::string name,
-                                      const int moduleAddress = -1);
-    template <typename B, typename T, typename ... Ts>
-    void                    createDerivedObject(const std::string name,
-                                                const Environment::Storage storage,
-                                                const unsigned int Ls,
-                                                Ts && ... args);
-    template <typename T, typename ... Ts>
-    void                    createObject(const std::string name,
-                                         const Environment::Storage storage,
-                                         const unsigned int Ls,
-                                         Ts && ... args);
-    void                    setObjectModule(const unsigned int objAddress,
-                                            const int modAddress);
-    template <typename B, typename T>
-    T *                     getDerivedObject(const unsigned int address) const;
-    template <typename B, typename T>
-    T *                     getDerivedObject(const std::string name) const;
-    template <typename T>
-    T *                     getObject(const unsigned int address) const;
-    template <typename T>
-    T *                     getObject(const std::string name) const;
-    unsigned int            getMaxAddress(void) const;
-    unsigned int            getObjectAddress(const std::string name) const;
-    std::string             getObjectName(const unsigned int address) const;
-    std::string             getObjectType(const unsigned int address) const;
-    std::string             getObjectType(const std::string name) const;
-    Size                    getObjectSize(const unsigned int address) const;
-    Size                    getObjectSize(const std::string name) const;
-    Storage                 getObjectStorage(const unsigned int address) const;
-    Storage                 getObjectStorage(const std::string name) const;
-    int                     getObjectModule(const unsigned int address) const;
-    int                     getObjectModule(const std::string name) const;
-    unsigned int            getObjectLs(const unsigned int address) const;
-    unsigned int            getObjectLs(const std::string name) const;
-    bool                    hasObject(const unsigned int address) const;
-    bool                    hasObject(const std::string name) const;
-    bool                    hasCreatedObject(const unsigned int address) const;
-    bool                    hasCreatedObject(const std::string name) const;
-    bool                    isObject5d(const unsigned int address) const;
-    bool                    isObject5d(const std::string name) const;
-    template <typename T>
-    bool                    isObjectOfType(const unsigned int address) const;
-    template <typename T>
-    bool                    isObjectOfType(const std::string name) const;
-    Environment::Size       getTotalSize(void) const;
-    void                    freeObject(const unsigned int address);
-    void                    freeObject(const std::string name);
-    void                    freeAll(void);
-    void                    protectObjects(const bool protect);
-    bool                    objectsProtected(void) const;
-    // print environment content
-    void                    printContent(void) const;
-private:
-    // general
-    double                              vol_;
-    bool                                protect_{true};
-    // grids
-    std::vector<int>                    dim_;
-    std::map<FineGridKey, GridPt>       grid4d_;
-    std::map<FineGridKey, GridPt>       grid5d_;
-    std::map<FineGridKey, GridRbPt>     gridRb4d_;
-    std::map<FineGridKey, GridRbPt>     gridRb5d_;
-    std::map<CoarseGridKey, GridPt>     gridCoarse4d_;
-    std::map<CoarseGridKey, GridPt>     gridCoarse5d_;
-    unsigned int                        nd_;
-    // random number generator
-    RngPt                               rng4d_;
-    // object store
-    std::vector<ObjInfo>                object_;
-    std::map<std::string, unsigned int> objectAddress_;
-};
-
-/******************************************************************************
- *                       Holder template implementation                       *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename T>
-Holder<T>::Holder(T *pt)
-: objPt_(pt)
-{}
-
-// access //////////////////////////////////////////////////////////////////////
-template <typename T>
-T & Holder<T>::get(void) const
-{
-    return *objPt_.get();
-}
-
-template <typename T>
-T * Holder<T>::getPt(void) const
-{
-    return objPt_.get();
-}
-
-template <typename T>
-void Holder<T>::reset(T *pt)
-{
-    objPt_.reset(pt);
-}
-
-/******************************************************************************
- *                     Environment template implementation                    *
- ******************************************************************************/
-// grids ///////////////////////////////////////////////////////////////////////
-#define HADRONS_DUMP_GRID(...)\
-LOG(Debug) << "New grid " << (__VA_ARGS__) << std::endl;\
-LOG(Debug) << " - cb  : " << (__VA_ARGS__)->_isCheckerBoarded << std::endl;\
-LOG(Debug) << " - fdim: " << (__VA_ARGS__)->_fdimensions << std::endl;\
-LOG(Debug) << " - gdim: " << (__VA_ARGS__)->_gdimensions << std::endl;\
-LOG(Debug) << " - ldim: " << (__VA_ARGS__)->_ldimensions << std::endl;\
-LOG(Debug) << " - rdim: " << (__VA_ARGS__)->_rdimensions << std::endl;
-
-template <typename VType>
-void Environment::createGrid(const unsigned int Ls)
-{
-    size_t hash = typeHash<VType>();
-
-    if (grid4d_.find({hash, 1}) == grid4d_.end())
-    {
-        grid4d_[{hash, 1}].reset(
-            SpaceTimeGrid::makeFourDimGrid(getDim(), 
-                                        GridDefaultSimd(getNd(), VType::Nsimd()),
-                                        GridDefaultMpi()));
-        HADRONS_DUMP_GRID(grid4d_[{hash, 1}].get());
-        gridRb4d_[{hash, 1}].reset(
-            SpaceTimeGrid::makeFourDimRedBlackGrid(grid4d_[{hash, 1}].get()));
-        HADRONS_DUMP_GRID(gridRb4d_[{hash, 1}].get());
-    }
-    if (grid5d_.find({hash, Ls}) == grid5d_.end())
-    {
-        auto g = grid4d_[{hash, 1}].get();
-        
-        grid5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimGrid(Ls, g));
-        HADRONS_DUMP_GRID(grid5d_[{hash, Ls}].get());
-        gridRb5d_[{hash, Ls}].reset(SpaceTimeGrid::makeFiveDimRedBlackGrid(Ls, g));
-        HADRONS_DUMP_GRID(gridRb5d_[{hash, Ls}].get());
-    }
-}
-
-template <typename VType>
-void Environment::createCoarseGrid(const std::vector<int> &blockSize,
-                                   const unsigned int Ls)
-{
-    int              nd      = getNd();
-    std::vector<int> fineDim = getDim(), coarseDim(nd);
-    unsigned int     cLs;
-    auto             key4d = blockSize, key5d = blockSize;
-    size_t           hash  = typeHash<VType>();
-
-    createGrid(Ls);
-    for (int d = 0; d < coarseDim.size(); d++)
-    {
-        coarseDim[d] = fineDim[d]/blockSize[d];
-        if (coarseDim[d]*blockSize[d] != fineDim[d])
-        {
-            HADRONS_ERROR(Size, "Fine dimension " + std::to_string(d) 
-                         + " (" + std::to_string(fineDim[d]) 
-                         + ") not divisible by coarse dimension ("
-                         + std::to_string(coarseDim[d]) + ")"); 
-        }
-    }
-    if (blockSize.size() > nd)
-    {
-        cLs = Ls/blockSize[nd];
-        if (cLs*blockSize[nd] != Ls)
-        {
-            HADRONS_ERROR(Size, "Fine Ls (" + std::to_string(Ls) 
-                         + ") not divisible by coarse Ls ("
-                         + std::to_string(cLs) + ")");
-        }
-    }
-    else
-    {
-        cLs = Ls;
-    }
-    key4d.resize(nd);
-    key5d.push_back(Ls);
-
-    CoarseGridKey hkey4d = {hash, key4d}, hkey5d = {hash, key5d};
-
-    if (gridCoarse4d_.find(hkey4d) == gridCoarse4d_.end())
-    {
-        gridCoarse4d_[hkey4d].reset(
-            SpaceTimeGrid::makeFourDimGrid(coarseDim, 
-                GridDefaultSimd(nd, VType::Nsimd()), GridDefaultMpi()));
-        HADRONS_DUMP_GRID(gridCoarse4d_[hkey4d].get());
-    }
-    if (gridCoarse5d_.find(hkey5d) == gridCoarse5d_.end())
-    {
-        gridCoarse5d_[hkey5d].reset(
-            SpaceTimeGrid::makeFiveDimGrid(cLs, gridCoarse4d_[hkey4d].get()));
-        HADRONS_DUMP_GRID(gridCoarse5d_[hkey5d].get());
-    }
-}
-
-#undef HADRONS_DUMP_GRID
-
-template <typename VType>
-GridCartesian * Environment::getGrid(void)
-{
-    FineGridKey key = {typeHash<VType>(), 1};
-
-    auto it = grid4d_.find(key);
-
-    if (it != grid4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(1);
-
-        return grid4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridRedBlackCartesian * Environment::getRbGrid(void)
-{
-    FineGridKey key = {typeHash<VType>(), 1};
-    auto        it  = gridRb4d_.find(key);
-
-    if (it != gridRb4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(1);
-
-        return gridRb4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize)
-{
-    std::vector<int> s = blockSize;
-
-    s.resize(getNd());
-
-    CoarseGridKey key = {typeHash<VType>(), s};
-    auto          it  = gridCoarse4d_.find(key);
-
-    if (it != gridCoarse4d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createCoarseGrid<VType>(blockSize, 1);
-        
-        return gridCoarse4d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getGrid(const unsigned int Ls)
-{
-    FineGridKey key = {typeHash<VType>(), Ls};
-    auto        it  = grid5d_.find(key);
-
-    if (it != grid5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(Ls);
-
-        return grid5d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridRedBlackCartesian * Environment::getRbGrid(const unsigned int Ls)
-{
-    FineGridKey key = {typeHash<VType>(), Ls};
-    auto        it  = gridRb5d_.find(key);
-
-    if (it != gridRb5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createGrid<VType>(Ls);
-
-        return gridRb5d_.at(key).get();
-    }
-}
-
-template <typename VType>
-GridCartesian * Environment::getCoarseGrid(const std::vector<int> &blockSize,
-                                           const unsigned int Ls)
-{
-    std::vector<int> s = blockSize;
-
-    s.push_back(Ls);
-
-    CoarseGridKey key = {typeHash<VType>(), s};
-
-    auto it = gridCoarse5d_.find(key);
-    if (it != gridCoarse5d_.end())
-    {
-        return it->second.get();
-    }
-    else
-    {
-        createCoarseGrid<VType>(blockSize, Ls);
-
-        return gridCoarse5d_.at(key).get();
-    }
-}
-
-
-// general memory management ///////////////////////////////////////////////////
-template <typename B, typename T, typename ... Ts>
-void Environment::createDerivedObject(const std::string name,
-                                      const Environment::Storage storage,
-                                      const unsigned int Ls,
-                                      Ts && ... args)
-{
-    if (!hasObject(name))
-    {
-        addObject(name);
-    }
-    
-    unsigned int address = getObjectAddress(name);
-    
-    if (!object_[address].data or !objectsProtected())
-    {
-        MemoryStats memStats;
-    
-        if (!MemoryProfiler::stats)
-        {
-            MemoryProfiler::stats = &memStats;
-        }
-        size_t initMem               = MemoryProfiler::stats->currentlyAllocated;
-        object_[address].storage     = storage;
-        object_[address].Ls          = Ls;
-        object_[address].data.reset(new Holder<B>(new T(std::forward<Ts>(args)...)));
-        object_[address].size        = MemoryProfiler::stats->maxAllocated - initMem;
-        object_[address].type        = typeIdPt<B>();
-        object_[address].derivedType = typeIdPt<T>();
-        if (MemoryProfiler::stats == &memStats)
-        {
-            MemoryProfiler::stats = nullptr;
-        }
-    }
-    // object already exists, no error if it is a cache, error otherwise
-    else if ((object_[address].storage               != Storage::cache) or 
-             (object_[address].storage               != storage)        or
-             (object_[address].name                  != name)           or
-             (typeHash(object_[address].type)        != typeHash<B>())  or
-             (typeHash(object_[address].derivedType) != typeHash<T>()))
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "object '" + name + "' already allocated", address);
-    }
-}
-
-template <typename T, typename ... Ts>
-void Environment::createObject(const std::string name, 
-                               const Environment::Storage storage,
-                               const unsigned int Ls,
-                               Ts && ... args)
-{
-    createDerivedObject<T, T>(name, storage, Ls, std::forward<Ts>(args)...);
-}
-
-template <typename B, typename T>
-T * Environment::getDerivedObject(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        if (hasCreatedObject(address))
-        {
-            if (auto h = dynamic_cast<Holder<B> *>(object_[address].data.get()))
-            {
-                if (&typeid(T) == &typeid(B))
-                {
-                    return dynamic_cast<T *>(h->getPt());
-                }
-                else
-                {
-                    if (auto hder = dynamic_cast<T *>(h->getPt()))
-                    {
-                        return hder;
-                    }
-                    else
-                    {
-                        HADRONS_ERROR_REF(ObjectType, "object with address " +
-                            std::to_string(address) +
-                            " cannot be casted to '" + typeName(&typeid(T)) +
-                            "' (has type '" + typeName(&typeid(h->get())) + "')", address);
-                    }
-                }
-            }
-            else
-            {
-                HADRONS_ERROR_REF(ObjectType, "object with address " + 
-                            std::to_string(address) +
-                            " does not have type '" + typeName(&typeid(B)) +
-                            "' (has type '" + getObjectType(address) + "')", address);
-            }
-        }
-        else
-        {
-            HADRONS_ERROR_REF(ObjectDefinition, "object with address " + 
-                              std::to_string(address) + " is empty", address);
-        }
-    }
-    else
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "no object with address " + 
-                          std::to_string(address), address);
-    }
-}
-
-template <typename B, typename T>
-T * Environment::getDerivedObject(const std::string name) const
-{
-    return getDerivedObject<B, T>(getObjectAddress(name));
-}
-
-template <typename T>
-T * Environment::getObject(const unsigned int address) const
-{
-    return getDerivedObject<T, T>(address);
-}
-
-template <typename T>
-T * Environment::getObject(const std::string name) const
-{
-    return getObject<T>(getObjectAddress(name));
-}
-
-template <typename T>
-bool Environment::isObjectOfType(const unsigned int address) const
-{
-    if (hasObject(address))
-    {
-        if (auto h = dynamic_cast<Holder<T> *>(object_[address].data.get()))
-        {
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-    else
-    {
-        HADRONS_ERROR_REF(ObjectDefinition, "no object with address " 
-                          + std::to_string(address), address);
-    }
-}
-
-template <typename T>
-bool Environment::isObjectOfType(const std::string name) const
-{
-    return isObjectOfType<T>(getObjectAddress(name));
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Environment_hpp_

Hadrons/Exceptions.cc

@@ -1,102 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Exceptions.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Exceptions.hpp>
-#include <Hadrons/VirtualMachine.hpp>
-#include <Hadrons/Module.hpp>
-
-#ifndef ERR_SUFF
-#define ERR_SUFF " (" + loc + ")"
-#endif
-
-#define CTOR_EXC(name, init) \
-name::name(std::string msg, std::string loc)\
-:init\
-{}
-
-#define CTOR_EXC_REF(name, init) \
-name::name(std::string msg, std::string loc, const unsigned int address)\
-:init\
-{}
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace Exceptions;
-
-// backtrace cache
-std::vector<std::string> Grid::Hadrons::Exceptions::backtraceStr;
-
-// logic errors
-CTOR_EXC(Logic, logic_error(msg + ERR_SUFF))
-CTOR_EXC(Definition, Logic("definition error: " + msg, loc))
-CTOR_EXC(Implementation, Logic("implementation error: " + msg, loc))
-CTOR_EXC(Range, Logic("range error: " + msg, loc))
-CTOR_EXC(Size, Logic("size error: " + msg, loc))
-
-// runtime errors
-CTOR_EXC(Runtime, runtime_error(msg + ERR_SUFF))
-CTOR_EXC(Argument, Runtime("argument error: " + msg, loc))
-CTOR_EXC(Io, Runtime("IO error: " + msg, loc))
-CTOR_EXC(Memory, Runtime("memory error: " + msg, loc))
-CTOR_EXC(Parsing, Runtime("parsing error: " + msg, loc))
-CTOR_EXC(Program, Runtime("program error: " + msg, loc))
-CTOR_EXC(System, Runtime("system error: " + msg, loc))
-
-// virtual machine errors
-CTOR_EXC_REF(ObjectDefinition, RuntimeRef("object definition error: " + msg, loc, address));
-CTOR_EXC_REF(ObjectType, RuntimeRef("object type error: " + msg, loc, address));
-
-// abort functions
-void Grid::Hadrons::Exceptions::abort(const std::exception& e)
-{
-    auto &vm = VirtualMachine::getInstance();
-    int  mod = vm.getCurrentModule();
-
-    LOG(Error) << "FATAL ERROR -- Exception " << typeName(&typeid(e)) 
-               << std::endl;
-    if (mod >= 0)
-    {
-        LOG(Error) << "During execution of module '"
-                    << vm.getModuleName(mod) << "' (address " << mod << ")"
-                    << std::endl;
-    }
-    LOG(Error) << e.what() << std::endl;
-    if (!backtraceStr.empty())
-    {
-        LOG(Error) << "-- BACKTRACE --------------" << std::endl;
-        for (auto &s: backtraceStr)
-        {
-            LOG(Error) << s << std::endl;
-        }
-        LOG(Error) << "---------------------------" << std::endl;
-    }
-    LOG(Error) << "Aborting program" << std::endl;
-    Grid_finalize();
-
-    exit(EXIT_FAILURE);
-}

Hadrons/Exceptions.hpp

@@ -1,129 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Exceptions.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Exceptions_hpp_
-#define Hadrons_Exceptions_hpp_
-
-#include <stdexcept>
-#include <execinfo.h>
-#ifndef Hadrons_Global_hpp_
-#include <Hadrons/Global.hpp>
-#endif
-
-#define HADRONS_SRC_LOC std::string(__FUNCTION__) + " at " \
-                        + std::string(__FILE__) + ":" + std::to_string(__LINE__)
-#define HADRONS_BACKTRACE_MAX 128
-#ifdef HAVE_EXECINFO_H
-#define HADRONS_CACHE_BACKTRACE \
-{\
-    void* _callstack[HADRONS_BACKTRACE_MAX];\
-    int _i, _frames = backtrace(_callstack, HADRONS_BACKTRACE_MAX);\
-    char** _strs = backtrace_symbols(_callstack, _frames);\
-    Grid::Hadrons::Exceptions::backtraceStr.clear();\
-    for (_i = 0; _i < _frames; ++_i)\
-    {\
-        Hadrons::Exceptions::backtraceStr.push_back(std::string(_strs[_i]));\
-    }\
-    free(_strs);\
-}
-#else
-#define HADRONS_CACHE_BACKTRACE \
-Grid::Hadrons::Exceptions::backtraceStr.clear();\
-Grid::Hadrons::Exceptions::backtraceStr.push_back("<backtrace not supported>");
-#endif
-
-#define HADRONS_ERROR(exc, msg)\
-HADRONS_CACHE_BACKTRACE \
-throw(Exceptions::exc(msg, HADRONS_SRC_LOC));
-
-#define HADRONS_ERROR_REF(exc, msg, address)\
-HADRONS_CACHE_BACKTRACE \
-throw(Exceptions::exc(msg, HADRONS_SRC_LOC, address));
-
-#define DECL_EXC(name, base) \
-class name: public base\
-{\
-public:\
-    name(std::string msg, std::string loc);\
-}
-
-#define DECL_EXC_REF(name, base) \
-class name: public base\
-{\
-public:\
-    name(std::string msg, std::string loc, const unsigned int address);\
-}
-
-BEGIN_HADRONS_NAMESPACE
-
-namespace Exceptions
-{
-    // backtrace cache
-    extern std::vector<std::string> backtraceStr;
-
-    // logic errors
-    DECL_EXC(Logic, std::logic_error);
-    DECL_EXC(Definition, Logic);
-    DECL_EXC(Implementation, Logic);
-    DECL_EXC(Range, Logic);
-    DECL_EXC(Size, Logic);
-
-    // runtime errors
-    DECL_EXC(Runtime, std::runtime_error);
-    DECL_EXC(Argument, Runtime);
-    DECL_EXC(Io, Runtime);
-    DECL_EXC(Memory, Runtime);
-    DECL_EXC(Parsing, Runtime);
-    DECL_EXC(Program, Runtime);
-    DECL_EXC(System, Runtime);
-
-    // virtual machine errors
-    class RuntimeRef: public Runtime
-    {
-    public:
-        RuntimeRef(std::string msg, std::string loc, const unsigned int address)
-        : Runtime(msg, loc), address_(address)
-        {}
-        unsigned int getAddress(void) const
-        {
-            return address_;
-        }
-    private:
-        unsigned int address_;
-    };
-
-    DECL_EXC_REF(ObjectDefinition, RuntimeRef);
-    DECL_EXC_REF(ObjectType, RuntimeRef);
-
-    // abort functions
-    void abort(const std::exception& e);
-}
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Exceptions_hpp_

Hadrons/Global.cc

@@ -1,214 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Global.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Global.hpp>
-
-using namespace Grid;
-using namespace QCD;
-using namespace Hadrons;
-
-HadronsLogger Hadrons::HadronsLogError(1,"Error");
-HadronsLogger Hadrons::HadronsLogWarning(1,"Warning");
-HadronsLogger Hadrons::HadronsLogMessage(1,"Message");
-HadronsLogger Hadrons::HadronsLogIterative(1,"Iterative");
-HadronsLogger Hadrons::HadronsLogDebug(1,"Debug");
-HadronsLogger Hadrons::HadronsLogIRL(1,"IRL");
-
-void Hadrons::initLogger(void)
-{
-    auto w  = std::string("Hadrons").length();
-    int  cw = 8;
-
-
-    GridLogError.setTopWidth(w);
-    GridLogWarning.setTopWidth(w);
-    GridLogMessage.setTopWidth(w);
-    GridLogIterative.setTopWidth(w);
-    GridLogDebug.setTopWidth(w);
-    GridLogIRL.setTopWidth(w);
-    GridLogError.setChanWidth(cw);
-    GridLogWarning.setChanWidth(cw);
-    GridLogMessage.setChanWidth(cw);
-    GridLogIterative.setChanWidth(cw);
-    GridLogDebug.setChanWidth(cw);
-    GridLogIRL.setChanWidth(cw);
-    HadronsLogError.Active(true);
-    HadronsLogWarning.Active(true);
-    HadronsLogMessage.Active(GridLogMessage.isActive());
-    HadronsLogIterative.Active(GridLogIterative.isActive());
-    HadronsLogDebug.Active(GridLogDebug.isActive());
-    HadronsLogIRL.Active(GridLogIRL.isActive());
-    HadronsLogError.setChanWidth(cw);
-    HadronsLogWarning.setChanWidth(cw);
-    HadronsLogMessage.setChanWidth(cw);
-    HadronsLogIterative.setChanWidth(cw);
-    HadronsLogDebug.setChanWidth(cw);
-    HadronsLogIRL.setChanWidth(cw);
-}
-
-// type utilities //////////////////////////////////////////////////////////////
-size_t Hadrons::typeHash(const std::type_info *info)
-{
-    return info->hash_code();
-}
-
-constexpr unsigned int maxNameSize = 1024u;
-
-std::string Hadrons::typeName(const std::type_info *info)
-{
-    char        *buf;
-    std::string name;
-    
-    buf  = abi::__cxa_demangle(info->name(), nullptr, nullptr, nullptr);
-    name = buf;
-    free(buf);
-    
-    return name;
-}
-
-// default writers/readers /////////////////////////////////////////////////////
-#ifdef HAVE_HDF5
-const std::string Hadrons::resultFileExt = "h5";
-#else
-const std::string Hadrons::resultFileExt = "xml";
-#endif
-
-// recursive mkdir /////////////////////////////////////////////////////////////
-int Hadrons::mkdir(const std::string dirName)
-{
-    if (!dirName.empty() and access(dirName.c_str(), R_OK|W_OK|X_OK))
-    {
-        mode_t mode755;
-        char   tmp[MAX_PATH_LENGTH];
-        char   *p = NULL;
-        size_t len;
-
-        mode755 = S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
-
-        snprintf(tmp, sizeof(tmp), "%s", dirName.c_str());
-        len = strlen(tmp);
-        if(tmp[len - 1] == '/')
-        {
-            tmp[len - 1] = 0;
-        }
-        for(p = tmp + 1; *p; p++)
-        {
-            if(*p == '/')
-            {
-                *p = 0;
-                ::mkdir(tmp, mode755);
-                *p = '/';
-            }
-        }
-
-        return ::mkdir(tmp, mode755);
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-std::string Hadrons::basename(const std::string &s)
-{
-    constexpr char sep = '/';
-    size_t         i   = s.rfind(sep, s.length());
-    
-    if (i != std::string::npos)
-    {
-        return s.substr(i+1, s.length() - i);
-    }
-    else
-    {
-        return s;
-    }
-}
-
-std::string Hadrons::dirname(const std::string &s)
-{
-    constexpr char sep = '/';
-    size_t         i   = s.rfind(sep, s.length());
-    
-    if (i != std::string::npos)
-    {
-        return s.substr(0, i);
-    }
-    else
-    {
-        return "";
-    }
-}
-
-void Hadrons::makeFileDir(const std::string filename, GridBase *g)
-{
-    bool doIt = true;
-
-    if (g)
-    {
-        doIt = g->IsBoss();
-    }
-    if (doIt)
-    {
-        std::string dir    = dirname(filename);
-        int         status = mkdir(dir);
-
-        if (status)
-        {
-            HADRONS_ERROR(Io, "cannot create directory '" + dir
-                          + "' ( " + std::strerror(errno) + ")");
-        }
-    }
-}
-
-void Hadrons::printTimeProfile(const std::map<std::string, GridTime> &timing, 
-                               GridTime total)
-{
-    typedef decltype(total.count()) Count;
-
-    std::map<Count, std::string, std::greater<Count>> rtiming;
-    const double dtotal = static_cast<double>(total.count());
-    auto cf = std::cout.flags();
-    auto p  = std::cout.precision();
-    unsigned int width = 0;
-
-    for (auto &t: timing)
-    {
-        width = std::max(width, static_cast<unsigned int>(t.first.length()));
-        rtiming[t.second.count()] = t.first;
-    }
-    for (auto &rt: rtiming)
-    {
-        LOG(Message) << std::setw(width) << rt.second << ": " 
-                     << rt.first << " us (" << std::fixed 
-                     << std::setprecision(1) 
-                     << static_cast<double>(rt.first)/dtotal*100 << "%)"
-                     << std::endl;
-    }
-    std::cout.flags(cf);
-    std::cout.precision(p);
-}

Hadrons/Global.hpp

@@ -1,297 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Global.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Lanny91 <andrew.lawson@gmail.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Global_hpp_
-#define Hadrons_Global_hpp_
-
-#include <set>
-#include <stack>
-#include <regex>
-#include <Grid/Grid.h>
-#include <cxxabi.h>
-
-#ifndef SITE_SIZE_TYPE
-#define SITE_SIZE_TYPE size_t
-#endif
-
-#ifndef DEFAULT_ASCII_PREC
-#define DEFAULT_ASCII_PREC 16
-#endif
-
-/* the 'using Grid::operator<<;' statement prevents a very nasty compilation
- * error with GCC 5 (clang & GCC 6 compile fine without it).
- */
-
-#define BEGIN_HADRONS_NAMESPACE \
-namespace Grid {\
-using namespace QCD;\
-namespace Hadrons {\
-using Grid::operator<<;\
-using Grid::operator>>;
-#define END_HADRONS_NAMESPACE }}
-
-#define BEGIN_MODULE_NAMESPACE(name)\
-namespace name {\
-using Grid::operator<<;\
-using Grid::operator>>;
-
-#define END_MODULE_NAMESPACE }
-
-#define _HADRONS_IMPL(impl, sub) impl##sub
-#define HADRONS_IMPL(impl, sub)   _HADRONS_IMPL(impl, sub)
-
-#ifndef FIMPLBASE
-#define FIMPLBASE WilsonImpl
-#endif
-#define FIMPL  HADRONS_IMPL(FIMPLBASE, R)
-#define FIMPLF HADRONS_IMPL(FIMPLBASE, F)
-#define FIMPLD HADRONS_IMPL(FIMPLBASE, D)
-
-#ifndef ZFIMPLBASE
-#define ZFIMPLBASE ZWilsonImpl
-#endif
-#define ZFIMPL  HADRONS_IMPL(ZFIMPLBASE, R)
-#define ZFIMPLF HADRONS_IMPL(ZFIMPLBASE, F)
-#define ZFIMPLD HADRONS_IMPL(ZFIMPLBASE, D)
-
-#ifndef SIMPLBASE
-#define SIMPLBASE ScalarImplC
-#endif
-#define SIMPL  HADRONS_IMPL(SIMPLBASE, R)
-#define SIMPLF HADRONS_IMPL(SIMPLBASE, F)
-#define SIMPLD HADRONS_IMPL(SIMPLBASE, D)
-
-#ifndef GIMPLBASE
-#define GIMPLBASE PeriodicGimpl
-#endif
-#define GIMPL  HADRONS_IMPL(GIMPLBASE, R)
-#define GIMPLF HADRONS_IMPL(GIMPLBASE, F)
-#define GIMPLD HADRONS_IMPL(GIMPLBASE, D)
-
-BEGIN_HADRONS_NAMESPACE
-
-// type aliases
-#define BASIC_TYPE_ALIASES(Impl, suffix)\
-typedef typename Impl::Field                         ScalarField##suffix;\
-typedef typename Impl::PropagatorField               PropagatorField##suffix;\
-typedef typename Impl::SitePropagator::scalar_object SitePropagator##suffix;\
-typedef std::vector<SitePropagator##suffix>          SlicedPropagator##suffix;
-
-#define FERM_TYPE_ALIASES(FImpl, suffix)\
-BASIC_TYPE_ALIASES(FImpl, suffix);\
-typedef FermionOperator<FImpl>            FMat##suffix;\
-typedef typename FImpl::FermionField      FermionField##suffix;\
-typedef typename FImpl::GaugeField        GaugeField##suffix;\
-typedef typename FImpl::DoubledGaugeField DoubledGaugeField##suffix;\
-typedef typename FImpl::ComplexField      ComplexField##suffix;
-
-#define GAUGE_TYPE_ALIASES(GImpl, suffix)\
-typedef typename GImpl::GaugeField GaugeField##suffix;
-
-#define SOLVER_TYPE_ALIASES(FImpl, suffix)\
-typedef Solver<FImpl> Solver##suffix;
-
-#define SINK_TYPE_ALIASES(suffix)\
-typedef std::function<SlicedPropagator##suffix\
-                      (const PropagatorField##suffix &)> SinkFn##suffix;
-
-// logger
-class HadronsLogger: public Logger
-{
-public:
-    HadronsLogger(int on, std::string nm): Logger("Hadrons", on, nm,
-                                                  GridLogColours, "BLACK"){};
-};
-
-#define LOG(channel) std::cout << HadronsLog##channel
-#define HADRONS_DEBUG_VAR(var) LOG(Debug) << #var << "= " << (var) << std::endl;
-
-extern HadronsLogger HadronsLogError;
-extern HadronsLogger HadronsLogWarning;
-extern HadronsLogger HadronsLogMessage;
-extern HadronsLogger HadronsLogIterative;
-extern HadronsLogger HadronsLogDebug;
-extern HadronsLogger HadronsLogIRL;
-
-void initLogger(void);
-
-// singleton pattern
-#define SINGLETON(name)\
-public:\
-    name(const name &e) = delete;\
-    void operator=(const name &e) = delete;\
-    static name & getInstance(void)\
-    {\
-        static name e;\
-        return e;\
-    }\
-private:\
-    name(void);
-
-#define SINGLETON_DEFCTOR(name)\
-public:\
-    name(const name &e) = delete;\
-    void operator=(const name &e) = delete;\
-    static name & getInstance(void)\
-    {\
-        static name e;\
-        return e;\
-    }\
-private:\
-    name(void) = default;
-
-// type utilities
-template <typename T>
-const std::type_info * typeIdPt(const T &x)
-{
-    return &typeid(x);
-}
-
-template <typename T>
-const std::type_info * typeIdPt(void)
-{
-    return &typeid(T);
-}
-
-size_t typeHash(const std::type_info *info);
-
-template <typename T>
-size_t typeHash(const T &x)
-{
-    return typeHash(typeIdPt(x));
-}
-
-template <typename T>
-size_t typeHash(void)
-{
-    return typeHash(typeIdPt<T>());
-}
-
-std::string typeName(const std::type_info *info);
-
-template <typename T>
-std::string typeName(const T &x)
-{
-    return typeName(typeIdPt(x));
-}
-
-template <typename T>
-std::string typeName(void)
-{
-    return typeName(typeIdPt<T>());
-}
-
-// default writers/readers
-extern const std::string resultFileExt;
-
-#ifdef HAVE_HDF5
-typedef Hdf5Reader ResultReader;
-typedef Hdf5Writer ResultWriter;
-#else
-typedef XmlReader ResultReader;
-typedef XmlWriter ResultWriter;
-#endif
-
-#define RESULT_FILE_NAME(name, traj) \
-name + "." + std::to_string(traj) + "." + resultFileExt
-
-// recursive mkdir
-#define MAX_PATH_LENGTH 512u
-int         mkdir(const std::string dirName);
-std::string basename(const std::string &s);
-std::string dirname(const std::string &s);
-void        makeFileDir(const std::string filename, GridBase *g = nullptr);
-
-// default Schur convention
-#ifndef HADRONS_DEFAULT_SCHUR 
-#define HADRONS_DEFAULT_SCHUR DiagTwo
-#endif
-#define _HADRONS_SCHUR_OP_(conv) Schur##conv##Operator
-#define HADRONS_SCHUR_OP(conv) _HADRONS_SCHUR_OP_(conv)
-#define HADRONS_DEFAULT_SCHUR_OP HADRONS_SCHUR_OP(HADRONS_DEFAULT_SCHUR)
-#define _HADRONS_SCHUR_SOLVE_(conv) SchurRedBlack##conv##Solve
-#define HADRONS_SCHUR_SOLVE(conv) _HADRONS_SCHUR_SOLVE_(conv)
-#define HADRONS_DEFAULT_SCHUR_SOLVE HADRONS_SCHUR_SOLVE(HADRONS_DEFAULT_SCHUR)
-#define _HADRONS_SCHUR_A2A_(conv) A2AVectorsSchur##conv
-#define HADRONS_SCHUR_A2A(conv) _HADRONS_SCHUR_A2A_(conv)
-#define HADRONS_DEFAULT_SCHUR_A2A HADRONS_SCHUR_A2A(HADRONS_DEFAULT_SCHUR)
-
-// stringify macro
-#define _HADRONS_STR(x) #x
-#define HADRONS_STR(x) _HADRONS_STR(x)
-
-// pretty print time profile
-void printTimeProfile(const std::map<std::string, GridTime> &timing, GridTime total);
-
-// token replacement utility
-template <typename T>
-void tokenReplace(std::string &str, const std::string token,
-                  const T &x, const std::string mark = "@")
-{
-    std::string fullToken = mark + token + mark;
-    
-    auto pos = str.find(fullToken);
-    if (pos != std::string::npos)
-    {
-        str.replace(pos, fullToken.size(), std::to_string(x));
-    }
-}
-
-// trajectory range
-class TrajRange: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrajRange,
-                                    unsigned int, start,
-                                    unsigned int, end,
-                                    unsigned int, step,
-                                    std::string,  exclude);
-
-    inline std::vector<unsigned int> getTrajectoryList(void)
-    {
-        std::vector<unsigned int> excVec = strToVec<unsigned int>(exclude);
-        std::vector<unsigned int> list;
-
-        for (unsigned int t = start; t < end; t += step)
-        {
-            if (std::find(excVec.begin(), excVec.end(), t) == excVec.end())
-            {
-                list.push_back(t);
-            }
-        }
-
-        return list;
-    }
-};
-
-END_HADRONS_NAMESPACE
-
-#include <Hadrons/Exceptions.hpp>
-
-#endif // Hadrons_Global_hpp_

Hadrons/Modules.hpp

@@ -1,74 +0,0 @@
-#include <Hadrons/Modules/MContraction/Baryon.hpp>
-#include <Hadrons/Modules/MContraction/A2AAslashField.hpp>
-#include <Hadrons/Modules/MContraction/A2AMesonField.hpp>
-#include <Hadrons/Modules/MContraction/Meson.hpp>
-#include <Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
-#include <Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp>
-#include <Hadrons/Modules/MContraction/DiscLoop.hpp>
-#include <Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp>
-#include <Hadrons/Modules/MContraction/Gamma3pt.hpp>
-#include <Hadrons/Modules/MContraction/WardIdentity.hpp>
-#include <Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp>
-#include <Hadrons/Modules/MFermion/FreeProp.hpp>
-#include <Hadrons/Modules/MFermion/GaugeProp.hpp>
-#include <Hadrons/Modules/MSource/SeqGamma.hpp>
-#include <Hadrons/Modules/MSource/Point.hpp>
-#include <Hadrons/Modules/MSource/Wall.hpp>
-#include <Hadrons/Modules/MSource/Z2.hpp>
-#include <Hadrons/Modules/MSource/SeqConserved.hpp>
-#include <Hadrons/Modules/MSource/Momentum.hpp>
-#include <Hadrons/Modules/MSink/Smear.hpp>
-#include <Hadrons/Modules/MSink/Point.hpp>
-#include <Hadrons/Modules/MSolver/MixedPrecisionRBPrecCG.hpp>
-#include <Hadrons/Modules/MSolver/LocalCoherenceLanczos.hpp>
-#include <Hadrons/Modules/MSolver/Guesser.hpp>
-#include <Hadrons/Modules/MSolver/RBPrecCG.hpp>
-#include <Hadrons/Modules/MSolver/A2AVectors.hpp>
-#include <Hadrons/Modules/MSolver/A2AAslashVectors.hpp>
-#include <Hadrons/Modules/MGauge/UnitEm.hpp>
-#include <Hadrons/Modules/MGauge/StoutSmearing.hpp>
-#include <Hadrons/Modules/MGauge/Unit.hpp>
-#include <Hadrons/Modules/MGauge/Electrify.hpp>
-#include <Hadrons/Modules/MGauge/Random.hpp>
-#include <Hadrons/Modules/MGauge/GaugeFix.hpp>
-#include <Hadrons/Modules/MGauge/FundtoHirep.hpp>
-#include <Hadrons/Modules/MGauge/StochEm.hpp>
-#include <Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp>
-#include <Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp>
-#include <Hadrons/Modules/MUtilities/PrecisionCast.hpp>
-#include <Hadrons/Modules/MUtilities/RandomVectors.hpp>
-#include <Hadrons/Modules/MUtilities/TestSeqGamma.hpp>
-#include <Hadrons/Modules/MUtilities/TestSeqConserved.hpp>
-#include <Hadrons/Modules/MLoop/NoiseLoop.hpp>
-#include <Hadrons/Modules/MScalar/FreeProp.hpp>
-#include <Hadrons/Modules/MScalar/VPCounterTerms.hpp>
-#include <Hadrons/Modules/MScalar/ScalarVP.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-#include <Hadrons/Modules/MScalar/ChargedProp.hpp>
-#include <Hadrons/Modules/MNPR/Bilinear.hpp>
-#include <Hadrons/Modules/MNPR/Amputate.hpp>
-#include <Hadrons/Modules/MNPR/FourQuark.hpp>
-#include <Hadrons/Modules/MAction/DWF.hpp>
-#include <Hadrons/Modules/MAction/MobiusDWF.hpp>
-#include <Hadrons/Modules/MAction/Wilson.hpp>
-#include <Hadrons/Modules/MAction/WilsonClover.hpp>
-#include <Hadrons/Modules/MAction/ZMobiusDWF.hpp>
-#include <Hadrons/Modules/MAction/ScaledDWF.hpp>
-#include <Hadrons/Modules/MScalarSUN/StochFreeField.hpp>
-#include <Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp>
-#include <Hadrons/Modules/MScalarSUN/ShiftProbe.hpp>
-#include <Hadrons/Modules/MScalarSUN/Div.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrMag.hpp>
-#include <Hadrons/Modules/MScalarSUN/EMT.hpp>
-#include <Hadrons/Modules/MScalarSUN/TwoPoint.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrPhi.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-#include <Hadrons/Modules/MScalarSUN/TransProj.hpp>
-#include <Hadrons/Modules/MScalarSUN/Grad.hpp>
-#include <Hadrons/Modules/MScalarSUN/TrKinetic.hpp>
-#include <Hadrons/Modules/MIO/LoadEigenPack.hpp>
-#include <Hadrons/Modules/MIO/LoadNersc.hpp>
-#include <Hadrons/Modules/MIO/LoadA2AVectors.hpp>
-#include <Hadrons/Modules/MIO/LoadCosmHol.hpp>
-#include <Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp>
-#include <Hadrons/Modules/MIO/LoadBinary.hpp>

Hadrons/Modules/MAction/DWF.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/DWF.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/DWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TDWF<FIMPLF>;
-#endif

Hadrons/Modules/MAction/MobiusDWF.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/MobiusDWF.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/MobiusDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TMobiusDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TMobiusDWF<FIMPLF>;
-#endif

Hadrons/Modules/MAction/MobiusDWF.hpp

@@ -1,140 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/MobiusDWF.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_MobiusDWF_hpp_
-#define Hadrons_MAction_MobiusDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      Mobius domain-wall fermion action                     *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class MobiusDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(MobiusDWFPar,
-                                    std::string , gauge,
-                                    unsigned int, Ls,
-                                    double      , mass,
-                                    double      , M5,
-                                    double      , b,
-                                    double      , c,
-                                    std::string , boundary,
-                                    std::string , twist);
-};
-
-template <typename FImpl>
-class TMobiusDWF: public Module<MobiusDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TMobiusDWF(const std::string name);
-    // destructor
-    virtual ~TMobiusDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(MobiusDWF, TMobiusDWF<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(MobiusDWFF, TMobiusDWF<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                      TMobiusDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TMobiusDWF<FImpl>::TMobiusDWF(const std::string name)
-: Module<MobiusDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TMobiusDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TMobiusDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMobiusDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up Mobius domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", b= " << par().b << ", c= " << par().c
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-    LOG(Message) << "Fermion boundary conditions: " << par().boundary
-                 << std::endl;
-
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    typename MobiusFermion<FImpl>::ImplParams implParams;
-    implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    envCreateDerived(FMat, MobiusFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, par().b, par().c,
-                     implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TMobiusDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_MobiusDWF_hpp_

Hadrons/Modules/MAction/ScaledDWF.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ScaledDWF.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/ScaledDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TScaledDWF<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TScaledDWF<FIMPLF>;
-#endif

Hadrons/Modules/MAction/ScaledDWF.hpp

@@ -1,139 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ScaledDWF.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_ScaledDWF_hpp_
-#define Hadrons_MAction_ScaledDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      Scaled domain wall fermion                            *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class ScaledDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScaledDWFPar,
-                                    std::string , gauge,
-                                    unsigned int, Ls,
-                                    double      , mass,
-                                    double      , M5,
-                                    double      , scale,
-                                    std::string , boundary,
-                                    std::string , twist);
-};
-
-template <typename FImpl>
-class TScaledDWF: public Module<ScaledDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TScaledDWF(const std::string name);
-    // destructor
-    virtual ~TScaledDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(ScaledDWF, TScaledDWF<FIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(ScaledDWFF, TScaledDWF<FIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                      TScaledDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TScaledDWF<FImpl>::TScaledDWF(const std::string name)
-: Module<ScaledDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TScaledDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TScaledDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TScaledDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up scaled domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", scale= " << par().scale
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-    LOG(Message) << "Fermion boundary conditions: " << par().boundary
-                 << std::endl;
-
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    typename ScaledShamirFermion<FImpl>::ImplParams implParams;
-    implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    envCreateDerived(FMat, ScaledShamirFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, par().scale,
-                     implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TScaledDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_ScaledDWF_hpp_

Hadrons/Modules/MAction/Wilson.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/Wilson.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/Wilson.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TWilson<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TWilson<FIMPLF>;
-#endif

Hadrons/Modules/MAction/WilsonClover.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/WilsonClover.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/WilsonClover.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TWilsonClover<FIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TWilsonClover<FIMPLF>;
-#endif

Hadrons/Modules/MAction/ZMobiusDWF.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ZMobiusDWF.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MAction/ZMobiusDWF.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MAction;
-
-template class Grid::Hadrons::MAction::TZMobiusDWF<ZFIMPL>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MAction::TZMobiusDWF<ZFIMPLF>;
-#endif

Hadrons/Modules/MAction/ZMobiusDWF.hpp

@@ -1,148 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MAction/ZMobiusDWF.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MAction_ZMobiusDWF_hpp_
-#define Hadrons_MAction_ZMobiusDWF_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      z-Mobius domain-wall fermion action                   *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MAction)
-
-class ZMobiusDWFPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ZMobiusDWFPar,
-                                    std::string                      , gauge,
-                                    unsigned int                     , Ls,
-                                    double                           , mass,
-                                    double                           , M5,
-                                    double                           , b,
-                                    double                           , c,
-                                    std::vector<std::complex<double>>, omega,
-                                    std::string                      , boundary,
-                                    std::string                      , twist);
-};
-
-template <typename FImpl>
-class TZMobiusDWF: public Module<ZMobiusDWFPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TZMobiusDWF(const std::string name);
-    // destructor
-    virtual ~TZMobiusDWF(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(ZMobiusDWF, TZMobiusDWF<ZFIMPL>, MAction);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(ZMobiusDWFF, TZMobiusDWF<ZFIMPLF>, MAction);
-#endif
-
-/******************************************************************************
- *                     TZMobiusDWF implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TZMobiusDWF<FImpl>::TZMobiusDWF(const std::string name)
-: Module<ZMobiusDWFPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TZMobiusDWF<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TZMobiusDWF<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZMobiusDWF<FImpl>::setup(void)
-{
-    LOG(Message) << "Setting up z-Mobius domain wall fermion matrix with m= "
-                 << par().mass << ", M5= " << par().M5 << ", Ls= " << par().Ls 
-                 << ", b= " << par().b << ", c= " << par().c
-                 << " using gauge field '" << par().gauge << "'"
-                 << std::endl;
-    LOG(Message) << "Omegas: " << std::endl;
-    for (unsigned int i = 0; i < par().omega.size(); ++i)
-    {
-        LOG(Message) << "  omega[" << i << "]= " << par().omega[i] << std::endl;
-    }
-    LOG(Message) << "Fermion boundary conditions: " << par().boundary
-                 << std::endl;
-
-    env().createGrid(par().Ls);
-    auto &U    = envGet(GaugeField, par().gauge);
-    auto &g4   = *envGetGrid(FermionField);
-    auto &grb4 = *envGetRbGrid(FermionField);
-    auto &g5   = *envGetGrid(FermionField, par().Ls);
-    auto &grb5 = *envGetRbGrid(FermionField, par().Ls);
-    auto omega = par().omega;
-    typename ZMobiusFermion<FImpl>::ImplParams implParams;
-    implParams.boundary_phases = strToVec<Complex>(par().boundary);
-    implParams.twist_n_2pi_L   = strToVec<Real>(par().twist);
-    envCreateDerived(FMat, ZMobiusFermion<FImpl>, getName(), par().Ls, U, g5,
-                     grb5, g4, grb4, par().mass, par().M5, omega,
-                     par().b, par().c, implParams);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TZMobiusDWF<FImpl>::execute(void)
-{}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MAction_ZMobiusDWF_hpp_

Hadrons/Modules/MContraction/A2AAslashField.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AAslashField.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/A2AAslashField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2AAslashField<FIMPL, PhotonR>;

Hadrons/Modules/MContraction/A2AAslashField.hpp

@@ -1,246 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AAslashField.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_A2AAslashField_hpp_
-#define Hadrons_MContraction_A2AAslashField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         A2AAslashField                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2AAslashFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AAslashFieldPar,
-                                    int, cacheBlock,
-                                    int, block,
-                                    std::string, left,
-                                    std::string, right,
-                                    std::string, output,
-                                    std::vector<std::string>, emField);
-};
-
-class A2AAslashFieldMetadata: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AAslashFieldMetadata,
-                                    std::string, emFieldName);
-};
-
-template <typename T, typename FImpl>
-class AslashFieldKernel: public A2AKernel<T, typename FImpl::FermionField>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    AslashFieldKernel(const std::vector<LatticeComplex> &emB0,
-                      const std::vector<LatticeComplex> &emB1,
-                      GridBase *grid)
-    : emB0_(emB0), emB1_(emB1), grid_(grid)
-    {
-        vol_ = 1.;
-        for (auto &d: grid_->GlobalDimensions())
-        {
-            vol_ *= d;
-        }
-    }
-
-    virtual ~AslashFieldKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const FermionField *left, 
-                            const FermionField *right,
-                            const unsigned int orthogDim, double &t)
-    {
-        A2Autils<FImpl>::AslashField(m, left, right, emB0_, emB1_, orthogDim, &t);
-    }
-
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return 0.;
-    }
-
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return 0.;
-    }
-private:
-    const std::vector<LatticeComplex> &emB0_, &emB1_;
-    GridBase                          *grid_;
-    double                            vol_;
-};
-
-template <typename FImpl, typename PhotonImpl>
-class TA2AAslashField: public Module<A2AAslashFieldPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef typename PhotonImpl::GaugeField EmField;
-    typedef A2AMatrixBlockComputation<Complex, 
-                                      FermionField, 
-                                      A2AAslashFieldMetadata, 
-                                      HADRONS_A2AM_IO_TYPE> Computation;
-    typedef AslashFieldKernel<Complex, FImpl> Kernel;
-public:
-    // constructor
-    TA2AAslashField(const std::string name);
-    // destructor
-    virtual ~TA2AAslashField(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(A2AAslashField, ARG(TA2AAslashField<FIMPL, PhotonR>), MContraction);
-
-/******************************************************************************
- *                 TA2AAslashField implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-TA2AAslashField<FImpl, PhotonImpl>::TA2AAslashField(const std::string name)
-: Module<A2AAslashFieldPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-std::vector<std::string> TA2AAslashField<FImpl, PhotonImpl>::getInput(void)
-{
-    std::vector<std::string> in = par().emField;
-    
-    in.push_back(par().left);
-    in.push_back(par().right);
-
-    return in;
-}
-
-template <typename FImpl, typename PhotonImpl>
-std::vector<std::string> TA2AAslashField<FImpl, PhotonImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-void TA2AAslashField<FImpl, PhotonImpl>::setup(void)
-{
-    envTmp(Computation, "computation", 1, envGetGrid(FermionField), 
-           env().getNd() - 1, par().emField.size(), 1, par().block, 
-           par().cacheBlock, this);
-    envTmp(std::vector<ComplexField>, "B0", 1, 
-           par().emField.size(), envGetGrid(ComplexField));
-    envTmp(std::vector<ComplexField>, "B1", 1, 
-           par().emField.size(), envGetGrid(ComplexField));
-    envTmpLat(ComplexField, "Amu");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl, typename PhotonImpl>
-void TA2AAslashField<FImpl, PhotonImpl>::execute(void)
-{
-    auto &left  = envGet(std::vector<FermionField>, par().left);
-    auto &right = envGet(std::vector<FermionField>, par().right);
-
-    int nt         = env().getDim().back();
-    int N_i        = left.size();
-    int N_j        = right.size();
-    int nem        = par().emField.size();
-    int block      = par().block;
-    int cacheBlock = par().cacheBlock;
-
-    LOG(Message) << "Computing all-to-all A-slash fields" << std::endl;
-    LOG(Message) << "Left: '" << par().left << "' Right: '" << par().right << "'" << std::endl;
-    LOG(Message) << "EM fields:" << std::endl;
-    for (auto &name: par().emField)
-    {
-        LOG(Message) << "  " << name << std::endl;
-    }
-    LOG(Message) << "A-slash field size: " << nt << "*" << N_i << "*" << N_j 
-                 << " (filesize " << sizeString(nt*N_i*N_j*sizeof(HADRONS_A2AM_IO_TYPE)) 
-                 << "/EM field)" << std::endl;
-    
-    // preparing "B" complexified fields
-    startTimer("Complexify EM fields");
-    envGetTmp(std::vector<ComplexField>, B0);
-    envGetTmp(std::vector<ComplexField>, B1);
-    for (unsigned int i = 0; i < par().emField.size(); ++i)
-    {
-        auto &A = envGet(EmField, par().emField[i]);
-        envGetTmp(ComplexField, Amu);
-
-        B0[i]  = peekLorentz(A, 0);
-        B0[i] += timesI(peekLorentz(A, 1));
-        B1[i]  = peekLorentz(A, 2);
-        B1[i] += timesI(peekLorentz(A, 3));
-    }
-    stopTimer("Complexify EM fields");
-
-    // I/O name & metadata lambdas
-    auto ionameFn = [this](const unsigned int em, const unsigned int dummy)
-    {
-        return par().emField[em];
-    };
-
-    auto filenameFn = [this, &ionameFn](const unsigned int em, const unsigned int dummy)
-    {
-        return par().output + "." + std::to_string(vm().getTrajectory()) 
-               + "/" + ionameFn(em, dummy) + ".h5";
-    };
-
-    auto metadataFn = [this](const unsigned int em, const unsigned int dummy)
-    {
-        A2AAslashFieldMetadata md;
-
-        md.emFieldName = par().emField[em];
-        
-        return md;
-    };
-
-    // executing computation
-    Kernel kernel(B0, B1, envGetGrid(FermionField));
-
-    envGetTmp(Computation, computation);
-    computation.execute(left, right, kernel, ionameFn, filenameFn, metadataFn);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2AAslashField_hpp_

Hadrons/Modules/MContraction/A2AMesonField.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AMesonField.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/A2AMesonField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TA2AMesonField<FIMPL>;

Hadrons/Modules/MContraction/A2AMesonField.hpp

@@ -1,315 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/A2AMesonField.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MContraction_A2AMesonField_hpp_
-#define Hadrons_MContraction_A2AMesonField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/A2AMatrix.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                     All-to-all meson field creation                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MContraction)
-
-class A2AMesonFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AMesonFieldPar,
-                                    int, cacheBlock,
-                                    int, block,
-                                    std::string, left,
-                                    std::string, right,
-                                    std::string, output,
-                                    std::string, gammas,
-                                    std::vector<std::string>, mom);
-};
-
-class A2AMesonFieldMetadata: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(A2AMesonFieldMetadata,
-                                    std::vector<RealF>, momentum,
-                                    Gamma::Algebra, gamma);
-};
-
-template <typename T, typename FImpl>
-class MesonFieldKernel: public A2AKernel<T, typename FImpl::FermionField>
-{
-public:
-    typedef typename FImpl::FermionField FermionField;
-public:
-    MesonFieldKernel(const std::vector<Gamma::Algebra> &gamma,
-                     const std::vector<LatticeComplex> &mom,
-                     GridBase *grid)
-    : gamma_(gamma), mom_(mom), grid_(grid)
-    {
-        vol_ = 1.;
-        for (auto &d: grid_->GlobalDimensions())
-        {
-            vol_ *= d;
-        }
-    }
-
-    virtual ~MesonFieldKernel(void) = default;
-    virtual void operator()(A2AMatrixSet<T> &m, const FermionField *left, 
-                            const FermionField *right,
-                            const unsigned int orthogDim, double &t)
-    {
-        A2Autils<FImpl>::MesonField(m, left, right, gamma_, mom_, orthogDim, &t);
-    }
-
-    virtual double flops(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return vol_*(2*8.0+6.0+8.0*mom_.size())*blockSizei*blockSizej*gamma_.size();
-    }
-
-    virtual double bytes(const unsigned int blockSizei, const unsigned int blockSizej)
-    {
-        return vol_*(12.0*sizeof(T))*blockSizei*blockSizej
-               +  vol_*(2.0*sizeof(T)*mom_.size())*blockSizei*blockSizej*gamma_.size();
-    }
-private:
-    const std::vector<Gamma::Algebra> &gamma_;
-    const std::vector<LatticeComplex> &mom_;
-    GridBase                          *grid_;
-    double                            vol_;
-};
-
-template <typename FImpl>
-class TA2AMesonField : public Module<A2AMesonFieldPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-    typedef A2AMatrixBlockComputation<Complex, 
-                                      FermionField, 
-                                      A2AMesonFieldMetadata, 
-                                      HADRONS_A2AM_IO_TYPE> Computation;
-    typedef MesonFieldKernel<Complex, FImpl> Kernel;
-public:
-    // constructor
-    TA2AMesonField(const std::string name);
-    // destructor
-    virtual ~TA2AMesonField(void){};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool                               hasPhase_{false};
-    std::string                        momphName_;
-    std::vector<Gamma::Algebra>        gamma_;
-    std::vector<std::vector<Real>>     mom_;
-};
-
-MODULE_REGISTER(A2AMesonField, ARG(TA2AMesonField<FIMPL>), MContraction);
-
-/******************************************************************************
-*                  TA2AMesonField implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TA2AMesonField<FImpl>::TA2AMesonField(const std::string name)
-: Module<A2AMesonFieldPar>(name)
-, momphName_(name + "_momph")
-{
-}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TA2AMesonField<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().left, par().right};
-
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TA2AMesonField<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AMesonField<FImpl>::setup(void)
-{
-    gamma_.clear();
-    mom_.clear();
-    if (par().gammas == "all")
-    {
-        gamma_ = {
-            Gamma::Algebra::Gamma5,
-            Gamma::Algebra::Identity,    
-            Gamma::Algebra::GammaX,
-            Gamma::Algebra::GammaY,
-            Gamma::Algebra::GammaZ,
-            Gamma::Algebra::GammaT,
-            Gamma::Algebra::GammaXGamma5,
-            Gamma::Algebra::GammaYGamma5,
-            Gamma::Algebra::GammaZGamma5,
-            Gamma::Algebra::GammaTGamma5,
-            Gamma::Algebra::SigmaXY,
-            Gamma::Algebra::SigmaXZ,
-            Gamma::Algebra::SigmaXT,
-            Gamma::Algebra::SigmaYZ,
-            Gamma::Algebra::SigmaYT,
-            Gamma::Algebra::SigmaZT
-        };
-    }
-    else
-    {
-        gamma_ = strToVec<Gamma::Algebra>(par().gammas);
-    }
-    for (auto &pstr: par().mom)
-    {
-        auto p = strToVec<Real>(pstr);
-
-        if (p.size() != env().getNd() - 1)
-        {
-            HADRONS_ERROR(Size, "Momentum has " + std::to_string(p.size())
-                                + " components instead of " 
-                                + std::to_string(env().getNd() - 1));
-        }
-        mom_.push_back(p);
-    }
-    envCache(std::vector<ComplexField>, momphName_, 1, 
-             par().mom.size(), envGetGrid(ComplexField));
-    envTmpLat(ComplexField, "coor");
-    envTmp(Computation, "computation", 1, envGetGrid(FermionField), 
-           env().getNd() - 1, mom_.size(), gamma_.size(), par().block, 
-           par().cacheBlock, this);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TA2AMesonField<FImpl>::execute(void)
-{
-    auto &left  = envGet(std::vector<FermionField>, par().left);
-    auto &right = envGet(std::vector<FermionField>, par().right);
-
-    int nt         = env().getDim().back();
-    int N_i        = left.size();
-    int N_j        = right.size();
-    int ngamma     = gamma_.size();
-    int nmom       = mom_.size();
-    int block      = par().block;
-    int cacheBlock = par().cacheBlock;
-
-    LOG(Message) << "Computing all-to-all meson fields" << std::endl;
-    LOG(Message) << "Left: '" << par().left << "' Right: '" << par().right << "'" << std::endl;
-    LOG(Message) << "Momenta:" << std::endl;
-    for (auto &p: mom_)
-    {
-        LOG(Message) << "  " << p << std::endl;
-    }
-    LOG(Message) << "Spin bilinears:" << std::endl;
-    for (auto &g: gamma_)
-    {
-        LOG(Message) << "  " << g << std::endl;
-    }
-    LOG(Message) << "Meson field size: " << nt << "*" << N_i << "*" << N_j 
-                 << " (filesize " << sizeString(nt*N_i*N_j*sizeof(HADRONS_A2AM_IO_TYPE)) 
-                 << "/momentum/bilinear)" << std::endl;
-
-    auto &ph = envGet(std::vector<ComplexField>, momphName_);
-
-    if (!hasPhase_)
-    {
-        startTimer("Momentum phases");
-        for (unsigned int j = 0; j < nmom; ++j)
-        {
-            Complex           i(0.0,1.0);
-            std::vector<Real> p;
-
-            envGetTmp(ComplexField, coor);
-            ph[j] = zero;
-            for(unsigned int mu = 0; mu < mom_[j].size(); mu++)
-            {
-                LatticeCoordinate(coor, mu);
-                ph[j] = ph[j] + (mom_[j][mu]/env().getDim(mu))*coor;
-            }
-            ph[j] = exp((Real)(2*M_PI)*i*ph[j]);
-        }
-        hasPhase_ = true;
-        stopTimer("Momentum phases");
-    }
-
-    auto ionameFn = [this](const unsigned int m, const unsigned int g)
-    {
-        std::stringstream ss;
-
-        ss << gamma_[g] << "_";
-        for (unsigned int mu = 0; mu < mom_[m].size(); ++mu)
-        {
-            ss << mom_[m][mu] << ((mu == mom_[m].size() - 1) ? "" : "_");
-        }
-
-        return ss.str();
-    };
-
-    auto filenameFn = [this, &ionameFn](const unsigned int m, const unsigned int g)
-    {
-        return par().output + "." + std::to_string(vm().getTrajectory()) 
-               + "/" + ionameFn(m, g) + ".h5";
-    };
-
-    auto metadataFn = [this](const unsigned int m, const unsigned int g)
-    {
-        A2AMesonFieldMetadata md;
-
-        for (auto pmu: mom_[m])
-        {
-            md.momentum.push_back(pmu);
-        }
-        md.gamma = gamma_[g];
-        
-        return md;
-    };
-
-    Kernel      kernel(gamma_, ph, envGetGrid(FermionField));
-
-    envGetTmp(Computation, computation);
-    computation.execute(left, right, kernel, ionameFn, filenameFn, metadataFn);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MContraction_A2AMesonField_hpp_

Hadrons/Modules/MContraction/DiscLoop.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/DiscLoop.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/DiscLoop.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TDiscLoop<FIMPL>;
-

Hadrons/Modules/MContraction/Meson.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/Meson.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/Meson.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TMeson<FIMPL,FIMPL>;
-

Hadrons/Modules/MContraction/WardIdentity.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MContraction/WardIdentity.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MContraction/WardIdentity.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MContraction;
-
-template class Grid::Hadrons::MContraction::TWardIdentity<FIMPL>;
-

Hadrons/Modules/MFermion/FreeProp.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/FreeProp.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MFermion/FreeProp.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MFermion;
-
-template class Grid::Hadrons::MFermion::TFreeProp<FIMPL>;
-

Hadrons/Modules/MFermion/FreeProp.hpp

@@ -1,188 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/FreeProp.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <vmg1n14@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-
-#ifndef Hadrons_MFermion_FreeProp_hpp_
-#define Hadrons_MFermion_FreeProp_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         FreeProp                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MFermion)
-
-class FreePropPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FreePropPar,
-                                    std::string, source,
-				    std::string,  action,
-				    double, mass,
-				    std::string,  twist);
-};
-
-template <typename FImpl>
-class TFreeProp: public Module<FreePropPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TFreeProp(const std::string name);
-    // destructor
-    virtual ~TFreeProp(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    unsigned int Ls_;
-};
-
-MODULE_REGISTER_TMP(FreeProp, TFreeProp<FIMPL>, MFermion);
-
-/******************************************************************************
- *                 TFreeProp implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TFreeProp<FImpl>::TFreeProp(const std::string name)
-: Module<FreePropPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TFreeProp<FImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().source, par().action};
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TFreeProp<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName(), getName() + "_5d"};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFreeProp<FImpl>::setup(void)
-{
-    Ls_ = env().getObjectLs(par().action);
-    envCreateLat(PropagatorField, getName());
-    envTmpLat(FermionField, "source", Ls_);
-    envTmpLat(FermionField, "sol", Ls_);
-    envTmpLat(FermionField, "tmp");
-    if (Ls_ > 1)
-    {
-        envCreateLat(PropagatorField, getName() + "_5d", Ls_);
-    }    
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFreeProp<FImpl>::execute(void)
-{
-    LOG(Message) << "Computing free fermion propagator '" << getName() << "'"
-                 << std::endl;
-    
-    std::string propName = (Ls_ == 1) ? getName() : (getName() + "_5d");
-    auto        &prop    = envGet(PropagatorField, propName);
-    auto        &fullSrc = envGet(PropagatorField, par().source);
-    auto        &mat = envGet(FMat, par().action);
-    RealD mass = par().mass;
-    
-    envGetTmp(FermionField, source);
-    envGetTmp(FermionField, sol);
-    envGetTmp(FermionField, tmp);
-    LOG(Message) << "Calculating a free Propagator with mass " << mass 
-		 << " using the action '" << par().action
-                 << "' on source '" << par().source << "'" << std::endl;
-    for (unsigned int s = 0; s < Ns; ++s)
-      for (unsigned int c = 0; c < FImpl::Dimension; ++c)
-    {
-        LOG(Message) << "Calculation for spin= " << s << ", color= " << c
-                     << std::endl;
-        // source conversion for 4D sources
-        if (!env().isObject5d(par().source))
-        {
-            if (Ls_ == 1)
-            {
-               PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-            else
-            {
-                PropToFerm<FImpl>(tmp, fullSrc, s, c);
-                mat.ImportPhysicalFermionSource(tmp, source);
-            }
-        }
-        // source conversion for 5D sources
-        else
-        {
-            if (Ls_ != env().getObjectLs(par().source))
-            {
-                HADRONS_ERROR(Size, "Ls mismatch between quark action and source");
-            }
-            else
-            {
-                PropToFerm<FImpl>(source, fullSrc, s, c);
-            }
-        }
-        sol = zero;
-	std::vector<double> twist = strToVec<double>(par().twist);
-	if(twist.size() != Nd) HADRONS_ERROR(Size, "number of twist angles does not match number of dimensions");
-	mat.FreePropagator(source,sol,mass,twist);
-        FermToProp<FImpl>(prop, sol, s, c);
-        // create 4D propagators from 5D one if necessary
-        if (Ls_ > 1)
-        {
-            PropagatorField &p4d = envGet(PropagatorField, getName());
-            mat.ExportPhysicalFermionSolution(sol, tmp);
-            FermToProp<FImpl>(p4d, tmp, s, c);
-        }
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MFermion_FreeProp_hpp_

Hadrons/Modules/MFermion/GaugeProp.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MFermion/GaugeProp.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MFermion/GaugeProp.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MFermion;
-
-template class Grid::Hadrons::MFermion::TGaugeProp<FIMPL>;
-template class Grid::Hadrons::MFermion::TGaugeProp<ZFIMPL>;

Hadrons/Modules/MGauge/Electrify.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Electrify.cc
-
-Copyright (C) 2015-2018
-
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Electrify.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TElectrify<GIMPL>;

Hadrons/Modules/MGauge/Electrify.hpp

@@ -1,151 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Electrify.hpp
-
-Copyright (C) 2015-2018
-
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGauge_Electrify_hpp_
-#define Hadrons_MGauge_Electrify_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              Electrify gauge                               *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-/****************************************************************************
-*  Electrify a gauge field:
-*
-*  Ue_mu(x) = U_mu(x)*exp(ieqA_mu(x))
-*
-*  with
-*
-*  - gauge: U_mu(x): gauge field
-*  - emField: A_mu(x): electromagnetic photon field
-*  - e: value for the elementary charge
-*  - q: charge in units of e
-*
-*****************************************************************************/
-
-
-class ElectrifyPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ElectrifyPar,
-                                    std::string, gauge,
-				    std::string, emField,
-				    double, e,
-				    double, charge);
-};
-
-template <typename GImpl>
-class TElectrify: public Module<ElectrifyPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    typedef PhotonR::GaugeField     EmField;
-public:
-    // constructor
-    TElectrify(const std::string name);
-    // destructor
-    virtual ~TElectrify(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Electrify, TElectrify<GIMPL>, MGauge);
-
-/******************************************************************************
-*                            TElectrify implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TElectrify<GImpl>::TElectrify(const std::string name)
-: Module<ElectrifyPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TElectrify<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge, par().emField};
-
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TElectrify<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TElectrify<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-    envTmpLat(LatticeComplex, "eiAmu");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TElectrify<GImpl>::execute(void)
-{
-    LOG(Message) << "Electrify the gauge field " << par().gauge << " using the photon field " 
-                  << par().emField << " with charge e*q= " << par().e << "*" << par().charge << std::endl;
-    
-    auto &Ue = envGet(GaugeField, getName());
-    auto &U = envGet(GaugeField, par().gauge);
-    auto &A = envGet(EmField,  par().emField);
-    envGetTmp(LatticeComplex, eiAmu);
-
-    Complex i(0.0,1.0);
-
-    for(unsigned int mu = 0; mu < env().getNd(); mu++)
-    {
-	eiAmu = exp(i * (Real)(par().e * par().charge) * PeekIndex<LorentzIndex>(A, mu));
-	PokeIndex<LorentzIndex>(Ue, PeekIndex<LorentzIndex>(U, mu) * eiAmu, mu);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_Electrify_hpp_

Hadrons/Modules/MGauge/GaugeFix.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/GaugeFix.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#include <Hadrons/Modules/MGauge/GaugeFix.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TGaugeFix<GIMPL>;

Hadrons/Modules/MGauge/GaugeFix.hpp

@@ -1,135 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/GaugeFix.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_MGaugeFix_hpp_
-#define Hadrons_MGaugeFix_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/qcd/utils/GaugeFix.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                              Fix gauge                                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class GaugeFixPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GaugeFixPar,
-                                    std::string, gauge,
-                                    Real,  alpha,
-                                    int, maxiter, 
-                                    Real, Omega_tol, 
-                                    Real, Phi_tol,
-                                    bool, Fourier);
-};
-
-template <typename GImpl>
-class TGaugeFix: public Module<GaugeFixPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TGaugeFix(const std::string name);
-    // destructor
-    virtual ~TGaugeFix(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(GaugeFix, TGaugeFix<GIMPL>, MGauge);
-
-/******************************************************************************
-*                            TGaugeFix implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TGaugeFix<GImpl>::TGaugeFix(const std::string name)
-: Module<GaugeFixPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TGaugeFix<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TGaugeFix<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TGaugeFix<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-}
-
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TGaugeFix<GImpl>::execute(void)
-//Loads the gauge and fixes it
-{
-    std::cout << "executing" << std::endl;
-    LOG(Message) << "Fixing the Gauge" << std::endl;
-    LOG(Message) << par().gauge << std::endl;
-    auto &U     = envGet(GaugeField, par().gauge);
-    auto &Umu   = envGet(GaugeField, getName());
-    LOG(Message) << "Gauge Field fetched" << std::endl;
-    //do we allow maxiter etc to be user set?
-    Real alpha     = par().alpha;
-    int  maxiter   = par().maxiter;
-    Real Omega_tol = par().Omega_tol;
-    Real Phi_tol   = par().Phi_tol;
-    bool Fourier   = par().Fourier;
-    FourierAcceleratedGaugeFixer<PeriodicGimplR>::SteepestDescentGaugeFix(U,alpha,maxiter,Omega_tol,Phi_tol,Fourier);
-    Umu = U;
-    LOG(Message) << "Gauge Fixed" << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGaugeFix_hpp_

Hadrons/Modules/MGauge/Random.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Random.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Random.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TRandom<GIMPL>;

Hadrons/Modules/MGauge/StoutSmearing.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StoutSmearing.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/StoutSmearing.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TStoutSmearing<GIMPL>;

Hadrons/Modules/MGauge/StoutSmearing.hpp

@@ -1,135 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/StoutSmearing.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MGauge_StoutSmearing_hpp_
-#define Hadrons_MGauge_StoutSmearing_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                            Stout smearing                                  *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MGauge)
-
-class StoutSmearingPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StoutSmearingPar,
-                                    std::string, gauge,
-                                    unsigned int, steps,
-                                    double, rho);
-};
-
-template <typename GImpl>
-class TStoutSmearing: public Module<StoutSmearingPar>
-{
-public:
-    GAUGE_TYPE_ALIASES(GImpl,);
-public:
-    // constructor
-    TStoutSmearing(const std::string name);
-    // destructor
-    virtual ~TStoutSmearing(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(StoutSmearing, TStoutSmearing<GIMPL>, MGauge);
-
-/******************************************************************************
- *                     TStoutSmearing implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename GImpl>
-TStoutSmearing<GImpl>::TStoutSmearing(const std::string name)
-: Module<StoutSmearingPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename GImpl>
-std::vector<std::string> TStoutSmearing<GImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().gauge};
-    
-    return in;
-}
-
-template <typename GImpl>
-std::vector<std::string> TStoutSmearing<GImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TStoutSmearing<GImpl>::setup(void)
-{
-    envCreateLat(GaugeField, getName());
-    envTmpLat(GaugeField, "buf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename GImpl>
-void TStoutSmearing<GImpl>::execute(void)
-{
-    LOG(Message) << "Smearing '" << par().gauge << "' with " << par().steps
-                 << " step" << ((par().steps > 1) ? "s" : "") 
-                 << " of stout smearing and rho= " << par().rho << std::endl;
-
-    Smear_Stout<GImpl> smearer(par().rho);
-    auto               &U    = envGet(GaugeField, par().gauge);
-    auto               &Usmr = envGet(GaugeField, getName());
-
-    envGetTmp(GaugeField, buf);
-    buf = U;
-    LOG(Message) << "plaquette= " << WilsonLoops<GImpl>::avgPlaquette(U)
-                 << std::endl;
-    for (unsigned int n = 0; n < par().steps; ++n)
-    {
-        smearer.smear(Usmr, buf);
-        buf = Usmr;
-        LOG(Message) << "plaquette= " << WilsonLoops<GImpl>::avgPlaquette(Usmr)
-                     << std::endl;
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MGauge_StoutSmearing_hpp_

Hadrons/Modules/MGauge/Unit.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MGauge/Unit.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MGauge/Unit.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MGauge;
-
-template class Grid::Hadrons::MGauge::TUnit<GIMPL>;

Hadrons/Modules/MIO/LoadA2AVectors.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadA2AVectors.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadA2AVectors.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadA2AVectors<FIMPL>;

Hadrons/Modules/MIO/LoadBinary.cc

@@ -1,40 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadBinary.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadBinary.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadBinary<GIMPL>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MIO::TLoadBinary<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MIO/LoadCoarseEigenPack.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCoarseEigenPack.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL,HADRONS_DEFAULT_LANCZOS_NBASIS>>;
-

Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp

@@ -1,135 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCoarseEigenPack.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadCoarseEigenPack_hpp_
-#define Hadrons_MIO_LoadCoarseEigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *              Load local coherence eigen vectors/values package             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadCoarseEigenPackPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadCoarseEigenPackPar,
-                                    std::string, filestem,
-                                    bool,         multiFile,
-                                    unsigned int, sizeFine,
-                                    unsigned int, sizeCoarse,
-                                    unsigned int, Ls,
-                                    std::vector<int>, blockSize);
-};
-
-template <typename Pack>
-class TLoadCoarseEigenPack: public Module<LoadCoarseEigenPackPar>
-{
-public:
-    typedef CoarseEigenPack<typename Pack::Field, typename Pack::CoarseField> BasePack;
-    template <typename vtype> 
-    using iImplScalar = iScalar<iScalar<iScalar<vtype>>>;
-    typedef iImplScalar<typename Pack::Field::vector_type> SiteComplex;
-public:
-    // constructor
-    TLoadCoarseEigenPack(const std::string name);
-    // destructor
-    virtual ~TLoadCoarseEigenPack(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadCoarseFermionEigenPack, ARG(TLoadCoarseEigenPack<CoarseFermionEigenPack<FIMPL, HADRONS_DEFAULT_LANCZOS_NBASIS>>), MIO);
-
-/******************************************************************************
- *                 TLoadCoarseEigenPack implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Pack>
-TLoadCoarseEigenPack<Pack>::TLoadCoarseEigenPack(const std::string name)
-: Module<LoadCoarseEigenPackPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Pack>
-std::vector<std::string> TLoadCoarseEigenPack<Pack>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename Pack>
-std::vector<std::string> TLoadCoarseEigenPack<Pack>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadCoarseEigenPack<Pack>::setup(void)
-{
-    env().createGrid(par().Ls);
-    env().createCoarseGrid(par().blockSize, par().Ls);
-    envCreateDerived(BasePack, Pack, getName(), par().Ls, par().sizeFine,
-                     par().sizeCoarse, env().getRbGrid(par().Ls), 
-                     env().getCoarseGrid(par().blockSize, par().Ls));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadCoarseEigenPack<Pack>::execute(void)
-{
-    auto                 cg     = env().getCoarseGrid(par().blockSize, par().Ls);
-    auto                 &epack = envGetDerived(BasePack, Pack, getName());
-    Lattice<SiteComplex> dummy(cg);
-
-    epack.read(par().filestem, par().multiFile, vm().getTrajectory());
-    LOG(Message) << "Block Gramm-Schmidt pass 1"<< std::endl;
-    blockOrthogonalise(dummy, epack.evec);
-    LOG(Message) << "Block Gramm-Schmidt pass 2"<< std::endl;
-    blockOrthogonalise(dummy, epack.evec);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadCoarseEigenPack_hpp_

Hadrons/Modules/MIO/LoadCosmHol.cc

@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCosmHol.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadCosmHol.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MIO::TLoadCosmHol<ScalarNxNAdjImplR<6>>;

Hadrons/Modules/MIO/LoadCosmHol.hpp

@@ -1,146 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadCosmHol.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadCosmHol_hpp_
-#define Hadrons_MIO_LoadCosmHol_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                    Load scalar SU(N) configurations                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadCosmHolPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadCosmHolPar,
-                                    std::string, file);
-};
-
-class ScalarActionParameters: Serializable 
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarActionParameters,
-                                    double, mass_squared,
-                                    double, lambda,
-                                    double, g);
-};
-
-template <typename SImpl>
-class TLoadCosmHol: public Module<LoadCosmHolPar>
-{
-public:
-    typedef typename SImpl::Field Field;
-public:
-    // constructor
-    TLoadCosmHol(const std::string name);
-    // destructor
-    virtual ~TLoadCosmHol(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadCosmHolSU2, TLoadCosmHol<ScalarNxNAdjImplR<2>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU3, TLoadCosmHol<ScalarNxNAdjImplR<3>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU4, TLoadCosmHol<ScalarNxNAdjImplR<4>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU5, TLoadCosmHol<ScalarNxNAdjImplR<5>>, MIO);
-MODULE_REGISTER_TMP(LoadCosmHolSU6, TLoadCosmHol<ScalarNxNAdjImplR<6>>, MIO);
-
-/******************************************************************************
- *                       TLoadCosmHol implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TLoadCosmHol<SImpl>::TLoadCosmHol(const std::string name)
-: Module<LoadCosmHolPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TLoadCosmHol<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TLoadCosmHol<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TLoadCosmHol<SImpl>::setup(void)
-{
-    envCreateLat(Field, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TLoadCosmHol<SImpl>::execute(void)
-{
-    ScalarActionParameters    md;
-    std::string        filename = par().file + "."
-                                  + std::to_string(vm().getTrajectory());
-    ScidacReader       reader;
-    const unsigned int N    = SImpl::Group::Dimension;
-    auto               &phi = envGet(Field, getName());
-
-    LOG(Message) << "Loading CosmHol configuration from file '" << filename
-                 << "'" << std::endl;
-    reader.open(filename);
-    reader.readScidacFieldRecord(phi, md);
-    reader.close();
-    LOG(Message) << "tr(phi^2) = " 
-                 << -TensorRemove(sum(trace(phi*phi))).real()/env().getVolume() 
-                 << std::endl;
-    LOG(Message) << "Configuration parameters:" << std::endl;
-    LOG(Message) << "     N = " << N << std::endl;
-    LOG(Message) << "   m^2 = " << md.mass_squared << std::endl;
-    LOG(Message) << "lambda = " << md.lambda << std::endl;
-    LOG(Message) << "     g = " << md.g << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadCosmHol_hpp_

Hadrons/Modules/MIO/LoadEigenPack.cc

@@ -1,37 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadEigenPack.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadEigenPack.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL>>;
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>>;
-#endif

Hadrons/Modules/MIO/LoadEigenPack.hpp

@@ -1,133 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadEigenPack.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MIO_LoadEigenPack_hpp_
-#define Hadrons_MIO_LoadEigenPack_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/EigenPack.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                   Load eigen vectors/values package                        *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MIO)
-
-class LoadEigenPackPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(LoadEigenPackPar,
-                                    std::string, filestem,
-                                    bool, multiFile,
-                                    unsigned int, size,
-                                    unsigned int, Ls);
-};
-
-template <typename Pack>
-class TLoadEigenPack: public Module<LoadEigenPackPar>
-{
-public:
-    typedef typename Pack::Field   Field;
-    typedef typename Pack::FieldIo FieldIo;
-    typedef BaseEigenPack<Field>   BasePack;
-public:
-    // constructor
-    TLoadEigenPack(const std::string name);
-    // destructor
-    virtual ~TLoadEigenPack(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(LoadFermionEigenPack, TLoadEigenPack<FermionEigenPack<FIMPL>>, MIO);
-#ifdef GRID_DEFAULT_PRECISION_DOUBLE
-MODULE_REGISTER_TMP(LoadFermionEigenPackIo32, ARG(TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>>), MIO);
-#endif
-
-/******************************************************************************
- *                    TLoadEigenPack implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename Pack>
-TLoadEigenPack<Pack>::TLoadEigenPack(const std::string name)
-: Module<LoadEigenPackPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename Pack>
-std::vector<std::string> TLoadEigenPack<Pack>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename Pack>
-std::vector<std::string> TLoadEigenPack<Pack>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadEigenPack<Pack>::setup(void)
-{
-    GridBase *gridIo = nullptr;
-
-    if (typeHash<Field>() != typeHash<FieldIo>())
-    {
-        gridIo = envGetRbGrid(FieldIo, par().Ls);
-    }
-    envCreateDerived(BasePack, Pack, getName(), par().Ls, par().size, 
-                     envGetRbGrid(Field, par().Ls), gridIo);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename Pack>
-void TLoadEigenPack<Pack>::execute(void)
-{
-    auto &epack = envGetDerived(BasePack, Pack, getName());
-
-    epack.read(par().filestem, par().multiFile, vm().getTrajectory());
-    epack.eval.resize(par().size);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MIO_LoadEigenPack_hpp_

Hadrons/Modules/MIO/LoadNersc.cc

@@ -1,34 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MIO/LoadNersc.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MIO/LoadNersc.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MIO;
-
-template class Grid::Hadrons::MIO::TLoadNersc<GIMPL>;

Hadrons/Modules/MLoop/NoiseLoop.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MLoop/NoiseLoop.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MLoop/NoiseLoop.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MLoop;
-
-template class Grid::Hadrons::MLoop::TNoiseLoop<FIMPL>;
-

Hadrons/Modules/MNPR/Amputate.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Amputate.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/Amputate.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TAmputate<FIMPL,FIMPL>;
-

Hadrons/Modules/MNPR/Amputate.hpp

@@ -1,200 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Amputate.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Amputate_hpp_
-#define Hadrons_Amputate_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/Eigen/LU>
-//#include <Grid/qcd/utils/PropagatorUtils.h>
-//#include <Grid/serialisation/Serialisation.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TAmputate                                       *
-        Performs bilinear contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class AmputatePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(AmputatePar,
-                                    std::string,    Sin, //need to make this a propogator type?
-                                    std::string,    Sout, //same
-                                    std::string,    vertex,
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    std::string,    output,
-                                    std::string,    input);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TAmputate: public Module<AmputatePar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<Complex>, Vamp,
-                                        ); 
-    };
-public:
-    // constructor
-    TAmputate(const std::string name);
-    // destructor
-    virtual ~TAmputate(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    virtual SpinColourMatrix invertspincolmat(SpinColourMatrix &scmat);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Amputate, ARG(TAmputate<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TAmputate implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TAmputate<FImpl1, FImpl2>::TAmputate(const std::string name)
-: Module<AmputatePar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TAmputate<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout, par().vertex};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TAmputate<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> output = {getName()};
-    
-    
-    return output;
-}
-
-// Invert spin colour matrix using Eigen
-template <typename Fimpl1, typename Fimpl2>
-SpinColourMatrix TAmputate<Fimpl1, Fimpl2>::invertspincolmat(SpinColourMatrix &scmat)
-{
-    Eigen::MatrixXcf scmat_2d(Ns*Nc,Ns*Nc);
-    for(int ic=0; ic<Nc; ic++){
-    for(int jc=0; jc<Nc; jc++){
-        for(int is=0; is<Ns; is++){
-        for(int js=0; js<Ns; js++){
-            scmat_2d(Ns*ic+is,Ns*jc+js) = scmat()(is,js)(ic,jc);
-        }}
-    }}      
-    Eigen::MatrixXcf scmat_2d_inv = scmat_2d.inverse();
-    SpinColourMatrix scmat_inv;
-    for(int ic=0; ic<Nc; ic++){
-    for(int jc=0; jc<Nc; jc++){
-        for(int is=0; is<Ns; is++){
-        for(int js=0; js<Ns; js++){
-            scmat_inv()(is,js)(ic,jc) = scmat_2d_inv(Ns*ic+is,Ns*jc+js);
-        }}
-    }}      
-    return scmat_inv;
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TAmputate<FImpl1, FImpl2>::execute(void)
-{
-    LOG(Message) << "Computing bilinear amputations '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-    BinaryWriter                    writer(par().output);
-    PropagatorField1                &Sin = *env().template getObject<PropagatorField1>(par().Sin); //Do these have the phases taken into account?? Don't think so. FIX
-    PropagatorField2                &Sout = *env().template getObject<PropagatorField2>(par().Sout);
-    std::vector<int>                pin  = strToVec<int>(par().pin), pout = strToVec<int>(par().pout);
-    std::vector<Real>               latt_size(pin.begin(), pin.end()); 
-    LatticeComplex                  pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    LOG(Message) << "Propagators set up " << std::endl;
-    std::vector<SpinColourMatrix>   vertex; // Let's read from file here
-    Gamma                           g5(Gamma::Algebra::Gamma5);
-    Result                          result;
-    LOG(Message) << "reading file - "  << par().input << std::endl;
-    BinaryReader                    reader(par().input); 
-    Complex                         Ci(0.0,1.0);
-
-    std::string svertex;
-    read(reader,"vertex", vertex);
-    LOG(Message) << "vertex read" << std::endl;
-
-    pdotxin=zero;
-    pdotxout=zero;
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-
-    SpinColourMatrix Sin_mom = sum(Sin);
-    SpinColourMatrix Sout_mom = sum(Sout);
-    LOG(Message) << "summed over lattice" << std::endl;
-   
-    LOG(Message) << "Lattice -> spincolourmatrix conversion" << std::endl;
-
-    SpinColourMatrix Sin_inv = invertspincolmat(Sin_mom);
-    SpinColourMatrix Sout_inv = invertspincolmat(Sout_mom);
-    LOG(Message) << "Inversions done" << std::endl;
-
-    result.Vamp.resize(Gamma::nGamma/2);
-    for( int mu=0; mu < Gamma::nGamma/2; mu++){
-        Gamma::Algebra gam = mu;
-        result.Vamp[mu] = 1/12.0*trace(adj(Gamma(mu*2+1))*g5*Sout_inv*g5*vertex[mu]*Sin_inv);
-        LOG(Message) << "Vamp[" << mu << "] - " << result.Vamp[mu] << std::endl;
-        }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Amputate_hpp_

Hadrons/Modules/MNPR/Bilinear.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Bilinear.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/Bilinear.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TBilinear<FIMPL,FIMPL>;
-

Hadrons/Modules/MNPR/Bilinear.hpp

@@ -1,225 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/Bilinear.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_Bilinear_hpp_
-#define Hadrons_Bilinear_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-//#include <Grid/qcd/utils/PropagatorUtils.h>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TBilinear                                       *
-        Performs bilinear contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta in Rome-Southampton NPR
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class BilinearPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(BilinearPar,
-                                    std::string,    Sin,
-                                    std::string,    Sout,
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    std::string,    output);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TBilinear: public Module<BilinearPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result, 
-                                        std::vector<SpinColourMatrix>, bilinear);
-    };
-public:
-    // constructor
-    TBilinear(const std::string name);
-    // destructor
-    virtual ~TBilinear(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    //LatticeSpinColourMatrix PhaseProps(LatticeSpinColourMatrix S, std::vector<Real> p);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(Bilinear, ARG(TBilinear<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TBilinear implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TBilinear<FImpl1, FImpl2>::TBilinear(const std::string name)
-: Module<BilinearPar>(name)
-{}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TBilinear<FImpl1, FImpl2>::setup(void)
-{
-    //env().template registerLattice<LatticeSpinColourMatrix>(getName());
-    //env().template registerObject<SpinColourMatrix>(getName());
-}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TBilinear<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TBilinear<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-/*
-/////Phase propagators//////////////////////////
-template <typename FImpl1, typename FImpl2>
-LatticeSpinColourMatrix TBilinear<FImpl1, FImpl2>::PhaseProps(LatticeSpinColourMatrix S, std::vector<Real> p)
-{
-    GridBase *grid = S._grid;
-    LatticeComplex      pdotx(grid),  coor(grid);
-    std::vector<int>   latt_size = grid->_fdimensions; 
-    Complex             Ci(0.0,1.0);
-    pdotx=zero;
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotx = pdotx +(TwoPiL * p[mu]) * coor;
-    }
-    S = S*exp(-Ci*pdotx);
-    return S;
-}
-*/
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TBilinear<FImpl1, FImpl2>::execute(void)
-{
-/**************************************************************************
-
-Compute the bilinear vertex needed for the NPR.
-V(G) = sum_x  [ g5 * adj(S'(x,p2)) * g5 * G * S'(x,p1) ]_{si,sj,ci,cj}
-G is one of the 16 gamma vertices [I,gmu,g5,g5gmu,sig(mu,nu)]
-
-        * G
-       / \
-    p1/   \p2
-     /     \
-    /       \
-
-Returns a spin-colour matrix, with indices si,sj, ci,cj
-
-Conventions:
-p1 - incoming momenta
-p2 - outgoing momenta
-q = (p1-p2)
-**************************************************************************/
-
-    LOG(Message) << "Computing bilinear contractions '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-     
-    BinaryWriter             writer(par().output);
-    
-
-    // Propogators
-    LatticeSpinColourMatrix     &Sin = *env().template getObject<LatticeSpinColourMatrix>(par().Sin);
-    LatticeSpinColourMatrix     &Sout = *env().template getObject<LatticeSpinColourMatrix>(par().Sout);
-    LatticeComplex              pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    // momentum on legs
-    std::vector<Real>           pin  = strToVec<Real>(par().pin), pout = strToVec<Real>(par().pout);
-    std::vector<Real>           latt_size(pin.begin(), pin.end()); 
-    //bilinears
-    LatticeSpinColourMatrix     bilinear_x(env().getGrid());
-    SpinColourMatrix            bilinear;
-    Gamma                       g5(Gamma::Algebra::Gamma5);
-    Result                      result;
-    Complex                     Ci(0.0,1.0);
-
-    //
-
-    pdotxin=zero;
-    pdotxout=zero;
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-    
-    ////Set up gamma vector//////////////////////////
-    std::vector<Gamma> gammavector;
-    for( int i=0; i<Gamma::nGamma; i++){
-        Gamma::Algebra gam = i;
-        gammavector.push_back(Gamma(gam));
-    }
-    result.bilinear.resize(Gamma::nGamma);
-    /////////////////////////////////////////////////
-    //LatticeSpinMatrix temp = g5*Sout;
-    ////////Form Vertex//////////////////////////////
-    for (int i=0; i < Gamma::nGamma; i++){
-        bilinear_x = g5*adj(Sout)*g5*gammavector[i]*Sin; 
-        result.bilinear[i] = sum(bilinear_x); //sum over lattice sites
-    }
-    //////////////////////////////////////////////////
-    write(writer, par().output, result.bilinear);
-    LOG(Message) << "Complete. Writing results to " << par().output << std:: endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_Bilinear_hpp_

Hadrons/Modules/MNPR/FourQuark.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/FourQuark.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNPR/FourQuark.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNPR;
-
-template class Grid::Hadrons::MNPR::TFourQuark<FIMPL,FIMPL>;
-

Hadrons/Modules/MNPR/FourQuark.hpp

@@ -1,274 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNPR/FourQuark.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Julia Kettle J.R.Kettle-2@sms.ed.ac.uk
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-
-#ifndef Hadrons_FourQuark_hpp_
-#define Hadrons_FourQuark_hpp_
-
-#include <typeinfo>
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Grid/serialisation/Serialisation.h>
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                                TFourQuark                                       *
-        Performs fourquark contractions of the type tr[g5*adj(Sout)*g5*G*Sin]
-        Suitable for non exceptional momenta
-******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNPR)
-
-class FourQuarkPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FourQuarkPar,
-                                    std::string,    Sin, //need to make this a propogator type?
-                                    std::string,    Sout, //same
-                                    std::string,    pin,
-                                    std::string,    pout,
-                                    bool,           fullbasis,
-                                    std::string,    output);
-};
-
-template <typename FImpl1, typename FImpl2>
-class TFourQuark: public Module<FourQuarkPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl1, 1);
-    FERM_TYPE_ALIASES(FImpl2, 2);
-    class Result: Serializable
-    {
-    public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<SpinColourSpinColourMatrix>, fourquark);
-    };
-public:
-    // constructor
-    TFourQuark(const std::string name);
-    // destructor
-    virtual ~TFourQuark(void) {};
-    // dependencies/products
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void tensorprod(LatticeSpinColourSpinColourMatrix &lret, LatticeSpinColourMatrix a, LatticeSpinColourMatrix b);
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(FourQuark, ARG(TFourQuark<FIMPL, FIMPL>), MNPR);
-
-/******************************************************************************
- *                           TFourQuark implementation                            *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-TFourQuark<FImpl1, FImpl2>::TFourQuark(const std::string name)
-: Module<FourQuarkPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TFourQuark<FImpl1, FImpl2>::getInput(void)
-{
-    std::vector<std::string> input = {par().Sin, par().Sout};
-    
-    return input;
-}
-
-template <typename FImpl1, typename FImpl2>
-std::vector<std::string> TFourQuark<FImpl1, FImpl2>::getOutput(void)
-{
-    std::vector<std::string> output = {getName()};
-    
-    return output;
-}
-
-
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::tensorprod(LatticeSpinColourSpinColourMatrix &lret, LatticeSpinColourMatrix a, LatticeSpinColourMatrix b)
-{
-#if 0
-            parallel_for(auto site=lret.begin();site<lret.end();site++) {
-                for (int si; si < 4; ++si){
-                for(int sj; sj <4; ++sj){
-                    for (int ci; ci < 3; ++ci){
-                    for (int cj; cj < 3; ++cj){
-                        for (int sk; sk < 4; ++sk){
-                        for(int sl; sl <4; ++sl){
-                            for (int ck; ck < 3; ++ck){
-                            for (int cl; cl < 3; ++cl){
-                        lret[site]()(si,sj)(ci,cj)(sk,sl)(ck,cl)=a[site]()(si,sj)(ci,cj)*b[site]()(sk,sl)(ck,cl);
-                            }}
-                        }}
-                    }}
-                }}
-        }
-#else 
-            // FIXME ; is there a general need for this construct ? In which case we should encapsulate the
-            //         below loops in a helper function.
-            //LOG(Message) << "sp co mat a is - " << a << std::endl;
-            //LOG(Message) << "sp co mat b is - " << b << std::endl;
-            parallel_for(auto site=lret.begin();site<lret.end();site++) {
-            vTComplex left;
-                for(int si=0; si < Ns; ++si){
-                for(int sj=0; sj < Ns; ++sj){
-                    for (int ci=0; ci < Nc; ++ci){
-                    for (int cj=0; cj < Nc; ++cj){
-                      //LOG(Message) << "si, sj, ci, cj -  " << si << ", " << sj  << ", "<< ci  << ", "<< cj << std::endl;
-                      left()()() = a[site]()(si,sj)(ci,cj);
-                      //LOG(Message) << left << std::endl;
-                      lret[site]()(si,sj)(ci,cj)=left()*b[site]();
-                    }}
-                }}
-            }
-#endif      
-}
-
-
-
-
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::setup(void)
-{
-    envCreateLat(LatticeSpinColourMatrix, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl1, typename FImpl2>
-void TFourQuark<FImpl1, FImpl2>::execute(void)
-{
-
-/*********************************************************************************
-
-TFourQuark : Creates the four quark vertex required for the NPR of four-quark ops
-
-V_{Gamma_1,Gamma_2} = sum_x [ ( g5 * adj(S'(x,p2)) * g5 * G1 * S'(x,p1) )_ci,cj;si,sj x ( g5 * adj(S'(x,p2)) * g5 * G2 S'(x,p1) )_ck,cl;sk,cl ]
-
-Create a bilinear vertex for G1 and G2  the spin and colour indices are kept free. Where there are 16 potential Gs.
-We then find the outer product of V1 and V2, keeping the spin and colour indices uncontracted
-Then this is summed over the lattice coordinate
-Result is a SpinColourSpinColourMatrix - with 4 colour and 4 spin indices. 
-We have up to 256 of these including the offdiag (G1 != G2).
-
-        \         /
-         \p1   p1/
-          \     /
-           \   /
-         G1 * * G2
-           /   \
-          /     \
-         /p2   p2\
-        /         \
-
-*********************************************************************************/
-
-
-
-
-    LOG(Message) << "Computing fourquark contractions '" << getName() << "' using"
-                 << " momentum '" << par().Sin << "' and '" << par().Sout << "'"
-                 << std::endl;
-    
-    BinaryWriter             writer(par().output);
-    
-    PropagatorField1                            &Sin = *env().template getObject<PropagatorField1>(par().Sin);
-    PropagatorField2                            &Sout = *env().template getObject<PropagatorField2>(par().Sout);
-    std::vector<Real>                           pin  = strToVec<Real>(par().pin), pout = strToVec<Real>(par().pout);
-    bool                                        fullbasis = par().fullbasis;
-    Gamma                                       g5(Gamma::Algebra::Gamma5);
-    Result                                      result;
-    std::vector<Real>                           latt_size(pin.begin(), pin.end());
-    LatticeComplex                              pdotxin(env().getGrid()), pdotxout(env().getGrid()), coor(env().getGrid());
-    LatticeSpinColourMatrix                     bilinear_mu(env().getGrid()), bilinear_nu(env().getGrid());
-    LatticeSpinColourSpinColourMatrix           lret(env().getGrid()); 
-    Complex                         Ci(0.0,1.0);
-
-    //Phase propagators
-    //Sin = Grid::QCD::PropUtils::PhaseProps(Sin,pin);
-    //Sout = Grid::QCD::PropUtils::PhaseProps(Sout,pout);
-    
-    //find p.x for in and out so phase can be accounted for in propagators
-    pdotxin=zero;
-    pdotxout=zero;
-    for (unsigned int mu = 0; mu < 4; ++mu)
-    {
-        Real TwoPiL =  M_PI * 2.0/ latt_size[mu];
-        LatticeCoordinate(coor,mu);
-        pdotxin = pdotxin +(TwoPiL * pin[mu]) * coor;
-        pdotxout= pdotxout +(TwoPiL * pout[mu]) * coor;
-    }
-    Sin = Sin*exp(-Ci*pdotxin); //phase corrections
-    Sout = Sout*exp(-Ci*pdotxout);
-
-
-    //Set up Gammas 
-    std::vector<Gamma> gammavector;
-     for( int i=1; i<Gamma::nGamma; i+=2){
-         Gamma::Algebra gam = i;
-         gammavector.push_back(Gamma(gam));
-       }
-    
-    lret = zero;
-    if (fullbasis == true){ // all combinations of mu and nu
-        result.fourquark.resize(Gamma::nGamma/2*Gamma::nGamma/2);
-        for( int mu=0; mu<Gamma::nGamma/2; mu++){ 
-            bilinear_mu = g5*adj(Sout)*g5*gammavector[mu]*Sin;
-            for ( int nu=0; nu<Gamma::nGamma; nu++){
-                LatticeSpinColourMatrix     bilinear_nu(env().getGrid());
-                bilinear_nu = g5*adj(Sout)*g5*gammavector[nu]*Sin;
-                LOG(Message) << "bilinear_nu for nu = " << nu << " is - " << bilinear_mu << std::endl;
-                result.fourquark[mu*Gamma::nGamma/2 + nu] = zero;
-                tensorprod(lret,bilinear_mu,bilinear_nu);
-                result.fourquark[mu*Gamma::nGamma/2 + nu] = sum(lret);
-            }
-        }
-    } else {
-        result.fourquark.resize(Gamma::nGamma/2);
-        for ( int mu=0; mu<1; mu++){
-        //for( int mu=0; mu<Gamma::nGamma/2; mu++ ){
-            bilinear_mu = g5*adj(Sout)*g5*gammavector[mu]*Sin;
-            //LOG(Message) << "bilinear_mu for mu = " << mu << " is - " << bilinear_mu << std::endl;
-            result.fourquark[mu] = zero;
-            tensorprod(lret,bilinear_mu,bilinear_mu); //tensor outer product
-            result.fourquark[mu] = sum(lret);
-        }
-    }
-    write(writer, "fourquark", result.fourquark);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_FourQuark_hpp_

Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc

@@ -1,36 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNoise;
-
-template class Grid::Hadrons::MNoise::TFullVolumeSpinColorDiagonal<FIMPL>;
-template class Grid::Hadrons::MNoise::TFullVolumeSpinColorDiagonal<ZFIMPL>;

Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp

@@ -1,121 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/FullVolumeSpinColorDiagonal.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: Vera Guelpers <Vera.Guelpers@ed.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_
-#define Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *             Generate full volume spin-color diagonal noise                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNoise)
-
-class FullVolumeSpinColorDiagonalPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(FullVolumeSpinColorDiagonalPar,
-                                    unsigned int, nsrc);
-};
-
-template <typename FImpl>
-class TFullVolumeSpinColorDiagonal: public Module<FullVolumeSpinColorDiagonalPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TFullVolumeSpinColorDiagonal(const std::string name);
-    // destructor
-    virtual ~TFullVolumeSpinColorDiagonal(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(FullVolumeSpinColorDiagonal, TFullVolumeSpinColorDiagonal<FIMPL>, MNoise);
-MODULE_REGISTER_TMP(ZFullVolumeSpinColorDiagonal, TFullVolumeSpinColorDiagonal<ZFIMPL>, MNoise);
-
-/******************************************************************************
- *              TFullVolumeSpinColorDiagonal implementation                  *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TFullVolumeSpinColorDiagonal<FImpl>::TFullVolumeSpinColorDiagonal(const std::string name)
-: Module<FullVolumeSpinColorDiagonalPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TFullVolumeSpinColorDiagonal<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TFullVolumeSpinColorDiagonal<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFullVolumeSpinColorDiagonal<FImpl>::setup(void)
-{
-    envCreateDerived(DilutedNoise<FImpl>, 
-                     FullVolumeSpinColorDiagonalNoise<FImpl>,
-                     getName(), 1, envGetGrid(FermionField), par().nsrc);
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TFullVolumeSpinColorDiagonal<FImpl>::execute(void)
-{
-    auto &noise = envGet(DilutedNoise<FImpl>, getName());
-    LOG(Message) << "Generating full volume, spin-color diagonal noise" << std::endl;
-    noise.generateNoise(rng4d());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MNoise_FullVolumeSpinColorDiagonal_hpp_

Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc

@@ -1,35 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MNoise;
-
-template class Grid::Hadrons::MNoise::TTimeDilutedSpinColorDiagonal<FIMPL>;
-template class Grid::Hadrons::MNoise::TTimeDilutedSpinColorDiagonal<ZFIMPL>;

Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp

@@ -1,114 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MNoise/TimeDilutedSpinColorDiagonal.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_
-#define Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/DilutedNoise.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *             Generate time diluted spin-color diagonal noise                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MNoise)
-
-template <typename FImpl>
-class TTimeDilutedSpinColorDiagonal: public Module<NoPar>
-{
-public:
-    FERM_TYPE_ALIASES(FImpl,);
-public:
-    // constructor
-    TTimeDilutedSpinColorDiagonal(const std::string name);
-    // destructor
-    virtual ~TTimeDilutedSpinColorDiagonal(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TimeDilutedSpinColorDiagonal, TTimeDilutedSpinColorDiagonal<FIMPL>, MNoise);
-MODULE_REGISTER_TMP(ZTimeDilutedSpinColorDiagonal, TTimeDilutedSpinColorDiagonal<ZFIMPL>, MNoise);
-
-/******************************************************************************
- *              TTimeDilutedSpinColorDiagonal implementation                  *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename FImpl>
-TTimeDilutedSpinColorDiagonal<FImpl>::TTimeDilutedSpinColorDiagonal(const std::string name)
-: Module<NoPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename FImpl>
-std::vector<std::string> TTimeDilutedSpinColorDiagonal<FImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename FImpl>
-std::vector<std::string> TTimeDilutedSpinColorDiagonal<FImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTimeDilutedSpinColorDiagonal<FImpl>::setup(void)
-{
-    envCreateDerived(DilutedNoise<FImpl>, 
-                     TimeDilutedSpinColorDiagonalNoise<FImpl>,
-                     getName(), 1, envGetGrid(FermionField));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename FImpl>
-void TTimeDilutedSpinColorDiagonal<FImpl>::execute(void)
-{
-    auto &noise = envGet(DilutedNoise<FImpl>, getName());
-
-    LOG(Message) << "Generating time-diluted, spin-color diagonal noise" << std::endl;
-    noise.generateNoise(rng4d());
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MNoise_TimeDilutedSpinColorDiagonal_hpp_

Hadrons/Modules/MScalar/ScalarVP.cc

@@ -1,564 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/ScalarVP.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/ChargedProp.hpp>
-#include <Hadrons/Modules/MScalar/ScalarVP.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/*
- * Scalar QED vacuum polarisation up to O(alpha)
- *
- * Conserved vector 2-point function diagram notation:
- *        _______
- *       /       \
- * U_nu *         * U_mu
- *       \_______/
- *
- *                (   adj(S(a\hat{nu}|x)) U_mu(x) S(0|x+a\hat{mu}) U_nu(0)    )
- *          = 2 Re(                             -                             )
- *                ( adj(S(a\hat{nu}|x+a\hat{mu})) adj(U_mu(x)) S(0|x) U_nu(0) )
- *  
- *
- *            _______
- *           /       \
- * free = 1 *         * 1
- *           \_______/
- *
- *
- *
- *             _______
- *            /       \
- * S = iA_nu *         * iA_mu
- *            \_______/
- *
- *
- *         Delta_1
- *         ___*___
- *        /       \
- * X = 1 *         * 1
- *        \___*___/
- *         Delta_1
- *
- *          Delta_1                     Delta_1
- *          ___*___                     ___*___
- *         /       \                   /       \
- *      1 *         * iA_mu  +  iA_nu *         * 1
- *         \_______/                   \_______/
- * 4C =        _______                     _______
- *            /       \                   /       \
- *      +  1 *         * iA_mu  +  iA_nu *         * 1
- *            \___*___/                   \___*___/
- *             Delta_1                     Delta_1
- *
- *     Delta_1   Delta_1
- *          _*___*_             _______
- *         /       \           /       \
- * 2E = 1 *         * 1  +  1 *         * 1
- *         \_______/           \_*___*_/
- *                         Delta_1   Delta_1
- *
- *          Delta_2
- *          ___*___             _______
- *         /       \           /       \
- * 2T = 1 *         * 1  +  1 *         * 1
- *         \_______/           \___*___/
- *                              Delta_2
- *
- *
- *                    _______
- *                   /       \
- * srcT = -A_nu^2/2 *         * 1
- *                   \_______/
- *
- *
- *
- *            _______
- *           /       \
- * snkT = 1 *         * -A_mu^2/2
- *           \_______/
- *
- * Full VP to O(alpha) = free + q^2*(S+X+4C+2E+2T+srcT+snkT)
- */
-
-/******************************************************************************
-*                  TScalarVP implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TScalarVP::TScalarVP(const std::string name)
-: Module<ScalarVPPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TScalarVP::getInput(void)
-{
-    prop0Name_ = par().scalarProp + "_0";
-    propQName_ = par().scalarProp + "_Q";
-    propSunName_ = par().scalarProp + "_Sun";
-    propTadName_ = par().scalarProp + "_Tad";
-
-	std::vector<std::string> in = {par().emField, prop0Name_, propQName_,
-                                   propSunName_, propTadName_};
-    
-    return in;
-}
-
-std::vector<std::string> TScalarVP::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        // out.push_back(getName() + "_propQ_" + std::to_string(mu));
-
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            out.push_back(getName() + "_" + std::to_string(mu)
-                          + "_" + std::to_string(nu));
-        }
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TScalarVP::setup(void)
-{
-	freeMomPropName_ = FREEMOMPROP(static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().mass);
-	GFSrcName_ = par().scalarProp + "_DinvSrc";
-    fftName_   = par().scalarProp + "_fft";
-	phaseName_.clear();
-	muPropQName_.clear();
-    vpTensorName_.clear();
-    momPhaseName_.clear();
-	for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        phaseName_.push_back("_shiftphase_" + std::to_string(mu));
-        muPropQName_.push_back(getName() + "_propQ_" + std::to_string(mu));
-
-        std::vector<std::string> vpTensorName_mu;
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            vpTensorName_mu.push_back(getName() + "_" + std::to_string(mu)
-                                      + "_" + std::to_string(nu));
-        }
-        vpTensorName_.push_back(vpTensorName_mu);
-    }
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p));
-        }
-    }
-
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-	{
-	    envCreateLat(ScalarField, muPropQName_[mu]);
-
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            envCreateLat(ScalarField, vpTensorName_[mu][nu]);
-        }
-	}
-    if (!par().output.empty())
-    {
-        momPhasesDone_ = env().hasCreatedObject(momPhaseName_[0]);
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            envCacheLat(ScalarField, momPhaseName_[i_p]);
-        }
-    }
-    envTmpLat(ScalarField, "buf");
-    envTmpLat(ScalarField, "result");
-    envTmpLat(ScalarField, "Amu");
-    envTmpLat(ScalarField, "Usnk");
-    envTmpLat(ScalarField, "tmpProp");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TScalarVP::execute(void)
-{
-    // CACHING ANALYTIC EXPRESSIONS
-    makeCaches();
-
-    Complex ci(0.0,1.0);
-    Real    q        = static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().charge;
-    auto    &prop0   = envGet(ScalarField, prop0Name_);
-    auto    &propQ   = envGet(ScalarField, propQName_);
-    auto    &propSun = envGet(ScalarField, propSunName_);
-    auto    &propTad = envGet(ScalarField, propTadName_);
-    auto    &GFSrc   = envGet(ScalarField, GFSrcName_);
-    auto    &G       = envGet(ScalarField, freeMomPropName_);
-    auto    &fft     = envGet(FFT, fftName_);
-    phase_.clear();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        auto &phmu = envGet(ScalarField, phaseName_[mu]);
-        phase_.push_back(&phmu);
-    }
-    
-    // PROPAGATORS FROM SHIFTED SOURCES
-    LOG(Message) << "Computing O(q) charged scalar propagators..."
-                 << std::endl;
-    std::vector<ScalarField *> muPropQ;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        auto &propmu = envGet(ScalarField, muPropQName_[mu]);
-
-        // -G*momD1*G*F*tau_mu*Src (momD1 = F*D1*Finv)
-        propmu = adj(*phase_[mu])*GFSrc;
-        momD1(propmu, fft);
-        propmu = -G*propmu;
-        fft.FFT_all_dim(propmu, propmu, FFT::backward);
-
-        muPropQ.push_back(&propmu);
-    }
-
-    // CONTRACTIONS
-    auto        &A = envGet(EmField, par().emField);
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-    envGetTmp(ScalarField, Usnk);
-    envGetTmp(ScalarField, tmpProp);
-    TComplex    Anu0, Usrc;
-    std::vector<int> coor0 = {0, 0, 0, 0};
-    std::vector<std::vector<ScalarField *> > vpTensor;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        std::vector<ScalarField *> vpTensor_mu;
-        for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-        {
-            auto &vpmunu = envGet(ScalarField, vpTensorName_[mu][nu]);
-            vpTensor_mu.push_back(&vpmunu);
-        }
-        vpTensor.push_back(vpTensor_mu);
-    }
-
-    // Prepare output data structure if necessary
-    Result outputData;
-    if (!par().output.empty())
-    {
-        outputData.projection.resize(par().outputMom.size());
-        outputData.lattice_size = env().getGrid()->_fdimensions;
-        outputData.mass = static_cast<TChargedProp *>(vm().getModule(par().scalarProp))->par().mass;
-        outputData.charge = q;
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            outputData.projection[i_p].momentum = strToVec<int>(par().outputMom[i_p]);
-            outputData.projection[i_p].pi.resize(env().getNd());
-            outputData.projection[i_p].pi_free.resize(env().getNd());
-            outputData.projection[i_p].pi_2E.resize(env().getNd());
-            outputData.projection[i_p].pi_2T.resize(env().getNd());
-            outputData.projection[i_p].pi_S.resize(env().getNd());
-            outputData.projection[i_p].pi_4C.resize(env().getNd());
-            outputData.projection[i_p].pi_X.resize(env().getNd());
-            outputData.projection[i_p].pi_srcT.resize(env().getNd());
-            outputData.projection[i_p].pi_snkT.resize(env().getNd());
-            for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-            {
-                outputData.projection[i_p].pi[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_free[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_2E[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_2T[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_S[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_4C[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_X[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_srcT[nu].resize(env().getNd());
-                outputData.projection[i_p].pi_snkT[nu].resize(env().getNd());
-            }
-        }
-    }
-
-    // Do contractions
-    for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-    {
-        peekSite(Anu0, peekLorentz(A, nu), coor0);
-
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            LOG(Message) << "Computing Pi[" << mu << "][" << nu << "]..."
-                         << std::endl;
-            Amu = peekLorentz(A, mu);
-
-            // free
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(0|x-a\hat{\nu})
-                                                 // = S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, prop0, tmpProp, Usrc, mu);
-            *vpTensor[mu][nu] = result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_free[mu][nu], result,
-                            i_p);
-                }
-            }
-            tmpProp = result; // Just using tmpProp as a temporary ScalarField
-                              // here (buf is modified by calls to writeVP())
-
-            // srcT
-            result = tmpProp * (-0.5)*Anu0*Anu0;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_srcT[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // snkT
-            result = tmpProp * (-0.5)*Amu*Amu;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_snkT[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // S
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = ci*Anu0;
-            Usnk    = ci*Amu;
-            vpContraction(result, prop0, tmpProp, Usrc, Usnk, mu);
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_S[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 4C
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            Usnk    = ci*Amu;
-            vpContraction(result, propQ, tmpProp, Usrc, Usnk, mu);
-            Usrc    = ci*Anu0;
-            vpContraction(buf, propQ, tmpProp, Usrc, mu);
-            result += buf;
-            vpContraction(buf, prop0, *muPropQ[nu], Usrc, mu);
-            result += buf;
-            Usrc = Complex(1.0,0.0);
-            Usnk = ci*Amu;
-            vpContraction(buf, prop0, *muPropQ[nu], Usrc, Usnk, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_4C[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // X
-            Usrc = Complex(1.0,0.0);
-            vpContraction(result, propQ, *muPropQ[nu], Usrc, mu);
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_X[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 2E
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, propSun, tmpProp, Usrc, mu);
-            tmpProp = Cshift(propSun, nu, -1);     // S_\Sigma(0|x-a\hat{\nu})
-                               //(Note: <S(0|x-a\hat{\nu})> = <S(a\hat{\nu}|x)>)
-            vpContraction(buf, prop0, tmpProp, Usrc, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_2E[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // 2T
-            tmpProp = Cshift(prop0, nu, -1);     // S_0(a\hat{\nu}|x)
-            Usrc    = Complex(1.0,0.0);
-            vpContraction(result, propTad, tmpProp, Usrc, mu);
-            tmpProp = Cshift(propTad, nu, -1);     // S_T(0|x-a\hat{\nu})
-            vpContraction(buf, prop0, tmpProp, Usrc, mu);
-            result += buf;
-            *vpTensor[mu][nu] += q*q*result;
-            // Do momentum projections if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi_2T[mu][nu], result,
-                            i_p);
-                }
-            }
-
-            // Do momentum projections of full VP if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pi[mu][nu],
-                            *vpTensor[mu][nu], i_p);
-                }
-            }
-        }
-    }
-
-    // OUTPUT IF NECESSARY
-    if (!par().output.empty())
-    {
-        LOG(Message) << "Saving momentum-projected HVP to '"
-                     << RESULT_FILE_NAME(par().output, vm().getTrajectory()) << "'..."
-                     << std::endl;
-        saveResult(par().output, "HVP", outputData);
-    }
-}
-
-void TScalarVP::makeCaches(void)
-{
-    envGetTmp(ScalarField, buf);
-
-    if ( (!par().output.empty()) && (!momPhasesDone_) )
-    {
-        LOG(Message) << "Caching phases for momentum projections..."
-                     << std::endl;
-        std::vector<int> &l = env().getGrid()->_fdimensions;
-        Complex          ci(0.0,1.0);
-
-        // Calculate phase factors
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            std::vector<int> mom = strToVec<int>(par().outputMom[i_p]);
-            auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]);
-            momph_ip = zero;
-            for (unsigned int j = 0; j < env().getNd()-1; ++j)
-            {
-                Real twoPiL = M_PI*2./l[j];
-                LatticeCoordinate(buf, j);
-                buf = mom[j]*twoPiL*buf;
-                momph_ip = momph_ip + buf;
-            }
-            momph_ip = exp(-ci*momph_ip);
-            momPhase_.push_back(&momph_ip);
-        }
-    }
-}
-
-void TScalarVP::vpContraction(ScalarField &vp,
-                   ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                   TComplex u_src, ScalarField &u_snk, int mu)
-{
-    // Note: this function assumes a point source is used.
-    vp = adj(prop_nu_x) * u_snk * Cshift(prop_0_x, mu, 1) * u_src;
-    vp -= Cshift(adj(prop_nu_x), mu, 1) * adj(u_snk) * prop_0_x * u_src;
-    vp = 2.0*real(vp);
-}
-
-void TScalarVP::vpContraction(ScalarField &vp,
-                   ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                   TComplex u_src, int mu)
-{
-    // Note: this function assumes a point source is used.
-    vp = adj(prop_nu_x) * Cshift(prop_0_x, mu, 1) * u_src;
-    vp -= Cshift(adj(prop_nu_x), mu, 1) * prop_0_x * u_src;
-    vp = 2.0*real(vp);
-}
-
-void TScalarVP::project(std::vector<Complex> &projection, const ScalarField &vp, int i_p)
-{
-    std::vector<TComplex>   vecBuf;
-    envGetTmp(ScalarField, buf);
-
-    buf = vp*(*momPhase_[i_p]);
-    sliceSum(buf, vecBuf, Tp);
-    projection.resize(vecBuf.size());
-    for (unsigned int t = 0; t < vecBuf.size(); ++t)
-    {
-        projection[t] = TensorRemove(vecBuf[t]);
-    }
-}
-
-void TScalarVP::momD1(ScalarField &s, FFT &fft)
-{
-    auto        &A = envGet(EmField, par().emField);
-    Complex     ci(0.0,1.0);
-
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, result);
-    envGetTmp(ScalarField, Amu);
-
-    result = zero;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = (*phase_[mu])*s;
-        fft.FFT_all_dim(buf, buf, FFT::backward);
-        buf = Amu*buf;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result - ci*buf;
-    }
-    fft.FFT_all_dim(s, s, FFT::backward);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Amu = peekLorentz(A, mu);
-        buf = Amu*s;
-        fft.FFT_all_dim(buf, buf, FFT::forward);
-        result = result + ci*adj(*phase_[mu])*buf;
-    }
-
-    s = result;
-}

Hadrons/Modules/MScalar/ScalarVP.hpp

@@ -1,129 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/ScalarVP.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_ScalarVP_hpp_
-#define Hadrons_MScalar_ScalarVP_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Scalar vacuum polarisation                         *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class ScalarVPPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ScalarVPPar,
-                                    std::string, emField,
-                                    std::string, scalarProp,
-                                    std::string, output,
-                                    std::vector<std::string>, outputMom);
-};
-
-class TScalarVP: public Module<ScalarVPPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-    typedef PhotonR::GaugeField     EmField;
-    typedef PhotonR::GaugeLinkField EmComp;
-    class Result: Serializable
-    {
-    public:
-        class Projection: Serializable
-        {
-        public:
-            GRID_SERIALIZABLE_CLASS_MEMBERS(Projection,
-                                            std::vector<int>,     momentum,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_free,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_2E,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_2T,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_S,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_4C,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_X,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_srcT,
-                                            std::vector<std::vector<std::vector<Complex>>>, pi_snkT);
-        };
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<int>,        lattice_size,
-                                        double,                  mass,
-                                        double,                  charge,
-                                        std::vector<Projection>, projection);
-    };
-public:
-    // constructor
-    TScalarVP(const std::string name);
-    // destructor
-    virtual ~TScalarVP(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    void makeCaches(void);
-    // conserved vector two-point contraction
-    void vpContraction(ScalarField &vp,
-                       ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                       TComplex u_src, ScalarField &u_snk, int mu);
-    // conserved vector two-point contraction with unit gauge link at sink
-    void vpContraction(ScalarField &vp,
-                       ScalarField &prop_0_x, ScalarField &prop_nu_x,
-                       TComplex u_src, int mu);
-    // write momentum-projected vacuum polarisation to file(s)
-    void project(std::vector<Complex> &projection, const ScalarField &vp,
-                 int i_p);
-    // momentum-space Delta_1 insertion
-    void momD1(ScalarField &s, FFT &fft);
-private:
-    bool                                        momPhasesDone_;
-    std::string                                 freeMomPropName_, GFSrcName_,
-                                                prop0Name_, propQName_,
-                                                propSunName_, propTadName_,
-                                                fftName_;
-    std::vector<std::string>                    phaseName_, muPropQName_,
-                                                momPhaseName_;
-    std::vector<std::vector<std::string> >      vpTensorName_;
-    std::vector<ScalarField *>                  phase_, momPhase_;
-};
-
-MODULE_REGISTER(ScalarVP, TScalarVP, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_ScalarVP_hpp_

Hadrons/Modules/MScalar/VPCounterTerms.cc

@@ -1,260 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/VPCounterTerms.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalar/VPCounterTerms.hpp>
-#include <Hadrons/Modules/MScalar/Scalar.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalar;
-
-/******************************************************************************
-*                  TVPCounterTerms implementation                             *
-******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-TVPCounterTerms::TVPCounterTerms(const std::string name)
-: Module<VPCounterTermsPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-std::vector<std::string> TVPCounterTerms::getInput(void)
-{
-    std::vector<std::string> in = {par().source};
-    
-    return in;
-}
-
-std::vector<std::string> TVPCounterTerms::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-void TVPCounterTerms::setup(void)
-{
-	freeMomPropName_ = FREEMOMPROP(par().mass);
-    phaseName_.clear();
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        phaseName_.push_back("_shiftphase_" + std::to_string(mu));
-    }
-    GFSrcName_ = getName() + "_DinvSrc";
-    phatsqName_ = getName() + "_pHatSquared";
-    prop0Name_ = getName() + "_freeProp";
-    twoscalarName_ = getName() + "_2scalarProp";
-    psquaredName_ = getName() + "_psquaredProp";
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            momPhaseName_.push_back("_momentumphase_" + std::to_string(i_p));
-        }
-    }
-
-    envCreateLat(ScalarField, freeMomPropName_);
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        envCreateLat(ScalarField, phaseName_[mu]);
-    }
-    envCreateLat(ScalarField, phatsqName_);
-    envCreateLat(ScalarField, GFSrcName_);
-    envCreateLat(ScalarField, prop0Name_);
-    envCreateLat(ScalarField, twoscalarName_);
-    envCreateLat(ScalarField, psquaredName_);
-    if (!par().output.empty())
-    {
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            envCacheLat(ScalarField, momPhaseName_[i_p]);
-        }
-    }
-    envTmpLat(ScalarField, "buf");
-    envTmpLat(ScalarField, "tmp_vp");
-    envTmpLat(ScalarField, "vpPhase");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-void TVPCounterTerms::execute(void)
-{
-	auto &source = envGet(ScalarField, par().source);
-    Complex     ci(0.0,1.0);
-    FFT         fft(env().getGrid());
-    envGetTmp(ScalarField, buf);
-    envGetTmp(ScalarField, tmp_vp);
-    
-    // Momentum-space free scalar propagator
-    auto &G = envGet(ScalarField, freeMomPropName_);
-    SIMPL::MomentumSpacePropagator(G, par().mass);
-
-    // Phases and hat{p}^2
-    auto &phatsq = envGet(ScalarField, phatsqName_);
-    std::vector<int> &l = env().getGrid()->_fdimensions;
-    
-    LOG(Message) << "Calculating shift phases..." << std::endl;
-    phatsq = zero;
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    {
-        Real    twoPiL = M_PI*2./l[mu];
-        auto &phmu  = envGet(ScalarField, phaseName_[mu]);
-
-        LatticeCoordinate(buf, mu);
-        phmu = exp(ci*twoPiL*buf);
-        phase_.push_back(&phmu);
-        buf = 2.*sin(.5*twoPiL*buf);
-		phatsq = phatsq + buf*buf;
-    }
-
-    // G*F*src
-    auto &GFSrc       = envGet(ScalarField, GFSrcName_);
-    fft.FFT_all_dim(GFSrc, source, FFT::forward);
-    GFSrc = G*GFSrc;
-
-    // Position-space free scalar propagator
-    auto &prop0       = envGet(ScalarField, prop0Name_);
-    prop0 = GFSrc;
-    fft.FFT_all_dim(prop0, prop0, FFT::backward);
-
-    // Propagators for counter-terms
-    auto &twoscalarProp        = envGet(ScalarField, twoscalarName_);
-    auto &psquaredProp         = envGet(ScalarField, psquaredName_);
-
-    twoscalarProp = G*GFSrc;
-    fft.FFT_all_dim(twoscalarProp, twoscalarProp, FFT::backward);
-
-    psquaredProp = G*phatsq*GFSrc;
-    fft.FFT_all_dim(psquaredProp, psquaredProp, FFT::backward);
-
-    // Prepare output data structure if necessary
-    Result outputData;
-    if (!par().output.empty())
-    {
-        outputData.projection.resize(par().outputMom.size());
-        outputData.lattice_size = env().getGrid()->_fdimensions;
-        outputData.mass = par().mass;
-        for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-        {
-            outputData.projection[i_p].momentum = strToVec<int>(par().outputMom[i_p]);
-            outputData.projection[i_p].twoScalar.resize(env().getNd());
-            outputData.projection[i_p].threeScalar.resize(env().getNd());
-            outputData.projection[i_p].pSquaredInsertion.resize(env().getNd());
-            for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-            {
-                outputData.projection[i_p].twoScalar[nu].resize(env().getNd());
-                outputData.projection[i_p].threeScalar[nu].resize(env().getNd());
-                outputData.projection[i_p].pSquaredInsertion[nu].resize(env().getNd());
-            }
-            // Calculate phase factors
-            auto &momph_ip = envGet(ScalarField, momPhaseName_[i_p]);
-            momph_ip = zero;
-            for (unsigned int j = 0; j < env().getNd()-1; ++j)
-            {
-                Real twoPiL = M_PI*2./l[j];
-                LatticeCoordinate(buf, j);
-                buf = outputData.projection[i_p].momentum[j]*twoPiL*buf;
-                momph_ip = momph_ip + buf;
-            }
-            momph_ip = exp(-ci*momph_ip);
-            momPhase_.push_back(&momph_ip);
-        }
-    }
-
-    // Contractions
-    for (unsigned int nu = 0; nu < env().getNd(); ++nu)
-    {
-    	buf = adj(Cshift(prop0, nu, -1));
-        for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-        {
-            // Two-scalar loop
-            tmp_vp = buf * Cshift(prop0, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * prop0;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].twoScalar[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-
-        	// Three-scalar loop (no vertex)
-    		tmp_vp = buf * Cshift(twoscalarProp, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * twoscalarProp;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].threeScalar[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-
-            // Three-scalar loop (hat{p}^2 insertion)
-    		tmp_vp = buf * Cshift(psquaredProp, mu, 1);
-            tmp_vp -= Cshift(buf, mu, 1) * psquaredProp;
-            tmp_vp = 2.0*real(tmp_vp);
-            // Output if necessary
-            if (!par().output.empty())
-            {
-                for (unsigned int i_p = 0; i_p < par().outputMom.size(); ++i_p)
-                {
-                    project(outputData.projection[i_p].pSquaredInsertion[mu][nu],
-                            tmp_vp, i_p);
-                }
-            }
-        }
-    }
-
-    // OUTPUT IF NECESSARY
-    if (!par().output.empty())
-    {
-        LOG(Message) << "Saving momentum-projected correlators to '"
-                     << RESULT_FILE_NAME(par().output, vm().getTrajectory()) << "'..."
-                     << std::endl;
-        saveResult(par().output, "scalar_loops", outputData);
-    }
-}
-
-void TVPCounterTerms::project(std::vector<Complex> &projection, const ScalarField &vp, int i_p)
-{
-    std::vector<TComplex>   vecBuf;
-    envGetTmp(ScalarField, vpPhase);
-
-    vpPhase = vp*(*momPhase_[i_p]);
-    sliceSum(vpPhase, vecBuf, Tp);
-    projection.resize(vecBuf.size());
-    for (unsigned int t = 0; t < vecBuf.size(); ++t)
-    {
-        projection[t] = TensorRemove(vecBuf[t]);
-    }
-}

Hadrons/Modules/MScalar/VPCounterTerms.hpp

@@ -1,103 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalar/VPCounterTerms.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-Author: James Harrison <jch1g10@soton.ac.uk>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalar_VPCounterTerms_hpp_
-#define Hadrons_MScalar_VPCounterTerms_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         VPCounterTerms                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalar)
-
-class VPCounterTermsPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(VPCounterTermsPar,
-                                    std::string, source,
-                                    double,      mass,
-                                    std::string, output,
-                                    std::vector<std::string>, outputMom);
-};
-
-class TVPCounterTerms: public Module<VPCounterTermsPar>
-{
-public:
-    BASIC_TYPE_ALIASES(SIMPL,);
-    class Result: Serializable
-    {
-    public:
-        class Projection: Serializable
-        {
-        public:
-            GRID_SERIALIZABLE_CLASS_MEMBERS(Projection,
-                                            std::vector<int>,     momentum,
-                                            std::vector<std::vector<std::vector<Complex>>>, twoScalar,
-                                            std::vector<std::vector<std::vector<Complex>>>, threeScalar,
-                                            std::vector<std::vector<std::vector<Complex>>>, pSquaredInsertion);
-        };
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
-                                        std::vector<int>,        lattice_size,
-                                        double,                  mass,
-                                        std::vector<Projection>, projection);
-    };
-public:
-    // constructor
-    TVPCounterTerms(const std::string name);
-    // destructor
-    virtual ~TVPCounterTerms(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-protected:
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    void project(std::vector<Complex> &projection, const ScalarField &vp, int i_p);
-private:
-    std::string                freeMomPropName_, GFSrcName_, phatsqName_, prop0Name_,
-                               twoscalarName_, twoscalarVertexName_,
-                               psquaredName_, psquaredVertexName_;
-    std::vector<std::string>   phaseName_, momPhaseName_;
-    std::vector<ScalarField *> phase_, momPhase_;
-};
-
-MODULE_REGISTER(VPCounterTerms, TVPCounterTerms, MScalar);
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalar_VPCounterTerms_hpp_

Hadrons/Modules/MScalarSUN/Div.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Div.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/Div.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TDiv<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/EMT.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/EMT.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/EMT.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TEMT<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/EMT.hpp

@@ -1,217 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/EMT.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_EMT_hpp_
-#define Hadrons_MScalarSUN_EMT_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Energy-momentum tensor                             *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class EMTPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(EMTPar,
-                                    std::string, kinetic,
-                                    std::string, phiPow,
-                                    std::string, improvement,
-                                    double     , m2,
-                                    double     , lambda,
-                                    double     , g,
-                                    double     , xi,
-                                    std::string, output);
-};
-
-class EMTResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(EMTResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    double,                            m2,
-                                    double,                            lambda,
-                                    double,                            g,
-                                    double,                            xi);
-};
-
-template <typename SImpl>
-class TEMT: public Module<EMTPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TEMT(const std::string name);
-    // destructor
-    virtual ~TEMT(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(EMTSU2, TEMT<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU3, TEMT<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU4, TEMT<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU5, TEMT<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(EMTSU6, TEMT<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                           TEMT implementation                              *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TEMT<SImpl>::TEMT(const std::string name)
-: Module<EMTPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TEMT<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        in.push_back(varName(par().kinetic, mu, nu));
-        if (!par().improvement.empty())
-        {
-            in.push_back(varName(par().improvement, mu, nu));
-        }
-    }
-    in.push_back(varName(par().kinetic, "sum"));
-    in.push_back(varName(par().phiPow, 2));
-    in.push_back(varName(par().phiPow, 4));
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TEMT<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TEMT<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TEMT<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing energy-momentum tensor" << std::endl;
-    LOG(Message) << "  kinetic terms: '" << par().kinetic << "'" << std::endl;
-    LOG(Message) << "      tr(phi^n): '" << par().phiPow << "'" << std::endl;
-    if (!par().improvement.empty())
-    {
-        LOG(Message) << "    improvement: '" << par().improvement << "'" << std::endl;
-    }
-    LOG(Message) << "            m^2= " << par().m2 << std::endl;
-    LOG(Message) << "         lambda= " << par().lambda << std::endl;
-    LOG(Message) << "              g= " << par().g << std::endl;
-    if (!par().improvement.empty())
-    {
-        LOG(Message) << "             xi= " << par().xi << std::endl;
-    }
-
-    const unsigned int N = SImpl::Group::Dimension, nd = env().getNd();
-    auto               &trphi2 = envGet(ComplexField, varName(par().phiPow, 2));
-    auto               &trphi4 = envGet(ComplexField, varName(par().phiPow, 4));
-    auto               &sumkin = envGet(ComplexField, varName(par().kinetic, "sum"));
-    EMTResult          result;
-
-    if (!par().output.empty())
-    {
-        result.m2     = par().m2;
-        result.g      = par().g;
-        result.lambda = par().lambda;
-        result.xi     = par().xi;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out   = envGet(ComplexField, varName(getName(), mu, nu));
-        auto &trkin = envGet(ComplexField, varName(par().kinetic, mu, nu));
-        
-        out = 2.*trkin;
-        if (!par().improvement.empty())
-        {
-            auto &imp = envGet(ComplexField, varName(par().improvement, mu, nu));
-
-            out += par().xi*imp;
-        }
-        if (mu == nu)
-        {
-            out -= sumkin + par().m2*trphi2 + par().lambda*trphi4;
-        }
-        out *= N/par().g;
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "emt", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_EMT_hpp_

Hadrons/Modules/MScalarSUN/Grad.cc

@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Grad.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/Grad.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TGrad<ScalarNxNAdjImplR<6>>;

Hadrons/Modules/MScalarSUN/Grad.hpp

@@ -1,166 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Grad.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_Grad_hpp_
-#define Hadrons_MScalarSUN_Grad_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                       Gradient of a complex field                          *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class GradPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GradPar,
-                                    std::string, op,
-                                    DiffType,    type,
-                                    std::string, output);
-};
-
-class GradResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(GradResult,
-                                    DiffType,              type,
-                                    std::vector<Complex>,  value);
-};
-
-template <typename SImpl>
-class TGrad: public Module<GradPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TGrad(const std::string name);
-    // destructor
-    virtual ~TGrad(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(GradSU2, TGrad<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU3, TGrad<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU4, TGrad<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU5, TGrad<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(GradSU6, TGrad<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                         TGrad implementation                               *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TGrad<SImpl>::TGrad(const std::string name)
-: Module<GradPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TGrad<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().op};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TGrad<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    const auto               nd = env().getNd();
-
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        out.push_back(varName(getName(), mu));
-    }
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TGrad<SImpl>::setup(void)
-{
-    const auto nd = env().getNd();
-
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu));
-    }
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TGrad<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing the " << par().type << " gradient of '"
-                 << par().op << "'" << std::endl;
-
-    const unsigned int nd = env().getNd();
-    GradResult         result;
-    auto               &op = envGet(ComplexField, par().op);
-
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd);
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        auto &der = envGet(ComplexField, varName(getName(), mu));
-
-        dmu(der, op, mu, par().type);
-        if (!par().output.empty())
-        {
-            result.value[mu] = TensorRemove(sum(der));
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "grad", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_Grad_hpp_

Hadrons/Modules/MScalarSUN/ShiftProbe.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/ShiftProbe.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/ShiftProbe.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TShiftProbe<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TShiftProbe<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TShiftProbe<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TShiftProbe<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TShiftProbe<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/ShiftProbe.hpp

@@ -1,177 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/ShiftProbe.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_ShiftProbe_hpp_
-#define Hadrons_MScalarSUN_ShiftProbe_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *         Ward identity phi^n probe with fields at different positions       *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-typedef std::pair<int, int> ShiftPair;
-
-class ShiftProbePar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ShiftProbePar,
-                                    std::string, field,
-                                    std::string, shifts,
-                                    std::string, output);
-};
-
-class ShiftProbeResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(ShiftProbeResult,
-                                    std::string, shifts,
-                                    Complex,     value);
-};
-
-template <typename SImpl>
-class TShiftProbe: public Module<ShiftProbePar>
-{
-public:
-    typedef typename SImpl::Field                          Field;
-    typedef typename SImpl::ComplexField                   ComplexField;
-public:
-    // constructor
-    TShiftProbe(const std::string name);
-    // destructor
-    virtual ~TShiftProbe(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(ShiftProbeSU2, TShiftProbe<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(ShiftProbeSU3, TShiftProbe<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(ShiftProbeSU4, TShiftProbe<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(ShiftProbeSU5, TShiftProbe<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(ShiftProbeSU6, TShiftProbe<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                        TShiftProbe implementation                          *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TShiftProbe<SImpl>::TShiftProbe(const std::string name)
-: Module<ShiftProbePar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TShiftProbe<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TShiftProbe<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TShiftProbe<SImpl>::setup(void)
-{
-    envTmpLat(Field, "acc");
-    envCreateLat(ComplexField, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TShiftProbe<SImpl>::execute(void)
-{
-    LOG(Message) << "Creating shift probe for shifts " << par().shifts
-                 << std::endl;
-
-    std::vector<ShiftPair> shift;
-    double                 sign;
-    auto                   &phi   = envGet(Field, par().field);
-    auto                   &probe = envGet(ComplexField, getName());
-
-    shift = strToVec<ShiftPair>(par().shifts);
-    if (shift.size() % 2 != 0)
-    {
-        HADRONS_ERROR(Size, "the number of shifts is odd");
-    }
-    sign = (shift.size() % 4 == 0) ? 1. : -1.;
-    for (auto &s: shift)
-    {
-        if (s.first >= env().getNd())
-        {
-            HADRONS_ERROR(Size, "dimension to large for shift <" 
-                               + std::to_string(s.first) + " " 
-                               + std::to_string(s.second) + ">" );
-        }
-    }
-    envGetTmp(Field, acc);
-    acc = 1.;
-    for (unsigned int i = 0; i < shift.size(); ++i)
-    {
-        if (shift[i].second == 0)
-        {
-            acc *= phi;
-        }
-        else
-        {
-            acc *= Cshift(phi, shift[i].first, shift[i].second);
-        }
-    }
-    probe = sign*trace(acc);
-    if (!par().output.empty())
-    {
-        ShiftProbeResult r;
-
-        r.shifts = par().shifts;
-        r.value  = TensorRemove(sum(probe));
-        saveResult(par().output, "probe", r);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_ShiftProbe_hpp_

Hadrons/Modules/MScalarSUN/StochFreeField.cc

@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/StochFreeField.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/StochFreeField.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TStochFreeField<ScalarNxNAdjImplR<6>>;

Hadrons/Modules/MScalarSUN/StochFreeField.hpp

@@ -1,178 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/StochFreeField.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_StochFreeField_hpp_
-#define Hadrons_MScalarSUN_StochFreeField_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                      stochastic free SU(N) scalar field                    *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class StochFreeFieldPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(StochFreeFieldPar,
-                                    double, m2,
-                                    double, g,
-                                    double, smearing);
-};
-
-template <typename SImpl>
-class TStochFreeField: public Module<StochFreeFieldPar>
-{
-public:
-    typedef typename SImpl::Field                    Field;
-    typedef typename SImpl::ComplexField             ComplexField;
-    typedef typename SImpl::Group                    Group;
-    typedef typename SImpl::SiteField::scalar_object Site;
-public:
-    // constructor
-    TStochFreeField(const std::string name);
-    // destructor
-    virtual ~TStochFreeField(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    bool create_weight;
-};
-
-MODULE_REGISTER_TMP(StochFreeFieldSU2, TStochFreeField<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU3, TStochFreeField<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU4, TStochFreeField<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU5, TStochFreeField<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(StochFreeFieldSU6, TStochFreeField<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                 TStochFreeField implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TStochFreeField<SImpl>::TStochFreeField(const std::string name)
-: Module<StochFreeFieldPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TStochFreeField<SImpl>::getInput(void)
-{
-    std::vector<std::string> in;
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TStochFreeField<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {getName()};
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TStochFreeField<SImpl>::setup(void)
-{
-    create_weight = false; 
-    if (!env().hasCreatedObject("_" + getName() + "_weight"))
-    {
-        envCacheLat(ComplexField, "_" + getName() + "_weight");
-        envTmpLat(ComplexField, "smear");
-        create_weight = true;
-    }
-    envTmpLat(Field, "phift");
-    envTmpLat(ComplexField, "ca");
-    envCreateLat(Field, getName());
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TStochFreeField<SImpl>::execute(void)
-{
-    LOG(Message) << "Generating stochastic scalar field" << std::endl;
-    
-    const   unsigned int N    = Group::Dimension;
-    const   unsigned int Nadj = Group::AdjointDimension;
-    auto    &phi              = envGet(Field, getName());
-    auto    &w                = envGet(ComplexField, "_" + getName() + "_weight");
-    auto    &rng              = rng4d();
-    double  trphi2;
-    FFT     fft(envGetGrid(Field));
-    Integer vol;
-
-    vol = 1;
-    for(int d = 0; d < env().getNd(); d++)
-    {
-        vol = vol*env().getDim(d);
-    }
-    if (create_weight)
-    {
-        LOG(Message) << "Caching momentum-space scalar action" << std::endl;
-        
-        envGetTmp(ComplexField, smear);
-        SImpl::MomentaSquare(smear);
-        smear = exp(-par().smearing*smear);
-        SImpl::MomentumSpacePropagator(w, sqrt(par().m2));
-        w *= par().g/N*smear;
-        w  = sqrt(vol)*sqrt(w);
-    }
-    LOG(Message) << "Generating random momentum-space field" << std::endl;
-    envGetTmp(Field, phift);
-    envGetTmp(ComplexField, ca);
-    phift = zero;
-    for (int a = 0; a < Nadj; ++a) 
-    {
-        Site ta;
-
-        gaussian(rng, ca);
-        Group::generator(a, ta);
-        phift += ca*ta;
-    }
-    phift *= w;
-    LOG(Message) << "Field Fourier transform" << std::endl;
-    fft.FFT_all_dim(phi, phift, FFT::backward);
-    phi = 0.5*(phi - adj(phi));
-    trphi2 = -TensorRemove(sum(trace(phi*phi))).real()/vol;
-    LOG(Message) << "tr(phi^2)= " << trphi2 << std::endl;
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_StochFreeField_hpp_

Hadrons/Modules/MScalarSUN/TrKinetic.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrKinetic.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrKinetic.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrKinetic<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/TrKinetic.hpp

@@ -1,178 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrKinetic.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TrKinetic_hpp_
-#define Hadrons_MScalarSUN_TrKinetic_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Trace of kinetic term                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TrKineticPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrKineticPar,
-                                    std::string,  field,
-                                    DiffType,     type,
-                                    std::string,  output);
-};
-
-class TrKineticResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TrKineticResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    DiffType,                          type);
-};
-
-template <typename SImpl>
-class TTrKinetic: public Module<TrKineticPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TTrKinetic(const std::string name);
-    // destructor
-    virtual ~TTrKinetic(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TrKineticSU2, TTrKinetic<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU3, TTrKinetic<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU4, TTrKinetic<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU5, TTrKinetic<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TrKineticSU6, TTrKinetic<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                      TTrKinetic implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTrKinetic<SImpl>::TTrKinetic(const std::string name)
-: Module<TrKineticPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTrKinetic<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().field};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTrKinetic<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out ;
-
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-    out.push_back(varName(getName(), "sum"));
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrKinetic<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-    envCreateLat(ComplexField, varName(getName(), "sum"));
-    envTmp(std::vector<Field>, "der", 1, env().getNd(), envGetGrid(Field));
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTrKinetic<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing tr(d_mu phi*d_nu phi) using " << par().type
-                 << " derivative" << std::endl; 
-
-    const unsigned int nd = env().getNd();
-    TrKineticResult    result;
-    auto               &phi    = envGet(Field, par().field);
-    auto               &sumkin = envGet(ComplexField, varName(getName(), "sum"));
-
-    envGetTmp(std::vector<Field>, der);
-    sumkin = zero;
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        dmu(der[mu], phi, mu, par().type);
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out = envGet(ComplexField, varName(getName(), mu, nu));
-
-        out = -trace(der[mu]*der[nu]);
-        if (mu == nu)
-        {
-            sumkin += out;
-        }
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    saveResult(par().output, "trkinetic", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TrKinetic_hpp_

Hadrons/Modules/MScalarSUN/TrMag.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrMag.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrMag.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrMag<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/TrPhi.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TrPhi.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TrPhi.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTrPhi<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/TransProj.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TransProj.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TransProj.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTransProj<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/TransProj.hpp

@@ -1,187 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TransProj.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TransProj_hpp_
-#define Hadrons_MScalarSUN_TransProj_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         Transverse projection                              *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TransProjPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TransProjPar,
-                                    std::string,  op,
-                                    DiffType,     type,
-                                    std::string,  output);
-};
-
-class TransProjResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TransProjResult,
-                                    std::vector<std::vector<Complex>>, value,
-                                    DiffType,                          type);
-};
-
-template <typename SImpl>
-class TTransProj: public Module<TransProjPar>
-{
-public:
-    typedef typename SImpl::Field        Field;
-    typedef typename SImpl::ComplexField ComplexField;
-public:
-    // constructor
-    TTransProj(const std::string name);
-    // destructor
-    virtual ~TTransProj(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TransProjSU2, TTransProj<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU3, TTransProj<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU4, TTransProj<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU5, TTransProj<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TransProjSU6, TTransProj<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                        TTransProj implementation                           *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTransProj<SImpl>::TTransProj(const std::string name)
-: Module<TransProjPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTransProj<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = {par().op};
-    
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTransProj<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        out.push_back(varName(getName(), mu, nu));
-    }
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTransProj<SImpl>::setup(void)
-{
-    for (unsigned int mu = 0; mu < env().getNd(); ++mu)
-    for (unsigned int nu = mu; nu < env().getNd(); ++nu)
-    {
-        envCreateLat(ComplexField, varName(getName(), mu, nu));
-    }
-    envTmpLat(ComplexField, "buf1");
-    envTmpLat(ComplexField, "buf2");
-    envTmpLat(ComplexField, "lap");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTransProj<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing (delta_mu,nu d^2 - d_mu*d_nu)*op using " 
-                 << par().type << " derivatives and op= '" << par().op 
-                 << "'" << std::endl; 
-
-    const unsigned int nd = env().getNd();
-    TransProjResult    result;
-    auto               &op = envGet(ComplexField, par().op);
-
-    envGetTmp(ComplexField, buf1);
-    envGetTmp(ComplexField, buf2);
-    envGetTmp(ComplexField, lap);
-    lap = zero;
-    if (!par().output.empty())
-    {
-        result.type = par().type;
-        result.value.resize(nd, std::vector<Complex>(nd));
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    {
-        dmu(buf1, op, mu, par().type);
-        dmu(buf2, buf1, mu, par().type);
-        lap += buf2;
-    }
-    for (unsigned int mu = 0; mu < nd; ++mu)
-    for (unsigned int nu = mu; nu < nd; ++nu)
-    {
-        auto &out = envGet(ComplexField, varName(getName(), mu, nu));
-        dmu(buf1, op, mu, par().type);
-        dmu(buf2, buf1, nu, par().type);
-        out = -buf2;
-        if (mu == nu)
-        {
-            out += lap;
-        }
-        if (!par().output.empty())
-        {
-            result.value[mu][nu] = TensorRemove(sum(out));
-            result.value[mu][nu] = result.value[nu][mu];
-        }
-    }
-    if (!par().output.empty())
-    {
-        saveResult(par().output, "transproj", result);
-    }
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TransProj_hpp_

Hadrons/Modules/MScalarSUN/TwoPoint.cc

@@ -1,39 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPoint.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TwoPoint.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPoint<ScalarNxNAdjImplR<6>>;
-

Hadrons/Modules/MScalarSUN/TwoPoint.hpp

@@ -1,226 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPoint.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TwoPoint_hpp_
-#define Hadrons_MScalarSUN_TwoPoint_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                 2-pt functions for a given set of operators                *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TwoPointPar: Serializable
-{
-public:
-    typedef std::pair<std::string, std::string> OpPair;
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointPar,
-                                    std::vector<OpPair>,      op,
-                                    std::vector<std::string>, mom,
-                                    std::string,              output);
-};
-
-class TwoPointResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointResult,
-                                    std::string, sink,
-                                    std::string, source,
-                                    std::vector<int>, mom,
-                                    std::vector<Complex>, data);
-};
-
-template <typename SImpl>
-class TTwoPoint: public Module<TwoPointPar>
-{
-public:
-    typedef typename SImpl::Field         Field;
-    typedef typename SImpl::ComplexField  ComplexField;
-    typedef          std::vector<Complex> SlicedOp;
-public:
-    // constructor
-    TTwoPoint(const std::string name);
-    // destructor
-    virtual ~TTwoPoint(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-private:
-    std::vector<std::vector<int>> mom_;
-};
-
-MODULE_REGISTER_TMP(TwoPointSU2, TTwoPoint<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU3, TTwoPoint<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU4, TTwoPoint<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU5, TTwoPoint<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointSU6, TTwoPoint<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                       TTwoPoint implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTwoPoint<SImpl>::TTwoPoint(const std::string name)
-: Module<TwoPointPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTwoPoint<SImpl>::getInput(void)
-{   
-    std::vector<std::string> in;
-    std::set<std::string>    ops;
-
-    for (auto &p: par().op)
-    {
-        ops.insert(p.first);
-        ops.insert(p.second);
-    }
-    for (auto &o: ops)
-    {
-        in.push_back(o);
-    }
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTwoPoint<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out = {};
-
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPoint<SImpl>::setup(void)
-{
-    const unsigned int nd = env().getDim().size();
-
-    mom_.resize(par().mom.size());
-    for (unsigned int i = 0; i < mom_.size(); ++i)
-    {
-        mom_[i] = strToVec<int>(par().mom[i]);
-        if (mom_[i].size() != nd - 1)
-        {
-            HADRONS_ERROR(Size, "momentum number of components different from " 
-                               + std::to_string(nd-1));
-        }
-        for (unsigned int j = 0; j < nd - 1; ++j)
-        {
-            mom_[i][j] = (mom_[i][j] + env().getDim(j)) % env().getDim(j);
-        }
-    }
-    envTmpLat(ComplexField, "ftBuf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPoint<SImpl>::execute(void)
-{
-    LOG(Message) << "Computing 2-point functions" << std::endl;
-    for (auto &p: par().op)
-    {
-        LOG(Message) << "  <" << p.first << " " << p.second << ">" << std::endl;
-    }
-
-    const unsigned int                           nd      = env().getNd();
-    const unsigned int                           nt      = env().getDim().back();
-    const unsigned int                           nop     = par().op.size();
-    const unsigned int                           nmom    = mom_.size();
-    double                                       partVol = 1.;
-    std::vector<int>                             dMask(nd, 1);
-    std::set<std::string>                        ops;
-    std::vector<TwoPointResult>                  result;
-    std::map<std::string, std::vector<SlicedOp>> slicedOp;
-    FFT                                          fft(envGetGrid(Field));
-    TComplex                                     buf;
-
-    envGetTmp(ComplexField, ftBuf);
-    dMask[nd - 1] = 0;
-    for (unsigned int mu = 0; mu < nd - 1; ++mu)
-    {
-        partVol *= env().getDim()[mu];
-    }
-    for (auto &p: par().op)
-    {
-        ops.insert(p.first);
-        ops.insert(p.second);
-    }
-    for (auto &o: ops)
-    {
-        auto &op = envGet(ComplexField, o);
-
-        slicedOp[o].resize(nmom);
-        LOG(Message) << "Operator '" << o << "' FFT" << std::endl;
-        fft.FFT_dim_mask(ftBuf, op, dMask, FFT::forward);
-        for (unsigned int m = 0; m < nmom; ++m)
-        {
-            auto qt = mom_[m];
-
-            qt.resize(nd);
-            slicedOp[o][m].resize(nt);
-            for (unsigned int t = 0; t < nt; ++t)
-            {
-                qt[nd - 1] = t;
-                peekSite(buf, ftBuf, qt);
-                slicedOp[o][m][t] = TensorRemove(buf);
-            }
-        }
-    }
-    LOG(Message) << "Making contractions" << std::endl;
-    for (unsigned int m = 0; m < nmom; ++m)
-    for (auto &p: par().op)
-    {
-        TwoPointResult r;
-
-        r.sink   = p.first;
-        r.source = p.second;
-        r.mom    = mom_[m];
-        r.data   = makeTwoPoint(slicedOp[p.first][m], slicedOp[p.second][m], 
-                                1./partVol);
-        result.push_back(r);
-    }
-    saveResult(par().output, "twopt", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TwoPoint_hpp_

Hadrons/Modules/MScalarSUN/TwoPointNPR.cc

@@ -1,38 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPointNPR.cc
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#include <Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp>
-
-using namespace Grid;
-using namespace Hadrons;
-using namespace MScalarSUN;
-
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<2>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<3>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<4>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<5>>;
-template class Grid::Hadrons::MScalarSUN::TTwoPointNPR<ScalarNxNAdjImplR<6>>;

Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp

@@ -1,218 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/TwoPointNPR.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_TwoPointNPR_hpp_
-#define Hadrons_MScalarSUN_TwoPointNPR_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-#include <Hadrons/ModuleFactory.hpp>
-#include <Hadrons/Modules/MScalarSUN/Utils.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-/******************************************************************************
- *                         TwoPointNPR                                 *
- ******************************************************************************/
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-class TwoPointNPRPar: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointNPRPar,
-                                    std::vector<std::string>, op,
-                                    std::string,              field,
-                                    std::string,              output);
-};
-
-class TwoPointNPRResult: Serializable
-{
-public:
-    GRID_SERIALIZABLE_CLASS_MEMBERS(TwoPointNPRResult,
-                                    std::string,          op,
-                                    std::vector<Complex>, data);
-};
-
-template <typename SImpl>
-class TTwoPointNPR: public Module<TwoPointNPRPar>
-{
-public:
-    typedef typename SImpl::Field                    Field;
-    typedef typename SImpl::SiteField::scalar_object Site;
-    typedef typename SImpl::ComplexField             ComplexField;
-public:
-    // constructor
-    TTwoPointNPR(const std::string name);
-    // destructor
-    virtual ~TTwoPointNPR(void) {};
-    // dependency relation
-    virtual std::vector<std::string> getInput(void);
-    virtual std::vector<std::string> getOutput(void);
-    // setup
-    virtual void setup(void);
-    // execution
-    virtual void execute(void);
-};
-
-MODULE_REGISTER_TMP(TwoPointNPRSU2, TTwoPointNPR<ScalarNxNAdjImplR<2>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU3, TTwoPointNPR<ScalarNxNAdjImplR<3>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU4, TTwoPointNPR<ScalarNxNAdjImplR<4>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU5, TTwoPointNPR<ScalarNxNAdjImplR<5>>, MScalarSUN);
-MODULE_REGISTER_TMP(TwoPointNPRSU6, TTwoPointNPR<ScalarNxNAdjImplR<6>>, MScalarSUN);
-
-/******************************************************************************
- *                 TTwoPointNPR implementation                             *
- ******************************************************************************/
-// constructor /////////////////////////////////////////////////////////////////
-template <typename SImpl>
-TTwoPointNPR<SImpl>::TTwoPointNPR(const std::string name)
-: Module<TwoPointNPRPar>(name)
-{}
-
-// dependencies/products ///////////////////////////////////////////////////////
-template <typename SImpl>
-std::vector<std::string> TTwoPointNPR<SImpl>::getInput(void)
-{
-    std::vector<std::string> in = par().op;
-
-    in.push_back(par().field);
-
-    return in;
-}
-
-template <typename SImpl>
-std::vector<std::string> TTwoPointNPR<SImpl>::getOutput(void)
-{
-    std::vector<std::string> out;
-    
-    return out;
-}
-
-// setup ///////////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPointNPR<SImpl>::setup(void)
-{
-    const unsigned int nl = env().getDim(0);
-
-    for (unsigned int mu = 1; mu < env().getNd(); ++mu)
-    {
-        if (nl != env().getDim(mu))
-        {
-            HADRONS_ERROR(Size, "non-cubic grid");
-        }
-    }
-    envTmpLat(ComplexField, "ftBuf");
-    envTmpLat(Field, "ftMatBuf");
-}
-
-// execution ///////////////////////////////////////////////////////////////////
-template <typename SImpl>
-void TTwoPointNPR<SImpl>::execute(void)
-{
-    const unsigned int             nd   = env().getNd();
-    const unsigned int             nl   = env().getDim(0);
-    const Real                     invV = 1./env().getVolume();
-    FFT                            fft(envGetGrid(Field));
-    std::vector<TwoPointNPRResult> result;
-    TwoPointNPRResult              twoPtp1, twoPtp2, twoPtDisc;
-    auto                           &phi    = envGet(Field, par().field);
-    bool                           doAux = true;
-
-    envGetTmp(ComplexField, ftBuf);
-    envGetTmp(Field, ftMatBuf);
-    LOG(Message) << "FFT: field '" << par().field << "'" << std::endl;
-    fft.FFT_all_dim(ftMatBuf, phi, FFT::forward);
-    for (auto &opName: par().op)
-    {
-        auto              &op = envGet(ComplexField, opName);
-        std::vector<int>  p1, p2, p;
-        Site              phip1, phip2;
-        TComplex          opp;
-        TwoPointNPRResult r, rDisc;
-
-        LOG(Message) << "FFT: operator '" << opName << "'" << std::endl;
-        fft.FFT_all_dim(ftBuf, op, FFT::forward);
-        LOG(Message) << "Generating vertex function" << std::endl;
-        r.op = opName;
-        r.data.resize(nl);
-        rDisc.op = opName + "_disc";
-        rDisc.data.resize(nl);
-        if (doAux)
-        {
-            twoPtp1.op = "phi_prop_p1";
-            twoPtp1.data.resize(nl);
-            twoPtp2.op = "phi_prop_p2";
-            twoPtp2.data.resize(nl);
-            twoPtDisc.op = "phi_prop_disc";
-            twoPtDisc.data.resize(nl);
-        }
-        for (unsigned int n = 0; n < nl; ++n)
-        {
-            p1.assign(nd, 0);
-            p2.assign(nd, 0);
-            p.assign(nd, 0);
-            // non-exceptional RI/SMOM kinematic
-            // p1 = mu*(1,1,0): in mom
-            // p2 = mu*(0,1,1): out mom
-            // p  = p1 - p2 = mu*(1,0,-1)
-            // mu = 2*n*pi/L
-            p1[0] = n;
-            p1[1] = n;
-            p2[1] = n;
-            p2[2] = n;
-            p[0]  = n;
-            p[2]  = (nl - n) % nl;
-            peekSite(phip1, ftMatBuf, p1);
-            peekSite(phip2, ftMatBuf, p2);
-            peekSite(opp, ftBuf, p);
-            if (doAux)
-            {
-                twoPtp1.data[n]   = invV*TensorRemove(trace(phip1*adj(phip1)));
-                twoPtp2.data[n]   = invV*TensorRemove(trace(phip2*adj(phip2)));
-                twoPtDisc.data[n] = invV*TensorRemove(trace(phip2*adj(phip1)));
-            }
-            r.data[n]     = invV*TensorRemove(trace(phip2*adj(phip1))*opp);
-            rDisc.data[n] = invV*TensorRemove(trace(phip1*adj(phip1))*opp);
-        }
-        if (doAux)
-        {
-            result.push_back(twoPtp1);
-            result.push_back(twoPtp2);
-            result.push_back(twoPtDisc);
-        }
-        result.push_back(r);
-        result.push_back(rDisc);
-        doAux = false;
-    }
-    saveResult(par().output, "twoptnpr", result);
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_TwoPointNPR_hpp_

Hadrons/Modules/MScalarSUN/Utils.hpp

@@ -1,134 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid 
-
-Source file: Hadrons/Modules/MScalarSUN/Utils.hpp
-
-Copyright (C) 2015-2018
-
-Author: Antonin Portelli <antonin.portelli@me.com>
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License along
-with this program; if not, write to the Free Software Foundation, Inc.,
-51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-See the full license in the file "LICENSE" in the top level distribution directory
-*************************************************************************************/
-/*  END LEGAL */
-#ifndef Hadrons_MScalarSUN_Utils_hpp_
-#define Hadrons_MScalarSUN_Utils_hpp_
-
-#include <Hadrons/Global.hpp>
-#include <Hadrons/Module.hpp>
-
-BEGIN_HADRONS_NAMESPACE
-
-BEGIN_MODULE_NAMESPACE(MScalarSUN)
-
-GRID_SERIALIZABLE_ENUM(DiffType, undef, forward, 1, backward, 2, central, 3);
-
-template <typename Field>
-inline void dmu(Field &out, const Field &in, const unsigned int mu, const DiffType type)
-{
-    auto & env = Environment::getInstance();
-
-    if (mu >= env.getNd())
-    {
-        HADRONS_ERROR(Range, "Derivative direction out of range");
-    }
-    switch(type)
-    {
-        case DiffType::backward:
-            out = in - Cshift(in, mu, -1);
-            break;
-        case DiffType::forward:
-            out = Cshift(in, mu, 1) - in;
-            break;
-        case DiffType::central:
-            out = 0.5*(Cshift(in, mu, 1) - Cshift(in, mu, -1));
-            break;
-        default:
-            HADRONS_ERROR(Argument, "Derivative type invalid");
-            break;
-    }
-}
-
-template <typename Field>
-inline void dmuAcc(Field &out, const Field &in, const unsigned int mu, const DiffType type)
-{
-    auto & env = Environment::getInstance();
-
-    if (mu >= env.getNd())
-    {
-        HADRONS_ERROR(Range, "Derivative direction out of range");
-    }
-    switch(type)
-    {
-        case DiffType::backward:
-            out += in - Cshift(in, mu, -1);
-            break;
-        case DiffType::forward:
-            out += Cshift(in, mu, 1) - in;
-            break;
-        case DiffType::central:
-            out += 0.5*(Cshift(in, mu, 1) - Cshift(in, mu, -1));
-            break;
-        default:
-            HADRONS_ERROR(Argument, "Derivative type invalid");
-            break;
-    }
-}
-
-template <class SinkSite, class SourceSite>
-std::vector<Complex> makeTwoPoint(const std::vector<SinkSite>   &sink,
-                                  const std::vector<SourceSite> &source,
-                                  const double factor = 1.)
-{
-    assert(sink.size() == source.size());
-    
-    unsigned int         nt = sink.size();
-    std::vector<Complex> res(nt, 0.);
-    
-    for (unsigned int dt = 0; dt < nt; ++dt)
-    {
-        for (unsigned int t  = 0; t < nt; ++t)
-        {
-            res[dt] += trace(sink[(t+dt)%nt]*adj(source[t]));
-        }
-        res[dt] *= factor/static_cast<double>(nt);
-    }
-    
-    return res;
-}
-
-inline std::string varName(const std::string name, const std::string suf)
-{
-    return name + "_" + suf;
-}
-
-inline std::string varName(const std::string name, const unsigned int mu)
-{
-    return varName(name, std::to_string(mu));
-}
-
-inline std::string varName(const std::string name, const unsigned int mu, 
-                           const unsigned int nu)
-{
-    return varName(name, std::to_string(mu) + "_" + std::to_string(nu));
-}
-
-END_MODULE_NAMESPACE
-
-END_HADRONS_NAMESPACE
-
-#endif // Hadrons_MScalarSUN_Utils_hpp_