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

.gitignore

@@ -92,6 +92,7 @@ build*/*
 #####################
 *.xcodeproj/*
 build.sh
+.vscode
 
 # Eigen source #
 ################
@@ -106,6 +107,10 @@ lib/fftw/*
 m4/lt*
 m4/libtool.m4
 
+# github pages #
+################
+gh-pages/
+
 # Buck files #
 ##############
 .buck*
@@ -117,3 +122,4 @@ make-bin-BUCK.sh
 #####################
 lib/qcd/spin/gamma-gen/*.h
 lib/qcd/spin/gamma-gen/*.cc
+

.travis.yml

@@ -10,6 +10,7 @@ matrix:
       osx_image: xcode8.3
       compiler: clang
     - compiler: gcc
+      dist: trusty
       sudo: required
       addons:
         apt:
@@ -25,6 +26,7 @@ matrix:
             - binutils-dev
       env: VERSION=-4.9
     - compiler: gcc
+      dist: trusty
       sudo: required
       addons:
         apt:
@@ -40,6 +42,7 @@ matrix:
             - binutils-dev
       env: VERSION=-5
     - compiler: clang
+      dist: trusty
       addons:
         apt:
           sources:
@@ -54,6 +57,7 @@ matrix:
             - binutils-dev
       env: CLANG_LINK=http://llvm.org/releases/3.8.0/clang+llvm-3.8.0-x86_64-linux-gnu-ubuntu-14.04.tar.xz
     - compiler: clang
+      dist: trusty
       addons:
         apt:
           sources:
@@ -80,6 +84,10 @@ install:
     - export CC=$CC$VERSION
     - export CXX=$CXX$VERSION
     - echo $PATH
+    - which autoconf
+    - autoconf  --version
+    - which automake
+    - automake  --version
     - which $CC
     - $CC  --version
     - which $CXX
@@ -97,9 +105,10 @@ script:
     - ../configure --enable-precision=double --enable-simd=SSE4 --enable-comms=none
     - make -j4
     - ./benchmarks/Benchmark_dwf --threads 1 --debug-signals
+    - make check
     - echo make clean
-    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ../configure --enable-precision=single --enable-simd=SSE4 --enable-comms=mpi-auto CXXFLAGS='-DMPI_UINT32_T=MPI_UNSIGNED -DMPI_UINT64_T=MPI_UNSIGNED_LONG'; fi
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then ../configure --enable-precision=single --enable-simd=SSE4 --enable-comms=mpi-auto ; fi
-    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then make -j4; fi
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then make -j4; fi
-    - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then mpirun.openmpi -n 2 ./benchmarks/Benchmark_dwf --threads 1 --mpi 2.1.1.1; fi
+    - if [[ "$TRAVIS_OS_NAME" == "linux" ]] && [[ "$CC" == "clang" ]]; then mpirun.openmpi -n 2 ./benchmarks/Benchmark_dwf --threads 1 --mpi 2.1.1.1; fi
 
 

Makefile.am

@@ -3,10 +3,15 @@ SUBDIRS = lib benchmarks tests extras
 
 include $(top_srcdir)/doxygen.inc
 
-tests: all
+bin_SCRIPTS=grid-config
-	$(MAKE) -C tests tests
 
-.PHONY: tests doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
+
+.PHONY: bench check tests doxygen-run doxygen-doc $(DX_PS_GOAL) $(DX_PDF_GOAL)
+
+tests-local: all
+bench-local: all
+check-local: all
 
 AM_CXXFLAGS += -I$(top_builddir)/include
+
 ACLOCAL_AMFLAGS = -I m4

README.md

@@ -22,6 +22,26 @@ Last update Nov 2016.
 
 _Please do not send pull requests to the `master` branch which is reserved for releases._
 
+### Compilers
+
+Intel ICPC v16.0.3 and later
+
+Clang v3.5 and later (need 3.8 and later for OpenMP)
+
+GCC   v4.9.x (recommended)
+
+GCC   v6.3 and later
+
+### Important: 
+
+Some versions of GCC appear to have a bug under high optimisation (-O2, -O3).
+
+The safety of these compiler versions cannot be guaranteed at this time. Follow Issue 100 for details and updates.
+
+GCC   v5.x
+
+GCC   v6.1, v6.2
+
 ### Bug report
 
 _To help us tracking and solving more efficiently issues with Grid, please report problems using the issue system of GitHub rather than sending emails to Grid developers._
@@ -32,7 +52,7 @@ When you file an issue, please go though the following checklist:
 2. Give a description of the target platform (CPU, network, compiler). Please give the full CPU part description, using for example `cat /proc/cpuinfo | grep 'model name' | uniq` (Linux) or `sysctl machdep.cpu.brand_string` (macOS) and the full output the `--version` option of your compiler.
 3. Give the exact `configure` command used.
 4. Attach `config.log`.
-5. Attach `config.summary`.
+5. Attach `grid.config.summary`.
 6. Attach the output of `make V=1`.
 7. Describe the issue and any previous attempt to solve it. If relevant, show how to reproduce the issue using a minimal working example.
 
@@ -95,10 +115,10 @@ install Grid. Other options are detailed in the next section, you can also use `
 `CXX`, `CXXFLAGS`, `LDFLAGS`, ... environment variables can be modified to
 customise the build.
 
-Finally, you can build and install Grid:
+Finally, you can build, check, and install Grid:
 
 ``` bash
-make; make install
+make; make check; make install
 ```
 
 To minimise the build time, only the tests at the root of the `tests` directory are built by default. If you want to build tests in the sub-directory `<subdir>` you can execute:
@@ -121,7 +141,7 @@ If you want to build all the tests at once just use `make tests`.
 - `--enable-gen-simd-width=<size>`: select the size (in bytes) of the generic SIMD vector type (default: 32 bytes).
 - `--enable-precision={single|double}`: set the default precision (default: `double`).
 - `--enable-precision=<comm>`: Use `<comm>` for message passing (default: `none`). A list of possible SIMD targets is detailed in a section below.
-- `--enable-rng={ranlux48|mt19937}`: choose the RNG (default: `ranlux48 `).
+- `--enable-rng={sitmo|ranlux48|mt19937}`: choose the RNG (default: `sitmo `).
 - `--disable-timers`: disable system dependent high-resolution timers.
 - `--enable-chroma`: enable Chroma regression tests.
 - `--enable-doxygen-doc`: enable the Doxygen documentation generation (build with `make doxygen-doc`)
@@ -159,7 +179,6 @@ Alternatively, some CPU codenames can be directly used:
 
 | `<code>`    | Description                            |
 | ----------- | -------------------------------------- |
-| `KNC`       | [Intel Xeon Phi codename Knights Corner](http://ark.intel.com/products/codename/57721/Knights-Corner) |
 | `KNL`       | [Intel Xeon Phi codename Knights Landing](http://ark.intel.com/products/codename/48999/Knights-Landing) |
 | `BGQ`       | Blue Gene/Q                            |
 

VERSION

@@ -1,6 +1,5 @@
-Version : 0.6.0
+Version : 0.7.0
 
-- AVX512, AVX2, AVX, SSE good
+- Clang 3.5 and above, ICPC v16 and above, GCC 6.3 and above recommended
-- Clang 3.5 and above, ICPC v16 and above, GCC 4.9 and above
+- MPI and MPI3 comms optimisations for KNL and OPA finished
-- MPI and MPI3
+- Half precision comms
-- HiRep, Smearing, Generic gauge group

benchmarks/Benchmark_comms.cc

@@ -31,6 +31,32 @@ using namespace std;
 using namespace Grid;
 using namespace Grid::QCD;
 
+struct time_statistics{
+  double mean;
+  double err;
+  double min;
+  double max;
+
+  void statistics(std::vector<double> v){
+      double sum = std::accumulate(v.begin(), v.end(), 0.0);
+      mean = sum / v.size();
+
+      std::vector<double> diff(v.size());
+      std::transform(v.begin(), v.end(), diff.begin(), [=](double x) { return x - mean; });
+      double sq_sum = std::inner_product(diff.begin(), diff.end(), diff.begin(), 0.0);
+      err = std::sqrt(sq_sum / (v.size()*(v.size() - 1)));
+
+      auto result = std::minmax_element(v.begin(), v.end());
+      min = *result.first;
+      max = *result.second;
+}
+};
+
+void header(){
+  std::cout <<GridLogMessage << " L  "<<"\t"<<" Ls  "<<"\t"
+            <<std::setw(11)<<"bytes"<<"MB/s uni (err/min/max)"<<"\t\t"<<"MB/s bidi (err/min/max)"<<std::endl;
+};
+
 int main (int argc, char ** argv)
 {
   Grid_init(&argc,&argv);
@@ -40,15 +66,19 @@ int main (int argc, char ** argv)
   int threads = GridThread::GetThreads();
   std::cout<<GridLogMessage << "Grid is setup to use "<<threads<<" threads"<<std::endl;
 
-  int Nloop=10;
+  int Nloop=500;
   int nmu=0;
+  int maxlat=24;
   for(int mu=0;mu<Nd;mu++) if (mpi_layout[mu]>1) nmu++;
 
+  std::cout << GridLogMessage << "Number of iterations to average: "<< Nloop << std::endl;
+  std::vector<double> t_time(Nloop);
+  time_statistics timestat;
+
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
   std::cout<<GridLogMessage << "= Benchmarking concurrent halo exchange in "<<nmu<<" dimensions"<<std::endl;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
-  std::cout<<GridLogMessage << "  L  "<<"\t\t"<<" Ls  "<<"\t\t"<<"bytes"<<"\t\t"<<"MB/s uni"<<"\t\t"<<"MB/s bidi"<<std::endl;
+  header();
-  int maxlat=24;
   for(int lat=4;lat<=maxlat;lat+=4){
     for(int Ls=8;Ls<=32;Ls*=2){
 
@@ -65,8 +95,8 @@ int main (int argc, char ** argv)
       int ncomm;
       int bytes=lat*lat*lat*Ls*sizeof(HalfSpinColourVectorD);
 
-      double start=usecond();
       for(int i=0;i<Nloop;i++){
+      double start=usecond();
 
 	std::vector<CartesianCommunicator::CommsRequest_t> requests;
 
@@ -102,18 +132,24 @@ int main (int argc, char ** argv)
 	}
 	Grid.SendToRecvFromComplete(requests);
 	Grid.Barrier();
-
-      }
   double stop=usecond();
+  t_time[i] = stop-start; // microseconds
+      }
+
+      timestat.statistics(t_time);
 
       double dbytes    = bytes;
-      double xbytes    = Nloop*dbytes*2.0*ncomm;
+      double xbytes    = dbytes*2.0*ncomm;
       double rbytes    = xbytes;
       double bidibytes = xbytes+rbytes;
 
-      double time = stop-start; // microseconds
+      std::cout<<GridLogMessage << std::setw(4) << lat<<"\t"<<Ls<<"\t"
+               <<std::setw(11) << bytes<< std::fixed << std::setprecision(1) << std::setw(7)
+               <<std::right<< xbytes/timestat.mean<<"  "<< xbytes*timestat.err/(timestat.mean*timestat.mean)<< " "
+               <<xbytes/timestat.max <<" "<< xbytes/timestat.min  
+               << "\t\t"<<std::setw(7)<< bidibytes/timestat.mean<< "  " << bidibytes*timestat.err/(timestat.mean*timestat.mean) << " "
+               << bidibytes/timestat.max << " " << bidibytes/timestat.min << std::endl;
 
-      std::cout<<GridLogMessage << lat<<"\t\t"<<Ls<<"\t\t"<<bytes<<"\t\t"<<xbytes/time<<"\t\t"<<bidibytes/time<<std::endl;
     }
   }    
 
@@ -121,8 +157,7 @@ int main (int argc, char ** argv)
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
   std::cout<<GridLogMessage << "= Benchmarking sequential halo exchange in "<<nmu<<" dimensions"<<std::endl;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
-  std::cout<<GridLogMessage << "  L  "<<"\t\t"<<" Ls  "<<"\t\t"<<"bytes"<<"\t\t"<<"MB/s uni"<<"\t\t"<<"MB/s bidi"<<std::endl;
+  header();
-
 
   for(int lat=4;lat<=maxlat;lat+=4){
     for(int Ls=8;Ls<=32;Ls*=2){
@@ -138,8 +173,8 @@ int main (int argc, char ** argv)
       int ncomm;
       int bytes=lat*lat*lat*Ls*sizeof(HalfSpinColourVectorD);
 
-      double start=usecond();
       for(int i=0;i<Nloop;i++){
+      double start=usecond();
     
 	ncomm=0;
 	for(int mu=0;mu<4;mu++){
@@ -178,27 +213,34 @@ int main (int argc, char ** argv)
 	  }
 	}
 	Grid.Barrier();
+      double stop=usecond();
+    t_time[i] = stop-start; // microseconds
+
       }
 
-      double stop=usecond();
+      timestat.statistics(t_time);
       
       double dbytes    = bytes;
-      double xbytes    = Nloop*dbytes*2.0*ncomm;
+      double xbytes    = dbytes*2.0*ncomm;
       double rbytes    = xbytes;
       double bidibytes = xbytes+rbytes;
 
-      double time = stop-start;
+    std::cout<<GridLogMessage << std::setw(4) << lat<<"\t"<<Ls<<"\t"
+               <<std::setw(11) << bytes<< std::fixed << std::setprecision(1) << std::setw(7)
+               <<std::right<< xbytes/timestat.mean<<"  "<< xbytes*timestat.err/(timestat.mean*timestat.mean)<< " "
+               <<xbytes/timestat.max <<" "<< xbytes/timestat.min  
+               << "\t\t"<<std::setw(7)<< bidibytes/timestat.mean<< "  " << bidibytes*timestat.err/(timestat.mean*timestat.mean) << " "
+               << bidibytes/timestat.max << " " << bidibytes/timestat.min << std::endl;
+
       
-      std::cout<<GridLogMessage << lat<<"\t\t"<<Ls<<"\t\t"<<bytes<<"\t\t"<<xbytes/time<<"\t\t"<<bidibytes/time<<std::endl;
     }
   }  
 
 
-  Nloop=10;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
   std::cout<<GridLogMessage << "= Benchmarking concurrent STENCIL halo exchange in "<<nmu<<" dimensions"<<std::endl;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
-  std::cout<<GridLogMessage << "  L  "<<"\t\t"<<" Ls  "<<"\t\t"<<"bytes"<<"\t\t"<<"MB/s uni"<<"\t\t"<<"MB/s bidi"<<std::endl;
+  header();
 
   for(int lat=4;lat<=maxlat;lat+=4){
     for(int Ls=8;Ls<=32;Ls*=2){
@@ -221,8 +263,8 @@ int main (int argc, char ** argv)
       int ncomm;
       int bytes=lat*lat*lat*Ls*sizeof(HalfSpinColourVectorD);
 
-      double start=usecond();
       for(int i=0;i<Nloop;i++){
+      double start=usecond();
 
 	std::vector<CartesianCommunicator::CommsRequest_t> requests;
 
@@ -258,28 +300,34 @@ int main (int argc, char ** argv)
 	}
 	Grid.StencilSendToRecvFromComplete(requests);
 	Grid.Barrier();
+      double stop=usecond();
+    t_time[i] = stop-start; // microseconds
 
       }
-      double stop=usecond();
+
+      timestat.statistics(t_time);
 
       double dbytes    = bytes;
-      double xbytes    = Nloop*dbytes*2.0*ncomm;
+      double xbytes    = dbytes*2.0*ncomm;
       double rbytes    = xbytes;
       double bidibytes = xbytes+rbytes;
 
-      double time = stop-start; // microseconds
+      std::cout<<GridLogMessage << std::setw(4) << lat<<"\t"<<Ls<<"\t"
+               <<std::setw(11) << bytes<< std::fixed << std::setprecision(1) << std::setw(7)
+               <<std::right<< xbytes/timestat.mean<<"  "<< xbytes*timestat.err/(timestat.mean*timestat.mean)<< " "
+               <<xbytes/timestat.max <<" "<< xbytes/timestat.min  
+               << "\t\t"<<std::setw(7)<< bidibytes/timestat.mean<< "  " << bidibytes*timestat.err/(timestat.mean*timestat.mean) << " "
+               << bidibytes/timestat.max << " " << bidibytes/timestat.min << std::endl;
+
 
-      std::cout<<GridLogMessage << lat<<"\t\t"<<Ls<<"\t\t"<<bytes<<"\t\t"<<xbytes/time<<"\t\t"<<bidibytes/time<<std::endl;
     }
   }    
 
 
-
-  Nloop=100;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
   std::cout<<GridLogMessage << "= Benchmarking sequential STENCIL halo exchange in "<<nmu<<" dimensions"<<std::endl;
   std::cout<<GridLogMessage << "===================================================================================================="<<std::endl;
-  std::cout<<GridLogMessage << "  L  "<<"\t\t"<<" Ls  "<<"\t\t"<<"bytes"<<"\t\t"<<"MB/s uni"<<"\t\t"<<"MB/s bidi"<<std::endl;
+  header();
 
   for(int lat=4;lat<=maxlat;lat+=4){
     for(int Ls=8;Ls<=32;Ls*=2){
@@ -302,8 +350,8 @@ int main (int argc, char ** argv)
       int ncomm;
       int bytes=lat*lat*lat*Ls*sizeof(HalfSpinColourVectorD);
 
-      double start=usecond();
       for(int i=0;i<Nloop;i++){
+      double start=usecond();
 
 	std::vector<CartesianCommunicator::CommsRequest_t> requests;
 
@@ -342,18 +390,26 @@ int main (int argc, char ** argv)
 	  }
 	}
 	    Grid.Barrier();
+      double stop=usecond();
+      t_time[i] = stop-start; // microseconds
 
       }
-      double stop=usecond();
+
+      timestat.statistics(t_time);
 
       double dbytes    = bytes;
-      double xbytes    = Nloop*dbytes*2.0*ncomm;
+      double xbytes    = dbytes*2.0*ncomm;
       double rbytes    = xbytes;
       double bidibytes = xbytes+rbytes;
 
-      double time = stop-start; // microseconds
 
-      std::cout<<GridLogMessage << lat<<"\t\t"<<Ls<<"\t\t"<<bytes<<"\t\t"<<xbytes/time<<"\t\t"<<bidibytes/time<<std::endl;
+      std::cout<<GridLogMessage << std::setw(4) << lat<<"\t"<<Ls<<"\t"
+               <<std::setw(11) << bytes<< std::fixed << std::setprecision(1) << std::setw(7)
+               <<std::right<< xbytes/timestat.mean<<"  "<< xbytes*timestat.err/(timestat.mean*timestat.mean)<< " "
+               <<xbytes/timestat.max <<" "<< xbytes/timestat.min  
+               << "\t\t"<<std::setw(7)<< bidibytes/timestat.mean<< "  " << bidibytes*timestat.err/(timestat.mean*timestat.mean) << " "
+               << bidibytes/timestat.max << " " << bidibytes/timestat.min << std::endl;
+ 
     }
   }    
 

benchmarks/Benchmark_dwf.cc

@@ -1,28 +1,22 @@
  /*************************************************************************************
-
     Grid physics library, www.github.com/paboyle/Grid 
-
     Source file: ./benchmarks/Benchmark_dwf.cc
-
     Copyright (C) 2015
 
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+    Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <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 */
@@ -151,6 +145,7 @@ int main (int argc, char ** argv)
   RealD M5  =1.8;
 
   RealD NP = UGrid->_Nprocessors;
+  RealD NN = UGrid->NodeCount();
 
   std::cout << GridLogMessage<< "*****************************************************************" <<std::endl;
   std::cout << GridLogMessage<< "* Kernel options --dslash-generic, --dslash-unroll, --dslash-asm" <<std::endl;
@@ -160,6 +155,10 @@ int main (int argc, char ** argv)
   std::cout << GridLogMessage<< "* Vectorising space-time by "<<vComplex::Nsimd()<<std::endl;
   if ( sizeof(Real)==4 )   std::cout << GridLogMessage<< "* SINGLE precision "<<std::endl;
   if ( sizeof(Real)==8 )   std::cout << GridLogMessage<< "* DOUBLE precision "<<std::endl;
+#ifdef GRID_OMP
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute ) std::cout << GridLogMessage<< "* Using Overlapped Comms/Compute" <<std::endl;
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsThenCompute) std::cout << GridLogMessage<< "* Using sequential comms compute" <<std::endl;
+#endif
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptGeneric   ) std::cout << GridLogMessage<< "* Using GENERIC Nc WilsonKernels" <<std::endl;
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptHandUnroll) std::cout << GridLogMessage<< "* Using Nc=3       WilsonKernels" <<std::endl;
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptInlineAsm ) std::cout << GridLogMessage<< "* Using Asm Nc=3   WilsonKernels" <<std::endl;
@@ -189,6 +188,7 @@ int main (int argc, char ** argv)
     //    std::cout<<GridLogMessage << "norm ref    "<< norm2(ref)<<std::endl;
     std::cout<<GridLogMessage << "mflop/s =   "<< flops/(t1-t0)<<std::endl;
     std::cout<<GridLogMessage << "mflop/s per rank =  "<< flops/(t1-t0)/NP<<std::endl;
+    std::cout<<GridLogMessage << "mflop/s per node =  "<< flops/(t1-t0)/NN<<std::endl;
     err = ref-result; 
     std::cout<<GridLogMessage << "norm diff   "<< norm2(err)<<std::endl;
 
@@ -225,6 +225,7 @@ int main (int argc, char ** argv)
     std::cout<<GridLogMessage << "Called half prec comms Dw "<<ncall<<" times in "<<t1-t0<<" us"<<std::endl;
     std::cout<<GridLogMessage << "mflop/s =   "<< flops/(t1-t0)<<std::endl;
     std::cout<<GridLogMessage << "mflop/s per rank =  "<< flops/(t1-t0)/NP<<std::endl;
+    std::cout<<GridLogMessage << "mflop/s per node =  "<< flops/(t1-t0)/NN<<std::endl;
     err = ref-result; 
     std::cout<<GridLogMessage << "norm diff   "<< norm2(err)<<std::endl;
 
@@ -240,6 +241,10 @@ int main (int argc, char ** argv)
     std::cout << GridLogMessage<< "* Vectorising fifth dimension by "<<vComplex::Nsimd()<<std::endl;
     if ( sizeof(Real)==4 )   std::cout << GridLogMessage<< "* SINGLE precision "<<std::endl;
     if ( sizeof(Real)==8 )   std::cout << GridLogMessage<< "* DOUBLE precision "<<std::endl;
+#ifdef GRID_OMP
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute ) std::cout << GridLogMessage<< "* Using Overlapped Comms/Compute" <<std::endl;
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsThenCompute) std::cout << GridLogMessage<< "* Using sequential comms compute" <<std::endl;
+#endif
     if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptGeneric   ) std::cout << GridLogMessage<< "* Using GENERIC Nc WilsonKernels" <<std::endl;
     if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptHandUnroll) std::cout << GridLogMessage<< "* Using Nc=3       WilsonKernels" <<std::endl;
     if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptInlineAsm ) std::cout << GridLogMessage<< "* Using Asm Nc=3   WilsonKernels" <<std::endl;
@@ -271,6 +276,7 @@ int main (int argc, char ** argv)
     std::cout<<GridLogMessage << "Called Dw s_inner "<<ncall<<" times in "<<t1-t0<<" us"<<std::endl;
     std::cout<<GridLogMessage << "mflop/s =   "<< flops/(t1-t0)<<std::endl;
     std::cout<<GridLogMessage << "mflop/s per rank =  "<< flops/(t1-t0)/NP<<std::endl;
+    std::cout<<GridLogMessage << "mflop/s per node =  "<< flops/(t1-t0)/NN<<std::endl;
     //    std::cout<<GridLogMessage<< "res norms "<< norm2(result)<<" " <<norm2(sresult)<<std::endl;
     sDw.Report();
     RealD sum=0;
@@ -303,6 +309,10 @@ int main (int argc, char ** argv)
       std::cout << GridLogMessage<< "* Vectorising fifth dimension by "<<vComplex::Nsimd()<<std::endl;
       if ( sizeof(Real)==4 )   std::cout << GridLogMessage<< "* SINGLE precision "<<std::endl;
       if ( sizeof(Real)==8 )   std::cout << GridLogMessage<< "* DOUBLE precision "<<std::endl;
+#ifdef GRID_OMP
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute ) std::cout << GridLogMessage<< "* Using Overlapped Comms/Compute" <<std::endl;
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsThenCompute) std::cout << GridLogMessage<< "* Using sequential comms compute" <<std::endl;
+#endif
       if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptGeneric   ) 
 	std::cout << GridLogMessage<< "* Using GENERIC Nc WilsonKernels" <<std::endl;
       if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptHandUnroll) 
@@ -342,6 +352,7 @@ int main (int argc, char ** argv)
 
       std::cout<<GridLogMessage << "sDeo mflop/s =   "<< flops/(t1-t0)<<std::endl;
       std::cout<<GridLogMessage << "sDeo mflop/s per rank   "<< flops/(t1-t0)/NP<<std::endl;
+      std::cout<<GridLogMessage << "sDeo mflop/s per node   "<< flops/(t1-t0)/NN<<std::endl;
       sDw.Report();
 
       sDw.DhopEO(ssrc_o,sr_e,DaggerNo);
@@ -420,14 +431,15 @@ int main (int argc, char ** argv)
 
 
   // S-direction is INNERMOST and takes no part in the parity.
-  static int Opt;  // these are a temporary hack
-  static int Comms;  // these are a temporary hack
-
   std::cout << GridLogMessage<< "*********************************************************" <<std::endl;
   std::cout << GridLogMessage<< "* Benchmarking DomainWallFermionR::DhopEO                "<<std::endl;
   std::cout << GridLogMessage<< "* Vectorising space-time by "<<vComplex::Nsimd()<<std::endl;
   if ( sizeof(Real)==4 )   std::cout << GridLogMessage<< "* SINGLE precision "<<std::endl;
   if ( sizeof(Real)==8 )   std::cout << GridLogMessage<< "* DOUBLE precision "<<std::endl;
+#ifdef GRID_OMP
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsAndCompute ) std::cout << GridLogMessage<< "* Using Overlapped Comms/Compute" <<std::endl;
+  if ( WilsonKernelsStatic::Comms == WilsonKernelsStatic::CommsThenCompute) std::cout << GridLogMessage<< "* Using sequential comms compute" <<std::endl;
+#endif
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptGeneric   ) std::cout << GridLogMessage<< "* Using GENERIC Nc WilsonKernels" <<std::endl;
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptHandUnroll) std::cout << GridLogMessage<< "* Using Nc=3       WilsonKernels" <<std::endl;
   if ( WilsonKernelsStatic::Opt == WilsonKernelsStatic::OptInlineAsm ) std::cout << GridLogMessage<< "* Using Asm Nc=3   WilsonKernels" <<std::endl;
@@ -448,6 +460,7 @@ int main (int argc, char ** argv)
 
     std::cout<<GridLogMessage << "Deo mflop/s =   "<< flops/(t1-t0)<<std::endl;
     std::cout<<GridLogMessage << "Deo mflop/s per rank   "<< flops/(t1-t0)/NP<<std::endl;
+    std::cout<<GridLogMessage << "Deo mflop/s per node   "<< flops/(t1-t0)/NN<<std::endl;
     Dw.Report();
   }
   Dw.DhopEO(src_o,r_e,DaggerNo);
@@ -479,3 +492,4 @@ int main (int argc, char ** argv)
 
   Grid_finalize();
 }
+

benchmarks/Benchmark_su3.cc

@@ -35,8 +35,9 @@ using namespace Grid::QCD;
 int main (int argc, char ** argv)
 {
   Grid_init(&argc,&argv);
+#define LMAX (32)
 
-  int Nloop=1000;
+  int Nloop=200;
 
   std::vector<int> simd_layout = GridDefaultSimd(Nd,vComplex::Nsimd());
   std::vector<int> mpi_layout  = GridDefaultMpi();
@@ -50,7 +51,7 @@ int main (int argc, char ** argv)
   std::cout<<GridLogMessage << "  L  "<<"\t\t"<<"bytes"<<"\t\t\t"<<"GB/s\t\t GFlop/s"<<std::endl;
   std::cout<<GridLogMessage << "----------------------------------------------------------"<<std::endl;
 
-  for(int lat=2;lat<=32;lat+=2){
+  for(int lat=2;lat<=LMAX;lat+=2){
 
       std::vector<int> latt_size  ({lat*mpi_layout[0],lat*mpi_layout[1],lat*mpi_layout[2],lat*mpi_layout[3]});
       int vol = latt_size[0]*latt_size[1]*latt_size[2]*latt_size[3];
@@ -82,7 +83,7 @@ int main (int argc, char ** argv)
   std::cout<<GridLogMessage << "  L  "<<"\t\t"<<"bytes"<<"\t\t\t"<<"GB/s\t\t GFlop/s"<<std::endl;
   std::cout<<GridLogMessage << "----------------------------------------------------------"<<std::endl;
 
-  for(int lat=2;lat<=32;lat+=2){
+  for(int lat=2;lat<=LMAX;lat+=2){
 
       std::vector<int> latt_size  ({lat*mpi_layout[0],lat*mpi_layout[1],lat*mpi_layout[2],lat*mpi_layout[3]});
       int vol = latt_size[0]*latt_size[1]*latt_size[2]*latt_size[3];
@@ -113,7 +114,7 @@ int main (int argc, char ** argv)
   std::cout<<GridLogMessage << "  L  "<<"\t\t"<<"bytes"<<"\t\t\t"<<"GB/s\t\t GFlop/s"<<std::endl;
   std::cout<<GridLogMessage << "----------------------------------------------------------"<<std::endl;
 
-  for(int lat=2;lat<=32;lat+=2){
+  for(int lat=2;lat<=LMAX;lat+=2){
 
       std::vector<int> latt_size  ({lat*mpi_layout[0],lat*mpi_layout[1],lat*mpi_layout[2],lat*mpi_layout[3]});
       int vol = latt_size[0]*latt_size[1]*latt_size[2]*latt_size[3];
@@ -144,7 +145,7 @@ int main (int argc, char ** argv)
   std::cout<<GridLogMessage << "  L  "<<"\t\t"<<"bytes"<<"\t\t\t"<<"GB/s\t\t GFlop/s"<<std::endl;
   std::cout<<GridLogMessage << "----------------------------------------------------------"<<std::endl;
 
-  for(int lat=2;lat<=32;lat+=2){
+  for(int lat=2;lat<=LMAX;lat+=2){
 
       std::vector<int> latt_size  ({lat*mpi_layout[0],lat*mpi_layout[1],lat*mpi_layout[2],lat*mpi_layout[3]});
       int vol = latt_size[0]*latt_size[1]*latt_size[2]*latt_size[3];

benchmarks/Makefile.am

@@ -1,11 +1,7 @@
 include Make.inc
 
-simple: simple_su3_test.o simple_su3_expr.o simple_simd_test.o
+bench-local: all
-
+	./Benchmark_su3
-EXTRA_LIBRARIES = libsimple_su3_test.a libsimple_su3_expr.a libsimple_simd_test.a
+	./Benchmark_memory_bandwidth
-
+	./Benchmark_wilson
-libsimple_su3_test_a_SOURCES = simple_su3_test.cc
+	./Benchmark_dwf --dslash-unroll
-
-libsimple_su3_expr_a_SOURCES = simple_su3_expr.cc
-
-libsimple_simd_test_a_SOURCES = simple_simd_test.cc

bootstrap.sh

@@ -1,6 +1,6 @@
-#!/usr/bin/env bash
+]#!/usr/bin/env bash
 
-EIGEN_URL='http://bitbucket.org/eigen/eigen/get/3.2.9.tar.bz2'
+EIGEN_URL='http://bitbucket.org/eigen/eigen/get/3.3.3.tar.bz2'
 
 echo "-- deploying Eigen source..."
 #wget ${EIGEN_URL} --no-check-certificate

configure.ac

@@ -1,16 +1,19 @@
 AC_PREREQ([2.63])
-AC_INIT([Grid], [0.6.0], [https://github.com/paboyle/Grid], [Grid])
+AC_INIT([Grid], [0.7.0], [https://github.com/paboyle/Grid], [Grid])
 AC_CANONICAL_BUILD
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
-AM_INIT_AUTOMAKE(subdir-objects)
+AM_INIT_AUTOMAKE([subdir-objects 1.13])
+AM_EXTRA_RECURSIVE_TARGETS([tests bench])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_SRCDIR([lib/Grid.h])
 AC_CONFIG_HEADERS([lib/Config.h],[sed -i 's|PACKAGE_|GRID_|' lib/Config.h])
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
+################ Get git info
+#AC_REVISION([m4_esyscmd_s([./scripts/configure.commit])])
+
 ############### Checks for programs
-CXXFLAGS="-O3 $CXXFLAGS"
 AC_PROG_CXX
 AC_PROG_RANLIB
 
@@ -24,6 +27,9 @@ AX_GXX_VERSION
 AC_DEFINE_UNQUOTED([GXX_VERSION],["$GXX_VERSION"],
       [version of g++ that will compile the code])
 
+CXXFLAGS="-O3 $CXXFLAGS"
+
+
 ############### Checks for typedefs, structures, and compiler characteristics
 AC_TYPE_SIZE_T
 AC_TYPE_UINT32_T
@@ -67,6 +73,13 @@ AC_ARG_WITH([fftw],
             [AM_CXXFLAGS="-I$with_fftw/include $AM_CXXFLAGS"]
             [AM_LDFLAGS="-L$with_fftw/lib $AM_LDFLAGS"])
 
+############### LIME
+AC_ARG_WITH([lime],
+            [AS_HELP_STRING([--with-lime=prefix],
+            [try this for a non-standard install prefix of the LIME library])],
+            [AM_CXXFLAGS="-I$with_lime/include $AM_CXXFLAGS"]
+            [AM_LDFLAGS="-L$with_lime/lib $AM_LDFLAGS"])
+
 ############### lapack
 AC_ARG_ENABLE([lapack],
     [AC_HELP_STRING([--enable-lapack=yes|no|prefix], [enable LAPACK])],
@@ -164,6 +177,14 @@ AC_SEARCH_LIBS([fftw_execute], [fftw3],
                [AC_DEFINE([HAVE_FFTW], [1], [Define to 1 if you have the `FFTW' library])]
                [have_fftw=true])
 
+AC_SEARCH_LIBS([limeCreateReader], [lime],
+               [AC_DEFINE([HAVE_LIME], [1], [Define to 1 if you have the `LIME' library])]
+               [have_lime=true],
+	       [AC_MSG_WARN(C-LIME library was not found in your system.
+In order to use ILGG file format please install or provide the correct path to your installation
+Info at: http://usqcd.jlab.org/usqcd-docs/c-lime/)])
+
+
 AC_SEARCH_LIBS([H5Fopen], [hdf5_cpp],
                [AC_DEFINE([HAVE_HDF5], [1], [Define to 1 if you have the `HDF5' library])]
                [have_hdf5=true]
@@ -403,32 +424,31 @@ DX_INIT_DOXYGEN([$PACKAGE_NAME], [doxygen.cfg])
 
 ############### Ouput
 cwd=`pwd -P`; cd ${srcdir}; abs_srcdir=`pwd -P`; cd ${cwd}
+GRID_CXXFLAGS="$AM_CXXFLAGS $CXXFLAGS"
+GRID_LDFLAGS="$AM_LDFLAGS $LDFLAGS"
+GRID_LIBS=$LIBS
+GRID_SHORT_SHA=`git rev-parse --short HEAD`
+GRID_SHA=`git rev-parse HEAD`
+GRID_BRANCH=`git rev-parse --abbrev-ref HEAD`
 AM_CXXFLAGS="-I${abs_srcdir}/include $AM_CXXFLAGS"
 AM_CFLAGS="-I${abs_srcdir}/include $AM_CFLAGS"
 AM_LDFLAGS="-L${cwd}/lib $AM_LDFLAGS"
 AC_SUBST([AM_CFLAGS])
 AC_SUBST([AM_CXXFLAGS])
 AC_SUBST([AM_LDFLAGS])
-AC_CONFIG_FILES(Makefile)
+AC_SUBST([GRID_CXXFLAGS])
-AC_CONFIG_FILES(lib/Makefile)
+AC_SUBST([GRID_LDFLAGS])
-AC_CONFIG_FILES(tests/Makefile)
+AC_SUBST([GRID_LIBS])
-AC_CONFIG_FILES(tests/IO/Makefile)
+AC_SUBST([GRID_SHA])
-AC_CONFIG_FILES(tests/core/Makefile)
+AC_SUBST([GRID_BRANCH])
-AC_CONFIG_FILES(tests/debug/Makefile)
+
-AC_CONFIG_FILES(tests/forces/Makefile)
+git_commit=`cd $srcdir && ./scripts/configure.commit`
-AC_CONFIG_FILES(tests/hadrons/Makefile)
-AC_CONFIG_FILES(tests/hmc/Makefile)
-AC_CONFIG_FILES(tests/solver/Makefile)
-AC_CONFIG_FILES(tests/qdpxx/Makefile)
-AC_CONFIG_FILES(tests/testu01/Makefile)
-AC_CONFIG_FILES(benchmarks/Makefile)
-AC_CONFIG_FILES(extras/Makefile)
-AC_CONFIG_FILES(extras/Hadrons/Makefile)
-AC_OUTPUT
 
 echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Summary of configuration for $PACKAGE v$VERSION
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----- GIT VERSION -------------------------------------
+$git_commit
 ----- PLATFORM ----------------------------------------
 architecture (build)        : $build_cpu
 os (build)                  : $build_os
@@ -446,6 +466,7 @@ RNG choice                  : ${ac_RNG}
 GMP                         : `if test "x$have_gmp" = xtrue; then echo yes; else echo no; fi`
 LAPACK                      : ${ac_LAPACK}
 FFTW                        : `if test "x$have_fftw" = xtrue; then echo yes; else echo no; fi`
+LIME (ILDG support)         : `if test "x$have_lime" = xtrue; then echo yes; else echo no; fi`
 HDF5                        : `if test "x$have_hdf5" = xtrue; then echo yes; else echo no; fi`
 build DOXYGEN documentation : `if test "$DX_FLAG_doc" = '1'; then echo yes; else echo no; fi`
 ----- BUILD FLAGS -------------------------------------
@@ -455,7 +476,32 @@ LDFLAGS:
 `echo ${AM_LDFLAGS} ${LDFLAGS} | tr ' ' '\n' | sed 's/^-/    -/g'`
 LIBS:
 `echo ${LIBS} | tr ' ' '\n' | sed 's/^-/    -/g'`
--------------------------------------------------------" > config.summary
+-------------------------------------------------------" > grid.configure.summary
+
+GRID_SUMMARY="`cat grid.configure.summary`"
+AM_SUBST_NOTMAKE([GRID_SUMMARY])
+AC_SUBST([GRID_SUMMARY])
+
+AC_CONFIG_FILES([grid-config], [chmod +x grid-config])
+AC_CONFIG_FILES(Makefile)
+AC_CONFIG_FILES(lib/Makefile)
+AC_CONFIG_FILES(tests/Makefile)
+AC_CONFIG_FILES(tests/IO/Makefile)
+AC_CONFIG_FILES(tests/core/Makefile)
+AC_CONFIG_FILES(tests/debug/Makefile)
+AC_CONFIG_FILES(tests/forces/Makefile)
+AC_CONFIG_FILES(tests/hadrons/Makefile)
+AC_CONFIG_FILES(tests/hmc/Makefile)
+AC_CONFIG_FILES(tests/solver/Makefile)
+AC_CONFIG_FILES(tests/smearing/Makefile)
+AC_CONFIG_FILES(tests/qdpxx/Makefile)
+AC_CONFIG_FILES(tests/testu01/Makefile)
+AC_CONFIG_FILES(benchmarks/Makefile)
+AC_CONFIG_FILES(extras/Makefile)
+AC_CONFIG_FILES(extras/Hadrons/Makefile)
+AC_OUTPUT
+
 echo ""
-cat config.summary
+cat grid.configure.summary
 echo ""
+

extras/Hadrons/Application.cc

@@ -162,7 +162,8 @@ void Application::saveParameterFile(const std::string parameterFileName)
 sizeString((size)*locVol_) << " (" << sizeString(size)  << "/site)"
 
 #define DEFINE_MEMPEAK \
-auto memPeak = [this](const std::vector<unsigned int> &program)\
+GeneticScheduler<unsigned int>::ObjFunc memPeak = \
+[this](const std::vector<unsigned int> &program)\
 {\
     unsigned int memPeak;\
     bool         msg;\

extras/Hadrons/Global.hpp

@@ -145,6 +145,15 @@ std::string typeName(void)
     return typeName(typeIdPt<T>());
 }
 
+// default writers/readers
+#ifdef HAVE_HDF5
+typedef Hdf5Reader CorrReader;
+typedef Hdf5Writer CorrWriter;
+#else
+typedef XmlReader CorrReader;
+typedef XmlWriter CorrWriter;
+#endif
+
 END_HADRONS_NAMESPACE
 
 #endif // Hadrons_Global_hpp_

extras/Hadrons/Modules.hpp

@@ -29,12 +29,20 @@ See the full license in the file "LICENSE" in the top level distribution directo
 #include <Grid/Hadrons/Modules/MAction/DWF.hpp>
 #include <Grid/Hadrons/Modules/MAction/Wilson.hpp>
 #include <Grid/Hadrons/Modules/MContraction/Baryon.hpp>
+#include <Grid/Hadrons/Modules/MContraction/DiscLoop.hpp>
+#include <Grid/Hadrons/Modules/MContraction/Gamma3pt.hpp>
 #include <Grid/Hadrons/Modules/MContraction/Meson.hpp>
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp>
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp>
+#include <Grid/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp>
 #include <Grid/Hadrons/Modules/MGauge/Load.hpp>
 #include <Grid/Hadrons/Modules/MGauge/Random.hpp>
 #include <Grid/Hadrons/Modules/MGauge/Unit.hpp>
+#include <Grid/Hadrons/Modules/MLoop/NoiseLoop.hpp>
 #include <Grid/Hadrons/Modules/MSolver/RBPrecCG.hpp>
 #include <Grid/Hadrons/Modules/MSource/Point.hpp>
 #include <Grid/Hadrons/Modules/MSource/SeqGamma.hpp>
+#include <Grid/Hadrons/Modules/MSource/Wall.hpp>
 #include <Grid/Hadrons/Modules/MSource/Z2.hpp>
 #include <Grid/Hadrons/Modules/Quark.hpp>

extras/Hadrons/Modules/MContraction/Baryon.hpp

@@ -112,7 +112,7 @@ void TBaryon<FImpl1, FImpl2, FImpl3>::execute(void)
                  << " quarks '" << par().q1 << "', '" << par().q2 << "', and '"
                  << par().q3 << "'" << std::endl;
     
-    XmlWriter             writer(par().output);
+    CorrWriter             writer(par().output);
     PropagatorField1      &q1 = *env().template getObject<PropagatorField1>(par().q1);
     PropagatorField2      &q2 = *env().template getObject<PropagatorField2>(par().q2);
     PropagatorField3      &q3 = *env().template getObject<PropagatorField3>(par().q2);

extras/Hadrons/Modules/MContraction/DiscLoop.hpp

@@ -0,0 +1,144 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/DiscLoop.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_DiscLoop_hpp_
+#define Hadrons_DiscLoop_hpp_
+
+#include <Grid/Hadrons/Global.hpp>
+#include <Grid/Hadrons/Module.hpp>
+#include <Grid/Hadrons/ModuleFactory.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/******************************************************************************
+ *                                DiscLoop                                    *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+class DiscLoopPar: Serializable
+{
+public:
+    GRID_SERIALIZABLE_CLASS_MEMBERS(DiscLoopPar,
+                                    std::string,    q_loop,
+                                    Gamma::Algebra, gamma,
+                                    std::string,    output);
+};
+
+template <typename FImpl>
+class TDiscLoop: public Module<DiscLoopPar>
+{
+    TYPE_ALIASES(FImpl,);
+    class Result: Serializable
+    {
+    public:
+        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
+                                        Gamma::Algebra, gamma,
+                                        std::vector<Complex>, corr);
+    };
+public:
+    // constructor
+    TDiscLoop(const std::string name);
+    // destructor
+    virtual ~TDiscLoop(void) = default;
+    // 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_NS(DiscLoop, TDiscLoop<FIMPL>, MContraction);
+
+/******************************************************************************
+ *                       TDiscLoop implementation                             *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+template <typename FImpl>
+TDiscLoop<FImpl>::TDiscLoop(const std::string name)
+: Module<DiscLoopPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+template <typename FImpl>
+std::vector<std::string> TDiscLoop<FImpl>::getInput(void)
+{
+    std::vector<std::string> in = {par().q_loop};
+    
+    return in;
+}
+
+template <typename FImpl>
+std::vector<std::string> TDiscLoop<FImpl>::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TDiscLoop<FImpl>::setup(void)
+{
+    
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TDiscLoop<FImpl>::execute(void)
+{
+    LOG(Message) << "Computing disconnected loop contraction '" << getName() 
+                 << "' using '" << par().q_loop << "' with " << par().gamma 
+                 << " insertion." << std::endl;
+
+    CorrWriter            writer(par().output);
+    PropagatorField       &q_loop = *env().template getObject<PropagatorField>(par().q_loop);
+    LatticeComplex        c(env().getGrid());
+    Gamma                 gamma(par().gamma);
+    std::vector<TComplex> buf;
+    Result                result;
+
+    c = trace(gamma*q_loop);
+    sliceSum(c, buf, Tp);
+
+    result.gamma = par().gamma;
+    result.corr.resize(buf.size());
+    for (unsigned int t = 0; t < buf.size(); ++t)
+    {
+        result.corr[t] = TensorRemove(buf[t]);
+    }
+
+    write(writer, "disc", result);
+}
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_DiscLoop_hpp_

extras/Hadrons/Modules/MContraction/Gamma3pt.hpp

@@ -0,0 +1,170 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/Gamma3pt.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_Gamma3pt_hpp_
+#define Hadrons_Gamma3pt_hpp_
+
+#include <Grid/Hadrons/Global.hpp>
+#include <Grid/Hadrons/Module.hpp>
+#include <Grid/Hadrons/ModuleFactory.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/*
+ * 3pt contraction with gamma matrix insertion.
+ *
+ * Schematic:
+ *
+ *             q2           q3
+ *        /----<------*------<----¬
+ *       /          gamma          \
+ *      /                           \
+ *   i *                            * f
+ *      \                          /
+ *       \                        /
+ *        \----------->----------/
+ *                   q1
+ *
+ *      trace(g5*q1*adj(q2)*g5*gamma*q3)
+ */
+
+/******************************************************************************
+ *                               Gamma3pt                                     *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+class Gamma3ptPar: Serializable
+{
+public:
+    GRID_SERIALIZABLE_CLASS_MEMBERS(Gamma3ptPar,
+                                    std::string,    q1,
+                                    std::string,    q2,
+                                    std::string,    q3,
+                                    Gamma::Algebra, gamma,
+                                    std::string,    output);
+};
+
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+class TGamma3pt: public Module<Gamma3ptPar>
+{
+    TYPE_ALIASES(FImpl1, 1);
+    TYPE_ALIASES(FImpl2, 2);
+    TYPE_ALIASES(FImpl3, 3);
+    class Result: Serializable
+    {
+    public:
+        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
+                                        Gamma::Algebra, gamma,
+                                        std::vector<Complex>, corr);
+    };
+public:
+    // constructor
+    TGamma3pt(const std::string name);
+    // destructor
+    virtual ~TGamma3pt(void) = default;
+    // 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_NS(Gamma3pt, ARG(TGamma3pt<FIMPL, FIMPL, FIMPL>), MContraction);
+
+/******************************************************************************
+ *                       TGamma3pt implementation                             *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+TGamma3pt<FImpl1, FImpl2, FImpl3>::TGamma3pt(const std::string name)
+: Module<Gamma3ptPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+std::vector<std::string> TGamma3pt<FImpl1, FImpl2, FImpl3>::getInput(void)
+{
+    std::vector<std::string> in = {par().q1, par().q2, par().q3};
+    
+    return in;
+}
+
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+std::vector<std::string> TGamma3pt<FImpl1, FImpl2, FImpl3>::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+void TGamma3pt<FImpl1, FImpl2, FImpl3>::setup(void)
+{
+    
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+template <typename FImpl1, typename FImpl2, typename FImpl3>
+void TGamma3pt<FImpl1, FImpl2, FImpl3>::execute(void)
+{
+    LOG(Message) << "Computing 3pt contractions '" << getName() << "' using"
+                 << " quarks '" << par().q1 << "', '" << par().q2 << "' and '"
+                 << par().q3 << "', with " << par().gamma << " insertion." 
+                 << std::endl;
+
+    CorrWriter            writer(par().output);
+    PropagatorField1      &q1 = *env().template getObject<PropagatorField1>(par().q1);
+    PropagatorField2      &q2 = *env().template getObject<PropagatorField2>(par().q2);
+    PropagatorField3      &q3 = *env().template getObject<PropagatorField3>(par().q3);
+    LatticeComplex        c(env().getGrid());
+    Gamma                 g5(Gamma::Algebra::Gamma5);
+    Gamma                 gamma(par().gamma);
+    std::vector<TComplex> buf;
+    Result                result;
+
+    c = trace(g5*q1*adj(q2)*(g5*gamma)*q3);
+    sliceSum(c, buf, Tp);
+
+    result.gamma = par().gamma;
+    result.corr.resize(buf.size());
+    for (unsigned int t = 0; t < buf.size(); ++t)
+    {
+        result.corr[t] = TensorRemove(buf[t]);
+    }
+
+    write(writer, "gamma3pt", result);
+}
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_Gamma3pt_hpp_

extras/Hadrons/Modules/MContraction/Meson.hpp

@@ -6,8 +6,10 @@ Source file: extras/Hadrons/Modules/MContraction/Meson.hpp
 
 Copyright (C) 2015
 Copyright (C) 2016
+Copyright (C) 2017
 
 Author: Antonin Portelli <antonin.portelli@me.com>
+        Andrew Lawson    <andrew.lawson1991@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
@@ -36,20 +38,39 @@ See the full license in the file "LICENSE" in the top level distribution directo
 
 BEGIN_HADRONS_NAMESPACE
 
+/*
+ 
+ Meson contractions
+ -----------------------------
+ 
+ * options:
+ - q1: input propagator 1 (string)
+ - q2: input propagator 2 (string)
+ - gammas: gamma products to insert at sink & source, pairs of gamma matrices 
+           (space-separated strings) in angled brackets (i.e. <g_sink g_src>),
+           in a sequence (e.g. "<Gamma5 Gamma5><Gamma5 GammaT>").
+
+           Special values: "all" - perform all possible contractions.
+ - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0."),
+        given as multiples of (2*pi) / L.
+*/
+
 /******************************************************************************
  *                                TMeson                                       *
  ******************************************************************************/
 BEGIN_MODULE_NAMESPACE(MContraction)
 
+typedef std::pair<Gamma::Algebra, Gamma::Algebra> GammaPair;
+
 class MesonPar: Serializable
 {
 public:
     GRID_SERIALIZABLE_CLASS_MEMBERS(MesonPar,
                                     std::string, q1,
                                     std::string, q2,
-                                    std::string,    output,
+                                    std::string, gammas,
-                                    Gamma::Algebra, gammaSource,
+                                    std::string, mom,
-                                    Gamma::Algebra, gammaSink);
+                                    std::string, output);
 };
 
 template <typename FImpl1, typename FImpl2>
@@ -61,7 +82,10 @@ public:
     class Result: Serializable
     {
     public:
-        GRID_SERIALIZABLE_CLASS_MEMBERS(Result, std::vector<Complex>, corr);
+        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,
+                                        Gamma::Algebra, gamma_snk,
+                                        Gamma::Algebra, gamma_src,
+                                        std::vector<Complex>, corr);
     };
 public:
     // constructor
@@ -71,6 +95,7 @@ public:
     // dependencies/products
     virtual std::vector<std::string> getInput(void);
     virtual std::vector<std::string> getOutput(void);
+    virtual void parseGammaString(std::vector<GammaPair> &gammaList);
     // execution
     virtual void execute(void);
 };
@@ -103,6 +128,32 @@ std::vector<std::string> TMeson<FImpl1, FImpl2>::getOutput(void)
     return output;
 }
 
+template <typename FImpl1, typename FImpl2>
+void TMeson<FImpl1, FImpl2>::parseGammaString(std::vector<GammaPair> &gammaList)
+{
+    // Determine gamma matrices to insert at source/sink.
+    if (par().gammas.compare("all") == 0)
+    {
+        // Do all contractions.
+        unsigned int n_gam = Ns * Ns;
+        gammaList.resize(n_gam*n_gam);
+        for (unsigned int i = 1; i < Gamma::nGamma; i += 2)
+        {
+            for (unsigned int j = 1; j < Gamma::nGamma; j += 2)
+            {
+                gammaList.push_back(std::make_pair((Gamma::Algebra)i, 
+                                                   (Gamma::Algebra)j));
+            }
+        }
+    }
+    else
+    {
+        // Parse individual contractions from input string.
+        gammaList = strToVec<GammaPair>(par().gammas);
+    }
+}
+
+
 // execution ///////////////////////////////////////////////////////////////////
 template <typename FImpl1, typename FImpl2>
 void TMeson<FImpl1, FImpl2>::execute(void)
@@ -111,21 +162,44 @@ void TMeson<FImpl1, FImpl2>::execute(void)
                  << " quarks '" << par().q1 << "' and '" << par().q2 << "'"
                  << std::endl;
     
-    XmlWriter             writer(par().output);
+    CorrWriter              writer(par().output);
     PropagatorField1       &q1 = *env().template getObject<PropagatorField1>(par().q1);
     PropagatorField2       &q2 = *env().template getObject<PropagatorField2>(par().q2);
     LatticeComplex         c(env().getGrid());
-    Gamma                 gSrc(par().gammaSource), gSnk(par().gammaSink);
     Gamma                  g5(Gamma::Algebra::Gamma5);
+    std::vector<GammaPair> gammaList;
     std::vector<TComplex>  buf;
-    Result                result;
+    std::vector<Result>    result;
+    std::vector<Real>      p;
 
-    c = trace(gSnk*q1*adj(gSrc)*g5*adj(q2)*g5);
+    p  = strToVec<Real>(par().mom);
+    LatticeComplex         ph(env().getGrid()), coor(env().getGrid());
+    Complex                i(0.0,1.0);
+    ph = zero;
+    for(unsigned int mu = 0; mu < env().getNd(); mu++)
+    {
+        LatticeCoordinate(coor, mu);
+        ph = ph + p[mu]*coor*((1./(env().getGrid()->_fdimensions[mu])));
+    }
+    ph = exp((Real)(2*M_PI)*i*ph);
+    
+    parseGammaString(gammaList);
+
+    result.resize(gammaList.size());
+    for (unsigned int i = 0; i < result.size(); ++i)
+    {
+        Gamma gSnk(gammaList[i].first);
+        Gamma gSrc(gammaList[i].second);
+        c = trace((g5*gSnk)*q1*(adj(gSrc)*g5)*adj(q2))*ph;
         sliceSum(c, buf, Tp);
-    result.corr.resize(buf.size());
+
+        result[i].gamma_snk = gammaList[i].first;
+        result[i].gamma_src = gammaList[i].second;
+        result[i].corr.resize(buf.size());
         for (unsigned int t = 0; t < buf.size(); ++t)
         {
-        result.corr[t] = TensorRemove(buf[t]);
+            result[i].corr[t] = TensorRemove(buf[t]);
+        }
     }
     write(writer, "meson", result);
 }

extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp

@@ -0,0 +1,114 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakHamiltonian.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_WeakHamiltonian_hpp_
+#define Hadrons_WeakHamiltonian_hpp_
+
+#include <Grid/Hadrons/Global.hpp>
+#include <Grid/Hadrons/Module.hpp>
+#include <Grid/Hadrons/ModuleFactory.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/******************************************************************************
+ *                         WeakHamiltonian                                    *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+/*******************************************************************************
+ * Utilities for contractions involving the Weak Hamiltonian.
+ ******************************************************************************/
+//// Sum and store correlator.
+#define MAKE_DIAG(exp, buf, res, n)\
+sliceSum(exp, buf, Tp);\
+res.name = (n);\
+res.corr.resize(buf.size());\
+for (unsigned int t = 0; t < buf.size(); ++t)\
+{\
+    res.corr[t] = TensorRemove(buf[t]);\
+}
+
+//// Contraction of mu index: use 'mu' variable in exp.
+#define SUM_MU(buf,exp)\
+buf = zero;\
+for (unsigned int mu = 0; mu < ndim; ++mu)\
+{\
+    buf += exp;\
+}
+
+enum 
+{
+  i_V = 0,
+  i_A = 1,
+  n_i = 2
+};
+
+class WeakHamiltonianPar: Serializable
+{
+public:
+    GRID_SERIALIZABLE_CLASS_MEMBERS(WeakHamiltonianPar,
+                                    std::string, q1,
+                                    std::string, q2,
+                                    std::string, q3,
+                                    std::string, q4,
+                                    std::string, output);
+};
+
+#define MAKE_WEAK_MODULE(modname)\
+class T##modname: public Module<WeakHamiltonianPar>\
+{\
+public:\
+    TYPE_ALIASES(FIMPL,)\
+    class Result: Serializable\
+    {\
+    public:\
+        GRID_SERIALIZABLE_CLASS_MEMBERS(Result,\
+                                        std::string, name,\
+                                        std::vector<Complex>, corr);\
+    };\
+public:\
+    /* constructor */ \
+    T##modname(const std::string name);\
+    /* destructor */ \
+    virtual ~T##modname(void) = default;\
+    /* 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);\
+    std::vector<std::string> VA_label = {"V", "A"};\
+};\
+MODULE_REGISTER_NS(modname, T##modname, MContraction);
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_WeakHamiltonian_hpp_

extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc

@@ -0,0 +1,137 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.cc
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp>
+
+using namespace Grid;
+using namespace Hadrons;
+using namespace MContraction;
+
+/*
+ * Weak Hamiltonian current-current contractions, Eye-type.
+ * 
+ * These contractions are generated by the Q1 and Q2 operators in the physical
+ * basis (see e.g. Fig 3 of arXiv:1507.03094).
+ * 
+ * Schematics:        q4                 |                  
+ *                  /-<-¬                |                             
+ *                 /     \               |             q2           q3
+ *                 \     /               |        /----<------*------<----¬                        
+ *            q2    \   /    q3          |       /          /-*-¬          \
+ *       /-----<-----* *-----<----¬      |      /          /     \          \
+ *    i *            H_W           * f   |   i *           \     /  q4      * f
+ *       \                        /      |      \           \->-/          /   
+ *        \                      /       |       \                        /       
+ *         \---------->---------/        |        \----------->----------/        
+ *                   q1                  |                   q1                  
+ *                                       |
+ *                Saucer (S)             |                  Eye (E)
+ * 
+ * S: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1]*q4*gL[mu][p_2])
+ * E: trace(q3*g5*q1*adj(q2)*g5*gL[mu][p_1])*trace(q4*gL[mu][p_2])
+ */
+
+/******************************************************************************
+ *                  TWeakHamiltonianEye implementation                        *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+TWeakHamiltonianEye::TWeakHamiltonianEye(const std::string name)
+: Module<WeakHamiltonianPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+std::vector<std::string> TWeakHamiltonianEye::getInput(void)
+{
+    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
+    
+    return in;
+}
+
+std::vector<std::string> TWeakHamiltonianEye::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+void TWeakHamiltonianEye::setup(void)
+{
+
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+void TWeakHamiltonianEye::execute(void)
+{
+    LOG(Message) << "Computing Weak Hamiltonian (Eye type) contractions '" 
+                 << getName() << "' using quarks '" << par().q1 << "', '" 
+                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
+                 << "'." << std::endl;
+
+    CorrWriter             writer(par().output);
+    PropagatorField &q1 = *env().template getObject<PropagatorField>(par().q1);
+    PropagatorField &q2 = *env().template getObject<PropagatorField>(par().q2);
+    PropagatorField &q3 = *env().template getObject<PropagatorField>(par().q3);
+    PropagatorField &q4 = *env().template getObject<PropagatorField>(par().q4);
+    Gamma g5            = Gamma(Gamma::Algebra::Gamma5);
+    LatticeComplex        expbuf(env().getGrid());
+    std::vector<TComplex> corrbuf;
+    std::vector<Result>   result(n_eye_diag);
+    unsigned int ndim   = env().getNd();
+
+    PropagatorField              tmp1(env().getGrid());
+    LatticeComplex               tmp2(env().getGrid());
+    std::vector<PropagatorField> S_body(ndim, tmp1);
+    std::vector<PropagatorField> S_loop(ndim, tmp1);
+    std::vector<LatticeComplex>  E_body(ndim, tmp2);
+    std::vector<LatticeComplex>  E_loop(ndim, tmp2);
+
+    // Setup for S-type contractions.
+    for (int mu = 0; mu < ndim; ++mu)
+    {
+        S_body[mu] = MAKE_SE_BODY(q1, q2, q3, GammaL(Gamma::gmu[mu]));
+        S_loop[mu] = MAKE_SE_LOOP(q4, GammaL(Gamma::gmu[mu]));
+    }
+
+    // Perform S-type contractions.    
+    SUM_MU(expbuf, trace(S_body[mu]*S_loop[mu]))
+    MAKE_DIAG(expbuf, corrbuf, result[S_diag], "HW_S")
+
+    // Recycle sub-expressions for E-type contractions.
+    for (unsigned int mu = 0; mu < ndim; ++mu)
+    {
+        E_body[mu] = trace(S_body[mu]);
+        E_loop[mu] = trace(S_loop[mu]);
+    }
+
+    // Perform E-type contractions.
+    SUM_MU(expbuf, E_body[mu]*E_loop[mu])
+    MAKE_DIAG(expbuf, corrbuf, result[E_diag], "HW_E")
+
+    write(writer, "HW_Eye", result);
+}

extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp

@@ -0,0 +1,58 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakHamiltonianEye.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_WeakHamiltonianEye_hpp_
+#define Hadrons_WeakHamiltonianEye_hpp_
+
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/******************************************************************************
+ *                         WeakHamiltonianEye                                 *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+enum
+{
+    S_diag = 0,
+    E_diag = 1,
+    n_eye_diag = 2
+};
+
+// Saucer and Eye subdiagram contractions.
+#define MAKE_SE_BODY(Q_1, Q_2, Q_3, gamma) (Q_3*g5*Q_1*adj(Q_2)*g5*gamma)
+#define MAKE_SE_LOOP(Q_loop, gamma) (Q_loop*gamma)
+
+MAKE_WEAK_MODULE(WeakHamiltonianEye)
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_WeakHamiltonianEye_hpp_

extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc

@@ -0,0 +1,139 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.cc
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp>
+
+using namespace Grid;
+using namespace Hadrons;
+using namespace MContraction;
+
+/*
+ * Weak Hamiltonian current-current contractions, Non-Eye-type.
+ * 
+ * These contractions are generated by the Q1 and Q2 operators in the physical
+ * basis (see e.g. Fig 3 of arXiv:1507.03094).
+ * 
+ * Schematic:     
+ *            q2             q3          |           q2              q3
+ *          /--<--¬       /--<--¬        |        /--<--¬         /--<--¬       
+ *         /       \     /       \       |       /       \       /       \      
+ *        /         \   /         \      |      /         \     /         \     
+ *       /           \ /           \     |     /           \   /           \    
+ *    i *             * H_W         *  f |  i *             * * H_W         * f 
+ *      \             *             |    |     \           /   \           /
+ *       \           / \           /     |      \         /     \         /    
+ *        \         /   \         /      |       \       /       \       /  
+ *         \       /     \       /       |        \-->--/         \-->--/      
+ *          \-->--/       \-->--/        |          q1               q4 
+ *            q1             q4          |
+ *                Connected (C)          |                 Wing (W)
+ *
+ * C: trace(q1*adj(q2)*g5*gL[mu]*q3*adj(q4)*g5*gL[mu])
+ * W: trace(q1*adj(q2)*g5*gL[mu])*trace(q3*adj(q4)*g5*gL[mu])
+ * 
+ */
+
+/******************************************************************************
+ *                  TWeakHamiltonianNonEye implementation                     *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+TWeakHamiltonianNonEye::TWeakHamiltonianNonEye(const std::string name)
+: Module<WeakHamiltonianPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+std::vector<std::string> TWeakHamiltonianNonEye::getInput(void)
+{
+    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
+    
+    return in;
+}
+
+std::vector<std::string> TWeakHamiltonianNonEye::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+void TWeakHamiltonianNonEye::setup(void)
+{
+
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+void TWeakHamiltonianNonEye::execute(void)
+{
+    LOG(Message) << "Computing Weak Hamiltonian (Non-Eye type) contractions '" 
+                 << getName() << "' using quarks '" << par().q1 << "', '" 
+                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
+                 << "'." << std::endl;
+    
+    CorrWriter             writer(par().output);
+    PropagatorField &q1 = *env().template getObject<PropagatorField>(par().q1);
+    PropagatorField &q2 = *env().template getObject<PropagatorField>(par().q2);
+    PropagatorField &q3 = *env().template getObject<PropagatorField>(par().q3);
+    PropagatorField &q4 = *env().template getObject<PropagatorField>(par().q4);
+    Gamma g5            = Gamma(Gamma::Algebra::Gamma5);
+    LatticeComplex        expbuf(env().getGrid());
+    std::vector<TComplex> corrbuf;
+    std::vector<Result>   result(n_noneye_diag); 
+    unsigned int ndim   = env().getNd();
+
+    PropagatorField              tmp1(env().getGrid());
+    LatticeComplex               tmp2(env().getGrid());
+    std::vector<PropagatorField> C_i_side_loop(ndim, tmp1);
+    std::vector<PropagatorField> C_f_side_loop(ndim, tmp1);
+    std::vector<LatticeComplex>  W_i_side_loop(ndim, tmp2);
+    std::vector<LatticeComplex>  W_f_side_loop(ndim, tmp2);
+
+    // Setup for C-type contractions.
+    for (int mu = 0; mu < ndim; ++mu)
+    {
+        C_i_side_loop[mu] = MAKE_CW_SUBDIAG(q1, q2, GammaL(Gamma::gmu[mu]));
+        C_f_side_loop[mu] = MAKE_CW_SUBDIAG(q3, q4, GammaL(Gamma::gmu[mu]));
+    }
+
+    // Perform C-type contractions.    
+    SUM_MU(expbuf, trace(C_i_side_loop[mu]*C_f_side_loop[mu]))
+    MAKE_DIAG(expbuf, corrbuf, result[C_diag], "HW_C")
+
+    // Recycle sub-expressions for W-type contractions.
+    for (unsigned int mu = 0; mu < ndim; ++mu)
+    {
+        W_i_side_loop[mu] = trace(C_i_side_loop[mu]);
+        W_f_side_loop[mu] = trace(C_f_side_loop[mu]);
+    }
+
+    // Perform W-type contractions.
+    SUM_MU(expbuf, W_i_side_loop[mu]*W_f_side_loop[mu])
+    MAKE_DIAG(expbuf, corrbuf, result[W_diag], "HW_W")
+
+    write(writer, "HW_NonEye", result);
+}

extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp

@@ -0,0 +1,57 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakHamiltonianNonEye.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_WeakHamiltonianNonEye_hpp_
+#define Hadrons_WeakHamiltonianNonEye_hpp_
+
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/******************************************************************************
+ *                         WeakHamiltonianNonEye                              *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+enum
+{
+    W_diag = 0,
+    C_diag = 1,
+    n_noneye_diag = 2
+};
+
+// Wing and Connected subdiagram contractions
+#define MAKE_CW_SUBDIAG(Q_1, Q_2, gamma) (Q_1*adj(Q_2)*g5*gamma)
+
+MAKE_WEAK_MODULE(WeakHamiltonianNonEye)
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_WeakHamiltonianNonEye_hpp_

extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc

@@ -0,0 +1,135 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.cc
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@gmail.com>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#include <Grid/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp>
+
+using namespace Grid;
+using namespace Hadrons;
+using namespace MContraction;
+
+/*
+ * Weak Hamiltonian + current contractions, disconnected topology for neutral 
+ * mesons.
+ * 
+ * These contractions are generated by operators Q_1,...,10 of the dS=1 Weak
+ * Hamiltonian in the physical basis and an additional current J (see e.g. 
+ * Fig 11 of arXiv:1507.03094).
+ * 
+ * Schematic:
+ *                        
+ *           q2          q4             q3
+ *       /--<--¬     /---<--¬       /---<--¬
+ *     /         \ /         \     /        \
+ *  i *           * H_W      |  J *          * f
+ *     \         / \         /     \        /
+ *      \--->---/   \-------/       \------/
+ *          q1 
+ * 
+ * options
+ * - q1: input propagator 1 (string)
+ * - q2: input propagator 2 (string)
+ * - q3: input propagator 3 (string), assumed to be sequential propagator 
+ * - q4: input propagator 4 (string), assumed to be a loop
+ * 
+ * type 1: trace(q1*adj(q2)*g5*gL[mu])*trace(loop*gL[mu])*trace(q3*g5)
+ * type 2: trace(q1*adj(q2)*g5*gL[mu]*loop*gL[mu])*trace(q3*g5)
+ */
+
+/*******************************************************************************
+ *                  TWeakNeutral4ptDisc implementation                         *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+TWeakNeutral4ptDisc::TWeakNeutral4ptDisc(const std::string name)
+: Module<WeakHamiltonianPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+std::vector<std::string> TWeakNeutral4ptDisc::getInput(void)
+{
+    std::vector<std::string> in = {par().q1, par().q2, par().q3, par().q4};
+    
+    return in;
+}
+
+std::vector<std::string> TWeakNeutral4ptDisc::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+void TWeakNeutral4ptDisc::setup(void)
+{
+
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+void TWeakNeutral4ptDisc::execute(void)
+{
+    LOG(Message) << "Computing Weak Hamiltonian neutral disconnected contractions '" 
+                 << getName() << "' using quarks '" << par().q1 << "', '" 
+                 << par().q2 << ", '" << par().q3 << "' and '" << par().q4 
+                 << "'." << std::endl;
+
+    CorrWriter             writer(par().output);
+    PropagatorField &q1 = *env().template getObject<PropagatorField>(par().q1);
+    PropagatorField &q2 = *env().template getObject<PropagatorField>(par().q2);
+    PropagatorField &q3 = *env().template getObject<PropagatorField>(par().q3);
+    PropagatorField &q4 = *env().template getObject<PropagatorField>(par().q4);
+    Gamma g5            = Gamma(Gamma::Algebra::Gamma5);
+    LatticeComplex        expbuf(env().getGrid());
+    std::vector<TComplex> corrbuf;
+    std::vector<Result>   result(n_neut_disc_diag);
+    unsigned int ndim   = env().getNd();
+
+    PropagatorField              tmp(env().getGrid());
+    std::vector<PropagatorField> meson(ndim, tmp);
+    std::vector<PropagatorField> loop(ndim, tmp);
+    LatticeComplex               curr(env().getGrid());
+
+    // Setup for type 1 contractions.
+    for (int mu = 0; mu < ndim; ++mu)
+    {
+        meson[mu] = MAKE_DISC_MESON(q1, q2, GammaL(Gamma::gmu[mu]));
+        loop[mu] = MAKE_DISC_LOOP(q4, GammaL(Gamma::gmu[mu]));
+    }
+    curr = MAKE_DISC_CURR(q3, GammaL(Gamma::Algebra::Gamma5));
+
+    // Perform type 1 contractions.    
+    SUM_MU(expbuf, trace(meson[mu]*loop[mu]))
+    expbuf *= curr;
+    MAKE_DIAG(expbuf, corrbuf, result[neut_disc_1_diag], "HW_disc0_1")
+
+    // Perform type 2 contractions.
+    SUM_MU(expbuf, trace(meson[mu])*trace(loop[mu]))
+    expbuf *= curr;
+    MAKE_DIAG(expbuf, corrbuf, result[neut_disc_2_diag], "HW_disc0_2")
+
+    write(writer, "HW_disc0", result);
+}

extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp

@@ -0,0 +1,59 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MContraction/WeakNeutral4ptDisc.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson    <andrew.lawson1991@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_WeakNeutral4ptDisc_hpp_
+#define Hadrons_WeakNeutral4ptDisc_hpp_
+
+#include <Grid/Hadrons/Modules/MContraction/WeakHamiltonian.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/******************************************************************************
+ *                         WeakNeutral4ptDisc                                 *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MContraction)
+
+enum
+{
+    neut_disc_1_diag = 0,
+    neut_disc_2_diag = 1,
+    n_neut_disc_diag = 2
+};
+
+// Neutral 4pt disconnected subdiagram contractions.
+#define MAKE_DISC_MESON(Q_1, Q_2, gamma) (Q_1*adj(Q_2)*g5*gamma)
+#define MAKE_DISC_LOOP(Q_LOOP, gamma) (Q_LOOP*gamma)
+#define MAKE_DISC_CURR(Q_c, gamma) (trace(Q_c*gamma))
+
+MAKE_WEAK_MODULE(WeakNeutral4ptDisc)
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_WeakNeutral4ptDisc_hpp_

extras/Hadrons/Modules/MLoop/NoiseLoop.hpp

@@ -0,0 +1,132 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MLoop/NoiseLoop.hpp
+
+Copyright (C) 2016
+
+Author: Andrew Lawson <andrew.lawson1991@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_NoiseLoop_hpp_
+#define Hadrons_NoiseLoop_hpp_
+
+#include <Grid/Hadrons/Global.hpp>
+#include <Grid/Hadrons/Module.hpp>
+#include <Grid/Hadrons/ModuleFactory.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/*
+ 
+ Noise loop propagator
+ -----------------------------
+ * loop_x = q_x * adj(eta_x)
+ 
+ * options:
+ - q = Result of inversion on noise source.
+ - eta = noise source.
+
+ */
+
+
+/******************************************************************************
+ *                         NoiseLoop                                          *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MLoop)
+
+class NoiseLoopPar: Serializable
+{
+public:
+    GRID_SERIALIZABLE_CLASS_MEMBERS(NoiseLoopPar,
+                                    std::string, q,
+                                    std::string, eta);
+};
+
+template <typename FImpl>
+class TNoiseLoop: public Module<NoiseLoopPar>
+{
+public:
+    TYPE_ALIASES(FImpl,);
+public:
+    // constructor
+    TNoiseLoop(const std::string name);
+    // destructor
+    virtual ~TNoiseLoop(void) = default;
+    // 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_NS(NoiseLoop, TNoiseLoop<FIMPL>, MLoop);
+
+/******************************************************************************
+ *                 TNoiseLoop implementation                                  *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+template <typename FImpl>
+TNoiseLoop<FImpl>::TNoiseLoop(const std::string name)
+: Module<NoiseLoopPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+template <typename FImpl>
+std::vector<std::string> TNoiseLoop<FImpl>::getInput(void)
+{
+    std::vector<std::string> in = {par().q, par().eta};
+    
+    return in;
+}
+
+template <typename FImpl>
+std::vector<std::string> TNoiseLoop<FImpl>::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TNoiseLoop<FImpl>::setup(void)
+{
+    env().template registerLattice<PropagatorField>(getName());
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TNoiseLoop<FImpl>::execute(void)
+{
+    PropagatorField &loop = *env().template createLattice<PropagatorField>(getName());
+    PropagatorField &q    = *env().template getObject<PropagatorField>(par().q);
+    PropagatorField &eta  = *env().template getObject<PropagatorField>(par().eta);
+    loop = q*adj(eta);
+}
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_NoiseLoop_hpp_

extras/Hadrons/Modules/MSource/SeqGamma.hpp

@@ -6,6 +6,7 @@ Source file: extras/Hadrons/Modules/MSource/SeqGamma.hpp
 
 Copyright (C) 2015
 Copyright (C) 2016
+Copyright (C) 2017
 
 Author: Antonin Portelli <antonin.portelli@me.com>
 
@@ -149,9 +150,9 @@ void TSeqGamma<FImpl>::execute(void)
     for(unsigned int mu = 0; mu < env().getNd(); mu++)
     {
         LatticeCoordinate(coor, mu);
-        ph = ph + p[mu]*coor;
+        ph = ph + p[mu]*coor*((1./(env().getGrid()->_fdimensions[mu])));
     }
-    ph = exp(i*ph);
+    ph = exp((Real)(2*M_PI)*i*ph);
     LatticeCoordinate(t, Tp);
     src = where((t >= par().tA) and (t <= par().tB), ph*(g*q), 0.*q);
 }

extras/Hadrons/Modules/MSource/Wall.hpp

@@ -0,0 +1,147 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid 
+
+Source file: extras/Hadrons/Modules/MSource/Wall.hpp
+
+Copyright (C) 2017
+
+Author: Andrew Lawson <andrew.lawson1991@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_WallSource_hpp_
+#define Hadrons_WallSource_hpp_
+
+#include <Grid/Hadrons/Global.hpp>
+#include <Grid/Hadrons/Module.hpp>
+#include <Grid/Hadrons/ModuleFactory.hpp>
+
+BEGIN_HADRONS_NAMESPACE
+
+/*
+ 
+ Wall source
+ -----------------------------
+ * src_x = delta(x_3 - tW) * exp(i x.mom)
+ 
+ * options:
+ - tW: source timeslice (integer)
+ - mom: momentum insertion, space-separated float sequence (e.g ".1 .2 1. 0.")
+ 
+ */
+
+/******************************************************************************
+ *                         Wall                                               *
+ ******************************************************************************/
+BEGIN_MODULE_NAMESPACE(MSource)
+
+class WallPar: Serializable
+{
+public:
+    GRID_SERIALIZABLE_CLASS_MEMBERS(WallPar,
+                                    unsigned int, tW,
+                                    std::string, mom);
+};
+
+template <typename FImpl>
+class TWall: public Module<WallPar>
+{
+public:
+    TYPE_ALIASES(FImpl,);
+public:
+    // constructor
+    TWall(const std::string name);
+    // destructor
+    virtual ~TWall(void) = default;
+    // 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_NS(Wall, TWall<FIMPL>, MSource);
+
+/******************************************************************************
+ *                 TWall implementation                                       *
+ ******************************************************************************/
+// constructor /////////////////////////////////////////////////////////////////
+template <typename FImpl>
+TWall<FImpl>::TWall(const std::string name)
+: Module<WallPar>(name)
+{}
+
+// dependencies/products ///////////////////////////////////////////////////////
+template <typename FImpl>
+std::vector<std::string> TWall<FImpl>::getInput(void)
+{
+    std::vector<std::string> in;
+    
+    return in;
+}
+
+template <typename FImpl>
+std::vector<std::string> TWall<FImpl>::getOutput(void)
+{
+    std::vector<std::string> out = {getName()};
+    
+    return out;
+}
+
+// setup ///////////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TWall<FImpl>::setup(void)
+{
+    env().template registerLattice<PropagatorField>(getName());
+}
+
+// execution ///////////////////////////////////////////////////////////////////
+template <typename FImpl>
+void TWall<FImpl>::execute(void)
+{    
+    LOG(Message) << "Generating wall source at t = " << par().tW 
+                 << " with momentum " << par().mom << std::endl;
+    
+    PropagatorField &src = *env().template createLattice<PropagatorField>(getName());
+    Lattice<iScalar<vInteger>> t(env().getGrid());
+    LatticeComplex             ph(env().getGrid()), coor(env().getGrid());
+    std::vector<Real>          p;
+    Complex                    i(0.0,1.0);
+    
+    p  = strToVec<Real>(par().mom);
+    ph = zero;
+    for(unsigned int mu = 0; mu < Nd; mu++)
+    {
+        LatticeCoordinate(coor, mu);
+        ph = ph + p[mu]*coor*((1./(env().getGrid()->_fdimensions[mu])));
+    }
+    ph = exp((Real)(2*M_PI)*i*ph);
+    LatticeCoordinate(t, Tp);
+    src = 1.;
+    src = where((t == par().tW), src*ph, 0.*src);
+}
+
+END_MODULE_NAMESPACE
+
+END_HADRONS_NAMESPACE
+
+#endif // Hadrons_WallSource_hpp_

extras/Hadrons/Modules/Quark.hpp

@@ -173,7 +173,7 @@ void TQuark<FImpl>::execute(void)
                 *env().template getObject<PropagatorField>(getName());
             
             axpby_ssp_pminus(sol, 0., sol, 1., sol, 0, 0);
-            axpby_ssp_pplus(sol, 0., sol, 1., sol, 0, Ls_-1);
+            axpby_ssp_pplus(sol, 1., sol, 1., sol, 0, Ls_-1);
             ExtractSlice(tmp, sol, 0, 0);
             FermToProp(p4d, tmp, s, c);
         }

extras/Hadrons/modules.inc

@@ -1,4 +1,7 @@
 modules_cc =\
+  Modules/MContraction/WeakHamiltonianEye.cc \
+  Modules/MContraction/WeakHamiltonianNonEye.cc \
+  Modules/MContraction/WeakNeutral4ptDisc.cc \
   Modules/MGauge/Load.cc \
   Modules/MGauge/Random.cc \
   Modules/MGauge/Unit.cc
@@ -7,13 +10,21 @@ modules_hpp =\
   Modules/MAction/DWF.hpp \
   Modules/MAction/Wilson.hpp \
   Modules/MContraction/Baryon.hpp \
+  Modules/MContraction/DiscLoop.hpp \
+  Modules/MContraction/Gamma3pt.hpp \
   Modules/MContraction/Meson.hpp \
+  Modules/MContraction/WeakHamiltonian.hpp \
+  Modules/MContraction/WeakHamiltonianEye.hpp \
+  Modules/MContraction/WeakHamiltonianNonEye.hpp \
+  Modules/MContraction/WeakNeutral4ptDisc.hpp \
   Modules/MGauge/Load.hpp \
   Modules/MGauge/Random.hpp \
   Modules/MGauge/Unit.hpp \
+  Modules/MLoop/NoiseLoop.hpp \
   Modules/MSolver/RBPrecCG.hpp \
   Modules/MSource/Point.hpp \
   Modules/MSource/SeqGamma.hpp \
+  Modules/MSource/Wall.hpp \
   Modules/MSource/Z2.hpp \
   Modules/Quark.hpp
 

gcc-bug-report/README

@@ -21,3 +21,16 @@ problem. The test case works with icpc and with clang++, but fails consistently
 current variants.
 
 Peter
+
+
+************
+
+Second GCC bug reported, see Issue 100.
+
+https://wandbox.org/permlink/tzssJza6R9XnqANw
+https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80652
+
+Getting Travis fails under gcc-5 for Test_simd, now that I added more comprehensive testing to the
+CI test suite. The limitations of Travis runtime limits & weak cores are being shown.
+
+Travis uses 5.4.1 for g++-5.

grid-config.in

@@ -0,0 +1,86 @@
+#! /bin/sh
+
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+
+usage()
+{
+  cat <<EOF
+Usage: grid-config [OPTION]
+
+Known values for OPTION are:
+
+  --prefix     show Grid installation prefix
+  --cxxflags   print pre-processor and compiler flags
+  --ldflags    print library linking flags
+  --libs       print library linking information
+  --summary    print full build summary
+  --help       display this help and exit
+  --version    output version information
+  --git        print git revision
+
+EOF
+  
+  exit $1
+}
+
+if test $# -eq 0; then
+  usage 1
+fi
+
+cflags=false
+libs=false
+
+while test $# -gt 0; do
+  case "$1" in
+    -*=*) optarg=`echo "$1" | sed 's/[-_a-zA-Z0-9]*=//'` ;;
+    *) optarg= ;;
+  esac
+  
+  case "$1" in
+    --prefix)
+      echo $prefix
+    ;;
+    
+    --version)
+      echo @VERSION@
+      exit 0
+    ;;
+    
+    --git)
+      echo "@GRID_BRANCH@ @GRID_SHA@"
+      exit 0
+    ;;
+    
+    --help)
+      usage 0
+    ;;
+    
+    --cxxflags)
+      echo @GRID_CXXFLAGS@
+    ;;
+    
+    --ldflags)
+      echo @GRID_LDFLAGS@
+    ;;
+    
+    --libs)
+      echo @GRID_LIBS@
+    ;;
+    
+    --summary)
+      echo ""
+      echo "@GRID_SUMMARY@"
+      echo ""
+    ;;
+    
+    *)
+      usage
+      exit 1
+    ;;
+  esac
+  shift
+done
+
+exit 0

lib/DisableWarnings.h

@@ -0,0 +1,37 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/DisableWarnings.h
+
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#ifndef DISABLE_WARNINGS_H
+#define DISABLE_WARNINGS_H
+
+ //disables and intel compiler specific warning (in json.hpp)
+#pragma warning disable 488  
+
+
+#endif

lib/GridCore.h

@@ -38,28 +38,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #ifndef GRID_BASE_H
 #define GRID_BASE_H
 
-///////////////////
+#include <Grid/GridStd.h>
-// Std C++ dependencies
-///////////////////
-#include <cassert>
-#include <complex>
-#include <vector>
-#include <iostream>
-#include <iomanip>
-#include <random>
-#include <functional>
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <ctime>
-#include <sys/time.h>
-#include <chrono>
-
-///////////////////
-// Grid headers
-///////////////////
-#include "Config.h"
 
 #include <Grid/perfmon/Timer.h>
 #include <Grid/perfmon/PerfCount.h>

lib/GridStd.h

@@ -0,0 +1,27 @@
+#ifndef GRID_STD_H
+#define GRID_STD_H
+
+///////////////////
+// Std C++ dependencies
+///////////////////
+#include <cassert>
+#include <complex>
+#include <vector>
+#include <iostream>
+#include <iomanip>
+#include <random>
+#include <functional>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <signal.h>
+#include <ctime>
+#include <sys/time.h>
+#include <chrono>
+
+///////////////////
+// Grid config
+///////////////////
+#include "Config.h"
+
+#endif /* GRID_STD_H */

lib/Grid_Eigen_Dense.h

@@ -0,0 +1,9 @@
+#pragma once
+#if defined __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+#include <Grid/Eigen/Dense>
+#if defined __GNUC__
+#pragma GCC diagnostic pop
+#endif

lib/algorithms/approx/Chebyshev.h

@@ -197,8 +197,9 @@ namespace Grid {
     void operator() (LinearOperatorBase<Field> &Linop, const Field &in, Field &out) {
 
       GridBase *grid=in._grid;
-//std::cout << "Chevyshef(): in._grid="<<in._grid<<std::endl;
+
-//<<" Linop.Grid()="<<Linop.Grid()<<"Linop.RedBlackGrid()="<<Linop.RedBlackGrid()<<std::endl;
+      // std::cout << "Chevyshef(): in._grid="<<in._grid<<std::endl;
+      //std::cout <<" Linop.Grid()="<<Linop.Grid()<<"Linop.RedBlackGrid()="<<Linop.RedBlackGrid()<<std::endl;
 
       int vol=grid->gSites();
 

lib/algorithms/approx/Remez.h

@@ -16,7 +16,7 @@
 #define INCLUDED_ALG_REMEZ_H
 
 #include <stddef.h>
-#include <Config.h>
+#include <Grid/GridStd.h>
 
 #ifdef HAVE_LIBGMP
 #include "bigfloat.h"

lib/algorithms/iterative/ConjugateGradient.h

@@ -123,8 +123,11 @@ class ConjugateGradient : public OperatorFunction<Field> {
       p = p * b + r;
 
       LinalgTimer.Stop();
+
       std::cout << GridLogIterative << "ConjugateGradient: Iteration " << k
                 << " residual " << cp << " target " << rsq << std::endl;
+      std::cout << GridLogDebug << "a = "<< a << " b_pred = "<< b_pred << "  b = "<< b << std::endl;
+      std::cout << GridLogDebug << "qq = "<< qq << " d = "<< d << "  c = "<< c << std::endl;
 
       // Stopping condition
       if (cp <= rsq) {
@@ -132,8 +135,6 @@ class ConjugateGradient : public OperatorFunction<Field> {
         Linop.HermOpAndNorm(psi, mmp, d, qq);
         p = mmp - src;
 
-        RealD mmpnorm = sqrt(norm2(mmp));
-        RealD psinorm = sqrt(norm2(psi));
         RealD srcnorm = sqrt(norm2(src));
         RealD resnorm = sqrt(norm2(p));
         RealD true_residual = resnorm / srcnorm;
@@ -157,8 +158,10 @@ class ConjugateGradient : public OperatorFunction<Field> {
     }
     std::cout << GridLogMessage << "ConjugateGradient did NOT converge"
               << std::endl;
+
     if (ErrorOnNoConverge) assert(0);
     IterationsToComplete = k;
+
   }
 };
 }

lib/cartesian/Cartesian_base.h

@@ -6,8 +6,9 @@
 
     Copyright (C) 2015
 
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+    Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
+    Author: paboyle <paboyle@ph.ed.ac.uk>
+    Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -121,6 +122,12 @@ public:
       Lexicographic::CoorFromIndex(coor,Oindex,_rdimensions);
     }
 
+    inline void InOutCoorToLocalCoor (std::vector<int> &ocoor, std::vector<int> &icoor, std::vector<int> &lcoor) {
+      lcoor.resize(_ndimension);
+      for (int d = 0; d < _ndimension; d++)
+        lcoor[d] = ocoor[d] + _rdimensions[d] * icoor[d];
+    }
+
     //////////////////////////////////////////////////////////
     // SIMD lane addressing
     //////////////////////////////////////////////////////////
@@ -128,6 +135,7 @@ public:
     {
       Lexicographic::CoorFromIndex(coor,lane,_simd_layout);
     }
+
     inline int PermuteDim(int dimension){
       return _simd_layout[dimension]>1;
     }
@@ -173,6 +181,24 @@ public:
     inline const std::vector<int> &LocalDimensions(void)        { return _ldimensions;};
     inline const std::vector<int> &VirtualLocalDimensions(void) { return _ldimensions;};
 
+    ////////////////////////////////////////////////////////////////
+    // Utility to print the full decomposition details 
+    ////////////////////////////////////////////////////////////////
+
+    void show_decomposition(){
+      std::cout << GridLogMessage << "Full Dimensions    : " << _fdimensions << std::endl;
+      std::cout << GridLogMessage << "Global Dimensions  : " << _gdimensions << std::endl;
+      std::cout << GridLogMessage << "Local Dimensions   : " << _ldimensions << std::endl;
+      std::cout << GridLogMessage << "Reduced Dimensions : " << _rdimensions << std::endl;
+      std::cout << GridLogMessage << "Outer strides      : " << _ostride << std::endl;
+      std::cout << GridLogMessage << "Inner strides      : " << _istride << std::endl;
+      std::cout << GridLogMessage << "iSites             : " << _isites << std::endl;
+      std::cout << GridLogMessage << "oSites             : " << _osites << std::endl;
+      std::cout << GridLogMessage << "lSites             : " << lSites() << std::endl;        
+      std::cout << GridLogMessage << "gSites             : " << gSites() << std::endl;
+      std::cout << GridLogMessage << "Nd                 : " << _ndimension << std::endl;             
+    } 
+
     ////////////////////////////////////////////////////////////////
     // Global addressing
     ////////////////////////////////////////////////////////////////
@@ -184,6 +210,9 @@ public:
       assert(lidx<lSites());
       Lexicographic::CoorFromIndex(lcoor,lidx,_ldimensions);
     }
+
+
+
     void GlobalCoorToGlobalIndex(const std::vector<int> & gcoor,int & gidx){
       gidx=0;
       int mult=1;

lib/lattice/Lattice_base.h

@@ -261,12 +261,22 @@ public:
   
   virtual ~Lattice(void) = default;
     
+  void reset(GridBase* grid) {
+    if (_grid != grid) {
+      _grid = grid;
+      _odata.resize(grid->oSites());
+      checkerboard = 0;
+    }
+  }
+  
+
   template<class sobj> strong_inline Lattice<vobj> & operator = (const sobj & r){
     parallel_for(int ss=0;ss<_grid->oSites();ss++){
       this->_odata[ss]=r;
     }
     return *this;
   }
+  
   template<class robj> strong_inline Lattice<vobj> & operator = (const Lattice<robj> & r){
     this->checkerboard = r.checkerboard;
     conformable(*this,r);
@@ -291,7 +301,7 @@ public:
     *this = (*this)+r;
     return *this;
   }
- }; // class Lattice
+}; // class Lattice
   
   template<class vobj> std::ostream& operator<< (std::ostream& stream, const Lattice<vobj> &o){
     std::vector<int> gcoor;

lib/lattice/Lattice_reduction.h

@@ -1,36 +1,28 @@
  /*************************************************************************************
-
     Grid physics library, www.github.com/paboyle/Grid 
-
     Source file: ./lib/lattice/Lattice_reduction.h
-
     Copyright (C) 2015
-
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: paboyle <paboyle@ph.ed.ac.uk>
-
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.
-
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.
-
     You should have received a copy of the GNU General Public License along
     with this program; if not, write to the Free Software Foundation, Inc.,
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
     See the full license in the file "LICENSE" in the top level distribution directory
     *************************************************************************************/
     /*  END LEGAL */
 #ifndef GRID_LATTICE_REDUCTION_H
 #define GRID_LATTICE_REDUCTION_H
 
-#include <Grid/Eigen/Dense>
+#include <Grid/Grid_Eigen_Dense.h>
 
 namespace Grid {
 #ifdef GRID_WARN_SUBOPTIMAL
@@ -336,6 +328,8 @@ static void sliceMaddVector(Lattice<vobj> &R,std::vector<RealD> &a,const Lattice
   typedef typename vobj::vector_type vector_type;
   typedef typename vobj::tensor_reduced tensor_reduced;
   
+  scalar_type zscale(scale);
+
   GridBase *grid  = X._grid;
 
   int Nsimd  =grid->Nsimd();
@@ -361,7 +355,7 @@ static void sliceMaddVector(Lattice<vobj> &R,std::vector<RealD> &a,const Lattice
       grid->iCoorFromIindex(icoor,l);
       int ldx =r+icoor[orthogdim]*rd;
       scalar_type *as =(scalar_type *)&av;
-      as[l] = scalar_type(a[ldx])*scale;
+      as[l] = scalar_type(a[ldx])*zscale;
     }
 
     tensor_reduced at; at=av;
@@ -404,7 +398,6 @@ static void sliceMaddVectorSlow (Lattice<vobj> &R,std::vector<RealD> &a,const La
     InsertSlice(Rslice,R,i,Orthog);
   }
 };
-
 template<class vobj>
 static void sliceInnerProductVectorSlow( std::vector<ComplexD> & vec, const Lattice<vobj> &lhs,const Lattice<vobj> &rhs,int Orthog) 
   {
@@ -418,11 +411,9 @@ static void sliceInnerProductVectorSlow( std::vector<ComplexD> & vec, const Latt
     typedef typename scalar::scalar_object  scomplex;
   
     int Nblock = lhs._grid->GlobalDimensions()[Orthog];
-
     vec.resize(Nblock);
     std::vector<scomplex> sip(Nblock);
     Lattice<scalar> IP(lhs._grid); 
-
     IP=localInnerProduct(lhs,rhs);
     sliceSum(IP,sip,Orthog);
   
@@ -528,3 +519,5 @@ static void sliceInnerProductMatrix(  Eigen::MatrixXcd &mat, const Lattice<vobj>
 } /*END NAMESPACE GRID*/
 #endif
 
+
+

lib/lattice/Lattice_rng.h

@@ -6,8 +6,8 @@
 
     Copyright (C) 2015
 
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+    Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
+    Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -75,6 +75,55 @@ namespace Grid {
     return multiplicity;
   }
 
+  
+// merge of April 11 2017
+//<<<<<<< HEAD
+
+
+  // this function is necessary for the LS vectorised field
+  inline int RNGfillable_general(GridBase *coarse,GridBase *fine)
+  {
+    int rngdims = coarse->_ndimension;
+    
+    // trivially extended in higher dims, with locality guaranteeing RNG state is local to node
+    int lowerdims   = fine->_ndimension - coarse->_ndimension;  assert(lowerdims >= 0);
+    // assumes that the higher dimensions are not using more processors
+    // all further divisions are local
+    for(int d=0;d<lowerdims;d++) assert(fine->_processors[d]==1);
+    for(int d=0;d<rngdims;d++) assert(coarse->_processors[d] == fine->_processors[d+lowerdims]);
+    
+
+    // then divide the number of local sites
+    // check that the total number of sims agree, meanse the iSites are the same
+    assert(fine->Nsimd() == coarse->Nsimd());
+
+    // check that the two grids divide cleanly
+    assert( (fine->lSites() / coarse->lSites() ) * coarse->lSites() == fine->lSites() );
+
+    return fine->lSites() / coarse->lSites();
+  }
+
+  /*
+  // Wrap seed_seq to give common interface with random_device
+  class fixedSeed {
+  public:
+    typedef std::seed_seq::result_type result_type;
+    std::seed_seq src;
+    
+    fixedSeed(const std::vector<int> &seeds) : src(seeds.begin(),seeds.end()) {};
+
+    result_type operator () (void){
+      std::vector<result_type> list(1);
+      src.generate(list.begin(),list.end());
+      return list[0];
+    }
+
+  };
+
+=======
+>>>>>>> develop
+  */
+  
   // real scalars are one component
   template<class scalar,class distribution,class generator> 
   void fillScalar(scalar &s,distribution &dist,generator & gen)
@@ -109,7 +158,7 @@ namespace Grid {
 #ifdef RNG_SITMO
     typedef sitmo::prng_engine 	RngEngine;
     typedef uint64_t    	RngStateType;
-    static const int    	RngStateCount = 4;
+    static const int    	RngStateCount = 13;
 #endif
 
     std::vector<RngEngine>                             _generators;
@@ -284,17 +333,19 @@ namespace Grid {
   };
 
   class GridParallelRNG : public GridRNGbase {
+
+    double _time_counter;
+
   public:
     GridBase *_grid;
-    int _vol;
+    unsigned int _vol;
-  public:
 
-    int generator_idx(int os,int is){
+    int generator_idx(int os,int is) {
       return is*_grid->oSites()+os;
     }
 
     GridParallelRNG(GridBase *grid) : GridRNGbase() {
-      _grid=grid;
+      _grid = grid;
       _vol  =_grid->iSites()*_grid->oSites();
 
       _generators.resize(_vol);
@@ -310,32 +361,33 @@ namespace Grid {
       typedef typename vobj::scalar_type scalar_type;
       typedef typename vobj::vector_type vector_type;
 
-      int multiplicity = RNGfillable(_grid,l._grid);
+      double inner_time_counter = usecond();
 
-      int     Nsimd =_grid->Nsimd();
+      int multiplicity = RNGfillable_general(_grid, l._grid); // l has finer or same grid
-      int     osites=_grid->oSites();
+      int Nsimd  = _grid->Nsimd();  // guaranteed to be the same for l._grid too
-      int words=sizeof(scalar_object)/sizeof(scalar_type);
+      int osites = _grid->oSites();  // guaranteed to be <= l._grid->oSites() by a factor multiplicity
+      int words  = sizeof(scalar_object) / sizeof(scalar_type);
 
       parallel_for(int ss=0;ss<osites;ss++){
-
         std::vector<scalar_object> buf(Nsimd);
-	for(int m=0;m<multiplicity;m++) {// Draw from same generator multiplicity times
+        for (int m = 0; m < multiplicity; m++) {  // Draw from same generator multiplicity times
 
-	  int sm=multiplicity*ss+m;      // Maps the generator site to the fine site
+          int sm = multiplicity * ss + m;  // Maps the generator site to the fine site
 
-	  for(int si=0;si<Nsimd;si++){
+          for (int si = 0; si < Nsimd; si++) {
-	    int gdx = generator_idx(ss,si); // index of generator state
+            
+            int gdx = generator_idx(ss, si);  // index of generator state
             scalar_type *pointer = (scalar_type *)&buf[si];
             dist[gdx].reset();
-	    for(int idx=0;idx<words;idx++){
+            for (int idx = 0; idx < words; idx++) 
-	      fillScalar(pointer[idx],dist[gdx],_generators[gdx]);
+              fillScalar(pointer[idx], dist[gdx], _generators[gdx]);
+          }
+          // merge into SIMD lanes, FIXME suboptimal implementation
+          merge(l._odata[sm], buf);
         }
       }
 
-	  // merge into SIMD lanes
+      _time_counter += usecond()- inner_time_counter;
-	  merge(l._odata[sm],buf);
-	}
-      }
     };
 
     void SeedFixedIntegers(const std::vector<int> &seeds){
@@ -412,6 +464,12 @@ namespace Grid {
       }
 #endif
     }
+
+    void Report(){
+      std::cout << GridLogMessage << "Time spent in the fill() routine by GridParallelRNG: "<< _time_counter/1e3 << " ms" << std::endl;
+    }
+
+
     ////////////////////////////////////////////////////////////////////////
     // Support for rigorous test of RNG's
     // Return uniform random uint32_t from requested site generator
@@ -419,7 +477,6 @@ namespace Grid {
     uint32_t GlobalU01(int gsite){
 
       uint32_t the_number;
-
       // who
       std::vector<int> gcoor;
       int rank,o_idx,i_idx;

lib/lattice/Lattice_unary.h

@@ -66,10 +66,21 @@ namespace Grid {
     Lattice<obj> ret(rhs._grid);
     ret.checkerboard = rhs.checkerboard;
     conformable(ret,rhs);
+    obj unit(1.0);
     parallel_for(int ss=0;ss<rhs._grid->oSites();ss++){
-      ret._odata[ss]=Exponentiate(rhs._odata[ss],alpha, Nexp);
+      //ret._odata[ss]=Exponentiate(rhs._odata[ss],alpha, Nexp);
+      ret._odata[ss] = unit;
+      for(int i=Nexp; i>=1;--i)
+	ret._odata[ss] = unit + ret._odata[ss]*rhs._odata[ss]*(alpha/RealD(i));
+
     }
+
     return ret;
+
+    
+    
+
+    
   }
 
 

lib/log/Log.cc

@@ -30,6 +30,7 @@ directory
 *************************************************************************************/
 /*  END LEGAL */
 #include <Grid/GridCore.h>
+#include <Grid/util/CompilerCompatible.h>
 
 #include <cxxabi.h>
 #include <memory>

lib/parallelIO/BinaryIO.h

@@ -6,8 +6,8 @@
 
     Copyright (C) 2015
 
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+    Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <paboyle@ph.ed.ac.uk>
+    Author: Guido Cossu<guido.cossu@ed.ac.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -30,6 +30,8 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #define GRID_BINARY_IO_H
 
 
+#include "IldgIOtypes.h"
+
 #ifdef HAVE_ENDIAN_H
 #include <endian.h>
 #endif
@@ -150,6 +152,47 @@ class BinaryIO {
     }
   }
 
+  // Simple classes for precision conversion
+  template <class fobj, class sobj>
+  struct BinarySimpleUnmunger {
+    typedef typename getPrecision<fobj>::real_scalar_type fobj_stype;
+    typedef typename getPrecision<sobj>::real_scalar_type sobj_stype;
+
+    void operator()(sobj &in, fobj &out, uint32_t &csum) {
+      // take word by word and transform accoding to the status
+      fobj_stype *out_buffer = (fobj_stype *)&out;
+      sobj_stype *in_buffer = (sobj_stype *)&in;
+      size_t fobj_words = sizeof(out) / sizeof(fobj_stype);
+      size_t sobj_words = sizeof(in) / sizeof(sobj_stype);
+      assert(fobj_words == sobj_words);
+
+      for (unsigned int word = 0; word < sobj_words; word++)
+        out_buffer[word] = in_buffer[word];  // type conversion on the fly
+
+      BinaryIO::Uint32Checksum((uint32_t *)&out, sizeof(out), csum);
+    }
+  };
+
+  template <class fobj, class sobj>
+  struct BinarySimpleMunger {
+    typedef typename getPrecision<fobj>::real_scalar_type fobj_stype;
+    typedef typename getPrecision<sobj>::real_scalar_type sobj_stype;
+
+    void operator()(fobj &in, sobj &out, uint32_t &csum) {
+      // take word by word and transform accoding to the status
+      fobj_stype *in_buffer = (fobj_stype *)&in;
+      sobj_stype *out_buffer = (sobj_stype *)&out;
+      size_t fobj_words = sizeof(in) / sizeof(fobj_stype);
+      size_t sobj_words = sizeof(out) / sizeof(sobj_stype);
+      assert(fobj_words == sobj_words);
+
+      for (unsigned int word = 0; word < sobj_words; word++)
+        out_buffer[word] = in_buffer[word];  // type conversion on the fly
+
+      BinaryIO::Uint32Checksum((uint32_t *)&in, sizeof(in), csum);
+    }
+  };
+
   template<class vobj,class fobj,class munger>
   static inline uint32_t readObjectSerial(Lattice<vobj> &Umu,std::string file,munger munge,int offset,const std::string &format)
   {
@@ -246,7 +289,6 @@ class BinaryIO {
 
       
       if ( grid->IsBoss() ) {
-  
 	if(ieee32big) htobe32_v((void *)&file_object,sizeof(file_object));
 	if(ieee32)    htole32_v((void *)&file_object,sizeof(file_object));
 	if(ieee64big) htobe64_v((void *)&file_object,sizeof(file_object));
@@ -270,24 +312,29 @@ class BinaryIO {
     typedef typename GridSerialRNG::RngStateType RngStateType;
     const int RngStateCount = GridSerialRNG::RngStateCount;
 
-
     GridBase *grid = parallel._grid;
     int gsites = grid->_gsites;
 
+    GridStopWatch timer; timer.Start();
     //////////////////////////////////////////////////
     // Serialise through node zero
     //////////////////////////////////////////////////
-    std::cout<< GridLogMessage<< "Serial RNG write I/O "<< file<<std::endl;
-
     std::ofstream fout;
-    if ( grid->IsBoss() ) {
+    if (grid->IsBoss()) {
-      fout.open(file,std::ios::binary|std::ios::out|std::ios::in);
+      fout.open(file, std::ios::binary | std::ios::out);
+      if (!fout.is_open()) {
+        std::cout << GridLogMessage << "writeRNGSerial: Error opening file " << file << std::endl;
+        exit(0);// write better error handling
+      }
       fout.seekp(offset);
     }
 
-    uint32_t csum=0;
+    std::cout << GridLogMessage << "Serial RNG write I/O on file " << file << std::endl;
+    uint32_t csum = 0;
     std::vector<RngStateType> saved(RngStateCount);
-    int bytes = sizeof(RngStateType)*saved.size();
+    int bytes = sizeof(RngStateType) * saved.size();
+    std::cout << GridLogDebug << "RngStateCount: " << RngStateCount << std::endl;
+    std::cout << GridLogDebug << "Type has " << bytes << " bytes" << std::endl;
     std::vector<int> gcoor;
 
     for(int gidx=0;gidx<gsites;gidx++){
@@ -301,8 +348,7 @@ class BinaryIO {
 	//  std::cout << "rank" << rank<<" Getting state for index "<<l_idx<<std::endl;
 	parallel.GetState(saved,l_idx);
       }
-
+      grid->Broadcast(rank, (void *)&saved[0], bytes);
-      grid->Broadcast(rank,(void *)&saved[0],bytes);
 
       if ( grid->IsBoss() ) {
 	Uint32Checksum((uint32_t *)&saved[0],bytes,csum);
@@ -316,9 +362,20 @@ class BinaryIO {
       Uint32Checksum((uint32_t *)&saved[0],bytes,csum);
       fout.write((char *)&saved[0],bytes);assert( fout.fail()==0);
     }
-    grid->Broadcast(0,(void *)&csum,sizeof(csum));
+
+    grid->Broadcast(0, (void *)&csum, sizeof(csum));
+
+    if (grid->IsBoss()) 
+      fout.close();
+
+    timer.Stop();
+
+    std::cout << GridLogMessage   << "RNG file checksum " << std::hex << csum << std::dec << std::endl;
+    std::cout << GridLogMessage << "RNG state saved in " << timer.Elapsed() << std::endl;
     return csum;
   }
+
+
   static inline uint32_t readRNGSerial(GridSerialRNG &serial,GridParallelRNG &parallel,std::string file,int offset)
   {
     typedef typename GridSerialRNG::RngStateType RngStateType;
@@ -330,22 +387,35 @@ class BinaryIO {
     //////////////////////////////////////////////////
     // Serialise through node zero
     //////////////////////////////////////////////////
-    std::cout<< GridLogMessage<< "Serial RNG read I/O "<< file<<std::endl;
+    std::cout<< GridLogMessage<< "Serial RNG read I/O of file "<<file<<std::endl;
 
-    std::ifstream fin(file,std::ios::binary|std::ios::in);
+    std::ifstream fin;
+    if (grid->IsBoss()) {
+      fin.open(file, std::ios::binary | std::ios::in);
+      if (!fin.is_open()) {
+        std::cout << GridLogMessage << "readRNGSerial: Error opening file " << file << std::endl;
+        exit(0);// write better error handling
+      }
       fin.seekg(offset);
+    }
+
     
     uint32_t csum=0;
     std::vector<RngStateType> saved(RngStateCount);
     int bytes = sizeof(RngStateType)*saved.size();
+    std::cout << GridLogDebug << "RngStateCount: " << RngStateCount << std::endl;
+    std::cout << GridLogDebug << "Type has " << bytes << " bytes" << std::endl;
     std::vector<int> gcoor;
 
+    std::cout << GridLogDebug << "gsites: " << gsites << " loop" << std::endl;
     for(int gidx=0;gidx<gsites;gidx++){
 
       int rank,o_idx,i_idx;
       grid->GlobalIndexToGlobalCoor(gidx,gcoor);
       grid->GlobalCoorToRankIndex(rank,o_idx,i_idx,gcoor);
       int l_idx=parallel.generator_idx(o_idx,i_idx);
+      //std::cout << GridLogDebug << "l_idx " << l_idx << " o_idx " << o_idx
+      //          << " i_idx " << i_idx << " rank " << rank << std::endl;
 
       if ( grid->IsBoss() ) {
 	fin.read((char *)&saved[0],bytes);assert( fin.fail()==0);
@@ -357,7 +427,6 @@ class BinaryIO {
       if( rank == grid->ThisRank() ){
         parallel.SetState(saved,l_idx);
       }
-
     }
 
     if ( grid->IsBoss() ) {
@@ -366,16 +435,21 @@ class BinaryIO {
       Uint32Checksum((uint32_t *)&saved[0],bytes,csum);
     }
 
+    std::cout << GridLogMessage << "RNG file checksum " << std::hex << csum << std::dec << std::endl;
+
     grid->Broadcast(0,(void *)&csum,sizeof(csum));
 
     return csum;
   }
 
 
-  template<class vobj,class fobj,class munger>
+  template <class vobj, class fobj, class munger>
-  static inline uint32_t readObjectParallel(Lattice<vobj> &Umu,std::string file,munger munge,int offset,
+  static inline uint32_t readObjectParallel(Lattice<vobj> &Umu,
-					    const std::string &format)
+                                            std::string file, 
-  {
+                                            munger munge,
+                                            int offset,
+                                            const std::string &format,
+                                            ILDGtype ILDG = ILDGtype()) {
     typedef typename vobj::scalar_object sobj;
 
     GridBase *grid = Umu._grid;
@@ -441,6 +515,7 @@ class BinaryIO {
     int myrank = grid->ThisRank();
     int iorank = grid->RankFromProcessorCoor(ioproc);
 
+    if (!ILDG.is_ILDG)
     	if ( IOnode ) { 
     		fin.open(file,std::ios::binary|std::ios::in);
     	}
@@ -451,7 +526,8 @@ class BinaryIO {
     // available (how short sighted is that?)
     //////////////////////////////////////////////////////////
     Umu = zero;
-    static uint32_t csum; csum=0;
+    static uint32_t csum; csum=0;//static for SHMEM
+
     fobj fileObj;
     static sobj siteObj; // Static to place in symmetric region for SHMEM
 
@@ -470,6 +546,7 @@ class BinaryIO {
 	gsite[d] = tsite[d]+start[d];               // global site
       }
 
+
       /////////////////////////
       // Get the rank of owner of data
       /////////////////////////
@@ -482,8 +559,18 @@ class BinaryIO {
       ////////////////////////////////
       if (myrank == iorank) {
 
+
+      	if (ILDG.is_ILDG){
+      		// use C-LIME to populate the record
+          #ifdef HAVE_LIME
+          uint64_t sizeFO = sizeof(fileObj);
+          limeReaderSeek(ILDG.LR, g_idx*sizeFO, SEEK_SET);
+          int status = limeReaderReadData((void *)&fileObj, &sizeFO, ILDG.LR);
+          #endif
+        } else{
           fin.seekg(offset+g_idx*sizeof(fileObj));
-	fin.read((char *)&fileObj,sizeof(fileObj));assert( fin.fail()==0);
+          fin.read((char *)&fileObj,sizeof(fileObj));
+        }
         bytes+=sizeof(fileObj);
 
         if(ieee32big) be32toh_v((void *)&fileObj,sizeof(fileObj));
@@ -515,17 +602,18 @@ class BinaryIO {
     timer.Stop();
     std::cout<<GridLogPerformance<<"readObjectParallel: read "<< bytes <<" bytes in "<<timer.Elapsed() <<" "
 	     << (double)bytes/timer.useconds() <<" MB/s "  <<std::endl;
-    
     return csum;
   }
 
   //////////////////////////////////////////////////////////
   // Parallel writer
   //////////////////////////////////////////////////////////
-  template<class vobj,class fobj,class munger>
+  template <class vobj, class fobj, class munger>
-  static inline uint32_t writeObjectParallel(Lattice<vobj> &Umu,std::string file,munger munge,int offset,
+  static inline uint32_t writeObjectParallel(Lattice<vobj> &Umu,
-					     const std::string & format)
+                                             std::string file, munger munge,
-  {
+                                             int offset,
+                                             const std::string &format,
+                                             ILDGtype ILDG = ILDGtype()) {
     typedef typename vobj::scalar_object sobj;
     GridBase *grid = Umu._grid;
 
@@ -534,13 +622,22 @@ class BinaryIO {
     int ieee64big = (format == std::string("IEEE64BIG"));
     int ieee64 = (format == std::string("IEEE64"));
 
+    if (!(ieee32big || ieee32 || ieee64big || ieee64)) {
+      std::cout << GridLogError << "Unrecognized file format " << format
+                << std::endl;
+      std::cout << GridLogError
+                << "Allowed: IEEE32BIG | IEEE32 | IEEE64BIG | IEEE64"
+                << std::endl;
+      exit(0);
+    }
+
     int nd = grid->_ndimension;
-    for(int d=0;d<nd;d++){
+    for (int d = 0; d < nd; d++) {
       assert(grid->CheckerBoarded(d) == 0);
     }
 
-    std::vector<int> parallel(nd,1);
+    std::vector<int> parallel(nd, 1);
-    std::vector<int> ioproc  (nd);
+    std::vector<int> ioproc(nd);
     std::vector<int> start(nd);
     std::vector<int> range(nd);
 
@@ -548,9 +645,8 @@ class BinaryIO {
 
     int IOnode = 1;
 
-    for(int d=0;d<grid->_ndimension;d++) {
+    for (int d = 0; d < grid->_ndimension; d++) {
-
+      if (d != grid->_ndimension - 1) parallel[d] = 0;
-      if ( d!= grid->_ndimension-1 ) parallel[d] = 0;
 
       if (parallel[d]) {
 	range[d] = grid->_ldimensions[d];
@@ -570,7 +666,8 @@ class BinaryIO {
     {
       uint32_t tmp = IOnode;
       grid->GlobalSum(tmp);
-      std::cout<< GridLogMessage<< "Parallel write I/O from "<< file << " with " <<tmp<< " IOnodes for subslice ";
+      std::cout<< GridLogMessage<< "Parallel write I/O from "<< file
+	       << " with " <<tmp<< " IOnodes for subslice ";
       for(int d=0;d<grid->_ndimension;d++){
 	std::cout<< range[d];
 	if( d< grid->_ndimension-1 ) 
@@ -579,7 +676,8 @@ class BinaryIO {
       std::cout << std::endl;
     }
     
-    GridStopWatch timer; timer.Start();
+    GridStopWatch timer;
+    timer.Start();
     uint64_t bytes=0;
 
     int myrank = grid->ThisRank();
@@ -590,48 +688,58 @@ class BinaryIO {
     // Ideally one reader/writer per xy plane and read these contiguously
     // with comms from nominated I/O nodes.
     std::ofstream fout;
-    if ( IOnode ) fout.open(file,std::ios::binary|std::ios::in|std::ios::out);
+    if (!ILDG.is_ILDG)
+    	if (IOnode){
+    		fout.open(file, std::ios::binary | std::ios::in | std::ios::out);
+    		if (!fout.is_open()) {
+    			std::cout << GridLogMessage << "writeObjectParallel: Error opening file " << file
+    			<< std::endl;
+    			exit(0);
+    		}
+    	}
+
 
     //////////////////////////////////////////////////////////
     // Find the location of each site and send to primary node
-    // Take loop order from Chroma; defines loop order now that NERSC doc no longer
+    // Take loop order from Chroma; defines loop order now that NERSC doc no
+    // longer
     // available (how short sighted is that?)
     //////////////////////////////////////////////////////////
 
-    uint32_t csum=0;
+    uint32_t csum = 0;
     fobj fileObj;
-    static sobj siteObj; // static for SHMEM target; otherwise dynamic allocate with AlignedAllocator
+    static sobj siteObj;  // static for SHMEM target; otherwise dynamic allocate
+                          // with AlignedAllocator
 
     // should aggregate a whole chunk and then write.
-    // need to implement these loops in Nd independent way with a lexico conversion
+    // need to implement these loops in Nd independent way with a lexico
-    for(int tlex=0;tlex<slice_vol;tlex++){
+    // conversion
-  
+    for (int tlex = 0; tlex < slice_vol; tlex++) {
       std::vector<int> tsite(nd);  // temporary mixed up site
       std::vector<int> gsite(nd);
       std::vector<int> lsite(nd);
       std::vector<int> iosite(nd);
 
-      Lexicographic::CoorFromIndex(tsite,tlex,range);
+      Lexicographic::CoorFromIndex(tsite, tlex, range);
 
-      for(int d=0;d<nd;d++){
+      for(int d = 0;d < nd; d++){
-	lsite[d] = tsite[d]%grid->_ldimensions[d];  // local site
+	lsite[d] = tsite[d] % grid->_ldimensions[d];  // local site
-	gsite[d] = tsite[d]+start[d];               // global site
+	gsite[d] = tsite[d] + start[d];               // global site
       }
 
-
       /////////////////////////
       // Get the rank of owner of data
       /////////////////////////
-      int rank, o_idx,i_idx, g_idx;
+      int rank, o_idx, i_idx, g_idx;
-      grid->GlobalCoorToRankIndex(rank,o_idx,i_idx,gsite);
+      grid->GlobalCoorToRankIndex(rank, o_idx, i_idx, gsite);
-      grid->GlobalCoorToGlobalIndex(gsite,g_idx);
+      grid->GlobalCoorToGlobalIndex(gsite, g_idx);
 
       ////////////////////////////////
       // iorank writes from the seek
       ////////////////////////////////
 
       // Owner of data peeks it
-      peekLocalSite(siteObj,Umu,lsite);
+      peekLocalSite(siteObj, Umu, lsite);
 
       // Pair of nodes may need to do pt2pt send
       if ( rank != iorank ) { // comms is necessary
@@ -644,17 +752,27 @@ class BinaryIO {
       grid->Barrier();  // necessary?
 
       if (myrank == iorank) {
+        munge(siteObj, fileObj, csum);
 
-	munge(siteObj,fileObj,csum);
+        if (ieee32big) htobe32_v((void *)&fileObj, sizeof(fileObj));
+        if (ieee32) htole32_v((void *)&fileObj, sizeof(fileObj));
+        if (ieee64big) htobe64_v((void *)&fileObj, sizeof(fileObj));
+        if (ieee64) htole64_v((void *)&fileObj, sizeof(fileObj));
 
-	if(ieee32big) htobe32_v((void *)&fileObj,sizeof(fileObj));
-	if(ieee32)    htole32_v((void *)&fileObj,sizeof(fileObj));
-	if(ieee64big) htobe64_v((void *)&fileObj,sizeof(fileObj));
-	if(ieee64)    htole64_v((void *)&fileObj,sizeof(fileObj));
 
-	fout.seekp(offset+g_idx*sizeof(fileObj));
+        if (ILDG.is_ILDG) {
-	fout.write((char *)&fileObj,sizeof(fileObj));assert( fout.fail()==0);
+          #ifdef HAVE_LIME
-	bytes+=sizeof(fileObj);
+          uint64_t sizeFO = sizeof(fileObj);
+ 					limeWriterSeek(ILDG.LW, g_idx*sizeFO, SEEK_SET);
+          int status = limeWriteRecordData((void *)&fileObj, &sizeFO, ILDG.LW);
+          #endif
+        } 
+
+        else {
+          fout.seekp(offset + g_idx * sizeof(fileObj));
+          fout.write((char *)&fileObj, sizeof(fileObj));assert( fout.fail()==0);
+        }
+        bytes += sizeof(fileObj);
       }
     }
     
@@ -662,14 +780,20 @@ class BinaryIO {
     grid->GlobalSum(bytes);
     
     timer.Stop();
-    std::cout<<GridLogPerformance<<"writeObjectParallel: wrote "<< bytes <<" bytes in "<<timer.Elapsed() <<" "
+    std::cout << GridLogPerformance << "writeObjectParallel: wrote " << bytes
-	     << (double)bytes/timer.useconds() <<" MB/s "  <<std::endl;
+              << " bytes in " << timer.Elapsed() << " "
+              << (double)bytes / timer.useconds() << " MB/s " << std::endl;
+
+
+
+     grid->Barrier();  // necessary?
+     if (IOnode) 
+      fout.close();
+
 
     return csum;
   }
-
 };
-
 }
 
 #endif

lib/parallelIO/IldgIO.h

@@ -0,0 +1,251 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/parallelIO/IldgIO.h
+
+Copyright (C) 2015
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin 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_ILDG_IO_H
+#define GRID_ILDG_IO_H
+
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+
+#include <pwd.h>
+#include <sys/utsname.h>
+#include <unistd.h>
+
+#ifdef HAVE_LIME
+
+extern "C" {  // for linkage
+#include "lime.h"
+}
+
+namespace Grid {
+namespace QCD {
+
+inline void ILDGGrid(GridBase *grid, ILDGField &header) {
+  assert(grid->_ndimension == 4);  // emit error if not
+  header.dimension.resize(4);
+  header.boundary.resize(4);
+  for (int d = 0; d < 4; d++) {
+    header.dimension[d] = grid->_fdimensions[d];
+    // Read boundary conditions from ... ?
+    header.boundary[d] = std::string("periodic");
+  }
+}
+
+inline void ILDGChecksum(uint32_t *buf, uint32_t buf_size_bytes,
+                         uint32_t &csum) {
+  BinaryIO::Uint32Checksum(buf, buf_size_bytes, csum);
+}
+
+//////////////////////////////////////////////////////////////////////
+// Utilities ; these are QCD aware
+//////////////////////////////////////////////////////////////////////
+template <class GaugeField>
+inline void ILDGStatistics(GaugeField &data, ILDGField &header) {
+  // How to convert data precision etc...
+  header.link_trace = Grid::QCD::WilsonLoops<PeriodicGimplR>::linkTrace(data);
+  header.plaquette = Grid::QCD::WilsonLoops<PeriodicGimplR>::avgPlaquette(data);
+  // header.polyakov =
+}
+
+// Forcing QCD here
+template <class fobj, class sobj>
+struct ILDGMunger {
+  void operator()(fobj &in, sobj &out, uint32_t &csum) {
+    for (int mu = 0; mu < 4; mu++) {
+      for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
+          out(mu)()(i, j) = in(mu)()(i, j);
+        }
+      }
+    }
+    ILDGChecksum((uint32_t *)&in, sizeof(in), csum);
+  };
+};
+
+template <class fobj, class sobj>
+struct ILDGUnmunger {
+  void operator()(sobj &in, fobj &out, uint32_t &csum) {
+    for (int mu = 0; mu < 4; mu++) {
+      for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
+          out(mu)()(i, j) = in(mu)()(i, j);
+        }
+      }
+    }
+    ILDGChecksum((uint32_t *)&out, sizeof(out), csum);
+  };
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// Write and read from fstream; compute header offset for payload
+////////////////////////////////////////////////////////////////////////////////
+enum ILDGstate {ILDGread, ILDGwrite};
+
+class ILDGIO : public BinaryIO {
+  FILE *File;
+  LimeWriter *LimeW;
+  LimeRecordHeader *LimeHeader;
+  LimeReader *LimeR;
+  std::string filename;
+
+
+ public:
+  ILDGIO(std::string file, ILDGstate RW) {
+      filename = file;
+    if (RW == ILDGwrite){
+      File = fopen(file.c_str(), "w");
+      // check if opened correctly
+
+      LimeW = limeCreateWriter(File);
+    } else {
+      File = fopen(file.c_str(), "r");
+      // check if opened correctly
+
+      LimeR = limeCreateReader(File);
+    }
+  }
+
+  ~ILDGIO() { fclose(File); }
+
+  int createHeader(std::string message, int MB, int ME, size_t PayloadSize, LimeWriter* L){
+    LimeRecordHeader *h;
+    h = limeCreateHeader(MB, ME, const_cast<char *>(message.c_str()), PayloadSize);
+    int status = limeWriteRecordHeader(h, L);
+    if (status < 0) {
+      std::cerr << "ILDG Header error\n";
+      return status;
+    }
+    limeDestroyHeader(h);
+    return LIME_SUCCESS;
+  }
+
+  unsigned int writeHeader(ILDGField &header) {
+    // write header in LIME
+    n_uint64_t nbytes;
+    int MB_flag = 1, ME_flag = 0;
+
+    char message[] = "ildg-format";
+    nbytes = strlen(message);
+    LimeHeader = limeCreateHeader(MB_flag, ME_flag, message, nbytes);
+    limeWriteRecordHeader(LimeHeader, LimeW);
+    limeDestroyHeader(LimeHeader);
+    // save the xml header here
+    // use the xml_writer to c++ streams in pugixml
+    // and convert to char message
+    limeWriteRecordData(message, &nbytes, LimeW);
+    limeWriterCloseRecord(LimeW);
+
+    return 0;
+  }
+
+  unsigned int readHeader(ILDGField &header) {
+    return 0;
+  }
+
+  template <class vsimd>
+  uint32_t readConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu) {
+    typedef Lattice<iLorentzColourMatrix<vsimd> > GaugeField;
+    typedef LorentzColourMatrixD sobjd;
+    typedef LorentzColourMatrixF sobjf;
+    typedef iLorentzColourMatrix<vsimd> itype;
+    typedef LorentzColourMatrix sobj;
+    GridBase *grid = Umu._grid;
+
+    ILDGField header;
+    readHeader(header);
+
+    // now just the conf, ignore the header
+    std::string format = std::string("IEEE64BIG");
+    do {limeReaderNextRecord(LimeR);}
+    while (strncmp(limeReaderType(LimeR), "ildg-binary-data",16));
+
+    n_uint64_t nbytes = limeReaderBytes(LimeR);//size of this record (configuration)
+
+
+    ILDGtype ILDGt(true, LimeR);
+    // this is special for double prec data, just for the moment
+    uint32_t csum = BinaryIO::readObjectParallel< itype, sobjd >(
+       Umu, filename, ILDGMunger<sobjd, sobj>(), 0, format, ILDGt);
+
+    // Check configuration 
+    // todo
+
+    return csum;
+  }
+
+  template <class vsimd>
+  uint32_t writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu, std::string format) {
+    typedef Lattice<iLorentzColourMatrix<vsimd> > GaugeField;
+    typedef iLorentzColourMatrix<vsimd> vobj;
+    typedef typename vobj::scalar_object sobj;
+    typedef LorentzColourMatrixD fobj;
+
+    ILDGField header;
+    // fill the header
+    header.floating_point = format;
+
+    ILDGUnmunger<fobj, sobj> munge;
+    unsigned int offset = writeHeader(header);
+
+    BinaryIO::Uint32Checksum<vobj, fobj>(Umu, munge, header.checksum);
+
+    // Write data record header
+    n_uint64_t PayloadSize = sizeof(fobj) * Umu._grid->_gsites;
+    createHeader("ildg-binary-data", 0, 1, PayloadSize, LimeW);
+
+    ILDGtype ILDGt(true, LimeW);
+    uint32_t csum = BinaryIO::writeObjectParallel<vobj, fobj>(
+       Umu, filename, munge, 0, header.floating_point, ILDGt);
+
+    limeWriterCloseRecord(LimeW);
+
+    // Last record
+    // the logical file name LNF
+    // look into documentation on how to generate this string
+    std::string LNF = "empty"; 
+
+
+    PayloadSize = sizeof(LNF);
+    createHeader("ildg-binary-lfn", 1 , 1, PayloadSize, LimeW);
+    limeWriteRecordData(const_cast<char*>(LNF.c_str()), &PayloadSize, LimeW);
+
+    limeWriterCloseRecord(LimeW);
+
+    return csum;
+  }
+
+  // format for RNG? Now just binary out
+};
+}
+}
+
+//HAVE_LIME
+#endif
+
+#endif

lib/parallelIO/IldgIOtypes.h

@@ -0,0 +1,80 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/parallelIO/IldgIO.h
+
+Copyright (C) 2015
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin 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_ILDGTYPES_IO_H
+#define GRID_ILDGTYPES_IO_H
+
+#ifdef HAVE_LIME
+extern "C" { // for linkage
+#include "lime.h"
+}
+
+namespace Grid {
+
+struct ILDGtype {
+  bool is_ILDG;
+  LimeWriter* LW;
+  LimeReader* LR;
+
+  ILDGtype(bool is, LimeWriter* L) : is_ILDG(is), LW(L), LR(NULL) {}
+  ILDGtype(bool is, LimeReader* L) : is_ILDG(is), LW(NULL), LR(L) {}
+  ILDGtype() : is_ILDG(false), LW(NULL), LR(NULL) {}
+};
+
+class ILDGField {
+ public:
+  // header strings (not in order)
+  std::vector<int> dimension;
+  std::vector<std::string> boundary;
+  int data_start;
+  std::string hdr_version;
+  std::string storage_format;
+  // Checks on data
+  double link_trace;
+  double plaquette;
+  uint32_t checksum;
+  unsigned int sequence_number;
+  std::string data_type;
+  std::string ensemble_id;
+  std::string ensemble_label;
+  std::string creator;
+  std::string creator_hardware;
+  std::string creation_date;
+  std::string archive_date;
+  std::string floating_point;
+};
+}
+#else
+namespace Grid {
+
+struct ILDGtype {
+  bool is_ILDG;
+  ILDGtype() : is_ILDG(false) {}
+};
+}
+
+#endif
+#endif

lib/parallelIO/NerscIO.h

@@ -1,4 +1,4 @@
-    /*************************************************************************************
+/*************************************************************************************
 
     Grid physics library, www.github.com/paboyle/Grid 
 
@@ -6,9 +6,9 @@
 
     Copyright (C) 2015
 
-Author: Matt Spraggs <matthew.spraggs@gmail.com>
+    Author: Matt Spraggs <matthew.spraggs@gmail.com>
-Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+    Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: paboyle <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
@@ -25,8 +25,8 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
     See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
+*************************************************************************************/
-    /*  END LEGAL */
+/*  END LEGAL */
 #ifndef GRID_NERSC_IO_H
 #define GRID_NERSC_IO_H
 
@@ -41,23 +41,23 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #include <pwd.h>
 
 namespace Grid {
-namespace QCD {
+  namespace QCD {
 
-using namespace Grid;
+    using namespace Grid;
 
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
-// Some data types for intermediate storage
+    // Some data types for intermediate storage
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
     template<typename vtype> using iLorentzColour2x3 = iVector<iVector<iVector<vtype, Nc>, 2>, 4 >;
 
     typedef iLorentzColour2x3<Complex>  LorentzColour2x3;
     typedef iLorentzColour2x3<ComplexF> LorentzColour2x3F;
     typedef iLorentzColour2x3<ComplexD> LorentzColour2x3D;
 
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
-// header specification/interpretation
+    // header specification/interpretation
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
-class NerscField {
+    class NerscField {
     public:
       // header strings (not in order)
       int dimension[4];
@@ -78,14 +78,14 @@ class NerscField {
       std::string creation_date ;
       std::string archive_date ;
       std::string floating_point;
-};
+    };
 
-//////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////
-// Bit and Physical Checksumming and QA of data
+    // Bit and Physical Checksumming and QA of data
-//////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////
 
-inline void NerscGrid(GridBase *grid,NerscField &header)
+    inline void NerscGrid(GridBase *grid,NerscField &header)
-{
+    {
       assert(grid->_ndimension==4);
       for(int d=0;d<4;d++) {
 	header.dimension[d] = grid->_fdimensions[d];
@@ -93,17 +93,17 @@ inline void NerscGrid(GridBase *grid,NerscField &header)
       for(int d=0;d<4;d++) {
 	header.boundary[d] = std::string("PERIODIC");
       }
-}
+    }
-template<class GaugeField>
+    template<class GaugeField>
-inline void NerscStatistics(GaugeField & data,NerscField &header)
+    inline void NerscStatistics(GaugeField & data,NerscField &header)
-{
+    {
       // How to convert data precision etc...
       header.link_trace=Grid::QCD::WilsonLoops<PeriodicGimplR>::linkTrace(data);
       header.plaquette =Grid::QCD::WilsonLoops<PeriodicGimplR>::avgPlaquette(data);
-}
+    }
 
-inline void NerscMachineCharacteristics(NerscField &header)
+    inline void NerscMachineCharacteristics(NerscField &header)
-{
+    {
       // Who
       struct passwd *pw = getpwuid (getuid());
       if (pw) header.creator = std::string(pw->pw_name); 
@@ -123,10 +123,10 @@ inline void NerscMachineCharacteristics(NerscField &header)
       header.creator_hardware+= std::string(name.sysname)+"-";
       header.creator_hardware+= std::string(name.release);
 
-}
+    }
-//////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////
-// Utilities ; these are QCD aware
+    // Utilities ; these are QCD aware
-//////////////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////////////
     inline void NerscChecksum(uint32_t *buf,uint32_t buf_size_bytes,uint32_t &csum)
     {
       BinaryIO::Uint32Checksum(buf,buf_size_bytes,csum);
@@ -145,27 +145,29 @@ inline void NerscMachineCharacteristics(NerscField &header)
 
     template<class fobj,class sobj>
     struct NerscSimpleMunger{
-
+      void operator()(fobj &in, sobj &out, uint32_t &csum) {
-      void operator() (fobj &in,sobj &out,uint32_t &csum){
+        for (int mu = 0; mu < Nd; mu++) {
-
+          for (int i = 0; i < Nc; i++) {
-      for(int mu=0;mu<4;mu++){
+            for (int j = 0; j < Nc; j++) {
-      for(int i=0;i<3;i++){
+              out(mu)()(i, j) = in(mu)()(i, j);
-      for(int j=0;j<3;j++){
+            }
-	out(mu)()(i,j) = in(mu)()(i,j);
+          }
-      }}}
+        }
-      NerscChecksum((uint32_t *)&in,sizeof(in),csum); 
+        NerscChecksum((uint32_t *)&in, sizeof(in), csum);
       };
     };
 
-    template<class fobj,class sobj>
+    template <class fobj, class sobj>
-    struct NerscSimpleUnmunger{
+    struct NerscSimpleUnmunger {
-      void operator() (sobj &in,fobj &out,uint32_t &csum){
+      void operator()(sobj &in, fobj &out, uint32_t &csum) {
-	for(int mu=0;mu<Nd;mu++){
+        for (int mu = 0; mu < Nd; mu++) {
-	for(int i=0;i<Nc;i++){
+          for (int i = 0; i < Nc; i++) {
-	for(int j=0;j<Nc;j++){
+            for (int j = 0; j < Nc; j++) {
-	  out(mu)()(i,j) = in(mu)()(i,j);
+              out(mu)()(i, j) = in(mu)()(i, j);
-	}}}
+            }
-	NerscChecksum((uint32_t *)&out,sizeof(out),csum); 
+          }
+        }
+        NerscChecksum((uint32_t *)&out, sizeof(out), csum);
       };
     };
 
@@ -204,39 +206,39 @@ inline void NerscMachineCharacteristics(NerscField &header)
     };
 
 
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
-// Write and read from fstream; comput header offset for payload
+    // Write and read from fstream; comput header offset for payload
-////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////
-class NerscIO : public BinaryIO { 
+    class NerscIO : public BinaryIO { 
     public:
 
       static inline void truncate(std::string file){
 	std::ofstream fout(file,std::ios::out);
       }
   
-  #define dump_nersc_header(field, s)\
+#define dump_nersc_header(field, s)					\
-  s << "BEGIN_HEADER"      << std::endl;\
+      s << "BEGIN_HEADER"      << std::endl;				\
-  s << "HDR_VERSION = "    << field.hdr_version    << std::endl;\
+      s << "HDR_VERSION = "    << field.hdr_version    << std::endl;	\
-  s << "DATATYPE = "       << field.data_type      << std::endl;\
+      s << "DATATYPE = "       << field.data_type      << std::endl;	\
-  s << "STORAGE_FORMAT = " << field.storage_format << std::endl;\
+      s << "STORAGE_FORMAT = " << field.storage_format << std::endl;	\
-  for(int i=0;i<4;i++){\
+      for(int i=0;i<4;i++){						\
-    s << "DIMENSION_" << i+1 << " = " << field.dimension[i] << std::endl ;\
+	s << "DIMENSION_" << i+1 << " = " << field.dimension[i] << std::endl ; \
-  }\
+      }									\
-  s << "LINK_TRACE = " << std::setprecision(10) << field.link_trace << std::endl;\
+      s << "LINK_TRACE = " << std::setprecision(10) << field.link_trace << std::endl; \
-  s << "PLAQUETTE  = " << std::setprecision(10) << field.plaquette  << std::endl;\
+      s << "PLAQUETTE  = " << std::setprecision(10) << field.plaquette  << std::endl; \
-  for(int i=0;i<4;i++){\
+      for(int i=0;i<4;i++){						\
-    s << "BOUNDARY_"<<i+1<<" = " << field.boundary[i] << std::endl;\
+	s << "BOUNDARY_"<<i+1<<" = " << field.boundary[i] << std::endl;	\
-  }\
+      }									\
 									\
-  s << "CHECKSUM = "<< std::hex << std::setw(10) << field.checksum << std::dec<<std::endl;\
+      s << "CHECKSUM = "<< std::hex << std::setw(10) << field.checksum << std::dec<<std::endl; \
-  s << "ENSEMBLE_ID = "     << field.ensemble_id      << std::endl;\
+      s << "ENSEMBLE_ID = "     << field.ensemble_id      << std::endl;	\
-  s << "ENSEMBLE_LABEL = "  << field.ensemble_label   << std::endl;\
+      s << "ENSEMBLE_LABEL = "  << field.ensemble_label   << std::endl;	\
-  s << "SEQUENCE_NUMBER = " << field.sequence_number  << std::endl;\
+      s << "SEQUENCE_NUMBER = " << field.sequence_number  << std::endl;	\
-  s << "CREATOR = "         << field.creator          << std::endl;\
+      s << "CREATOR = "         << field.creator          << std::endl;	\
-  s << "CREATOR_HARDWARE = "<< field.creator_hardware << std::endl;\
+      s << "CREATOR_HARDWARE = "<< field.creator_hardware << std::endl;	\
-  s << "CREATION_DATE = "   << field.creation_date    << std::endl;\
+      s << "CREATION_DATE = "   << field.creation_date    << std::endl;	\
-  s << "ARCHIVE_DATE = "    << field.archive_date     << std::endl;\
+      s << "ARCHIVE_DATE = "    << field.archive_date     << std::endl;	\
-  s << "FLOATING_POINT = "  << field.floating_point   << std::endl;\
+      s << "FLOATING_POINT = "  << field.floating_point   << std::endl;	\
       s << "END_HEADER"         << std::endl;
   
       static inline unsigned int writeHeader(NerscField &field,std::string file)
@@ -246,11 +248,11 @@ class NerscIO : public BinaryIO {
       dump_nersc_header(field, fout);
       field.data_start = fout.tellp();
       return field.data_start;
-}
+    }
 
-// for the header-reader
+      // for the header-reader
-static inline int readHeader(std::string file,GridBase *grid,  NerscField &field)
+      static inline int readHeader(std::string file,GridBase *grid,  NerscField &field)
-{
+      {
       int offset=0;
       std::map<std::string,std::string> header;
       std::string line;
@@ -319,17 +321,17 @@ static inline int readHeader(std::string file,GridBase *grid,  NerscField &field
       field.floating_point   = header["FLOATING_POINT"];
 
       return field.data_start;
-}
+    }
 
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// Now the meat: the object readers
+      // Now the meat: the object readers
-/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+      /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #define PARALLEL_READ
 #define PARALLEL_WRITE
 
-template<class vsimd>
+      template<class vsimd>
-static inline void readConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu,NerscField& header,std::string file)
+      static inline void readConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu,NerscField& header,std::string file)
-{
+      {
       typedef Lattice<iLorentzColourMatrix<vsimd> > GaugeField;
 
       GridBase *grid = Umu._grid;
@@ -402,11 +404,11 @@ static inline void readConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu,
       assert(csum == header.checksum );
 
       std::cout<<GridLogMessage <<"NERSC Configuration "<<file<< " and plaquette, link trace, and checksum agree"<<std::endl;
-}
+      }
 
-template<class vsimd>
+      template<class vsimd>
-static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu,std::string file, int two_row,int bits32)
+      static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu,std::string file, int two_row,int bits32)
-{
+      {
 	typedef Lattice<iLorentzColourMatrix<vsimd> > GaugeField;
 
 	typedef iLorentzColourMatrix<vsimd> vobj;
@@ -420,8 +422,6 @@ static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu
 
 	typedef LorentzColourMatrixD fobj3D;
 	typedef LorentzColour2x3D    fobj2D;
-  typedef LorentzColourMatrixF fobj3f;
-  typedef LorentzColour2x3F    fobj2f;
   
 	GridBase *grid = Umu._grid;
 
@@ -446,7 +446,6 @@ static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu
 #else
 	  csum=BinaryIO::writeObjectSerial<vobj,fobj2D>(Umu,file,munge,offset,header.floating_point);
 #endif
-
 	} else { 
 	  header.floating_point = std::string("IEEE64BIG");
 	  header.data_type      = std::string("4D_SU3_GAUGE_3x3");
@@ -460,7 +459,7 @@ static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu
 #endif
 	}
 
-  std::cout<<GridLogMessage <<"Written NERSC Configuration "<<file<< " checksum "<<std::hex<<csum<< std::dec<<" plaq "<< header.plaquette <<std::endl;
+	std::cout<<GridLogMessage <<"Written NERSC Configuration on "<< file << " checksum "<<std::hex<<csum<< std::dec<<" plaq "<< header.plaquette <<std::endl;
 
       }
 
@@ -468,8 +467,8 @@ static inline void writeConfiguration(Lattice<iLorentzColourMatrix<vsimd> > &Umu
       ///////////////////////////////
       // RNG state
       ///////////////////////////////
-static inline void writeRNGState(GridSerialRNG &serial,GridParallelRNG &parallel,std::string file)
+      static inline void writeRNGState(GridSerialRNG &serial,GridParallelRNG &parallel,std::string file)
-{
+      {
 	typedef typename GridParallelRNG::RngStateType RngStateType;
 
 	// Following should become arguments
@@ -511,8 +510,8 @@ static inline void writeRNGState(GridSerialRNG &serial,GridParallelRNG &parallel
 
       }
     
-static inline void readRNGState(GridSerialRNG &serial,GridParallelRNG & parallel,NerscField& header,std::string file)
+      static inline void readRNGState(GridSerialRNG &serial,GridParallelRNG & parallel,NerscField& header,std::string file)
-{
+      {
 	typedef typename GridParallelRNG::RngStateType RngStateType;
 
 	GridBase *grid = parallel._grid;
@@ -544,10 +543,10 @@ static inline void readRNGState(GridSerialRNG &serial,GridParallelRNG & parallel
 	assert(csum == header.checksum );
 
 	std::cout<<GridLogMessage <<"Read NERSC RNG file "<<file<< " format "<< data_type <<std::endl;
-}
+      }
 
-};
+    };
 
 
-}}
+  }}
 #endif

lib/perfmon/PerfCount.h

@@ -205,13 +205,14 @@ public:
   void Stop(void) {
     count=0;
     cycles=0;
-    size_t ign;
 #ifdef __linux__
+    ssize_t ign;
     if ( fd!= -1) {
       ::ioctl(fd, PERF_EVENT_IOC_DISABLE, 0);
       ::ioctl(cyclefd, PERF_EVENT_IOC_DISABLE, 0);
       ign=::read(fd, &count, sizeof(long long));
-      ign=::read(cyclefd, &cycles, sizeof(long long));
+      ign+=::read(cyclefd, &cycles, sizeof(long long));
+      assert(ign=2*sizeof(long long));
     }
     elapsed = cyclecount() - begin;
 #else

lib/qcd/LatticeTheories.h

@@ -0,0 +1,124 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/QCD.h
+
+Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: Peter Boyle <peterboyle@Peters-MacBook-Pro-2.local>
+Author: neo <cossu@post.kek.jp>
+Author: paboyle <paboyle@ph.ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_LT_H
+#define GRID_LT_H
+namespace Grid{
+
+// First steps in the complete generalization of the Physics part
+// Design not final
+namespace LatticeTheories {
+
+template <int Dimensions>
+struct LatticeTheory {
+  static const int Nd = Dimensions;
+  static const int Nds = Dimensions * 2;  // double stored field
+  template <typename vtype>
+  using iSinglet = iScalar<iScalar<iScalar<vtype> > >;
+};
+
+template <int Dimensions, int Colours>
+struct LatticeGaugeTheory : public LatticeTheory<Dimensions> {
+  static const int Nds = Dimensions * 2;
+  static const int Nd = Dimensions;
+  static const int Nc = Colours;
+
+  template <typename vtype> 
+  using iColourMatrix = iScalar<iScalar<iMatrix<vtype, Nc> > >;
+  template <typename vtype>
+  using iLorentzColourMatrix = iVector<iScalar<iMatrix<vtype, Nc> >, Nd>;
+  template <typename vtype>
+  using iDoubleStoredColourMatrix = iVector<iScalar<iMatrix<vtype, Nc> >, Nds>;
+  template <typename vtype>
+  using iColourVector = iScalar<iScalar<iVector<vtype, Nc> > >;
+};
+
+template <int Dimensions, int Colours, int Spin>
+struct FermionicLatticeGaugeTheory
+    : public LatticeGaugeTheory<Dimensions, Colours> {
+  static const int Nd = Dimensions;
+  static const int Nds = Dimensions * 2;
+  static const int Nc = Colours;
+  static const int Ns = Spin;
+
+  template <typename vtype>
+  using iSpinMatrix = iScalar<iMatrix<iScalar<vtype>, Ns> >;
+  template <typename vtype>
+  using iSpinColourMatrix = iScalar<iMatrix<iMatrix<vtype, Nc>, Ns> >;
+  template <typename vtype>
+  using iSpinVector = iScalar<iVector<iScalar<vtype>, Ns> >;
+  template <typename vtype>
+  using iSpinColourVector = iScalar<iVector<iVector<vtype, Nc>, Ns> >;
+  // These 2 only if Spin is a multiple of 2
+  static const int Nhs = Spin / 2;
+  template <typename vtype>
+  using iHalfSpinVector = iScalar<iVector<iScalar<vtype>, Nhs> >;
+  template <typename vtype>
+  using iHalfSpinColourVector = iScalar<iVector<iVector<vtype, Nc>, Nhs> >;
+
+  //tests
+  typedef iColourMatrix<Complex> ColourMatrix;
+  typedef iColourMatrix<ComplexF> ColourMatrixF;
+  typedef iColourMatrix<ComplexD> ColourMatrixD;
+
+
+};
+
+// Examples, not complete now.
+struct QCD : public FermionicLatticeGaugeTheory<4, 3, 4> {
+    static const int Xp = 0;
+    static const int Yp = 1;
+    static const int Zp = 2;
+    static const int Tp = 3;
+    static const int Xm = 4;
+    static const int Ym = 5;
+    static const int Zm = 6;
+    static const int Tm = 7;
+
+    typedef FermionicLatticeGaugeTheory FLGT;
+
+    typedef FLGT::iSpinMatrix<Complex  >          SpinMatrix;
+    typedef FLGT::iSpinMatrix<ComplexF >          SpinMatrixF;
+    typedef FLGT::iSpinMatrix<ComplexD >          SpinMatrixD;
+
+};
+struct QED : public FermionicLatticeGaugeTheory<4, 1, 4> {//fill
+};
+
+template <int Dimensions>
+struct Scalar : public LatticeTheory<Dimensions> {};
+
+};  // LatticeTheories
+
+} // Grid
+
+#endif

lib/qcd/QCD.h

@@ -32,9 +32,12 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
 #ifndef GRID_QCD_BASE_H
 #define GRID_QCD_BASE_H
 namespace Grid{
-
 namespace QCD {
 
+    static const int Xdir = 0;
+    static const int Ydir = 1;
+    static const int Zdir = 2;
+    static const int Tdir = 3;
 
     static const int Xp = 0;
     static const int Yp = 1;
@@ -492,6 +495,38 @@ namespace QCD {
 }   //namespace QCD
 } // Grid
 
+/*
+<<<<<<< HEAD
+#include <Grid/qcd/utils/SpaceTimeGrid.h>
+#include <Grid/qcd/spin/Dirac.h>
+#include <Grid/qcd/spin/TwoSpinor.h>
+#include <Grid/qcd/utils/LinalgUtils.h>
+#include <Grid/qcd/utils/CovariantCshift.h>
+
+// Include representations  
+#include <Grid/qcd/utils/SUn.h>
+#include <Grid/qcd/utils/SUnAdjoint.h>
+#include <Grid/qcd/utils/SUnTwoIndex.h>
+#include <Grid/qcd/representations/hmc_types.h>
+
+// Scalar field
+#include <Grid/qcd/utils/ScalarObjs.h>
+
+#include <Grid/qcd/action/Actions.h>
+
+#include <Grid/qcd/smearing/Smearing.h>
+
+#include <Grid/qcd/hmc/integrators/Integrator.h>
+#include <Grid/qcd/hmc/integrators/Integrator_algorithm.h>
+#include <Grid/qcd/observables/hmc_observable.h>
+#include <Grid/qcd/hmc/HMC.h>
+
+
+//#include <Grid/qcd/modules/mods.h>
+=======
+
+>>>>>>> develop
+*/
 
 
 #endif

lib/qcd/action/ActionBase.h

@@ -4,10 +4,11 @@ Grid physics library, www.github.com/paboyle/Grid
 
 Source file: ./lib/qcd/action/ActionBase.h
 
-Copyright (C) 2015
+Copyright (C) 2015-2016
 
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: neo <cossu@post.kek.jp>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -27,128 +28,29 @@ See the full license in the file "LICENSE" in the top level distribution
 directory
 *************************************************************************************/
 /*  END LEGAL */
-#ifndef QCD_ACTION_BASE
+
-#define QCD_ACTION_BASE
+#ifndef ACTION_BASE_H
+#define ACTION_BASE_H
+
 namespace Grid {
 namespace QCD {
 
-template <class GaugeField>
+template <class GaugeField >
-class Action {
+class Action 
+{
+
  public:
   bool is_smeared = false;
-  // Boundary conditions? // Heatbath?
+  // Heatbath?
-  virtual void refresh(const GaugeField& U,
+  virtual void refresh(const GaugeField& U, GridParallelRNG& pRNG) = 0; // refresh pseudofermions
-                       GridParallelRNG& pRNG) = 0;  // refresh pseudofermions
   virtual RealD S(const GaugeField& U) = 0;                             // evaluate the action
-  virtual void deriv(const GaugeField& U,
+  virtual void deriv(const GaugeField& U, GaugeField& dSdU) = 0;        // evaluate the action derivative
-                     GaugeField& dSdU) = 0;  // evaluate the action derivative
+  virtual std::string action_name()    = 0;                             // return the action name
-  virtual ~Action(){};
+  virtual std::string LogParameters()  = 0;                             // prints action parameters
+  virtual ~Action(){}
 };
 
-// Indexing of tuple types
-template <class T, class Tuple>
-struct Index;
-
-template <class T, class... Types>
-struct Index<T, std::tuple<T, Types...>> {
-  static const std::size_t value = 0;
-};
-
-template <class T, class U, class... Types>
-struct Index<T, std::tuple<U, Types...>> {
-  static const std::size_t value = 1 + Index<T, std::tuple<Types...>>::value;
-};
-
-/*
-template <class GaugeField>
-struct ActionLevel {
- public:
-  typedef Action<GaugeField>*
-      ActPtr;  // now force the same colours as the rest of the code
-
-  //Add supported representations here
-
-
-  unsigned int multiplier;
-
-  std::vector<ActPtr> actions;
-
-  ActionLevel(unsigned int mul = 1) : actions(0), multiplier(mul) {
-    assert(mul >= 1);
-  };
-
-  void push_back(ActPtr ptr) { actions.push_back(ptr); }
-};
-*/
-
-template <class GaugeField, class Repr = NoHirep >
-struct ActionLevel {
- public:
-  unsigned int multiplier; 
-
-  // Fundamental repr actions separated because of the smearing
-  typedef Action<GaugeField>* ActPtr;
-
-  // construct a tuple of vectors of the actions for the corresponding higher
-  // representation fields
-  typedef typename AccessTypes<Action, Repr>::VectorCollection action_collection;
-  action_collection actions_hirep;
-  typedef typename  AccessTypes<Action, Repr>::FieldTypeCollection action_hirep_types;
-
-  std::vector<ActPtr>& actions;
-
-  // Temporary conversion between ActionLevel and ActionLevelHirep
-  //ActionLevelHirep(ActionLevel<GaugeField>& AL ):actions(AL.actions), multiplier(AL.multiplier){}
-
-  ActionLevel(unsigned int mul = 1) : actions(std::get<0>(actions_hirep)), multiplier(mul) {
-    // initialize the hirep vectors to zero.
-    //apply(this->resize, actions_hirep, 0); //need a working resize
-    assert(mul >= 1);
-  };
-
-  //void push_back(ActPtr ptr) { actions.push_back(ptr); }
-
-
-
-  template < class Field >
-  void push_back(Action<Field>* ptr) {
-    // insert only in the correct vector
-    std::get< Index < Field, action_hirep_types>::value >(actions_hirep).push_back(ptr);
-  };
-
- 
-
-  template < class ActPtr>
-  static void resize(ActPtr ap, unsigned int n){
-    ap->resize(n);
-
-  }
-
-  //template <std::size_t I>
-  //auto getRepresentation(Repr& R)->decltype(std::get<I>(R).U)  {return std::get<I>(R).U;}
-
-  // Loop on tuple for a callable function
-  template <std::size_t I = 1, typename Callable, typename ...Args>
-  inline typename std::enable_if<I == std::tuple_size<action_collection>::value, void>::type apply(
-      Callable, Repr& R,Args&...) const {}
-
-  template <std::size_t I = 1, typename Callable, typename ...Args>
-  inline typename std::enable_if<I < std::tuple_size<action_collection>::value, void>::type apply(
-      Callable fn, Repr& R, Args&... arguments) const {
-    fn(std::get<I>(actions_hirep), std::get<I>(R.rep), arguments...);
-    apply<I + 1>(fn, R, arguments...);
-  }  
-
-};
-
-
-//template <class GaugeField>
-//using ActionSet = std::vector<ActionLevel<GaugeField> >;
-
-template <class GaugeField, class R>
-using ActionSet = std::vector<ActionLevel<GaugeField, R> >;
-
 }
 }
 
-#endif
+#endif // ACTION_BASE_H

lib/qcd/action/ActionCore.h

@@ -31,15 +31,31 @@ directory
 #define QCD_ACTION_CORE
 
 #include <Grid/qcd/action/ActionBase.h>
+#include <Grid/qcd/action/ActionSet.h>
 #include <Grid/qcd/action/ActionParams.h>
 
 ////////////////////////////////////////////
 // Gauge Actions
 ////////////////////////////////////////////
 #include <Grid/qcd/action/gauge/Gauge.h>
+
 ////////////////////////////////////////////
 // Fermion prereqs
 ////////////////////////////////////////////
 #include <Grid/qcd/action/fermion/FermionCore.h>
 
+////////////////////////////////////////////
+// Scalar Actions
+////////////////////////////////////////////
+#include <Grid/qcd/action/scalar/Scalar.h>
+
+////////////////////////////////////////////
+// Utility functions
+////////////////////////////////////////////
+#include <Grid/qcd/utils/Metric.h>
+#include <Grid/qcd/utils/CovariantLaplacian.h>
+
+
+
+
 #endif

lib/qcd/action/ActionParams.h

@@ -1,31 +1,34 @@
-    /*************************************************************************************
+/*************************************************************************************
 
-    Grid physics library, www.github.com/paboyle/Grid 
+Grid physics library, www.github.com/paboyle/Grid
 
-    Source file: ./lib/qcd/action/ActionParams.h
+Source file: ./lib/qcd/action/ActionParams.h
 
-    Copyright (C) 2015
+Copyright (C) 2015
 
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: paboyle <paboyle@ph.ed.ac.uk>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
-    This program is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
+it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+(at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
+with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
 
-    See the full license in the file "LICENSE" in the top level distribution directory
-    *************************************************************************************/
-    /*  END LEGAL */
 #ifndef GRID_QCD_ACTION_PARAMS_H
 #define GRID_QCD_ACTION_PARAMS_H
 
@@ -36,32 +39,54 @@ namespace QCD {
   struct GparityWilsonImplParams {
     bool overlapCommsCompute;
     std::vector<int> twists;
-      GparityWilsonImplParams () : twists(Nd,0), overlapCommsCompute(false) {};
+    GparityWilsonImplParams() : twists(Nd, 0), overlapCommsCompute(false){};
-
   };
   
   struct WilsonImplParams {
     bool overlapCommsCompute;
-      WilsonImplParams() : overlapCommsCompute(false) {};
+    std::vector<Complex> boundary_phases;
+    WilsonImplParams() : overlapCommsCompute(false) {
+      boundary_phases.resize(Nd, 1.0);
+    };
+    WilsonImplParams(const std::vector<Complex> phi)
+      : boundary_phases(phi), overlapCommsCompute(false) {}
   };
 
   struct StaggeredImplParams {
     StaggeredImplParams()  {};
   };
   
-    struct OneFlavourRationalParams { 
+  struct OneFlavourRationalParams : Serializable {
-      RealD  lo;
+    GRID_SERIALIZABLE_CLASS_MEMBERS(OneFlavourRationalParams, 
-      RealD  hi;
+				    RealD, lo, 
-      int MaxIter;   // Vector?
+				    RealD, hi, 
-      RealD tolerance; // Vector? 
+				    int,   MaxIter, 
-      int    degree=10;
+				    RealD, tolerance, 
-      int precision=64;
+				    int,   degree, 
+				    int,   precision);
     
-      OneFlavourRationalParams (RealD _lo,RealD _hi,int _maxit,RealD tol=1.0e-8,int _degree = 10,int _precision=64) :
+    // MaxIter and tolerance, vectors??
-        lo(_lo), hi(_hi), MaxIter(_maxit), tolerance(tol), degree(_degree), precision(_precision)
+    
-      {};
+    // constructor 
+    OneFlavourRationalParams(	RealD _lo      = 0.0, 
+				RealD _hi      = 1.0, 
+				int _maxit     = 1000,
+				RealD tol      = 1.0e-8, 
+                           	int _degree    = 10,
+				int _precision = 64)
+      : lo(_lo),
+	hi(_hi),
+	MaxIter(_maxit),
+	tolerance(tol),
+	degree(_degree),
+	precision(_precision){};
   };
   
-}}
+  
+}
+}
+
+
+
 
 #endif

lib/qcd/action/ActionSet.h

@@ -0,0 +1,116 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/ActionSet.h
+
+Copyright (C) 2015
+
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: neo <cossu@post.kek.jp>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin 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 ACTION_SET_H
+#define ACTION_SET_H
+
+namespace Grid {
+
+// Should drop this namespace here
+namespace QCD {
+
+//////////////////////////////////
+// Indexing of tuple types
+//////////////////////////////////
+
+template <class T, class Tuple>
+struct Index;
+
+template <class T, class... Types>
+struct Index<T, std::tuple<T, Types...>> {
+  static const std::size_t value = 0;
+};
+
+template <class T, class U, class... Types>
+struct Index<T, std::tuple<U, Types...>> {
+  static const std::size_t value = 1 + Index<T, std::tuple<Types...>>::value;
+};
+
+
+////////////////////////////////////////////
+// Action Level
+// Action collection 
+// in a integration level
+// (for multilevel integration schemes)
+////////////////////////////////////////////
+
+template <class Field, class Repr = NoHirep >
+struct ActionLevel {
+ public:
+  unsigned int multiplier;
+
+  // Fundamental repr actions separated because of the smearing
+  typedef Action<Field>* ActPtr;
+
+  // construct a tuple of vectors of the actions for the corresponding higher
+  // representation fields
+  typedef typename AccessTypes<Action, Repr>::VectorCollection action_collection;
+  typedef typename  AccessTypes<Action, Repr>::FieldTypeCollection action_hirep_types;
+
+  action_collection actions_hirep;
+  std::vector<ActPtr>& actions;
+
+  explicit ActionLevel(unsigned int mul = 1) : 
+  actions(std::get<0>(actions_hirep)), multiplier(mul) {
+    // initialize the hirep vectors to zero.
+    // apply(this->resize, actions_hirep, 0); //need a working resize
+    assert(mul >= 1);
+  }
+
+  template < class GenField >
+  void push_back(Action<GenField>* ptr) {
+    // insert only in the correct vector
+    std::get< Index < GenField, action_hirep_types>::value >(actions_hirep).push_back(ptr);
+  };
+
+  template <class ActPtr>
+  static void resize(ActPtr ap, unsigned int n) {
+    ap->resize(n);
+  }
+
+  // Loop on tuple for a callable function
+  template <std::size_t I = 1, typename Callable, typename ...Args>
+  inline typename std::enable_if<I == std::tuple_size<action_collection>::value, void>::type apply(Callable, Repr& R,Args&...) const {}
+
+  template <std::size_t I = 1, typename Callable, typename ...Args>
+  inline typename std::enable_if<I < std::tuple_size<action_collection>::value, void>::type apply(Callable fn, Repr& R, Args&... arguments) const {
+    fn(std::get<I>(actions_hirep), std::get<I>(R.rep), arguments...);
+    apply<I + 1>(fn, R, arguments...);
+  }  
+
+};
+
+// Define the ActionSet
+template <class GaugeField, class R>
+using ActionSet = std::vector<ActionLevel<GaugeField, R> >;
+
+} // QCD
+} // Grid
+
+#endif  // ACTION_SET_H

lib/qcd/action/fermion/CayleyFermion5D.cc

@@ -29,7 +29,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
     *************************************************************************************/
     /*  END LEGAL */
 
-#include <Grid/Eigen/Dense>
+#include <Grid/Grid_Eigen_Dense.h>
 #include <Grid/qcd/action/fermion/FermionCore.h>
 #include <Grid/qcd/action/fermion/CayleyFermion5D.h>
 
@@ -320,7 +320,7 @@ void CayleyFermion5D<Impl>::MDeriv  (GaugeField &mat,const FermionField &U,const
     this->DhopDeriv(mat,U,Din,dag);
   } else {
     //      U d/du [D_w D5]^dag V = U D5^dag d/du DW^dag Y // implicit adj on U in call
-    MeooeDag5D(U,Din);
+    Meooe5D(U,Din);
     this->DhopDeriv(mat,Din,V,dag);
   }
 };
@@ -335,7 +335,7 @@ void CayleyFermion5D<Impl>::MoeDeriv(GaugeField &mat,const FermionField &U,const
     this->DhopDerivOE(mat,U,Din,dag);
   } else {
     //      U d/du [D_w D5]^dag V = U D5^dag d/du DW^dag Y // implicit adj on U in call
-      MeooeDag5D(U,Din);
+    Meooe5D(U,Din);
     this->DhopDerivOE(mat,Din,V,dag);
   }
 };
@@ -350,7 +350,7 @@ void CayleyFermion5D<Impl>::MeoDeriv(GaugeField &mat,const FermionField &U,const
     this->DhopDerivEO(mat,U,Din,dag);
   } else {
     //      U d/du [D_w D5]^dag V = U D5^dag d/du DW^dag Y // implicit adj on U in call
-    MeooeDag5D(U,Din);
+    Meooe5D(U,Din);
     this->DhopDerivEO(mat,Din,V,dag);
   }
 };
@@ -380,6 +380,8 @@ void CayleyFermion5D<Impl>::SetCoefficientsInternal(RealD zolo_hi,std::vector<Co
   ///////////////////////////////////////////////////////////
   // The Cayley coeffs (unprec)
   ///////////////////////////////////////////////////////////
+  assert(gamma.size()==Ls);
+
   omega.resize(Ls);
   bs.resize(Ls);
   cs.resize(Ls);
@@ -412,6 +414,7 @@ void CayleyFermion5D<Impl>::SetCoefficientsInternal(RealD zolo_hi,std::vector<Co
   for(int i=0; i < Ls; i++){
     as[i] = 1.0;
     omega[i] = gamma[i]*zolo_hi; //NB reciprocal relative to Chroma NEF code
+    //    assert(fabs(omega[i])>0.0);
     bs[i] = 0.5*(bpc/omega[i] + bmc);
     cs[i] = 0.5*(bpc/omega[i] - bmc);
     std::cout<<GridLogMessage << "CayleyFermion5D "<<i<<" bs="<<bs[i]<<" cs="<<cs[i]<< std::endl;
@@ -428,11 +431,11 @@ void CayleyFermion5D<Impl>::SetCoefficientsInternal(RealD zolo_hi,std::vector<Co
   
   for(int i=0;i<Ls;i++){
     bee[i]=as[i]*(bs[i]*(4.0-this->M5) +1.0);     
+    //    assert(fabs(bee[i])>0.0);
     cee[i]=as[i]*(1.0-cs[i]*(4.0-this->M5));
     beo[i]=as[i]*bs[i];
     ceo[i]=-as[i]*cs[i];
   }
-  
   aee.resize(Ls);
   aeo.resize(Ls);
   for(int i=0;i<Ls;i++){
@@ -476,14 +479,16 @@ void CayleyFermion5D<Impl>::SetCoefficientsInternal(RealD zolo_hi,std::vector<Co
 	
   { 
     Coeff_t delta_d=mass*cee[Ls-1];
-    for(int j=0;j<Ls-1;j++) delta_d *= cee[j]/bee[j];
+    for(int j=0;j<Ls-1;j++) {
+      //      assert(fabs(bee[j])>0.0);
+      delta_d *= cee[j]/bee[j];
+    }
     dee[Ls-1] += delta_d;
   }  
 
   int inv=1;
   this->MooeeInternalCompute(0,inv,MatpInv,MatmInv);
   this->MooeeInternalCompute(1,inv,MatpInvDag,MatmInvDag);
-
 }
 
 
@@ -497,7 +502,9 @@ void CayleyFermion5D<Impl>::MooeeInternalCompute(int dag, int inv,
   GridBase *grid = this->FermionRedBlackGrid();
   int LLs = grid->_rdimensions[0];
 
-  if ( LLs == Ls ) return; // Not vectorised in 5th direction
+  if ( LLs == Ls ) {
+    return; // Not vectorised in 5th direction
+  }
 
   Eigen::MatrixXcd Pplus  = Eigen::MatrixXcd::Zero(Ls,Ls);
   Eigen::MatrixXcd Pminus = Eigen::MatrixXcd::Zero(Ls,Ls);

lib/qcd/action/fermion/CayleyFermion5Ddense.cc

@@ -29,7 +29,7 @@ Author: paboyle <paboyle@ph.ed.ac.uk>
     *************************************************************************************/
     /*  END LEGAL */
 
-#include <Grid/Eigen/Dense>
+#include <Grid/Grid_Eigen_Dense.h>
 #include <Grid/qcd/action/fermion/FermionCore.h>
 #include <Grid/qcd/action/fermion/CayleyFermion5D.h>
 

lib/qcd/action/fermion/DomainWallFermion.h

@@ -68,7 +68,7 @@ namespace Grid {
 	Approx::zolotarev_data *zdata = Approx::higham(eps,this->Ls);// eps is ignored for higham
 	assert(zdata->n==this->Ls);
 	
-	//	std::cout<<GridLogMessage << "DomainWallFermion with Ls="<<this->Ls<<std::endl;
+	std::cout<<GridLogMessage << "DomainWallFermion with Ls="<<this->Ls<<std::endl;
 	// Call base setter
 	this->SetCoefficientsTanh(zdata,1.0,0.0);
 

lib/qcd/action/fermion/Fermion.h

@@ -1,4 +1,4 @@
-    /*************************************************************************************
+/*************************************************************************************
 
     Grid physics library, www.github.com/paboyle/Grid 
 

lib/qcd/action/fermion/FermionOperatorImpl.h

@@ -198,7 +198,9 @@ namespace QCD {
     
     ImplParams Params;
     
-    WilsonImpl(const ImplParams &p = ImplParams()) : Params(p){};
+    WilsonImpl(const ImplParams &p = ImplParams()) : Params(p){
+      assert(Params.boundary_phases.size() == Nd);
+    };
       
     bool overlapCommsCompute(void) { return Params.overlapCommsCompute; };
       
@@ -218,14 +220,32 @@ namespace QCD {
       
     inline void DoubleStore(GridBase *GaugeGrid,
                             DoubledGaugeField &Uds,
-			    const GaugeField &Umu) {
+                            const GaugeField &Umu) 
+    {
+      typedef typename Simd::scalar_type scalar_type;
+
       conformable(Uds._grid, GaugeGrid);
       conformable(Umu._grid, GaugeGrid);
+
       GaugeLinkField U(GaugeGrid);
+      GaugeLinkField tmp(GaugeGrid);
+
+      Lattice<iScalar<vInteger> > coor(GaugeGrid);
       for (int mu = 0; mu < Nd; mu++) {
+
+	      auto pha = Params.boundary_phases[mu];
+	      scalar_type phase( real(pha),imag(pha) );
+
+        int Lmu = GaugeGrid->GlobalDimensions()[mu] - 1;
+
+        LatticeCoordinate(coor, mu);
+
         U = PeekIndex<LorentzIndex>(Umu, mu);
-	PokeIndex<LorentzIndex>(Uds, U, mu);
+        tmp = where(coor == Lmu, phase * U, U);
+        PokeIndex<LorentzIndex>(Uds, tmp, mu);
+
         U = adj(Cshift(U, mu, -1));
+        U = where(coor == 0, conjugate(phase) * U, U); 
         PokeIndex<LorentzIndex>(Uds, U, mu + 4);
       }
     }
@@ -353,9 +373,52 @@ class DomainWallVec5dImpl :  public PeriodicGaugeImpl< GaugeImplTypes< S,Nrepres
     assert(0);
   }
 
-  inline void InsertForce5D(GaugeField &mat, FermionField &Btilde,FermionField &Atilde, int mu) 
+  inline void InsertForce5D(GaugeField &mat, FermionField &Btilde, FermionField &Atilde, int mu) {
-  {
+
     assert(0);
+    // Following lines to be revised after Peter's addition of half prec
+    // missing put lane...
+    /*
+    typedef decltype(traceIndex<SpinIndex>(outerProduct(Btilde[0], Atilde[0]))) result_type;
+    unsigned int LLs = Btilde._grid->_rdimensions[0];
+    conformable(Atilde._grid,Btilde._grid);
+    GridBase* grid = mat._grid;
+    GridBase* Bgrid = Btilde._grid;
+    unsigned int dimU = grid->Nd();
+    unsigned int dimF = Bgrid->Nd();
+    GaugeLinkField tmp(grid); 
+    tmp = zero;
+    
+    // FIXME 
+    // Current implementation works, thread safe, probably suboptimal
+    // Passing through the local coordinate for grid transformation
+    // the force grid is in general very different from the Ls vectorized grid
+
+    PARALLEL_FOR_LOOP
+    for (int so = 0; so < grid->oSites(); so++) {
+      std::vector<typename result_type::scalar_object> vres(Bgrid->Nsimd());
+      std::vector<int> ocoor;  grid->oCoorFromOindex(ocoor,so); 
+      for (int si = 0; si < tmp._grid->iSites(); si++){
+        typename result_type::scalar_object scalar_object; scalar_object = zero;
+        std::vector<int> local_coor;      
+        std::vector<int> icoor; grid->iCoorFromIindex(icoor,si);
+        grid->InOutCoorToLocalCoor(ocoor, icoor, local_coor);
+        for (int s = 0; s < LLs; s++) {
+          std::vector<int> slocal_coor(dimF);
+          slocal_coor[0] = s;
+          for (int s4d = 1; s4d< dimF; s4d++) slocal_coor[s4d] = local_coor[s4d-1];
+          int sF = Bgrid->oIndexReduced(slocal_coor);  
+          assert(sF < Bgrid->oSites());
+
+          extract(traceIndex<SpinIndex>(outerProduct(Btilde[sF], Atilde[sF])), vres); 
+          // sum across the 5d dimension
+          for (auto v : vres) scalar_object += v;  
+        }
+        tmp._odata[so].putlane(scalar_object, si);
+      }
+    }
+    PokeIndex<LorentzIndex>(mat, tmp, mu);
+    */
   }
 };
     
@@ -512,6 +575,7 @@ class GparityWilsonImpl : public ConjugateGaugeImpl<GaugeImplTypes<S, Nrepresent
        Utmp = where(coor==0,Uconj,Utmp);
      }
 
+	  
      parallel_for(auto ss=U.begin();ss<U.end();ss++){
        Uds[ss](0)(mu+4) = Utmp[ss]();
      }
@@ -535,7 +599,7 @@ class GparityWilsonImpl : public ConjugateGaugeImpl<GaugeImplTypes<S, Nrepresent
    // use lorentz for flavour as hack.
    auto tmp = TraceIndex<SpinIndex>(outerProduct(Btilde, A));
    parallel_for(auto ss = tmp.begin(); ss < tmp.end(); ss++) {
-     link[ss]() = tmp[ss](0, 0) - conjugate(tmp[ss](1, 1));
+     link[ss]() = tmp[ss](0, 0) + conjugate(tmp[ss](1, 1));
    }
    PokeIndex<LorentzIndex>(mat, link, mu);
    return;

lib/qcd/action/fermion/WilsonFermion.cc

@@ -230,8 +230,7 @@ void WilsonFermion<Impl>::DerivInternal(StencilImpl &st, DoubledGaugeField &U,
 }
 
 template <class Impl>
-void WilsonFermion<Impl>::DhopDeriv(GaugeField &mat, const FermionField &U,
+void WilsonFermion<Impl>::DhopDeriv(GaugeField &mat, const FermionField &U, const FermionField &V, int dag) {
-                                    const FermionField &V, int dag) {
   conformable(U._grid, _grid);
   conformable(U._grid, V._grid);
   conformable(U._grid, mat._grid);
@@ -242,11 +241,11 @@ void WilsonFermion<Impl>::DhopDeriv(GaugeField &mat, const FermionField &U,
 }
 
 template <class Impl>
-void WilsonFermion<Impl>::DhopDerivOE(GaugeField &mat, const FermionField &U,
+void WilsonFermion<Impl>::DhopDerivOE(GaugeField &mat, const FermionField &U, const FermionField &V, int dag) {
-                                      const FermionField &V, int dag) {
   conformable(U._grid, _cbgrid);
   conformable(U._grid, V._grid);
-  conformable(U._grid, mat._grid);
+  //conformable(U._grid, mat._grid); not general, leaving as a comment (Guido)
+  // Motivation: look at the SchurDiff operator
   
   assert(V.checkerboard == Even);
   assert(U.checkerboard == Odd);
@@ -256,11 +255,10 @@ void WilsonFermion<Impl>::DhopDerivOE(GaugeField &mat, const FermionField &U,
 }
 
 template <class Impl>
-void WilsonFermion<Impl>::DhopDerivEO(GaugeField &mat, const FermionField &U,
+void WilsonFermion<Impl>::DhopDerivEO(GaugeField &mat, const FermionField &U, const FermionField &V, int dag) {
-                                      const FermionField &V, int dag) {
   conformable(U._grid, _cbgrid);
   conformable(U._grid, V._grid);
-  conformable(U._grid, mat._grid);
+  //conformable(U._grid, mat._grid);
 
   assert(V.checkerboard == Odd);
   assert(U.checkerboard == Even);

lib/qcd/action/fermion/WilsonFermion5D.cc

@@ -11,6 +11,7 @@ Author: Peter Boyle <pabobyle@ph.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: Peter Boyle <peterboyle@Peters-MacBook-Pro-2.local>
 Author: paboyle <paboyle@ph.ed.ac.uk>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -117,7 +118,6 @@ WilsonFermion5D<Impl>::WilsonFermion5D(GaugeField &_Umu,
     
   // Allocate the required comms buffer
   ImportGauge(_Umu);
-
   // Build lists of exterior only nodes
   int LLs = FiveDimGrid._rdimensions[0];
   int vol4;
@@ -267,6 +267,8 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
   DerivCommTime+=usecond();
 
   Atilde=A;
+  int LLs = B._grid->_rdimensions[0];
+
 
   DerivComputeTime-=usecond();
   for (int mu = 0; mu < Nd; mu++) {
@@ -296,6 +298,9 @@ void WilsonFermion5D<Impl>::DerivInternal(StencilImpl & st,
         ////////////////////////////
       }
     }
+    ////////////////////////////
+    // spin trace outer product
+    ////////////////////////////
     DerivDhopComputeTime += usecond();
     Impl::InsertForce5D(mat, Btilde, Atilde, mu);
   }
@@ -310,7 +315,8 @@ void WilsonFermion5D<Impl>::DhopDeriv(GaugeField &mat,
 {
   conformable(A._grid,FermionGrid());  
   conformable(A._grid,B._grid);
-  conformable(GaugeGrid(),mat._grid);
+
+  //conformable(GaugeGrid(),mat._grid);// this is not general! leaving as a comment
 
   mat.checkerboard = A.checkerboard;
 
@@ -324,7 +330,6 @@ void WilsonFermion5D<Impl>::DhopDerivEO(GaugeField &mat,
                                         int dag)
 {
   conformable(A._grid,FermionRedBlackGrid());
-  conformable(GaugeRedBlackGrid(),mat._grid);
   conformable(A._grid,B._grid);
 
   assert(B.checkerboard==Odd);
@@ -342,7 +347,6 @@ void WilsonFermion5D<Impl>::DhopDerivOE(GaugeField &mat,
                                         int dag)
 {
   conformable(A._grid,FermionRedBlackGrid());
-  conformable(GaugeRedBlackGrid(),mat._grid);
   conformable(A._grid,B._grid);
 
   assert(B.checkerboard==Even);

lib/qcd/action/gauge/Gauge.h

@@ -29,7 +29,7 @@ directory
 #ifndef GRID_QCD_GAUGE_H
 #define GRID_QCD_GAUGE_H
 
-#include <Grid/qcd/action/gauge/GaugeImpl.h>
+#include <Grid/qcd/action/gauge/GaugeImplementations.h>
 #include <Grid/qcd/utils/WilsonLoops.h>
 #include <Grid/qcd/action/gauge/WilsonGaugeAction.h>
 #include <Grid/qcd/action/gauge/PlaqPlusRectangleAction.h>

lib/qcd/action/gauge/GaugeImplTypes.h

@@ -0,0 +1,142 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/gauge/GaugeImpl.h
+
+Copyright (C) 2015
+
+Author: paboyle <paboyle@ph.ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_GAUGE_IMPL_TYPES_H
+#define GRID_GAUGE_IMPL_TYPES_H
+
+namespace Grid {
+namespace QCD {
+
+////////////////////////////////////////////////////////////////////////
+// Implementation dependent gauge types
+////////////////////////////////////////////////////////////////////////
+
+#define INHERIT_GIMPL_TYPES(GImpl)                  \
+  typedef typename GImpl::Simd Simd;                \
+  typedef typename GImpl::LinkField GaugeLinkField; \
+  typedef typename GImpl::Field GaugeField;         \
+  typedef typename GImpl::SiteField SiteGaugeField; \
+  typedef typename GImpl::SiteLink SiteGaugeLink;
+
+#define INHERIT_FIELD_TYPES(Impl)             \
+  typedef typename Impl::Simd Simd;           \
+  typedef typename Impl::SiteField SiteField; \
+  typedef typename Impl::Field Field;
+
+// hardcodes the exponential approximation in the template
+template <class S, int Nrepresentation = Nc, int Nexp = 12 > class GaugeImplTypes {
+public:
+  typedef S Simd;
+
+  template <typename vtype> using iImplGaugeLink  = iScalar<iScalar<iMatrix<vtype, Nrepresentation>>>;
+  template <typename vtype> using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation>>, Nd>;
+
+  typedef iImplGaugeLink<Simd>  SiteLink;
+  typedef iImplGaugeField<Simd> SiteField;
+
+  typedef Lattice<SiteLink>  LinkField; 
+  typedef Lattice<SiteField> Field;
+
+  // Guido: we can probably separate the types from the HMC functions
+  // this will create 2 kind of implementations
+  // probably confusing the users
+  // Now keeping only one class
+
+
+  // Move this elsewhere? FIXME
+  static inline void AddLink(Field &U, LinkField &W,
+                                  int mu) { // U[mu] += W
+    PARALLEL_FOR_LOOP
+    for (auto ss = 0; ss < U._grid->oSites(); ss++) {
+      U._odata[ss]._internal[mu] =
+          U._odata[ss]._internal[mu] + W._odata[ss]._internal;
+    }
+  }
+
+  ///////////////////////////////////////////////////////////
+  // Move these to another class
+  // HMC auxiliary functions 
+  static inline void generate_momenta(Field &P, GridParallelRNG &pRNG) {
+    // specific for SU gauge fields
+    LinkField Pmu(P._grid);
+    Pmu = zero;
+    for (int mu = 0; mu < Nd; mu++) {
+      SU<Nrepresentation>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
+      PokeIndex<LorentzIndex>(P, Pmu, mu);
+    }
+  }
+
+  static inline Field projectForce(Field &P) { return Ta(P); }
+  
+  static inline void update_field(Field& P, Field& U, double ep){
+    for (int mu = 0; mu < Nd; mu++) {
+      auto Umu = PeekIndex<LorentzIndex>(U, mu);
+      auto Pmu = PeekIndex<LorentzIndex>(P, mu);
+      Umu = expMat(Pmu, ep, Nexp) * Umu;
+      PokeIndex<LorentzIndex>(U, ProjectOnGroup(Umu), mu);
+    }
+  }
+
+  static inline RealD FieldSquareNorm(Field& U){
+    LatticeComplex Hloc(U._grid);
+    Hloc = zero;
+    for (int mu = 0; mu < Nd; mu++) {
+      auto Umu = PeekIndex<LorentzIndex>(U, mu);
+      Hloc += trace(Umu * Umu);
+    }
+    Complex Hsum = sum(Hloc);
+    return Hsum.real();
+  }
+
+  static inline void HotConfiguration(GridParallelRNG &pRNG, Field &U) {
+    SU<Nc>::HotConfiguration(pRNG, U);
+  }
+
+  static inline void TepidConfiguration(GridParallelRNG &pRNG, Field &U) {
+    SU<Nc>::TepidConfiguration(pRNG, U);
+  }
+
+  static inline void ColdConfiguration(GridParallelRNG &pRNG, Field &U) {
+    SU<Nc>::ColdConfiguration(pRNG, U);
+  }
+};
+
+
+typedef GaugeImplTypes<vComplex, Nc> GimplTypesR;
+typedef GaugeImplTypes<vComplexF, Nc> GimplTypesF;
+typedef GaugeImplTypes<vComplexD, Nc> GimplTypesD;
+
+typedef GaugeImplTypes<vComplex, SU<Nc>::AdjointDimension> GimplAdjointTypesR;
+typedef GaugeImplTypes<vComplexF, SU<Nc>::AdjointDimension> GimplAdjointTypesF;
+typedef GaugeImplTypes<vComplexD, SU<Nc>::AdjointDimension> GimplAdjointTypesD;
+
+
+} // QCD
+} // Grid
+
+#endif // GRID_GAUGE_IMPL_TYPES_H

lib/qcd/action/gauge/GaugeImplementations.h

@@ -2,7 +2,7 @@
 
 Grid physics library, www.github.com/paboyle/Grid
 
-Source file: ./lib/qcd/action/gauge/GaugeImpl.h
+Source file: ./lib/qcd/action/gauge/GaugeImplementations.h
 
 Copyright (C) 2015
 
@@ -26,53 +26,14 @@ See the full license in the file "LICENSE" in the top level distribution
 directory
 *************************************************************************************/
 /*  END LEGAL */
-#ifndef GRID_QCD_GAUGE_IMPL_H
+#ifndef GRID_QCD_GAUGE_IMPLEMENTATIONS_H
-#define GRID_QCD_GAUGE_IMPL_H
+#define GRID_QCD_GAUGE_IMPLEMENTATIONS_H
+
+#include "GaugeImplTypes.h"
 
 namespace Grid {
 namespace QCD {
 
-////////////////////////////////////////////////////////////////////////
-// Implementation dependent gauge types
-////////////////////////////////////////////////////////////////////////
-
-template <class Gimpl> class WilsonLoops;
-
-#define INHERIT_GIMPL_TYPES(GImpl)                                             \
-  typedef typename GImpl::Simd Simd;                                           \
-  typedef typename GImpl::GaugeLinkField GaugeLinkField;                       \
-  typedef typename GImpl::GaugeField GaugeField;                               \
-  typedef typename GImpl::SiteGaugeField SiteGaugeField;                       \
-  typedef typename GImpl::SiteGaugeLink SiteGaugeLink;
-
-//
-template <class S, int Nrepresentation = Nc> class GaugeImplTypes {
-public:
-  typedef S Simd;
-
-  template <typename vtype>
-  using iImplGaugeLink  = iScalar<iScalar<iMatrix<vtype, Nrepresentation>>>;
-  template <typename vtype>
-  using iImplGaugeField = iVector<iScalar<iMatrix<vtype, Nrepresentation>>, Nd>;
-
-  typedef iImplGaugeLink<Simd> SiteGaugeLink;
-  typedef iImplGaugeField<Simd> SiteGaugeField;
-
-  typedef Lattice<SiteGaugeLink> GaugeLinkField; // bit ugly naming; polarised
-                                                 // gauge field, lorentz... all
-                                                 // ugly
-  typedef Lattice<SiteGaugeField> GaugeField;
-
-  // Move this elsewhere? FIXME
-  static inline void AddGaugeLink(GaugeField &U, GaugeLinkField &W,
-                                  int mu) { // U[mu] += W
-    parallel_for (auto ss = 0; ss < U._grid->oSites(); ss++) {
-      U._odata[ss]._internal[mu] =
-          U._odata[ss]._internal[mu] + W._odata[ss]._internal;
-    }
-  }
-};
-
 // Composition with smeared link, bc's etc.. probably need multiple inheritance
 // Variable precision "S" and variable Nc
 template <class GimplTypes> class PeriodicGaugeImpl : public GimplTypes {
@@ -168,14 +129,6 @@ public:
   static inline bool isPeriodicGaugeField(void) { return false; }
 };
 
-typedef GaugeImplTypes<vComplex, Nc> GimplTypesR;
-typedef GaugeImplTypes<vComplexF, Nc> GimplTypesF;
-typedef GaugeImplTypes<vComplexD, Nc> GimplTypesD;
-
-typedef GaugeImplTypes<vComplex, SU<Nc>::AdjointDimension> GimplAdjointTypesR;
-typedef GaugeImplTypes<vComplexF, SU<Nc>::AdjointDimension> GimplAdjointTypesF;
-typedef GaugeImplTypes<vComplexD, SU<Nc>::AdjointDimension> GimplAdjointTypesD;
-
 typedef PeriodicGaugeImpl<GimplTypesR> PeriodicGimplR; // Real.. whichever prec
 typedef PeriodicGaugeImpl<GimplTypesF> PeriodicGimplF; // Float
 typedef PeriodicGaugeImpl<GimplTypesD> PeriodicGimplD; // Double
@@ -187,6 +140,8 @@ typedef PeriodicGaugeImpl<GimplAdjointTypesD> PeriodicGimplAdjD; // Double
 typedef ConjugateGaugeImpl<GimplTypesR> ConjugateGimplR; // Real.. whichever prec
 typedef ConjugateGaugeImpl<GimplTypesF> ConjugateGimplF; // Float
 typedef ConjugateGaugeImpl<GimplTypesD> ConjugateGimplD; // Double
+
+
 }
 }
 

lib/qcd/action/gauge/PlaqPlusRectangleAction.h

@@ -48,8 +48,18 @@ namespace Grid{
     public:
     PlaqPlusRectangleAction(RealD b,RealD c): c_plaq(b),c_rect(c){};
 
+      virtual std::string action_name(){return "PlaqPlusRectangleAction";}
+      
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {}; // noop as no pseudoferms
       
+      virtual std::string LogParameters(){
+      	std::stringstream sstream;
+      	sstream << GridLogMessage << "["<<action_name() <<"] c_plaq: " << c_plaq << std::endl;
+      	sstream << GridLogMessage << "["<<action_name() <<"] c_rect: " << c_rect << std::endl;
+      	return sstream.str();
+      }
+
+
       virtual RealD S(const GaugeField &U) {
 	RealD vol = U._grid->gSites();
 
@@ -108,32 +118,32 @@ namespace Grid{
     class RBCGaugeAction : public PlaqPlusRectangleAction<Gimpl> {
     public:
       INHERIT_GIMPL_TYPES(Gimpl);
-      RBCGaugeAction(RealD beta,RealD c1) : PlaqPlusRectangleAction<Gimpl>(beta*(1.0-8.0*c1), beta*c1) {
+      RBCGaugeAction(RealD beta,RealD c1) : PlaqPlusRectangleAction<Gimpl>(beta*(1.0-8.0*c1), beta*c1) {};
-      };
+      virtual std::string action_name(){return "RBCGaugeAction";}
     };
 
     template<class Gimpl>
     class IwasakiGaugeAction : public RBCGaugeAction<Gimpl> {
     public:
       INHERIT_GIMPL_TYPES(Gimpl);
-      IwasakiGaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-0.331) {
+      IwasakiGaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-0.331) {};
-      };
+      virtual std::string action_name(){return "IwasakiGaugeAction";}
     };
 
     template<class Gimpl>
     class SymanzikGaugeAction : public RBCGaugeAction<Gimpl> {
     public:
       INHERIT_GIMPL_TYPES(Gimpl);
-      SymanzikGaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-1.0/12.0) {
+      SymanzikGaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-1.0/12.0) {};
-      };
+      virtual std::string action_name(){return "SymanzikGaugeAction";}
     };
 
     template<class Gimpl>
     class DBW2GaugeAction : public RBCGaugeAction<Gimpl> {
     public:
       INHERIT_GIMPL_TYPES(Gimpl);
-      DBW2GaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-1.4067) {
+      DBW2GaugeAction(RealD beta) : RBCGaugeAction<Gimpl>(beta,-1.4067) {};
-      };
+      virtual std::string action_name(){return "DBW2GaugeAction";}
     };
 
   }

lib/qcd/action/gauge/WilsonGaugeAction.h

@@ -1,86 +1,95 @@
-    /*************************************************************************************
+/*************************************************************************************
 
-    Grid physics library, www.github.com/paboyle/Grid 
+Grid physics library, www.github.com/paboyle/Grid
 
-    Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
 
-    Copyright (C) 2015
+Copyright (C) 2015
 
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: neo <cossu@post.kek.jp>
 Author: paboyle <paboyle@ph.ed.ac.uk>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
-    This program is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
+it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+(at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
+with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-    See the full license in the file "LICENSE" in the top level distribution directory
+See the full license in the file "LICENSE" in the top level distribution
-    *************************************************************************************/
+directory
-    /*  END LEGAL */
+*************************************************************************************/
+/*  END LEGAL */
 #ifndef QCD_WILSON_GAUGE_ACTION_H
 #define QCD_WILSON_GAUGE_ACTION_H
 
-namespace Grid{
+namespace Grid {
-  namespace QCD{
+namespace QCD {
 
-    ////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
-    // Wilson Gauge Action .. should I template the Nc etc..
+// Wilson Gauge Action .. should I template the Nc etc..
-    ////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////
-    template<class Gimpl>
+template <class Gimpl>
-    class WilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
+class WilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
  public:  
-
   INHERIT_GIMPL_TYPES(Gimpl);
 
-      //      typedef LorentzScalar<GaugeField> GaugeLinkField;
+  /////////////////////////// constructors
+  explicit WilsonGaugeAction(RealD beta_):beta(beta_){};
 
-    private:
+  virtual std::string action_name() {return "WilsonGaugeAction";}
-      RealD beta;
-    public:
-    WilsonGaugeAction(RealD b):beta(b){};
 
-      virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {}; // noop as no pseudoferms
+  virtual std::string LogParameters(){
+    std::stringstream sstream;
+    sstream << GridLogMessage << "[WilsonGaugeAction] Beta: " << beta << std::endl;
+    return sstream.str();
+  }
+
+  virtual void refresh(const GaugeField &U,
+                       GridParallelRNG &pRNG){};  // noop as no pseudoferms
 
   virtual RealD S(const GaugeField &U) {
     RealD plaq = WilsonLoops<Gimpl>::avgPlaquette(U);
     RealD vol = U._grid->gSites();
-	RealD action=beta*(1.0 -plaq)*(Nd*(Nd-1.0))*vol*0.5;
+    RealD action = beta * (1.0 - plaq) * (Nd * (Nd - 1.0)) * vol * 0.5;
     return action;
   };
 
-      virtual void deriv(const GaugeField &U,GaugeField & dSdU) {
+  virtual void deriv(const GaugeField &U, GaugeField &dSdU) {
-	//not optimal implementation FIXME
+    // not optimal implementation FIXME
-	//extend Ta to include Lorentz indexes
+    // extend Ta to include Lorentz indexes
 
-	//RealD factor = 0.5*beta/RealD(Nc);
+    RealD factor = 0.5 * beta / RealD(Nc);
-	RealD factor = 0.5*beta/RealD(Nc);
 
     GaugeLinkField Umu(U._grid);
     GaugeLinkField dSdU_mu(U._grid);
-	for (int mu=0; mu < Nd; mu++){
+    for (int mu = 0; mu < Nd; mu++) {
-
+      Umu = PeekIndex<LorentzIndex>(U, mu);
-	  Umu = PeekIndex<LorentzIndex>(U,mu);
 
       // Staple in direction mu
-	  WilsonLoops<Gimpl>::Staple(dSdU_mu,U,mu);
+      WilsonLoops<Gimpl>::Staple(dSdU_mu, U, mu);
-	  dSdU_mu = Ta(Umu*dSdU_mu)*factor;
+      dSdU_mu = Ta(Umu * dSdU_mu) * factor;
+
       PokeIndex<LorentzIndex>(dSdU, dSdU_mu, mu);
     }
-      };
-    };
-    
   }
+private:
+  RealD beta;  
+};
+
+
+
+}
 }
 
 #endif

lib/qcd/action/pseudofermion/EvenOddSchurDifferentiable.h

@@ -7,6 +7,7 @@
     Copyright (C) 2015
 
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -53,10 +54,6 @@ namespace Grid{
         
           GridBase *fgrid   = this->_Mat.FermionGrid();
           GridBase *fcbgrid = this->_Mat.FermionRedBlackGrid();
-	  GridBase *ugrid   = this->_Mat.GaugeGrid();
-	  GridBase *ucbgrid = this->_Mat.GaugeRedBlackGrid();
-
-	  Real coeff = 1.0;
 
           FermionField tmp1(fcbgrid);
           FermionField tmp2(fcbgrid);
@@ -68,15 +65,20 @@ namespace Grid{
           assert(U.checkerboard==Odd);
           assert(V.checkerboard==U.checkerboard);
 
-	  GaugeField ForceO(ucbgrid);
+          // NOTE Guido: WE DO NOT WANT TO USE THE ucbgrid GRID FOR THE FORCE
-	  GaugeField ForceE(ucbgrid);
+          // it is not conformable with the HMC force field
+	  // Case: Ls vectorised fields
+          // INHERIT FROM THE Force field instead
+          GridRedBlackCartesian* forcecb = new GridRedBlackCartesian(Force._grid);
+          GaugeField ForceO(forcecb);
+          GaugeField ForceE(forcecb);
+
 
           //  X^dag Der_oe MeeInv Meo Y
           // Use Mooee as nontrivial but gauge field indept
           this->_Mat.Meooe   (V,tmp1);      // odd->even -- implicit -0.5 factor to be applied
 	  this->_Mat.MooeeInv(tmp1,tmp2);   // even->even 
           this->_Mat.MoeDeriv(ForceO,U,tmp2,DaggerNo);
-	  
           //  Accumulate X^dag M_oe MeeInv Der_eo Y
           this->_Mat.MeooeDag   (U,tmp1);    // even->odd -- implicit -0.5 factor to be applied
           this->_Mat.MooeeInvDag(tmp1,tmp2); // even->even 
@@ -88,6 +90,8 @@ namespace Grid{
           setCheckerboard(Force,ForceE); 
           setCheckerboard(Force,ForceO);
           Force=-Force;
+
+          delete forcecb;
         }
 
 
@@ -95,10 +99,6 @@ namespace Grid{
         
           GridBase *fgrid   = this->_Mat.FermionGrid();
           GridBase *fcbgrid = this->_Mat.FermionRedBlackGrid();
-	  GridBase *ugrid   = this->_Mat.GaugeGrid();
-	  GridBase *ucbgrid = this->_Mat.GaugeRedBlackGrid();
-
-	  Real coeff = 1.0;
 
           FermionField tmp1(fcbgrid);
           FermionField tmp2(fcbgrid);
@@ -110,8 +110,12 @@ namespace Grid{
           assert(V.checkerboard==Odd);
           assert(V.checkerboard==V.checkerboard);
 
-	  GaugeField ForceO(ucbgrid);
+          // NOTE Guido: WE DO NOT WANT TO USE THE ucbgrid GRID FOR THE FORCE
-	  GaugeField ForceE(ucbgrid);
+          // it is not conformable with the HMC force field
+          // INHERIT FROM THE Force field instead
+	  GridRedBlackCartesian* forcecb = new GridRedBlackCartesian(Force._grid);
+          GaugeField ForceO(forcecb);
+          GaugeField ForceE(forcecb);
 
           //  X^dag Der_oe MeeInv Meo Y
           // Use Mooee as nontrivial but gauge field indept
@@ -130,6 +134,8 @@ namespace Grid{
           setCheckerboard(Force,ForceE); 
           setCheckerboard(Force,ForceO);
           Force=-Force;
+
+          delete forcecb;
         }
 
     };

lib/qcd/action/pseudofermion/OneFlavourEvenOddRational.h

@@ -1,3 +1,4 @@
+
 /*************************************************************************************
 
 Grid physics library, www.github.com/paboyle/Grid
@@ -90,6 +91,19 @@ class OneFlavourEvenOddRationalPseudoFermionAction
     PowerNegQuarter.Init(remez, param.tolerance, true);
   };
 
+  virtual std::string action_name(){return "OneFlavourEvenOddRationalPseudoFermionAction";}
+
+  virtual std::string LogParameters(){
+    std::stringstream sstream;
+    sstream << GridLogMessage << "["<<action_name()<<"] Low            :" << param.lo <<  std::endl;
+    sstream << GridLogMessage << "["<<action_name()<<"] High           :" << param.hi <<  std::endl;
+    sstream << GridLogMessage << "["<<action_name()<<"] Max iterations :" << param.MaxIter <<  std::endl;
+    sstream << GridLogMessage << "["<<action_name()<<"] Tolerance      :" << param.tolerance <<  std::endl;
+    sstream << GridLogMessage << "["<<action_name()<<"] Degree         :" << param.degree <<  std::endl;
+    sstream << GridLogMessage << "["<<action_name()<<"] Precision      :" << param.precision <<  std::endl;
+    return sstream.str();
+  }
+  
   virtual void refresh(const GaugeField &U, GridParallelRNG &pRNG) {
     // P(phi) = e^{- phi^dag (MpcdagMpc)^-1/2 phi}
     //        = e^{- phi^dag (MpcdagMpc)^-1/4 (MpcdagMpc)^-1/4 phi}

lib/qcd/action/pseudofermion/OneFlavourEvenOddRationalRatio.h

@@ -88,6 +88,20 @@ namespace Grid{
 	PowerNegQuarter.Init(remez,param.tolerance,true);
       };
 
+      virtual std::string action_name(){return "OneFlavourEvenOddRatioRationalPseudoFermionAction";}
+
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] Low            :" << param.lo <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] High           :" << param.hi <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Max iterations :" << param.MaxIter <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Tolerance      :" << param.tolerance <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Degree         :" << param.degree <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Precision      :" << param.precision <<  std::endl;
+	return sstream.str();
+      }
+      
+      
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {
 
 	// S_f = chi^dag* P(V^dag*V)/Q(V^dag*V)* N(M^dag*M)/D(M^dag*M)* P(V^dag*V)/Q(V^dag*V)* chi       

lib/qcd/action/pseudofermion/OneFlavourRational.h

@@ -84,8 +84,24 @@ namespace Grid{
 	PowerNegQuarter.Init(remez,param.tolerance,true);
       };
 
+      virtual std::string action_name(){return "OneFlavourRationalPseudoFermionAction";}
+
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] Low            :" << param.lo <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] High           :" << param.hi <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Max iterations :" << param.MaxIter <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Tolerance      :" << param.tolerance <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Degree         :" << param.degree <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Precision      :" << param.precision <<  std::endl;
+	return sstream.str();
+      }  
+
+
+      
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {
 
+	
 	// P(phi) = e^{- phi^dag (MdagM)^-1/2 phi}
 	//        = e^{- phi^dag (MdagM)^-1/4 (MdagM)^-1/4 phi}
 	// Phi = Mdag^{1/4} eta 

lib/qcd/action/pseudofermion/OneFlavourRationalRatio.h

@@ -82,6 +82,20 @@ namespace Grid{
 	PowerNegQuarter.Init(remez,param.tolerance,true);
       };
 
+      virtual std::string action_name(){return "OneFlavourRatioRationalPseudoFermionAction";}
+      
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] Low            :" << param.lo <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] High           :" << param.hi <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Max iterations :" << param.MaxIter <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Tolerance      :" << param.tolerance <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Degree         :" << param.degree <<  std::endl;
+	sstream << GridLogMessage << "["<<action_name()<<"] Precision      :" << param.precision <<  std::endl;
+	return sstream.str();
+      }
+      
+
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {
 
 	// S_f = chi^dag* P(V^dag*V)/Q(V^dag*V)* N(M^dag*M)/D(M^dag*M)* P(V^dag*V)/Q(V^dag*V)* chi       

lib/qcd/action/pseudofermion/TwoFlavour.h

@@ -62,6 +62,15 @@ class TwoFlavourPseudoFermionAction : public Action<typename Impl::GaugeField> {
         ActionSolver(AS),
         Phi(Op.FermionGrid()){};
 
+
+  virtual std::string action_name(){return "TwoFlavourPseudoFermionAction";}
+
+  virtual std::string LogParameters(){
+    std::stringstream sstream;
+    sstream << GridLogMessage << "["<<action_name()<<"] has no parameters" << std::endl;
+    return sstream.str();
+  }  
+  
   //////////////////////////////////////////////////////////////////////////////////////
   // Push the gauge field in to the dops. Assume any BC's and smearing already applied
   //////////////////////////////////////////////////////////////////////////////////////
@@ -80,7 +89,9 @@ class TwoFlavourPseudoFermionAction : public Action<typename Impl::GaugeField> {
     //         in the Phi integral, and thus is only an irrelevant prefactor for
     //         the partition function.
     //
+
     RealD scale = std::sqrt(0.5);
+
     FermionField eta(FermOp.FermionGrid());
 
     gaussian(pRNG, eta);

lib/qcd/action/pseudofermion/TwoFlavourEvenOdd.h

@@ -31,13 +31,13 @@ directory
 #define QCD_PSEUDOFERMION_TWO_FLAVOUR_EVEN_ODD_H
 
 namespace Grid {
-namespace QCD {
+  namespace QCD {
 
-////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////
-// Two flavour pseudofermion action for any EO prec dop
+    // Two flavour pseudofermion action for any EO prec dop
-////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////
-template <class Impl>
+    template <class Impl>
-class TwoFlavourEvenOddPseudoFermionAction
+    class TwoFlavourEvenOddPseudoFermionAction
       : public Action<typename Impl::GaugeField> {
     public:
       INHERIT_IMPL_TYPES(Impl);
@@ -65,6 +65,15 @@ class TwoFlavourEvenOddPseudoFermionAction
 	  PhiOdd(Op.FermionRedBlackGrid())
       {};
   
+      virtual std::string action_name(){return "TwoFlavourEvenOddPseudoFermionAction";}
+      
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] has no parameters" << std::endl;
+	return sstream.str();
+      }  
+
+
       //////////////////////////////////////////////////////////////////////////////////////
       // Push the gauge field in to the dops. Assume any BC's and smearing already applied
       //////////////////////////////////////////////////////////////////////////////////////
@@ -135,7 +144,6 @@ class TwoFlavourEvenOddPseudoFermionAction
       //
       //////////////////////////////////////////////////////
       virtual void deriv(const GaugeField &U,GaugeField & dSdU) {
-
 	FermOp.ImportGauge(U);
 
 	FermionField X(FermOp.FermionRedBlackGrid());

lib/qcd/action/pseudofermion/TwoFlavourEvenOddRatio.h

@@ -68,6 +68,15 @@ namespace Grid{
           conformable(_NumOp.GaugeRedBlackGrid(), _DenOp.GaugeRedBlackGrid());
         };
 
+      virtual std::string action_name(){return "TwoFlavourEvenOddRatioPseudoFermionAction";}
+
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] has no parameters" << std::endl;
+	return sstream.str();
+      } 
+
+      
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {
 
         // P(phi) = e^{- phi^dag Vpc (MpcdagMpc)^-1 Vpcdag phi}
@@ -164,7 +173,8 @@ namespace Grid{
         FermionField  X(NumOp.FermionRedBlackGrid());
         FermionField  Y(NumOp.FermionRedBlackGrid());
 
-	GaugeField   force(NumOp.GaugeGrid());	
+        // This assignment is necessary to be compliant with the HMC grids
+	GaugeField force(dSdU._grid);
 
         //Y=Vdag phi
         //X = (Mdag M)^-1 V^dag phi
@@ -175,22 +185,21 @@ namespace Grid{
         Mpc.Mpc(X,Y);                  // Y=  Mdag^-1 Vdag phi
 
         // phi^dag V (Mdag M)^-1 dV^dag  phi
-	Vpc.MpcDagDeriv(force , X, PhiOdd );  dSdU=force;
+        Vpc.MpcDagDeriv(force , X, PhiOdd );   dSdU = force;
   
         // phi^dag dV (Mdag M)^-1 V^dag  phi
-	Vpc.MpcDeriv(force , PhiOdd, X );  dSdU=dSdU+force;
+        Vpc.MpcDeriv(force , PhiOdd, X );      dSdU = dSdU+force;
 
         //    -    phi^dag V (Mdag M)^-1 Mdag dM   (Mdag M)^-1 V^dag  phi
         //    -    phi^dag V (Mdag M)^-1 dMdag M   (Mdag M)^-1 V^dag  phi
-	Mpc.MpcDeriv(force,Y,X);   dSdU=dSdU-force;
+        Mpc.MpcDeriv(force,Y,X);              dSdU = dSdU-force;
-	Mpc.MpcDagDeriv(force,X,Y);  dSdU=dSdU-force;
+        Mpc.MpcDagDeriv(force,X,Y);           dSdU = dSdU-force;
 
         // FIXME No force contribution from EvenEven assumed here
         // Needs a fix for clover.
         assert(NumOp.ConstEE() == 1);
         assert(DenOp.ConstEE() == 1);
 
-	//dSdU = -Ta(dSdU);
         dSdU = -dSdU;
         
       };

lib/qcd/action/pseudofermion/TwoFlavourRatio.h

@@ -57,6 +57,14 @@ namespace Grid{
 					 OperatorFunction<FermionField> & AS
 					 ) : NumOp(_NumOp), DenOp(_DenOp), DerivativeSolver(DS), ActionSolver(AS), Phi(_NumOp.FermionGrid()) {};
       
+      virtual std::string action_name(){return "TwoFlavourRatioPseudoFermionAction";}
+
+      virtual std::string LogParameters(){
+	std::stringstream sstream;
+	sstream << GridLogMessage << "["<<action_name()<<"] has no parameters" << std::endl;
+	return sstream.str();
+      }  
+      
       virtual void refresh(const GaugeField &U, GridParallelRNG& pRNG) {
 
 	// P(phi) = e^{- phi^dag V (MdagM)^-1 Vdag phi}

lib/qcd/action/scalar/Scalar.h

@@ -0,0 +1,45 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/gauge/Scalar.h
+
+Copyright (C) 2017
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_QCD_SCALAR_H
+#define GRID_QCD_SCALAR_H
+
+#include <Grid/qcd/action/scalar/ScalarImpl.h>
+#include <Grid/qcd/action/scalar/ScalarAction.h>
+
+namespace Grid {
+namespace QCD {
+
+  typedef ScalarAction<ScalarImplR>                 ScalarActionR;
+  typedef ScalarAction<ScalarImplF>                 ScalarActionF;
+  typedef ScalarAction<ScalarImplD>                 ScalarActionD;
+
+}
+}
+
+#endif  // GRID_QCD_SCALAR_H

lib/qcd/action/scalar/ScalarAction.h

@@ -0,0 +1,84 @@
+/*************************************************************************************
+
+  Grid physics library, www.github.com/paboyle/Grid
+
+  Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+
+  Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: neo <cossu@post.kek.jp>
+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 SCALAR_ACTION_H
+#define SCALAR_ACTION_H
+
+namespace Grid {
+  // FIXME drop the QCD namespace everywhere here
+  
+  template <class Impl>
+  class ScalarAction : public QCD::Action<typename Impl::Field> {
+  public:
+    INHERIT_FIELD_TYPES(Impl);
+    
+  private:
+    RealD mass_square;
+    RealD lambda;
+    
+  public:
+    ScalarAction(RealD ms, RealD l) : mass_square(ms), lambda(l){};
+
+    virtual std::string LogParameters(){
+      std::stringstream sstream;
+      sstream << GridLogMessage << "[ScalarAction] lambda      : " << lambda      << std::endl;
+      sstream << GridLogMessage << "[ScalarAction] mass_square : " << mass_square << std::endl;
+      return sstream.str();
+      
+    }
+    
+    virtual std::string action_name(){return "ScalarAction";}
+    
+    virtual void refresh(const Field &U,
+			 GridParallelRNG &pRNG){};  // noop as no pseudoferms
+    
+    virtual RealD S(const Field &p) {
+      return (mass_square * 0.5 + QCD::Nd) * ScalarObs<Impl>::sumphisquared(p) +
+	(lambda / 24.) * ScalarObs<Impl>::sumphifourth(p) +
+	ScalarObs<Impl>::sumphider(p);
+    };
+    
+    virtual void deriv(const Field &p,
+		       Field &force) {
+      Field tmp(p._grid);
+      Field p2(p._grid);
+      ScalarObs<Impl>::phisquared(p2, p);
+      tmp = -(Cshift(p, 0, -1) + Cshift(p, 0, 1));
+      for (int mu = 1; mu < QCD::Nd; mu++) tmp -= Cshift(p, mu, -1) + Cshift(p, mu, 1);
+      
+      force=+(mass_square + 2. * QCD::Nd) * p + (lambda / 6.) * p2 * p + tmp;
+    };
+  };
+  
+} // Grid
+
+#endif // SCALAR_ACTION_H

lib/qcd/action/scalar/ScalarImpl.h

@@ -0,0 +1,100 @@
+#ifndef SCALAR_IMPL
+#define SCALAR_IMPL
+
+
+namespace Grid {
+  //namespace QCD {
+
+  template <class S>
+  class ScalarImplTypes {
+  public:
+    typedef S Simd;
+    
+    template <typename vtype>
+    using iImplField = iScalar<iScalar<iScalar<vtype> > >;
+    
+    typedef iImplField<Simd> SiteField;
+    
+    
+    typedef Lattice<SiteField> Field;
+    
+    static inline void generate_momenta(Field& P, GridParallelRNG& pRNG){
+      gaussian(pRNG, P);
+    }
+    
+    static inline Field projectForce(Field& P){return P;}
+    
+    static inline void update_field(Field& P, Field& U, double ep){
+      U += P*ep;
+    }
+    
+    static inline RealD FieldSquareNorm(Field& U){
+      return (- sum(trace(U*U))/2.0);
+    }
+    
+    static inline void HotConfiguration(GridParallelRNG &pRNG, Field &U) {
+      gaussian(pRNG, U);
+    }
+    
+    static inline void TepidConfiguration(GridParallelRNG &pRNG, Field &U) {
+      gaussian(pRNG, U);
+    }
+    
+    static inline void ColdConfiguration(GridParallelRNG &pRNG, Field &U) {
+      U = 1.0;
+    }
+    
+  };
+
+  template <class S, unsigned int N>
+  class ScalarMatrixImplTypes {
+  public:
+    typedef S Simd;
+    
+    template <typename vtype>
+    using iImplField = iScalar<iScalar<iMatrix<vtype, N> > >;
+    
+    typedef iImplField<Simd> SiteField;
+    
+    
+    typedef Lattice<SiteField> Field;
+    
+    static inline void generate_momenta(Field& P, GridParallelRNG& pRNG){
+      gaussian(pRNG, P);
+    }
+    
+    static inline Field projectForce(Field& P){return P;}
+    
+    static inline void update_field(Field& P, Field& U, double ep){
+      U += P*ep;
+    }
+    
+    static inline RealD FieldSquareNorm(Field& U){
+      return (TensorRemove(- sum(trace(U*U))*0.5).real());
+    }
+    
+    static inline void HotConfiguration(GridParallelRNG &pRNG, Field &U) {
+      gaussian(pRNG, U);
+    }
+    
+    static inline void TepidConfiguration(GridParallelRNG &pRNG, Field &U) {
+      gaussian(pRNG, U);
+    }
+    
+    static inline void ColdConfiguration(GridParallelRNG &pRNG, Field &U) {
+      U = 1.0;
+    }
+    
+  };
+
+
+  
+  
+  typedef ScalarImplTypes<vReal> ScalarImplR;
+  typedef ScalarImplTypes<vRealF> ScalarImplF;
+  typedef ScalarImplTypes<vRealD> ScalarImplD;
+  
+  //} 
+} 
+
+#endif

lib/qcd/action/scalar/ScalarInteractionAction.h

@@ -0,0 +1,84 @@
+/*************************************************************************************
+
+  Grid physics library, www.github.com/paboyle/Grid
+
+  Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+
+  Copyright (C) 2015
+
+Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
+Author: Peter Boyle <paboyle@ph.ed.ac.uk>
+Author: neo <cossu@post.kek.jp>
+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 SCALAR_ACTION_H
+#define SCALAR_ACTION_H
+
+namespace Grid {
+  // FIXME drop the QCD namespace everywhere here
+  
+  template <class Impl>
+  class ScalarInteractionAction : public QCD::Action<typename Impl::Field> {
+  public:
+    INHERIT_FIELD_TYPES(Impl);
+    
+  private:
+    RealD mass_square;
+    RealD lambda;
+    
+  public:
+    ScalarAction(RealD ms, RealD l) : mass_square(ms), lambda(l){};
+
+    virtual std::string LogParameters(){
+      std::stringstream sstream;
+      sstream << GridLogMessage << "[ScalarAction] lambda      : " << lambda      << std::endl;
+      sstream << GridLogMessage << "[ScalarAction] mass_square : " << mass_square << std::endl;
+      return sstream.str();
+      
+    }
+    
+    virtual std::string action_name(){return "ScalarAction";}
+    
+    virtual void refresh(const Field &U,
+			 GridParallelRNG &pRNG){};  // noop as no pseudoferms
+    
+    virtual RealD S(const Field &p) {
+      return (mass_square * 0.5 + QCD::Nd) * ScalarObs<Impl>::sumphisquared(p) +
+	(lambda / 24.) * ScalarObs<Impl>::sumphifourth(p) +
+	ScalarObs<Impl>::sumphider(p);
+    };
+    
+    virtual void deriv(const Field &p,
+		       Field &force) {
+      Field tmp(p._grid);
+      Field p2(p._grid);
+      ScalarObs<Impl>::phisquared(p2, p);
+      tmp = -(Cshift(p, 0, -1) + Cshift(p, 0, 1));
+      for (int mu = 1; mu < QCD::Nd; mu++) tmp -= Cshift(p, mu, -1) + Cshift(p, mu, 1);
+      
+      force=+(mass_square + 2. * QCD::Nd) * p + (lambda / 6.) * p2 * p + tmp;
+    };
+  };
+  
+} // Grid
+
+#endif // SCALAR_ACTION_H

lib/qcd/hmc/GenericHMCrunner.h

@@ -0,0 +1,213 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/GenericHmcRunner.h
+
+Copyright (C) 2015
+
+Author: paboyle <paboyle@ph.ed.ac.uk>
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+  See the full license in the file "LICENSE" in the top level distribution
+  directory
+  *************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_GENERIC_HMC_RUNNER
+#define GRID_GENERIC_HMC_RUNNER
+
+#include <unordered_map>
+
+namespace Grid {
+namespace QCD {
+
+
+// very ugly here but possibly resolved if we had a base Reader class
+template < class ReaderClass >
+class HMCRunnerBase {
+public:
+  virtual void Run() = 0;
+  virtual void initialize(ReaderClass& ) = 0;
+};
+
+
+template <class Implementation,
+          template <typename, typename, typename> class Integrator,
+          class RepresentationsPolicy = NoHirep, class ReaderClass = XmlReader>
+class HMCWrapperTemplate: public HMCRunnerBase<ReaderClass> {
+ public:
+  INHERIT_FIELD_TYPES(Implementation);
+  typedef Implementation ImplPolicy;  // visible from outside
+  template <typename S = NoSmearing<Implementation> >
+  using IntegratorType = Integrator<Implementation, S, RepresentationsPolicy>;
+
+  HMCparameters Parameters;
+  std::string ParameterFile;
+  HMCResourceManager<Implementation> Resources;
+
+  // The set of actions (keep here for lower level users, for now)
+  ActionSet<Field, RepresentationsPolicy> TheAction;
+
+  HMCWrapperTemplate() = default;
+
+  HMCWrapperTemplate(HMCparameters Par){
+    Parameters = Par;
+  }
+
+  void initialize(ReaderClass & TheReader){
+    std::cout  << "Initialization of the HMC" << std::endl;
+    Resources.initialize(TheReader);
+
+    // eventually add smearing
+
+    Resources.GetActionSet(TheAction);    
+  }
+
+
+  void ReadCommandLine(int argc, char **argv) {
+    std::string arg;
+
+    if (GridCmdOptionExists(argv, argv + argc, "--StartingType")) {
+      arg = GridCmdOptionPayload(argv, argv + argc, "--StartingType");
+
+      if (arg != "HotStart" && arg != "ColdStart" && arg != "TepidStart" &&
+          arg != "CheckpointStart") {
+        std::cout << GridLogError << "Unrecognized option in --StartingType\n";
+        std::cout
+            << GridLogError
+            << "Valid [HotStart, ColdStart, TepidStart, CheckpointStart]\n";
+        exit(1);
+      }
+      Parameters.StartingType = arg;
+    }
+
+    if (GridCmdOptionExists(argv, argv + argc, "--StartingTrajectory")) {
+      arg = GridCmdOptionPayload(argv, argv + argc, "--StartingTrajectory");
+      std::vector<int> ivec(0);
+      GridCmdOptionIntVector(arg, ivec);
+      Parameters.StartTrajectory = ivec[0];
+    }
+
+    if (GridCmdOptionExists(argv, argv + argc, "--Trajectories")) {
+      arg = GridCmdOptionPayload(argv, argv + argc, "--Trajectories");
+      std::vector<int> ivec(0);
+      GridCmdOptionIntVector(arg, ivec);
+      Parameters.Trajectories = ivec[0];
+    }
+
+    if (GridCmdOptionExists(argv, argv + argc, "--Thermalizations")) {
+      arg = GridCmdOptionPayload(argv, argv + argc, "--Thermalizations");
+      std::vector<int> ivec(0);
+      GridCmdOptionIntVector(arg, ivec);
+      Parameters.NoMetropolisUntil = ivec[0];
+    }
+    if (GridCmdOptionExists(argv, argv + argc, "--ParameterFile")) {
+      arg = GridCmdOptionPayload(argv, argv + argc, "--ParameterFile");
+      ParameterFile = arg;
+    }
+  }
+
+
+  template <class SmearingPolicy>
+  void Run(SmearingPolicy &S) {
+    Runner(S);
+  }
+
+  void Run(){
+    NoSmearing<Implementation> S;
+    Runner(S);
+  }
+
+  //////////////////////////////////////////////////////////////////
+
+ private:
+  template <class SmearingPolicy>
+  void Runner(SmearingPolicy &Smearing) {
+    auto UGrid = Resources.GetCartesian();
+    Resources.AddRNGs();
+    Field U(UGrid);
+
+    // Can move this outside?
+    typedef IntegratorType<SmearingPolicy> TheIntegrator;
+    TheIntegrator MDynamics(UGrid, Parameters.MD, TheAction, Smearing);
+
+    if (Parameters.StartingType == "HotStart") {
+      // Hot start
+      Resources.SeedFixedIntegers();
+      Implementation::HotConfiguration(Resources.GetParallelRNG(), U);
+    } else if (Parameters.StartingType == "ColdStart") {
+      // Cold start
+      Resources.SeedFixedIntegers();
+      Implementation::ColdConfiguration(Resources.GetParallelRNG(), U);
+    } else if (Parameters.StartingType == "TepidStart") {
+      // Tepid start
+      Resources.SeedFixedIntegers();
+      Implementation::TepidConfiguration(Resources.GetParallelRNG(), U);
+    } else if (Parameters.StartingType == "CheckpointStart") {
+      // CheckpointRestart
+      Resources.GetCheckPointer()->CheckpointRestore(Parameters.StartTrajectory, U,
+                                   Resources.GetSerialRNG(),
+                                   Resources.GetParallelRNG());
+    }
+
+    Smearing.set_Field(U);
+
+    HybridMonteCarlo<TheIntegrator> HMC(Parameters, MDynamics,
+                                        Resources.GetSerialRNG(),
+                                        Resources.GetParallelRNG(), 
+                                        Resources.GetObservables(), U);
+
+    // Run it
+    HMC.evolve();
+  }
+};
+
+// These are for gauge fields, default integrator MinimumNorm2
+template <template <typename, typename, typename> class Integrator>
+using GenericHMCRunner = HMCWrapperTemplate<PeriodicGimplR, Integrator>;
+template <template <typename, typename, typename> class Integrator>
+using GenericHMCRunnerF = HMCWrapperTemplate<PeriodicGimplF, Integrator>;
+template <template <typename, typename, typename> class Integrator>
+using GenericHMCRunnerD = HMCWrapperTemplate<PeriodicGimplD, Integrator>;
+
+
+// These are for gauge fields, default integrator MinimumNorm2
+template <template <typename, typename, typename> class Integrator>
+using ConjugateHMCRunner = HMCWrapperTemplate<ConjugateGimplR, Integrator>;
+template <template <typename, typename, typename> class Integrator>
+using ConjugateHMCRunnerF = HMCWrapperTemplate<ConjugateGimplF, Integrator>;
+template <template <typename, typename, typename> class Integrator>
+using ConjugateHMCRunnerD = HMCWrapperTemplate<ConjugateGimplD, Integrator>;
+
+
+
+template <class RepresentationsPolicy,
+          template <typename, typename, typename> class Integrator>
+using GenericHMCRunnerHirep =
+    HMCWrapperTemplate<PeriodicGimplR, Integrator, RepresentationsPolicy>;
+
+template <class Implementation, class RepresentationsPolicy, 
+          template <typename, typename, typename> class Integrator>
+using GenericHMCRunnerTemplate = HMCWrapperTemplate<Implementation, Integrator, RepresentationsPolicy>;
+
+typedef HMCWrapperTemplate<ScalarImplR, MinimumNorm2, ScalarFields>
+    ScalarGenericHMCRunner;
+
+}  // namespace QCD
+}  // namespace Grid
+
+#endif  // GRID_GENERIC_HMC_RUNNER

lib/qcd/hmc/HMC.h

@@ -34,13 +34,15 @@ directory
  * @brief Classes for Hybrid Monte Carlo update
  *
  * @author Guido Cossu
- * Time-stamp: <2015-07-30 16:58:26 neo>
  */
 //--------------------------------------------------------------------
 #ifndef HMC_INCLUDED
 #define HMC_INCLUDED
 
 #include <string>
+#include <list>
+
+
 
 #include <Grid/qcd/hmc/integrators/Integrator.h>
 #include <Grid/qcd/hmc/integrators/Integrator_algorithm.h>
@@ -48,91 +50,64 @@ directory
 namespace Grid {
 namespace QCD {
 
-struct HMCparameters {
+struct HMCparameters: Serializable {
-  Integer StartTrajectory;
+	GRID_SERIALIZABLE_CLASS_MEMBERS(HMCparameters,
-  Integer Trajectories; /* @brief Number of sweeps in this run */
+                                  Integer, StartTrajectory,
-  bool MetropolisTest;
+                                  Integer, Trajectories, /* @brief Number of sweeps in this run */
-  Integer NoMetropolisUntil;
+                                  bool, MetropolisTest,
+                                  Integer, NoMetropolisUntil,
+                                  std::string, StartingType,
+                                  IntegratorParameters, MD)
 
   HMCparameters() {
     ////////////////////////////// Default values
     MetropolisTest    = true;
     NoMetropolisUntil = 10;
     StartTrajectory   = 0;
-    Trajectories = 200;
+    Trajectories      = 10;
+    StartingType      = "HotStart";
     /////////////////////////////////
   }
 
-  void print() const {
+  template <class ReaderClass >
-    std::cout << GridLogMessage << "[HMC parameter] Trajectories            : " << Trajectories << "\n";
+  HMCparameters(Reader<ReaderClass> & TheReader){
-    std::cout << GridLogMessage << "[HMC parameter] Start trajectory        : " << StartTrajectory << "\n";
+  	initialize(TheReader);
-    std::cout << GridLogMessage << "[HMC parameter] Metropolis test (on/off): " << MetropolisTest << "\n";
+  }
-    std::cout << GridLogMessage << "[HMC parameter] Thermalization trajs    : " << NoMetropolisUntil << "\n";
+
+  template < class ReaderClass > 
+  void initialize(Reader<ReaderClass> &TheReader){
+  	std::cout << "Reading HMC\n";
+  	read(TheReader, "HMC", *this);
+  }
+
+
+  void print_parameters() const {
+    std::cout << GridLogMessage << "[HMC parameters] Trajectories            : " << Trajectories << "\n";
+    std::cout << GridLogMessage << "[HMC parameters] Start trajectory        : " << StartTrajectory << "\n";
+    std::cout << GridLogMessage << "[HMC parameters] Metropolis test (on/off): " << std::boolalpha << MetropolisTest << "\n";
+    std::cout << GridLogMessage << "[HMC parameters] Thermalization trajs    : " << NoMetropolisUntil << "\n";
+    std::cout << GridLogMessage << "[HMC parameters] Starting type           : " << StartingType << "\n";
+    MD.print_parameters();
   }
   
 };
 	
-template <class GaugeField>
+template <class IntegratorType>
-class HmcObservable {
- public:
-  virtual void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG,
-                                  GridParallelRNG &pRNG) = 0;
-};
-
-template <class Gimpl>
-class PlaquetteLogger : public HmcObservable<typename Gimpl::GaugeField> {
- private:
-  std::string Stem;
-
- public:
-  INHERIT_GIMPL_TYPES(Gimpl);
-  PlaquetteLogger(std::string cf) { Stem = cf; };
-
-  void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG,
-                          GridParallelRNG &pRNG) {
-    std::string file;
-    {
-      std::ostringstream os;
-      os << Stem << "." << traj;
-      file = os.str();
-    }
-    std::ofstream of(file);
-
-    RealD peri_plaq = WilsonLoops<PeriodicGimplR>::avgPlaquette(U);
-    RealD peri_rect = WilsonLoops<PeriodicGimplR>::avgRectangle(U);
-
-    RealD impl_plaq = WilsonLoops<Gimpl>::avgPlaquette(U);
-    RealD impl_rect = WilsonLoops<Gimpl>::avgRectangle(U);
-
-    of << traj << " " << impl_plaq << " " << impl_rect << "  " << peri_plaq
-       << " " << peri_rect << std::endl;
-    std::cout << GridLogMessage << "traj"
-              << " "
-              << "plaq "
-              << " "
-              << " rect  "
-              << "  "
-              << "peri_plaq"
-              << " "
-              << "peri_rect" << std::endl;
-    std::cout << GridLogMessage << traj << " " << impl_plaq << " " << impl_rect
-              << "  " << peri_plaq << " " << peri_rect << std::endl;
-  }
-};
-
-//    template <class GaugeField, class Integrator, class Smearer, class
-//    Boundary>
-template <class GaugeField, class IntegratorType>
 class HybridMonteCarlo {
  private:
   const HMCparameters Params;
 
-  GridSerialRNG &sRNG;    // Fixme: need a RNG management strategy.
+  typedef typename IntegratorType::Field Field;
-  GridParallelRNG &pRNG;  // Fixme: need a RNG management strategy.
+  typedef std::vector< HmcObservable<Field> * > ObsListType;
-  GaugeField &Ucur;
+  
+  	//pass these from the resource manager
+  GridSerialRNG &sRNG;   
+  GridParallelRNG &pRNG; 
+
+  Field &Ucur;
   
   IntegratorType &TheIntegrator;
-  std::vector<HmcObservable<GaugeField> *> Observables;
+	ObsListType Observables;
 
   /////////////////////////////////////////////////////////
   // Metropolis step
@@ -167,13 +142,13 @@ class HybridMonteCarlo {
   /////////////////////////////////////////////////////////
   // Evolution
   /////////////////////////////////////////////////////////
-  RealD evolve_step(GaugeField &U) {
+  RealD evolve_hmc_step(Field &U) {
     TheIntegrator.refresh(U, pRNG);  // set U and initialize P and phi's
 
     RealD H0 = TheIntegrator.S(U);  // initial state action
 
     std::streamsize current_precision = std::cout.precision();
-    std::cout.precision(17);
+    std::cout.precision(15);
     std::cout << GridLogMessage << "Total H before trajectory = " << H0 << "\n";
     std::cout.precision(current_precision);
 
@@ -181,7 +156,19 @@ class HybridMonteCarlo {
 
     RealD H1 = TheIntegrator.S(U);  // updated state action
 
-    std::cout.precision(17);
+    ///////////////////////////////////////////////////////////
+    if(0){
+      std::cout << "------------------------- Reversibility test" << std::endl;
+      TheIntegrator.reverse_momenta();
+      TheIntegrator.integrate(U);
+
+      H1 = TheIntegrator.S(U);  // updated state action
+      std::cout << "--------------------------------------------" << std::endl;
+    }
+    ///////////////////////////////////////////////////////////
+
+
+    std::cout.precision(15);
     std::cout << GridLogMessage << "Total H after trajectory  = " << H1
 	      << "  dH = " << H1 - H0 << "\n";
     std::cout.precision(current_precision);
@@ -189,56 +176,76 @@ class HybridMonteCarlo {
     return (H1 - H0);
   }
   
+
+  
+
  public:
   /////////////////////////////////////////
   // Constructor
   /////////////////////////////////////////
-  HybridMonteCarlo(HMCparameters Pams, IntegratorType &_Int,
+  HybridMonteCarlo(HMCparameters _Pams, IntegratorType &_Int,
-                   GridSerialRNG &_sRNG, GridParallelRNG &_pRNG, GaugeField &_U)
+                   GridSerialRNG &_sRNG, GridParallelRNG &_pRNG, 
-      : Params(Pams), TheIntegrator(_Int), sRNG(_sRNG), pRNG(_pRNG), Ucur(_U) {}
+                   ObsListType _Obs, Field &_U)
+    : Params(_Pams), TheIntegrator(_Int), sRNG(_sRNG), pRNG(_pRNG), Observables(_Obs), Ucur(_U) {}
   ~HybridMonteCarlo(){};
 
-  void AddObservable(HmcObservable<GaugeField> *obs) {
-    Observables.push_back(obs);
-  }
-
   void evolve(void) {
     Real DeltaH;
 
-    GaugeField Ucopy(Ucur._grid);
+    Field Ucopy(Ucur._grid);
 
-    Params.print();
+    Params.print_parameters();
+    TheIntegrator.print_actions();
 
     // Actual updates (evolve a copy Ucopy then copy back eventually)
-    for (int traj = Params.StartTrajectory;
+    unsigned int FinalTrajectory = Params.Trajectories + Params.NoMetropolisUntil + Params.StartTrajectory;
-         traj < Params.Trajectories + Params.StartTrajectory; ++traj) {
+    for (int traj = Params.StartTrajectory; traj < FinalTrajectory; ++traj) {
       std::cout << GridLogMessage << "-- # Trajectory = " << traj << "\n";
+      if (traj < Params.StartTrajectory + Params.NoMetropolisUntil) {
+      	std::cout << GridLogMessage << "-- Thermalization" << std::endl;
+      }
+      
+      double t0=usecond();
       Ucopy = Ucur;
 
-      DeltaH = evolve_step(Ucopy);
+      DeltaH = evolve_hmc_step(Ucopy);
-
+      // Metropolis-Hastings test
       bool accept = true;
-      if (traj >= Params.NoMetropolisUntil) {
+      if (traj >= Params.StartTrajectory + Params.NoMetropolisUntil) {
         accept = metropolis_test(DeltaH);
+      } else {
+      	std::cout << GridLogMessage << "Skipping Metropolis test" << std::endl;
       }
 
-      if (accept) {
+      if (accept)
         Ucur = Ucopy; 
-      }
+      
+     
+      
+      double t1=usecond();
+      std::cout << GridLogMessage << "Total time for trajectory (s): " << (t1-t0)/1e6 << std::endl;
+
 
       for (int obs = 0; obs < Observables.size(); obs++) {
+      	std::cout << GridLogDebug << "Observables # " << obs << std::endl;
+      	std::cout << GridLogDebug << "Observables total " << Observables.size() << std::endl;
+      	std::cout << GridLogDebug << "Observables pointer " << Observables[obs] << std::endl;
         Observables[obs]->TrajectoryComplete(traj + 1, Ucur, sRNG, pRNG);
       }
+      std::cout << GridLogMessage << ":::::::::::::::::::::::::::::::::::::::::::" << std::endl;
     }
   }
+
 };
 
 
 }  // QCD
 }  // Grid
 
-#include <Grid/parallelIO/NerscIO.h>
+
-#include <Grid/qcd/hmc/NerscCheckpointer.h>
+// april 11 2017 merge, Guido, commenting out
-#include <Grid/qcd/hmc/HmcRunner.h>
+//#include <Grid/parallelIO/NerscIO.h>
+//#include <Grid/qcd/hmc/NerscCheckpointer.h>
+//#include <Grid/qcd/hmc/HmcRunner.h>
 
 #endif

lib/qcd/hmc/HMCModules.h

@@ -0,0 +1,111 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/GenericHmcRunner.h
+
+Copyright (C) 2015
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef GRID_HMC_MODULES
+#define GRID_HMC_MODULES
+
+
+#include "HMC_GridModules.h"
+
+namespace Grid {
+namespace QCD {
+
+////////////////////////////////////////////////////////////////////
+struct RNGModuleParameters: Serializable {
+  GRID_SERIALIZABLE_CLASS_MEMBERS(RNGModuleParameters,
+  std::string, serial_seeds,
+  std::string, parallel_seeds,);
+
+  std::vector<int> getSerialSeeds(){return strToVec<int>(serial_seeds);}
+  std::vector<int> getParallelSeeds(){return strToVec<int>(parallel_seeds);}
+
+  RNGModuleParameters(): serial_seeds("1"), parallel_seeds("1"){}
+
+  template <class ReaderClass >
+  RNGModuleParameters(Reader<ReaderClass>& Reader){
+    read(Reader, "RandomNumberGenerator", *this); 
+  }
+  
+};
+
+// Random number generators module
+class RNGModule{
+   GridSerialRNG sRNG_;
+   std::unique_ptr<GridParallelRNG> pRNG_;
+   RNGModuleParameters Params_;
+
+public:
+
+  RNGModule(){};
+
+  void set_pRNG(GridParallelRNG* pRNG){
+    pRNG_.reset(pRNG);
+  }
+
+  void set_RNGSeeds(RNGModuleParameters& Params) {
+    Params_ = Params;
+  }
+
+  GridSerialRNG& get_sRNG() { return sRNG_; }
+  GridParallelRNG& get_pRNG() { return *pRNG_.get(); }
+
+  void seed() {
+    auto SerialSeeds   = Params_.getSerialSeeds();
+    auto ParallelSeeds = Params_.getParallelSeeds();
+    if (SerialSeeds.size() == 0 && ParallelSeeds.size() == 0) {
+      std::cout << GridLogError << "Seeds not initialized" << std::endl;
+      exit(1);
+    }
+    sRNG_.SeedFixedIntegers(SerialSeeds);
+    pRNG_->SeedFixedIntegers(ParallelSeeds);
+  }
+};
+
+
+/*
+///////////////////////////////////////////////////////////////////
+/// Smearing module
+template <class ImplementationPolicy>
+class SmearingModule{
+   virtual void get_smearing();
+};
+
+template <class ImplementationPolicy>
+class StoutSmearingModule: public SmearingModule<ImplementationPolicy>{
+   SmearedConfiguration<ImplementationPolicy> SmearingPolicy;
+};
+
+*/
+
+
+
+}  // namespace QCD
+}  // namespace Grid
+
+#endif  // GRID_HMC_MODULES

lib/qcd/hmc/HMCResourceManager.h

@@ -0,0 +1,300 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/GenericHmcRunner.h
+
+Copyright (C) 2015
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+  See the full license in the file "LICENSE" in the top level distribution
+  directory
+  *************************************************************************************/
+/*  END LEGAL */
+#ifndef HMC_RESOURCE_MANAGER_H
+#define HMC_RESOURCE_MANAGER_H
+
+#include <unordered_map>
+
+// One function per Checkpointer, use a macro to simplify
+#define RegisterLoadCheckPointerFunction(NAME)                           \
+  void Load##NAME##Checkpointer(const CheckpointerParameters& Params_) { \
+    if (!have_CheckPointer) {                                            \
+      std::cout << GridLogDebug << "Loading Checkpointer " << #NAME      \
+                << std::endl;                                            \
+      CP = std::unique_ptr<CheckpointerBaseModule>(                      \
+        new NAME##CPModule<ImplementationPolicy>(Params_));              \
+      have_CheckPointer = true;                                          \
+    } else {                                                             \
+      std::cout << GridLogError << "Checkpointer already loaded "        \
+                << std::endl;                                            \
+      exit(1);                                                           \
+    }                                                                    \
+  }
+
+namespace Grid {
+namespace QCD {
+
+// HMC Resource manager
+template <class ImplementationPolicy>
+class HMCResourceManager {
+  typedef HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > CheckpointerBaseModule;
+  typedef HMCModuleBase< QCD::HmcObservable<typename ImplementationPolicy::Field> > ObservableBaseModule;
+  typedef ActionModuleBase< QCD::Action<typename ImplementationPolicy::Field>, GridModule > ActionBaseModule;
+
+  // Named storage for grid pairs (std + red-black)
+  std::unordered_map<std::string, GridModule> Grids;
+  RNGModule RNGs;
+
+  // SmearingModule<ImplementationPolicy> Smearing;
+  std::unique_ptr<CheckpointerBaseModule> CP;
+
+  // A vector of HmcObservable modules
+  std::vector<std::unique_ptr<ObservableBaseModule> > ObservablesList;
+
+
+  // A vector of HmcObservable modules
+  std::multimap<int, std::unique_ptr<ActionBaseModule> > ActionsList;
+  std::vector<int> multipliers;
+
+  bool have_RNG;
+  bool have_CheckPointer;
+
+  // NOTE: operator << is not overloaded for std::vector<string> 
+  // so thsi function is necessary
+  void output_vector_string(const std::vector<std::string> &vs){
+    for (auto &i: vs)
+      std::cout << i << " ";
+    std::cout << std::endl;
+  }
+
+
+ public:
+  HMCResourceManager() : have_RNG(false), have_CheckPointer(false) {}
+
+  template <class ReaderClass, class vector_type = vComplex >
+  void initialize(ReaderClass &Read){
+    // assumes we are starting from the main node
+
+    // Geometry
+    GridModuleParameters GridPar(Read);
+    GridFourDimModule<vector_type> GridMod( GridPar) ;
+    AddGrid("gauge", GridMod);
+
+    // Checkpointer
+    auto &CPfactory = HMC_CPModuleFactory<cp_string, ImplementationPolicy, ReaderClass >::getInstance();
+    Read.push("Checkpointer");
+    std::string cp_type;
+    read(Read,"name", cp_type);
+    std::cout << "Registered types " << std::endl;
+    output_vector_string(CPfactory.getBuilderList());
+
+
+    CP = CPfactory.create(cp_type, Read);
+    CP->print_parameters();
+    Read.pop();    
+    have_CheckPointer = true;  
+
+    RNGModuleParameters RNGpar(Read);
+    SetRNGSeeds(RNGpar);
+
+    // Observables
+    auto &ObsFactory = HMC_ObservablesModuleFactory<observable_string, typename ImplementationPolicy::Field, ReaderClass>::getInstance(); 
+    Read.push(observable_string);// here must check if existing...
+    do {
+      std::string obs_type;
+      read(Read,"name", obs_type);
+      std::cout << "Registered types " << std::endl;
+      output_vector_string(ObsFactory.getBuilderList() );
+
+      ObservablesList.emplace_back(ObsFactory.create(obs_type, Read));
+      ObservablesList[ObservablesList.size() - 1]->print_parameters();
+    } while (Read.nextElement(observable_string));
+    Read.pop();
+
+    // Loop on levels
+    if(!Read.push("Actions")){
+      std::cout << "Actions not found" << std::endl; 
+      exit(1);
+    }
+
+    if(!Read.push("Level")){// push must check if the node exist
+         std::cout << "Level not found" << std::endl; 
+      exit(1);
+    }
+    do
+    {
+      fill_ActionsLevel(Read); 
+    }
+    while(Read.push("Level"));
+
+    Read.pop();
+  }
+
+
+ 
+  template <class RepresentationPolicy>
+  void GetActionSet(ActionSet<typename ImplementationPolicy::Field, RepresentationPolicy>& Aset){
+    Aset.resize(multipliers.size());
+ 
+    for(auto it = ActionsList.begin(); it != ActionsList.end(); it++){
+      (*it).second->acquireResource(Grids["gauge"]);
+      Aset[(*it).first-1].push_back((*it).second->getPtr());
+    }
+  }
+
+
+
+  //////////////////////////////////////////////////////////////
+  // Grids
+  //////////////////////////////////////////////////////////////
+
+  void AddGrid(std::string s, GridModule& M) {
+    // Check for name clashes
+    auto search = Grids.find(s);
+    if (search != Grids.end()) {
+      std::cout << GridLogError << "Grid with name \"" << search->first
+                << "\" already present. Terminating\n";
+      exit(1);
+    }
+    Grids[s] = std::move(M);
+  }
+
+  // Add a named grid set, 4d shortcut
+  void AddFourDimGrid(std::string s) {
+    GridFourDimModule<vComplex> Mod;
+    AddGrid(s, Mod);
+  }
+
+
+
+  GridCartesian* GetCartesian(std::string s = "") {
+    if (s.empty()) s = Grids.begin()->first;
+    std::cout << GridLogDebug << "Getting cartesian grid from: " << s
+              << std::endl;
+    return Grids[s].get_full();
+  }
+
+  GridRedBlackCartesian* GetRBCartesian(std::string s = "") {
+    if (s.empty()) s = Grids.begin()->first;
+    std::cout << GridLogDebug << "Getting rb-cartesian grid from: " << s
+              << std::endl;
+    return Grids[s].get_rb();
+  }
+
+  //////////////////////////////////////////////////////
+  // Random number generators
+  //////////////////////////////////////////////////////
+
+  void AddRNGs(std::string s = "") {
+    // Couple the RNGs to the GridModule tagged by s
+    // the default is the first grid registered
+    assert(Grids.size() > 0 && !have_RNG);
+    if (s.empty()) s = Grids.begin()->first;
+    std::cout << GridLogDebug << "Adding RNG to grid: " << s << std::endl;
+    RNGs.set_pRNG(new GridParallelRNG(GetCartesian(s)));
+    have_RNG = true;
+  }
+
+  void SetRNGSeeds(RNGModuleParameters& Params) { RNGs.set_RNGSeeds(Params); }
+
+  GridSerialRNG& GetSerialRNG() { return RNGs.get_sRNG(); }
+
+  GridParallelRNG& GetParallelRNG() {
+    assert(have_RNG);
+    return RNGs.get_pRNG();
+  }
+
+  void SeedFixedIntegers() {
+    assert(have_RNG);
+    RNGs.seed();
+  }
+
+  //////////////////////////////////////////////////////
+  // Checkpointers
+  //////////////////////////////////////////////////////
+
+  BaseHmcCheckpointer<ImplementationPolicy>* GetCheckPointer() {
+    if (have_CheckPointer)
+      return CP->getPtr();
+    else {
+      std::cout << GridLogError << "Error: no checkpointer defined"
+                << std::endl;
+      exit(1);
+    }
+  }
+
+  RegisterLoadCheckPointerFunction(Binary);
+  RegisterLoadCheckPointerFunction(Nersc);
+  #ifdef HAVE_LIME
+  RegisterLoadCheckPointerFunction(ILDG);
+  #endif
+
+  ////////////////////////////////////////////////////////
+  // Observables
+  ////////////////////////////////////////////////////////
+
+  template<class T, class... Types>
+  void AddObservable(Types&&... Args){
+    ObservablesList.push_back(std::unique_ptr<T>(new T(std::forward<Types>(Args)...)));
+  }
+
+  std::vector<HmcObservable<typename ImplementationPolicy::Field>* > GetObservables(){
+    std::vector<HmcObservable<typename ImplementationPolicy::Field>* > out;
+    for (auto &i : ObservablesList){
+      out.push_back(i->getPtr());
+    }
+
+    // Add the checkpointer to the observables
+    out.push_back(GetCheckPointer());
+    return out;
+  }
+
+
+
+private:
+   // this private
+  template <class ReaderClass >
+  void fill_ActionsLevel(ReaderClass &Read){
+    // Actions set
+    int m;
+    Read.readDefault("multiplier",m);
+    multipliers.push_back(m);
+    std::cout << "Level : " << multipliers.size()  << " with multiplier : " << m << std::endl; 
+    // here gauge
+    Read.push("Action");
+    do{
+      auto &ActionFactory = HMC_ActionModuleFactory<gauge_string, typename ImplementationPolicy::Field, ReaderClass>::getInstance(); 
+      std::string action_type;
+      Read.readDefault("name", action_type); 
+      output_vector_string(ActionFactory.getBuilderList() );
+      ActionsList.emplace(m, ActionFactory.create(action_type, Read));
+    } while (Read.nextElement("Action"));
+    ActionsList.find(m)->second->print_parameters();    
+    Read.pop();
+
+  }
+
+
+
+};
+}
+}
+
+#endif  // HMC_RESOURCE_MANAGER_H

lib/qcd/hmc/HMCRunnerModule.h

@@ -0,0 +1,137 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/GenericHmcRunner.h
+
+Copyright (C) 2015
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef HMC_RUNNER_MODULE
+#define HMC_RUNNER_MODULE
+
+namespace Grid {
+
+// the reader class is necessary here for the automatic initialization of the resources
+// if we had a virtual reader would have been unecessary
+template <class HMCType, class ReaderClass >
+class HMCModule
+    : public Parametrized< QCD::HMCparameters >,
+      public HMCModuleBase< QCD::HMCRunnerBase<ReaderClass> > {
+ public:
+  typedef HMCModuleBase< QCD::HMCRunnerBase<ReaderClass> > Base;
+  typedef typename Base::Product Product;
+
+  std::unique_ptr<HMCType> HMCPtr;
+
+  HMCModule(QCD::HMCparameters Par) : Parametrized<QCD::HMCparameters>(Par) {}
+
+  template <class ReaderCl>
+  HMCModule(Reader<ReaderCl>& R) : Parametrized<QCD::HMCparameters>(R, "HMC"){};
+
+  Product* getPtr() {
+    if (!HMCPtr) initialize();
+ 
+    return HMCPtr.get();
+  }
+
+ private:
+  virtual void initialize() = 0;
+};
+
+// Factory
+template <char const *str, class ReaderClass >
+class HMCRunnerModuleFactory
+    : public Factory < HMCModuleBase< QCD::HMCRunnerBase<ReaderClass> > ,	Reader<ReaderClass> > {
+ public:
+ 	typedef Reader<ReaderClass> TheReader; 
+ 	// use SINGLETON FUNCTOR MACRO HERE
+  HMCRunnerModuleFactory(const HMCRunnerModuleFactory& e) = delete;
+  void operator=(const HMCRunnerModuleFactory& e) = delete;
+  static HMCRunnerModuleFactory& getInstance(void) {
+    static HMCRunnerModuleFactory e;
+    return e;
+  }
+
+ private:
+  HMCRunnerModuleFactory(void) = default;
+  std::string obj_type() const {
+  	return std::string(str);
+  }
+};
+
+
+
+
+
+///////////////
+// macro for these
+
+template < class ImplementationPolicy, class RepresentationPolicy, class ReaderClass >
+class HMCLeapFrog: public HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::LeapFrog>, ReaderClass >{
+  typedef HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::LeapFrog>, ReaderClass  > HMCBaseMod;
+  using HMCBaseMod::HMCBaseMod;
+
+  // aquire resource
+  virtual void initialize(){
+    this->HMCPtr.reset(new QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::LeapFrog>(this->Par_) );
+  }
+};
+
+template < class ImplementationPolicy, class RepresentationPolicy, class ReaderClass >
+class HMCMinimumNorm2: public HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::MinimumNorm2>, ReaderClass  >{
+  typedef HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::MinimumNorm2>, ReaderClass  > HMCBaseMod;
+  using HMCBaseMod::HMCBaseMod;
+
+  // aquire resource
+  virtual void initialize(){
+    this->HMCPtr.reset(new QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::MinimumNorm2>(this->Par_));
+  }
+};
+
+
+template < class ImplementationPolicy, class RepresentationPolicy, class ReaderClass >
+class HMCForceGradient: public HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::ForceGradient>, ReaderClass  >{
+  typedef HMCModule< QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::ForceGradient>, ReaderClass   > HMCBaseMod;
+  using HMCBaseMod::HMCBaseMod;
+
+  // aquire resource
+  virtual void initialize(){
+    this->HMCPtr.reset(new QCD::GenericHMCRunnerTemplate<ImplementationPolicy, RepresentationPolicy, QCD::ForceGradient>(this->Par_) );
+  }
+};
+
+extern char hmc_string[];
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////
+
+
+
+}
+
+#endif

lib/qcd/hmc/HMC_GridModules.h

@@ -0,0 +1,133 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/HMC_GridModules.h
+
+Copyright (C) 2015
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef HMC_GRID_MODULES
+#define HMC_GRID_MODULES
+
+namespace Grid {
+
+// Resources
+// Modules for grids 
+
+// Introduce another namespace HMCModules?
+
+class GridModuleParameters: Serializable{   
+public:
+  GRID_SERIALIZABLE_CLASS_MEMBERS(GridModuleParameters,
+  std::string, lattice,
+  std::string, mpi);
+
+  std::vector<int> getLattice(){return strToVec<int>(lattice);}
+  std::vector<int> getMpi()    {return strToVec<int>(mpi);}
+
+  void check(){
+    if (getLattice().size() != getMpi().size()) {
+      std::cout << GridLogError 
+                << "Error in GridModuleParameters: lattice and mpi dimensions "
+                   "do not match"
+                << std::endl;
+      exit(1);
+    }
+  }    
+
+  template <class ReaderClass>
+  GridModuleParameters(Reader<ReaderClass>& Reader, std::string n = "LatticeGrid"):name(n) {
+    read(Reader, name, *this);
+    check();
+  }
+
+  // Save on file
+  template< class WriterClass>
+  void save(Writer<WriterClass>& Writer){
+    check();
+    write(Writer, name, *this);
+  }
+private:
+    std::string name;
+};
+
+// Lower level class
+class GridModule {
+ public:
+  GridCartesian* get_full() { 
+    std::cout << GridLogDebug << "Getting cartesian in module"<< std::endl;
+    return grid_.get(); }
+  GridRedBlackCartesian* get_rb() { 
+    std::cout << GridLogDebug << "Getting rb-cartesian in module"<< std::endl;
+    return rbgrid_.get(); }
+
+  void set_full(GridCartesian* grid) { grid_.reset(grid); }
+  void set_rb(GridRedBlackCartesian* rbgrid) { rbgrid_.reset(rbgrid); }
+
+ protected:
+  std::unique_ptr<GridCartesian> grid_;
+  std::unique_ptr<GridRedBlackCartesian> rbgrid_;
+  
+};
+
+////////////////////////////////////
+// Classes for the user
+////////////////////////////////////
+// Note: the space time grid should be out of the QCD namespace
+template< class vector_type>
+class GridFourDimModule : public GridModule {
+ public:
+  GridFourDimModule() {
+    using namespace QCD;
+    set_full(SpaceTimeGrid::makeFourDimGrid(
+        GridDefaultLatt(), GridDefaultSimd(4, vector_type::Nsimd()),
+        GridDefaultMpi()));
+    set_rb(SpaceTimeGrid::makeFourDimRedBlackGrid(grid_.get()));
+  }
+
+  GridFourDimModule(GridModuleParameters Params) {
+    using namespace QCD;
+    Params.check();
+    std::vector<int> lattice_v = Params.getLattice();
+    std::vector<int> mpi_v = Params.getMpi();
+    if (lattice_v.size() == 4) {
+      set_full(SpaceTimeGrid::makeFourDimGrid(
+          lattice_v, GridDefaultSimd(4, vector_type::Nsimd()),
+          mpi_v));
+      set_rb(SpaceTimeGrid::makeFourDimRedBlackGrid(grid_.get()));
+    } else {
+      std::cout << GridLogError 
+          << "Error in GridFourDimModule: lattice dimension different from 4"
+          << std::endl;
+      exit(1);
+    }
+  }
+};
+
+typedef GridFourDimModule<vComplex> GridDefaultFourDimModule;
+
+
+}  // namespace Grid
+
+#endif  // HMC_GRID_MODULES

lib/qcd/hmc/HMC_aggregate.h

@@ -33,10 +33,20 @@ directory
 
 #include <string>
 
+#include <Grid/qcd/observables/hmc_observable.h>
 #include <Grid/qcd/hmc/HMC.h>
+
+
 // annoying location; should move this ?
+#include <Grid/parallelIO/IldgIOtypes.h>
+#include <Grid/parallelIO/IldgIO.h>
 #include <Grid/parallelIO/NerscIO.h>
-#include <Grid/qcd/hmc/NerscCheckpointer.h>
+
-#include <Grid/qcd/hmc/HmcRunner.h>
+#include <Grid/qcd/hmc/checkpointers/CheckPointers.h>
+#include <Grid/qcd/hmc/HMCModules.h>
+#include <Grid/qcd/modules/mods.h>
+#include <Grid/qcd/hmc/HMCResourceManager.h>
+#include <Grid/qcd/hmc/GenericHMCrunner.h>
+#include <Grid/qcd/hmc/HMCRunnerModule.h>
 
 #endif

lib/qcd/hmc/HmcRunner.h

@@ -1,191 +0,0 @@
-/*************************************************************************************
-
-Grid physics library, www.github.com/paboyle/Grid
-
-Source file: ./lib/qcd/hmc/HmcRunner.h
-
-Copyright (C) 2015
-
-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 HMC_RUNNER
-#define HMC_RUNNER
-
-namespace Grid {
-namespace QCD {
-
-template <class Gimpl, class RepresentationsPolicy = NoHirep >
-class NerscHmcRunnerTemplate {
- public:
-  INHERIT_GIMPL_TYPES(Gimpl);
-
-  enum StartType_t { ColdStart, HotStart, TepidStart, CheckpointStart };
-
-  ActionSet<GaugeField, RepresentationsPolicy> TheAction;
-
-  GridCartesian *UGrid;
-  GridCartesian *FGrid;
-  GridRedBlackCartesian *UrbGrid;
-  GridRedBlackCartesian *FrbGrid;
-
-  virtual void BuildTheAction(int argc, char **argv) = 0;  // necessary?
-
-  void Run(int argc, char **argv) {
-    StartType_t StartType = HotStart;
-
-    std::string arg;
-
-    if (GridCmdOptionExists(argv, argv + argc, "--StartType")) {
-      arg = GridCmdOptionPayload(argv, argv + argc, "--StartType");
-      if (arg == "HotStart") {
-        StartType = HotStart;
-      } else if (arg == "ColdStart") {
-        StartType = ColdStart;
-      } else if (arg == "TepidStart") {
-        StartType = TepidStart;
-      } else if (arg == "CheckpointStart") {
-        StartType = CheckpointStart;
-      } else {
-        std::cout << GridLogError << "Unrecognized option in --StartType\n";
-        std::cout << GridLogError << "Valid [HotStart, ColdStart, TepidStart, CheckpointStart]\n";
-        assert(0);
-      }
-    }
-
-    int StartTraj = 0;
-    if (GridCmdOptionExists(argv, argv + argc, "--StartTrajectory")) {
-      arg = GridCmdOptionPayload(argv, argv + argc, "--StartTrajectory");
-      std::vector<int> ivec(0);
-      GridCmdOptionIntVector(arg, ivec);
-      StartTraj = ivec[0];
-    }
-
-    int NumTraj = 1;
-    if (GridCmdOptionExists(argv, argv + argc, "--Trajectories")) {
-      arg = GridCmdOptionPayload(argv, argv + argc, "--Trajectories");
-      std::vector<int> ivec(0);
-      GridCmdOptionIntVector(arg, ivec);
-      NumTraj = ivec[0];
-    }
-
-    int NumThermalizations = 10;
-    if (GridCmdOptionExists(argv, argv + argc, "--Thermalizations")) {
-      arg = GridCmdOptionPayload(argv, argv + argc, "--Thermalizations");
-      std::vector<int> ivec(0);
-      GridCmdOptionIntVector(arg, ivec);
-      NumThermalizations = ivec[0];
-    }
-
-    GridSerialRNG sRNG;
-    GridParallelRNG pRNG(UGrid);
-    LatticeGaugeField U(UGrid);  // change this to an extended field (smearing class)?
-
-    std::vector<int> SerSeed({1, 2, 3, 4, 5});
-    std::vector<int> ParSeed({6, 7, 8, 9, 10});
-
-    // Create integrator, including the smearing policy
-    // Smearing policy, only defined for Nc=3
-    /*
-    std::cout << GridLogDebug << " Creating the Stout class\n";
-    double rho = 0.1;  // smearing parameter, now hardcoded
-    int Nsmear = 1;    // number of smearing levels
-    Smear_Stout<Gimpl> Stout(rho);
-    std::cout << GridLogDebug << " Creating the SmearedConfiguration class\n";
-    //SmearedConfiguration<Gimpl> SmearingPolicy(UGrid, Nsmear, Stout);
-    std::cout << GridLogDebug << " done\n";
-    */
-    //////////////
-    NoSmearing<Gimpl> SmearingPolicy;
-    // change here to change the algorithm
-    typedef MinimumNorm2<GaugeField, NoSmearing<Gimpl>, RepresentationsPolicy >  IntegratorType;  
-    IntegratorParameters MDpar(40, 1.0);
-    IntegratorType MDynamics(UGrid, MDpar, TheAction, SmearingPolicy);
-
-    // Checkpoint strategy
-    NerscHmcCheckpointer<Gimpl> Checkpoint(std::string("ckpoint_lat"),
-                                           std::string("ckpoint_rng"), 1);
-    PlaquetteLogger<Gimpl> PlaqLog(std::string("plaq"));
-
-    HMCparameters HMCpar;
-    HMCpar.StartTrajectory = StartTraj;
-    HMCpar.Trajectories = NumTraj;
-    HMCpar.NoMetropolisUntil = NumThermalizations;
-
-    if (StartType == HotStart) {
-      // Hot start
-      HMCpar.MetropolisTest = true;
-      sRNG.SeedFixedIntegers(SerSeed);
-      pRNG.SeedFixedIntegers(ParSeed);
-      SU<Nc>::HotConfiguration(pRNG, U);
-    } else if (StartType == ColdStart) {
-      // Cold start
-      HMCpar.MetropolisTest = true;
-      sRNG.SeedFixedIntegers(SerSeed);
-      pRNG.SeedFixedIntegers(ParSeed);
-      SU<Nc>::ColdConfiguration(pRNG, U);
-    } else if (StartType == TepidStart) {
-      // Tepid start
-      HMCpar.MetropolisTest = true;
-      sRNG.SeedFixedIntegers(SerSeed);
-      pRNG.SeedFixedIntegers(ParSeed);
-      SU<Nc>::TepidConfiguration(pRNG, U);
-    } else if (StartType == CheckpointStart) {
-      HMCpar.MetropolisTest = true;
-      // CheckpointRestart
-      Checkpoint.CheckpointRestore(StartTraj, U, sRNG, pRNG);
-    }
-
-    // Attach the gauge field to the smearing Policy and create the fill the
-    // smeared set
-    // notice that the unit configuration is singular in this procedure
-    std::cout << GridLogMessage << "Filling the smeared set\n";
-    SmearingPolicy.set_GaugeField(U);
-
-    HybridMonteCarlo<GaugeField, IntegratorType> HMC(HMCpar, MDynamics, sRNG,
-                                                     pRNG, U);
-    HMC.AddObservable(&Checkpoint);
-    HMC.AddObservable(&PlaqLog);
-
-    // Run it
-    HMC.evolve();
-  }
-};
-
-typedef NerscHmcRunnerTemplate<PeriodicGimplR> NerscHmcRunner;
-typedef NerscHmcRunnerTemplate<PeriodicGimplF> NerscHmcRunnerF;
-typedef NerscHmcRunnerTemplate<PeriodicGimplD> NerscHmcRunnerD;
-
-typedef NerscHmcRunnerTemplate<PeriodicGimplR> PeriodicNerscHmcRunner;
-typedef NerscHmcRunnerTemplate<PeriodicGimplF> PeriodicNerscHmcRunnerF;
-typedef NerscHmcRunnerTemplate<PeriodicGimplD> PeriodicNerscHmcRunnerD;
-
-typedef NerscHmcRunnerTemplate<ConjugateGimplR> ConjugateNerscHmcRunner;
-typedef NerscHmcRunnerTemplate<ConjugateGimplF> ConjugateNerscHmcRunnerF;
-typedef NerscHmcRunnerTemplate<ConjugateGimplD> ConjugateNerscHmcRunnerD;
-
-template <class RepresentationsPolicy>
-using NerscHmcRunnerHirep = NerscHmcRunnerTemplate<PeriodicGimplR, RepresentationsPolicy>;
-
-
-
-}
-}
-#endif

lib/qcd/hmc/NerscCheckpointer.h

@@ -1,80 +0,0 @@
-    /*************************************************************************************
-
-    Grid physics library, www.github.com/paboyle/Grid 
-
-    Source file: ./lib/qcd/hmc/NerscCheckpointer.h
-
-    Copyright (C) 2015
-
-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 NERSC_CHECKPOINTER
-#define NERSC_CHECKPOINTER
-
-#include <string>
-#include <iostream>
-#include <sstream>
-
-
-namespace Grid{
-  namespace QCD{
-    
-
-    template<class Gimpl> 
-    class NerscHmcCheckpointer : public HmcObservable<typename Gimpl::GaugeField> {
-    private:
-      std::string configStem;
-      std::string rngStem;
-      int SaveInterval;
-    public:
-      INHERIT_GIMPL_TYPES(Gimpl);
-
-      NerscHmcCheckpointer(std::string cf, std::string rn,int savemodulo) {
-        configStem  = cf;
-        rngStem     = rn;
-        SaveInterval= savemodulo;
-      };
-
-      void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG, GridParallelRNG & pRNG )
-      {
-	if ( (traj % SaveInterval)== 0 ) {
-	  std::string rng;   { std::ostringstream os; os << rngStem     <<"."<< traj; rng = os.str(); }
-	  std::string config;{ std::ostringstream os; os << configStem  <<"."<< traj; config = os.str();}
-
-	  int precision32=1;
-	  int tworow     =0;
-	  NerscIO::writeRNGState(sRNG,pRNG,rng);
-	  NerscIO::writeConfiguration(U,config,tworow,precision32);
-	}
-      };
-
-      void CheckpointRestore(int traj, GaugeField &U, GridSerialRNG &sRNG, GridParallelRNG & pRNG ){
-
-	std::string rng;   { std::ostringstream os; os << rngStem     <<"."<< traj; rng = os.str(); }
-	std::string config;{ std::ostringstream os; os << configStem  <<"."<< traj; config = os.str();}
-
-	NerscField header;
-	NerscIO::readRNGState(sRNG,pRNG,header,rng);
-	NerscIO::readConfiguration(U,header,config);
-      };
-
-    };
-}}
-#endif

lib/qcd/hmc/UsingHMC.md

@@ -0,0 +1,107 @@
+Using HMC in Grid version 0.5.1
+
+These are the instructions to use the Generalised HMC on Grid version 0.5.1.
+Disclaimer: GRID is still under active development so any information here can be changed in future releases.
+
+
+Command line options
+===================
+(relevant file GenericHMCrunner.h)
+The initial configuration can be changed at the command line using 
+--StartType <your choice>
+valid choices, one among these
+HotStart, ColdStart, TepidStart, CheckpointStart
+default: HotStart
+
+example
+./My_hmc_exec  --StartType HotStart
+
+The CheckpointStart option uses the prefix for the configurations and rng seed files defined in your executable and the initial configuration is specified by
+--StartTrajectory <integer>
+default: 0
+
+The number of trajectories for a specific run are specified at command line by
+--Trajectories <integer>
+default: 1
+
+The number of thermalization steps (i.e. steps when the Metropolis acceptance check is turned off) is specified by
+--Thermalizations <integer>
+default: 10
+
+
+Any other parameter is defined in the source for the executable.
+
+HMC controls
+===========
+
+The lines 
+
+  std::vector<int> SerSeed({1, 2, 3, 4, 5});
+  std::vector<int> ParSeed({6, 7, 8, 9, 10});
+
+define the seeds for the serial and the parallel RNG.
+
+The line 
+
+  TheHMC.MDparameters.set(20, 1.0);// MDsteps, traj length
+
+declares the number of molecular dynamics steps and the total trajectory length.
+
+
+Actions
+======
+
+Action names are defined in the file
+lib/qcd/Actions.h
+
+Gauge actions list:
+
+WilsonGaugeActionR;
+WilsonGaugeActionF;
+WilsonGaugeActionD;
+PlaqPlusRectangleActionR;
+PlaqPlusRectangleActionF;
+PlaqPlusRectangleActionD;
+IwasakiGaugeActionR;
+IwasakiGaugeActionF;
+IwasakiGaugeActionD;
+SymanzikGaugeActionR;
+SymanzikGaugeActionF;
+SymanzikGaugeActionD;
+
+
+ConjugateWilsonGaugeActionR;
+ConjugateWilsonGaugeActionF;
+ConjugateWilsonGaugeActionD;
+ConjugatePlaqPlusRectangleActionR;
+ConjugatePlaqPlusRectangleActionF;
+ConjugatePlaqPlusRectangleActionD;
+ConjugateIwasakiGaugeActionR;
+ConjugateIwasakiGaugeActionF;
+ConjugateIwasakiGaugeActionD;
+ConjugateSymanzikGaugeActionR;
+ConjugateSymanzikGaugeActionF;
+ConjugateSymanzikGaugeActionD;
+
+
+ScalarActionR;
+ScalarActionF;
+ScalarActionD;
+
+
+each of these action accept one single parameter at creation time (beta).
+Example for creating a Symanzik action with beta=4.0
+
+	SymanzikGaugeActionR(4.0)
+
+The suffixes R,F,D in the action names refer to the Real
+(the precision is defined at compile time by the --enable-precision flag in the configure),
+Float and Double, that force the precision of the action to be 32, 64 bit respectively.
+
+
+
+
+
+
+
+

lib/qcd/hmc/checkpointers/BaseCheckpointer.h

@@ -0,0 +1,89 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/BaseCheckpointer.h
+
+Copyright (C) 2015
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef BASE_CHECKPOINTER
+#define BASE_CHECKPOINTER
+
+namespace Grid {
+namespace QCD {
+
+class CheckpointerParameters : Serializable {
+ public:
+  GRID_SERIALIZABLE_CLASS_MEMBERS(CheckpointerParameters, 
+  	std::string, config_prefix, 
+  	std::string, rng_prefix, 
+  	int, saveInterval, 
+  	std::string, format, );
+
+  CheckpointerParameters(std::string cf = "cfg", std::string rn = "rng",
+   		      int savemodulo = 1, const std::string &f = "IEEE64BIG")
+      : config_prefix(cf),
+        rng_prefix(rn),
+        saveInterval(savemodulo),
+        format(f){};
+
+
+  template <class ReaderClass >
+  CheckpointerParameters(Reader<ReaderClass> &Reader) {
+    read(Reader, "Checkpointer", *this);
+  }
+ 
+
+};
+
+//////////////////////////////////////////////////////////////////////////////
+// Base class for checkpointers
+template <class Impl>
+class BaseHmcCheckpointer : public HmcObservable<typename Impl::Field> {
+ public:
+  void build_filenames(int traj, CheckpointerParameters &Params,
+                       std::string &conf_file, std::string &rng_file) {
+    {
+      std::ostringstream os;
+      os << Params.rng_prefix << "." << traj;
+      rng_file = os.str();
+    }
+
+    {
+      std::ostringstream os;
+      os << Params.config_prefix << "." << traj;
+      conf_file = os.str();
+    }
+ 	} 
+
+  virtual void initialize(const CheckpointerParameters &Params) = 0;
+
+  virtual void CheckpointRestore(int traj, typename Impl::Field &U,
+                                 GridSerialRNG &sRNG,
+                                 GridParallelRNG &pRNG) = 0;
+
+};  // class BaseHmcCheckpointer
+///////////////////////////////////////////////////////////////////////////////
+}
+}
+#endif

lib/qcd/hmc/checkpointers/BinaryCheckpointer.h

@@ -0,0 +1,99 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/BinaryCheckpointer.h
+
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef BINARY_CHECKPOINTER
+#define BINARY_CHECKPOINTER
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace Grid {
+namespace QCD {
+
+// Simple checkpointer, only binary file
+template <class Impl>
+class BinaryHmcCheckpointer : public BaseHmcCheckpointer<Impl> {
+ private:
+  CheckpointerParameters Params;
+
+ public:
+  INHERIT_FIELD_TYPES(Impl);  // Gets the Field type, a Lattice object
+
+  // Extract types from the Field
+  typedef typename Field::vector_object vobj;
+  typedef typename vobj::scalar_object sobj;
+  typedef typename getPrecision<sobj>::real_scalar_type sobj_stype;
+  typedef typename sobj::DoublePrecision sobj_double;
+
+  BinaryHmcCheckpointer(const CheckpointerParameters &Params_) {
+    initialize(Params_);
+  }
+
+  void initialize(const CheckpointerParameters &Params_) { Params = Params_; }
+
+  void truncate(std::string file) {
+    std::ofstream fout(file, std::ios::out);
+    fout.close();
+  }
+
+  void TrajectoryComplete(int traj, Field &U, GridSerialRNG &sRNG,
+                          GridParallelRNG &pRNG) {
+    if ((traj % Params.saveInterval) == 0) {
+      std::string config, rng;
+      this->build_filenames(traj, Params, config, rng);
+
+      BinaryIO::BinarySimpleUnmunger<sobj_double, sobj> munge;
+      truncate(rng);
+      BinaryIO::writeRNGSerial(sRNG, pRNG, rng, 0);
+      truncate(config);
+      uint32_t csum = BinaryIO::writeObjectParallel<vobj, sobj_double>(
+          U, config, munge, 0, Params.format);
+
+      std::cout << GridLogMessage << "Written Binary Configuration " << config
+                << " checksum " << std::hex << csum << std::dec << std::endl;
+    }
+  };
+
+  void CheckpointRestore(int traj, Field &U, GridSerialRNG &sRNG,
+                         GridParallelRNG &pRNG) {
+    std::string config, rng;
+    this->build_filenames(traj, Params, config, rng);
+
+    BinaryIO::BinarySimpleMunger<sobj_double, sobj> munge;
+    BinaryIO::readRNGSerial(sRNG, pRNG, rng, 0);
+    uint32_t csum = BinaryIO::readObjectParallel<vobj, sobj_double>(
+        U, config, munge, 0, Params.format);
+
+    std::cout << GridLogMessage << "Read Binary Configuration " << config
+              << " checksum " << std::hex << csum << std::dec << std::endl;
+  };
+};
+}
+}
+#endif

lib/qcd/hmc/checkpointers/CheckPointerModules.h

@@ -0,0 +1,158 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#ifndef CP_MODULES_H
+#define CP_MODULES_H
+
+
+// FIXME  Reorganize QCD namespace 
+
+
+namespace Grid {
+
+////////////////////////////////////////////////////////////////////////
+// Checkpoint module, owns the Checkpointer
+////////////////////////////////////////////////////////////////////////
+
+template <class ImplementationPolicy>
+class CheckPointerModule: public Parametrized<QCD::CheckpointerParameters>, public HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> >  {
+ public:
+ 	std::unique_ptr<QCD::BaseHmcCheckpointer<ImplementationPolicy> > CheckPointPtr;
+ 	typedef QCD::CheckpointerParameters APar;
+  typedef HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > Base;
+  typedef typename Base::Product Product;
+
+  CheckPointerModule(APar Par): Parametrized<APar>(Par) {}
+  template <class ReaderClass>
+  CheckPointerModule(Reader<ReaderClass>& Reader) : Parametrized<APar>(Reader){};
+
+  virtual void print_parameters(){
+  	std::cout << this->Par_ << std::endl;
+  }
+
+  Product* getPtr() {
+    if (!CheckPointPtr) initialize();
+
+    return CheckPointPtr.get();
+  }
+
+ private:
+  virtual void initialize() = 0;
+
+};
+
+
+
+template <char const *str, class ImplementationPolicy, class ReaderClass >
+class HMC_CPModuleFactory
+    : public Factory < HMCModuleBase< QCD::BaseHmcCheckpointer<ImplementationPolicy> > ,	Reader<ReaderClass> > {
+ public:
+ 	typedef Reader<ReaderClass> TheReader; 
+ 	// use SINGLETON FUNCTOR MACRO HERE
+  HMC_CPModuleFactory(const HMC_CPModuleFactory& e) = delete;
+  void operator=(const HMC_CPModuleFactory& e) = delete;
+  static HMC_CPModuleFactory& getInstance(void) {
+    static HMC_CPModuleFactory e;
+    return e;
+  }
+
+ private:
+  HMC_CPModuleFactory(void) = default;
+  std::string obj_type() const {
+  	return std::string(str);
+  }
+};
+
+
+
+/////////////////////////////////////////////////////////////////////
+// Concrete classes
+/////////////////////////////////////////////////////////////////////
+namespace QCD{
+
+template<class ImplementationPolicy>
+class BinaryCPModule: public CheckPointerModule< ImplementationPolicy> {
+  typedef CheckPointerModule< ImplementationPolicy> CPBase;
+  using CPBase::CPBase; // for constructors
+
+  // acquire resource
+  virtual void initialize(){
+    this->CheckPointPtr.reset(new BinaryHmcCheckpointer<ImplementationPolicy>(this->Par_));
+  }
+
+};
+
+
+template<class ImplementationPolicy>
+class NerscCPModule: public CheckPointerModule< ImplementationPolicy> {
+  typedef CheckPointerModule< ImplementationPolicy> CPBase;
+  using CPBase::CPBase; // for constructors inheritance
+
+  // acquire resource
+  virtual void initialize(){
+     this->CheckPointPtr.reset(new NerscHmcCheckpointer<ImplementationPolicy>(this->Par_));
+  }
+
+};
+
+
+#ifdef HAVE_LIME
+  
+template<class ImplementationPolicy>
+class ILDGCPModule: public CheckPointerModule< ImplementationPolicy> {
+  typedef CheckPointerModule< ImplementationPolicy> CPBase;
+  using CPBase::CPBase; // for constructors
+
+  // acquire resource
+  virtual void initialize(){
+     this->CheckPointPtr.reset(new ILDGHmcCheckpointer<ImplementationPolicy>(this->Par_));
+  }
+
+};
+
+#endif
+
+
+}// QCD temporarily here
+
+
+extern char cp_string[];
+
+/*
+// use macros?
+static Registrar<QCD::BinaryCPModule<QCD::PeriodicGimplR>, HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPBinarymodXMLInit("Binary");
+static Registrar<QCD::NerscCPModule<QCD::PeriodicGimplR> , HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPNerscmodXMLInit("Nersc");
+
+#ifdef HAVE_LIME
+static Registrar<QCD::ILDGCPModule<QCD::PeriodicGimplR>  , HMC_CPModuleFactory<cp_string, QCD::PeriodicGimplR, XmlReader> > __CPILDGmodXMLInit("ILDG");
+#endif
+*/
+
+}// Grid
+#endif //CP_MODULES_H

lib/qcd/hmc/checkpointers/CheckPointers.h

@@ -0,0 +1,40 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/action/gauge/WilsonGaugeAction.h
+
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+
+#ifndef CHECKPOINTERS_H
+#define CHECKPOINTERS_H
+
+#include <Grid/qcd/hmc/checkpointers/BaseCheckpointer.h>
+#include <Grid/qcd/hmc/checkpointers/NerscCheckpointer.h>
+#include <Grid/qcd/hmc/checkpointers/BinaryCheckpointer.h>
+#include <Grid/qcd/hmc/checkpointers/ILDGCheckpointer.h>
+//#include <Grid/qcd/hmc/checkpointers/CheckPointerModules.h>
+
+
+#endif // CHECKPOINTERS_H

lib/qcd/hmc/checkpointers/ILDGCheckpointer.h

@@ -0,0 +1,104 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/ILDGCheckpointer.h
+
+Copyright (C) 2016
+
+Author: Guido Cossu <guido.cossu@ed.ac.uk>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+See the full license in the file "LICENSE" in the top level distribution
+directory
+*************************************************************************************/
+/*  END LEGAL */
+#ifndef ILDG_CHECKPOINTER
+#define ILDG_CHECKPOINTER
+
+#ifdef HAVE_LIME
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace Grid {
+namespace QCD {
+
+// Only for Gauge fields
+template <class Implementation>
+class ILDGHmcCheckpointer : public BaseHmcCheckpointer<Implementation> {
+ private:
+  CheckpointerParameters Params;
+
+ public:
+  INHERIT_GIMPL_TYPES(Implementation);
+
+  ILDGHmcCheckpointer(const CheckpointerParameters &Params_) { initialize(Params_); }
+
+  void initialize(const CheckpointerParameters &Params_) {
+    Params = Params_;
+
+    // check here that the format is valid
+    int ieee32big = (Params.format == std::string("IEEE32BIG"));
+    int ieee32 = (Params.format == std::string("IEEE32"));
+    int ieee64big = (Params.format == std::string("IEEE64BIG"));
+    int ieee64 = (Params.format == std::string("IEEE64"));
+
+    if (!(ieee64big || ieee32 || ieee32big || ieee64)) {
+      std::cout << GridLogError << "Unrecognized file format " << Params.format
+                << std::endl;
+      std::cout << GridLogError
+                << "Allowed: IEEE32BIG | IEEE32 | IEEE64BIG | IEEE64"
+                << std::endl;
+
+      exit(1);
+    }
+  }
+
+  void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG,
+                          GridParallelRNG &pRNG) {
+    if ((traj % Params.saveInterval) == 0) {
+      std::string config, rng;
+      this->build_filenames(traj, Params, config, rng);
+
+      ILDGIO IO(config, ILDGwrite);
+      BinaryIO::writeRNGSerial(sRNG, pRNG, rng, 0);
+      uint32_t csum = IO.writeConfiguration(U, Params.format);
+
+      std::cout << GridLogMessage << "Written ILDG Configuration on " << config
+                << " checksum " << std::hex << csum << std::dec << std::endl;
+    }
+  };
+
+  void CheckpointRestore(int traj, GaugeField &U, GridSerialRNG &sRNG,
+                         GridParallelRNG &pRNG) {
+    std::string config, rng;
+    this->build_filenames(traj, Params, config, rng);
+
+    ILDGIO IO(config, ILDGread);
+    BinaryIO::readRNGSerial(sRNG, pRNG, rng, 0);
+    uint32_t csum = IO.readConfiguration(U);  // format from the header
+
+    std::cout << GridLogMessage << "Read ILDG Configuration from " << config
+              << " checksum " << std::hex << csum << std::dec << std::endl;
+  };
+};
+}
+}
+
+#endif  // HAVE_LIME
+#endif  // ILDG_CHECKPOINTER

lib/qcd/hmc/checkpointers/NerscCheckpointer.h

@@ -0,0 +1,80 @@
+/*************************************************************************************
+
+Grid physics library, www.github.com/paboyle/Grid
+
+Source file: ./lib/qcd/hmc/NerscCheckpointer.h
+
+Copyright (C) 2015
+
+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 NERSC_CHECKPOINTER
+#define NERSC_CHECKPOINTER
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+namespace Grid {
+namespace QCD {
+
+// Only for Gauge fields
+template <class Gimpl>
+class NerscHmcCheckpointer : public BaseHmcCheckpointer<Gimpl> {
+ private:
+  CheckpointerParameters Params;
+
+ public:
+  INHERIT_GIMPL_TYPES(Gimpl);  // only for gauge configurations
+
+  NerscHmcCheckpointer(const CheckpointerParameters &Params_) { initialize(Params_); }
+
+  void initialize(const CheckpointerParameters &Params_) {
+    Params = Params_;
+    Params.format = "IEEE64BIG";  // fixed, overwrite any other choice
+  }
+
+  void TrajectoryComplete(int traj, GaugeField &U, GridSerialRNG &sRNG,
+                          GridParallelRNG &pRNG) {
+    if ((traj % Params.saveInterval) == 0) {
+      std::string config, rng;
+      this->build_filenames(traj, Params, config, rng);
+
+      int precision32 = 1;
+      int tworow = 0;
+      NerscIO::writeRNGState(sRNG, pRNG, rng);
+      NerscIO::writeConfiguration(U, config, tworow, precision32);
+    }
+  };
+
+  void CheckpointRestore(int traj, GaugeField &U, GridSerialRNG &sRNG,
+                         GridParallelRNG &pRNG) {
+    std::string config, rng;
+    this->build_filenames(traj, Params, config, rng);
+
+    NerscField header;
+    NerscIO::readRNGState(sRNG, pRNG, header, rng);
+    NerscIO::readConfiguration(U, header, config);
+  };
+};
+}
+}
+#endif

lib/qcd/hmc/integrators/Integrator.h

@@ -8,8 +8,7 @@ Copyright (C) 2015
 
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
-Author: neo <cossu@post.kek.jp>
+Author: Guido Cossu <cossu@post.kek.jp>
-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
@@ -30,79 +29,62 @@ directory
 *************************************************************************************/
 /*  END LEGAL */
 //--------------------------------------------------------------------
-/*! @file Integrator.h
- * @brief Classes for the Molecular Dynamics integrator
- *
- * @author Guido Cossu
- * Time-stamp: <2015-07-30 16:21:29 neo>
- */
-//--------------------------------------------------------------------
-
 #ifndef INTEGRATOR_INCLUDED
 #define INTEGRATOR_INCLUDED
 
-// class Observer;
-
 #include <memory>
 
 namespace Grid {
 namespace QCD {
 
-struct IntegratorParameters {
+class IntegratorParameters: Serializable {
-  int Nexp;
+public:
-  int MDsteps;  // number of outer steps
+        GRID_SERIALIZABLE_CLASS_MEMBERS(IntegratorParameters,
-  RealD trajL;  // trajectory length
+                std::string, name,      // name of the integrator
-  RealD stepsize;
+    unsigned int, MDsteps,  // number of outer steps
+    RealD, trajL,           // trajectory length
+  )
 
-  IntegratorParameters(int MDsteps_, RealD trajL_ = 1.0, int Nexp_ = 12)
+  IntegratorParameters(int MDsteps_ = 10, RealD trajL_ = 1.0)
-      : Nexp(Nexp_),
+      : MDsteps(MDsteps_),
-        MDsteps(MDsteps_),
+        trajL(trajL_){
-        trajL(trajL_),
-        stepsize(trajL / MDsteps){
         // empty body constructor
   };
+
+
+  template <class ReaderClass, typename std::enable_if<isReader<ReaderClass>::value, int >::type = 0 >
+  IntegratorParameters(ReaderClass & Reader){
+    std::cout << "Reading integrator\n";
+        read(Reader, "Integrator", *this);
+  }
+
+  void print_parameters() const {
+    std::cout << GridLogMessage << "[Integrator] Type               : " << name << std::endl;
+    std::cout << GridLogMessage << "[Integrator] Trajectory length  : " << trajL << std::endl;
+    std::cout << GridLogMessage << "[Integrator] Number of MD steps : " << MDsteps << std::endl;
+    std::cout << GridLogMessage << "[Integrator] Step size          : " << trajL/MDsteps << std::endl;
+  }
 };
 
 /*! @brief Class for Molecular Dynamics management */
-template <class GaugeField, class SmearingPolicy, class RepresentationPolicy>
+template <class FieldImplementation, class SmearingPolicy, class RepresentationPolicy>
 class Integrator {
  protected:
-  typedef IntegratorParameters ParameterType;
+  typedef typename FieldImplementation::Field MomentaField;  //for readability
+  typedef typename FieldImplementation::Field Field;
 
+  int levels;  // number of integration levels
+  double t_U;  // Track time passing on each level and for U and for P
+  std::vector<double> t_P;  
+
+  MomentaField P;
+  SmearingPolicy& Smearer;
+  RepresentationPolicy Representations;
   IntegratorParameters Params;
 
-  const ActionSet<GaugeField, RepresentationPolicy> as;
+  const ActionSet<Field, RepresentationPolicy> as;
 
-  int levels;  //
+  void update_P(Field& U, int level, double ep) {
-  double t_U;  // Track time passing on each level and for U and for P
-  std::vector<double> t_P;  //
-
-  GaugeField P;
-
-  SmearingPolicy& Smearer;
-
-  RepresentationPolicy Representations;
-
-  // Should match any legal (SU(n)) gauge field
-  // Need to use this template to match Ncol to pass to SU<N> class
-  template <int Ncol, class vec>
-  void generate_momenta(Lattice<iVector<iScalar<iMatrix<vec, Ncol> >, Nd> >& P,
-                        GridParallelRNG& pRNG) {
-    typedef Lattice<iScalar<iScalar<iMatrix<vec, Ncol> > > > GaugeLinkField;
-    GaugeLinkField Pmu(P._grid);
-    Pmu = zero;
-    for (int mu = 0; mu < Nd; mu++) {
-      SU<Ncol>::GaussianFundamentalLieAlgebraMatrix(pRNG, Pmu);
-      PokeIndex<LorentzIndex>(P, Pmu, mu);
-    }
-  }
-
-  // ObserverList observers; // not yet
-  //      typedef std::vector<Observer*> ObserverList;
-  //      void register_observers();
-  //      void notify_observers();
-
-  void update_P(GaugeField& U, int level, double ep) {
     t_P[level] += ep;
     update_P(P, U, level, ep);
 
@@ -120,31 +102,29 @@ class Integrator {
         FieldType forceR(U._grid);
         // Implement smearing only for the fundamental representation now
         repr_set.at(a)->deriv(Rep.U, forceR);
-        GF force =
+        GF force = Rep.RtoFundamentalProject(forceR);  // Ta for the fundamental rep
-            Rep.RtoFundamentalProject(forceR);  // Ta for the fundamental rep
+        Real force_abs = std::sqrt(norm2(force)/(U._grid->gSites()));
-        std::cout << GridLogIntegrator << "Hirep Force average: "
+        std::cout << GridLogIntegrator << "Hirep Force average: " << force_abs << std::endl;
-                  << norm2(force) / (U._grid->gSites()) << std::endl;
         Mom -= force * ep ;
       }
     }
   } update_P_hireps{};
 
-  void update_P(GaugeField& Mom, GaugeField& U, int level, double ep) {
+  void update_P(MomentaField& Mom, Field& U, int level, double ep) {
     // input U actually not used in the fundamental case
     // Fundamental updates, include smearing
+
    for (int a = 0; a < as[level].actions.size(); ++a) {
-      GaugeField force(U._grid);
+      Field force(U._grid);
-      GaugeField& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared);
+      conformable(U._grid, Mom._grid);
+      Field& Us = Smearer.get_U(as[level].actions.at(a)->is_smeared);
       as[level].actions.at(a)->deriv(Us, force);  // deriv should NOT include Ta
 
-      std::cout << GridLogIntegrator
+      std::cout << GridLogIntegrator << "Smearing (on/off): " << as[level].actions.at(a)->is_smeared << std::endl;
-                << "Smearing (on/off): " << as[level].actions.at(a)->is_smeared
-                << std::endl;
       if (as[level].actions.at(a)->is_smeared) Smearer.smeared_force(force);
-      force = Ta(force);
+      force = FieldImplementation::projectForce(force); // Ta for gauge fields
-      std::cout << GridLogIntegrator
+      Real force_abs = std::sqrt(norm2(force)/U._grid->gSites());
-                << "Force average: " << norm2(force) / (U._grid->gSites())
+      std::cout << GridLogIntegrator << "Force average: " << force_abs << std::endl;
-                << std::endl;
       Mom -= force * ep; 
     }
 
@@ -152,35 +132,30 @@ class Integrator {
     as[level].apply(update_P_hireps, Representations, Mom, U, ep);
   }
 
-  void update_U(GaugeField& U, double ep) {
+  void update_U(Field& U, double ep) {
     update_U(P, U, ep);
 
     t_U += ep;
     int fl = levels - 1;
-    std::cout << GridLogIntegrator << "   "
+    std::cout << GridLogIntegrator << "   " << "[" << fl << "] U " << " dt " << ep << " : t_U " << t_U << std::endl;
-              << "[" << fl << "] U "
-              << " dt " << ep << " : t_U " << t_U << std::endl;
-  }
-  void update_U(GaugeField& Mom, GaugeField& U, double ep) {
-    // rewrite exponential to deal internally with the lorentz index?
-    for (int mu = 0; mu < Nd; mu++) {
-      auto Umu = PeekIndex<LorentzIndex>(U, mu);
-      auto Pmu = PeekIndex<LorentzIndex>(Mom, mu);
-      Umu = expMat(Pmu, ep, Params.Nexp) * Umu;
-      PokeIndex<LorentzIndex>(U, ProjectOnGroup(Umu), mu);
   }
   
+  void update_U(MomentaField& Mom, Field& U, double ep) {
+    // exponential of Mom*U in the gauge fields case
+    FieldImplementation::update_field(Mom, U, ep);
+
     // Update the smeared fields, can be implemented as observer
-    Smearer.set_GaugeField(U);
+    Smearer.set_Field(U);
+
     // Update the higher representations fields
     Representations.update(U);  // void functions if fundamental representation
   }
 
-  virtual void step(GaugeField& U, int level, int first, int last) = 0;
+  virtual void step(Field& U, int level, int first, int last) = 0;
 
  public:
   Integrator(GridBase* grid, IntegratorParameters Par,
-             ActionSet<GaugeField, RepresentationPolicy>& Aset,
+             ActionSet<Field, RepresentationPolicy>& Aset,
              SmearingPolicy& Sm)
       : Params(Par),
         as(Aset),
@@ -195,6 +170,31 @@ class Integrator {
 
   virtual ~Integrator() {}
 
+  virtual std::string integrator_name() = 0;
+
+  void print_parameters(){
+    std::cout << GridLogMessage << "[Integrator] Name : "<< integrator_name() << std::endl;
+    Params.print_parameters();
+  }
+
+  void print_actions(){
+        std::cout << GridLogMessage << ":::::::::::::::::::::::::::::::::::::::::" << std::endl;
+        std::cout << GridLogMessage << "[Integrator] Action summary: "<<std::endl;
+        for (int level = 0; level < as.size(); ++level) {
+                std::cout << GridLogMessage << "[Integrator] ---- Level: "<< level << std::endl;
+                for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
+                        std::cout << GridLogMessage << "["<< as[level].actions.at(actionID)->action_name() << "] ID: " << actionID << std::endl;
+                        std::cout << as[level].actions.at(actionID)->LogParameters();
+                }
+        }
+        std::cout << GridLogMessage << ":::::::::::::::::::::::::::::::::::::::::"<< std::endl;
+
+  }
+
+  void reverse_momenta(){
+    P *= -1.0;
+  }
+
   // to be used by the actionlevel class to iterate
   // over the representations
   struct _refresh {
@@ -210,14 +210,16 @@ class Integrator {
   } refresh_hireps{};
 
   // Initialization of momenta and actions
-  void refresh(GaugeField& U, GridParallelRNG& pRNG) {
+  void refresh(Field& U, GridParallelRNG& pRNG) {
+    assert(P._grid == U._grid);
     std::cout << GridLogIntegrator << "Integrator refresh\n";
-    generate_momenta(P, pRNG);
+
+    FieldImplementation::generate_momenta(P, pRNG);
 
     // Update the smeared fields, can be implemented as observer
     // necessary to keep the fields updated even after a reject
     // of the Metropolis
-    Smearer.set_GaugeField(U);
+    Smearer.set_Field(U);
     // Set the (eventual) representations gauge fields
     Representations.update(U);
 
@@ -228,7 +230,7 @@ class Integrator {
       for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
         // get gauge field from the SmearingPolicy and
         // based on the boolean is_smeared in actionID
-        GaugeField& Us =
+        Field& Us =
             Smearer.get_U(as[level].actions.at(actionID)->is_smeared);
         as[level].actions.at(actionID)->refresh(Us, pRNG);
       }
@@ -256,18 +258,9 @@ class Integrator {
   } S_hireps{};
 
   // Calculate action
-  RealD S(GaugeField& U) {  // here also U not used
+  RealD S(Field& U) {  // here also U not used
 
-    LatticeComplex Hloc(U._grid);
+    RealD H = - FieldImplementation::FieldSquareNorm(P); // - trace (P*P)
-    Hloc = zero;
-    // Momenta
-    for (int mu = 0; mu < Nd; mu++) {
-      auto Pmu = PeekIndex<LorentzIndex>(P, mu);
-      Hloc -= trace(Pmu * Pmu);
-    }
-    Complex Hsum = sum(Hloc);
-
-    RealD H = Hsum.real();
     RealD Hterm;
     std::cout << GridLogMessage << "Momentum action H_p = " << H << "\n";
 
@@ -276,7 +269,7 @@ class Integrator {
       for (int actionID = 0; actionID < as[level].actions.size(); ++actionID) {
         // get gauge field from the SmearingPolicy and
         // based on the boolean is_smeared in actionID
-        GaugeField& Us =
+        Field& Us =
             Smearer.get_U(as[level].actions.at(actionID)->is_smeared);
         Hterm = as[level].actions.at(actionID)->S(Us);
         std::cout << GridLogMessage << "S Level " << level << " term "
@@ -289,7 +282,7 @@ class Integrator {
     return H;
   }
 
-  void integrate(GaugeField& U) {
+  void integrate(Field& U) {
     // reset the clocks
     t_U = 0;
     for (int level = 0; level < as.size(); ++level) {
@@ -311,8 +304,14 @@ class Integrator {
 
     // and that we indeed got to the end of the trajectory
     assert(fabs(t_U - Params.trajL) < 1.0e-6);
+
   }
+
+
+  
+
 };
 }
 }
 #endif  // INTEGRATOR_INCLUDED
+

lib/qcd/hmc/integrators/Integrator_algorithm.h

@@ -1,46 +1,48 @@
-    /*************************************************************************************
+/*************************************************************************************
 
-    Grid physics library, www.github.com/paboyle/Grid 
+Grid physics library, www.github.com/paboyle/Grid
 
-    Source file: ./lib/qcd/hmc/integrators/Integrator_algorithm.h
+Source file: ./lib/qcd/hmc/integrators/Integrator_algorithm.h
 
-    Copyright (C) 2015
+Copyright (C) 2015
 
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
 Author: neo <cossu@post.kek.jp>
 
-    This program is free software; you can redistribute it and/or modify
+This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
+it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
+the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+(at your option) any later version.
 
-    This program is distributed in the hope that it will be useful,
+This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
+GNU General Public License for more details.
 
-    You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
+with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-    See the full license in the file "LICENSE" in the top level distribution directory
+See the full license in the file "LICENSE" in the top level distribution
-    *************************************************************************************/
+directory
-    /*  END LEGAL */
+*************************************************************************************/
+/*  END LEGAL */
 //--------------------------------------------------------------------
+
+
 /*! @file Integrator_algorithm.h
  * @brief Declaration of classes for the Molecular Dynamics algorithms
  *
- * @author Guido Cossu
  */
 //--------------------------------------------------------------------
 
 #ifndef INTEGRATOR_ALG_INCLUDED
 #define INTEGRATOR_ALG_INCLUDED
 
-namespace Grid{
+namespace Grid {
-  namespace QCD{
+namespace QCD {
 
-   /* PAB:
+/* PAB:
  *
  * Recursive leapfrog; explanation of nested stepping
  *
@@ -91,141 +93,146 @@ namespace Grid{
  *  P 1/2                            P 1/2
  */
 
-    template<class GaugeField,
+template <class FieldImplementation, class SmearingPolicy,
-	     class SmearingPolicy,
+          class RepresentationPolicy =
-	     class RepresentationPolicy = Representations< FundamentalRepresentation > > class LeapFrog :
+              Representations<FundamentalRepresentation> >
-      public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> {
+class LeapFrog : public Integrator<FieldImplementation, SmearingPolicy,
+                                   RepresentationPolicy> {
  public:
+  typedef LeapFrog<FieldImplementation, SmearingPolicy, RepresentationPolicy>
+      Algorithm;
+  INHERIT_FIELD_TYPES(FieldImplementation);
 
-      typedef LeapFrog<GaugeField, SmearingPolicy, RepresentationPolicy> Algorithm;
+  std::string integrator_name(){return "LeapFrog";}
 
-      LeapFrog(GridBase* grid, 
+  LeapFrog(GridBase* grid, IntegratorParameters Par,
-	       IntegratorParameters Par,
+           ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
-	       ActionSet<GaugeField, RepresentationPolicy> & Aset,
+      : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
-	       SmearingPolicy & Sm):
+            grid, Par, Aset, Sm){};
-	Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset,Sm) {};
 
-
+  void step(Field& U, int level, int _first, int _last) {
-      void step (GaugeField& U, int level,int _first, int _last){
+    int fl = this->as.size() - 1;
-
-	int fl = this->as.size() -1;
     // level  : current level
     // fl     : final level
     // eps    : current step size
 
     // Get current level step size
-        RealD eps = this->Params.stepsize;
+    RealD eps = this->Params.trajL/this->Params.MDsteps;
-	for(int l=0; l<=level; ++l) eps/= this->as[l].multiplier;
+    for (int l = 0; l <= level; ++l) eps /= this->as[l].multiplier;
 
     int multiplier = this->as[level].multiplier;
-	for(int e=0; e<multiplier; ++e){
+    for (int e = 0; e < multiplier; ++e) {
+      int first_step = _first && (e == 0);
+      int last_step = _last && (e == multiplier - 1);
 
-	  int first_step = _first && (e==0);
+      if (first_step) {  // initial half step
-	  int last_step  = _last  && (e==multiplier-1);
+        this->update_P(U, level, eps / 2.0);
-
-	  if(first_step){    // initial half step
-	    this->update_P(U, level,eps/2.0);
       }
 
-	  if(level == fl){          // lowest level
+      if (level == fl) {  // lowest level
         this->update_U(U, eps);
-	  }else{                 // recursive function call
+      } else {  // recursive function call
-	    this->step(U, level+1,first_step,last_step);
+        this->step(U, level + 1, first_step, last_step);
       }
 
       int mm = last_step ? 1 : 2;
-	  this->update_P(U, level,mm*eps/2.0);	    
+      this->update_P(U, level, mm * eps / 2.0);
-
     }
   }
-    };
+};
 
-    template<class GaugeField,
+template <class FieldImplementation, class SmearingPolicy,
-	     class SmearingPolicy,
+          class RepresentationPolicy =
-	     class RepresentationPolicy = Representations < FundamentalRepresentation > > class MinimumNorm2 :
+              Representations<FundamentalRepresentation> >
-      public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> {
+class MinimumNorm2 : public Integrator<FieldImplementation, SmearingPolicy,
+                                       RepresentationPolicy> {
  private:
   const RealD lambda = 0.1931833275037836;
 
  public:
+  INHERIT_FIELD_TYPES(FieldImplementation);
 
-      MinimumNorm2(GridBase* grid, 
+  MinimumNorm2(GridBase* grid, IntegratorParameters Par,
-		   IntegratorParameters Par,
+               ActionSet<Field, RepresentationPolicy>& Aset, SmearingPolicy& Sm)
-		   ActionSet<GaugeField, RepresentationPolicy> & Aset,
+      : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
-		   SmearingPolicy& Sm):
+            grid, Par, Aset, Sm){};
-	Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset,Sm) {};
 
-      void step (GaugeField& U, int level, int _first,int _last){
+  std::string integrator_name(){return "MininumNorm2";}
 
+  void step(Field& U, int level, int _first, int _last) {
     // level  : current level
     // fl     : final level
     // eps    : current step size
 
-	int fl = this->as.size() -1;
+    int fl = this->as.size() - 1;
 
-	RealD eps = this->Params.stepsize*2.0;                              
+    RealD eps = this->Params.trajL/this->Params.MDsteps * 2.0;
-	for(int l=0; l<=level; ++l) eps/= 2.0*this->as[l].multiplier;   
+    for (int l = 0; l <= level; ++l) eps /= 2.0 * this->as[l].multiplier;
 
     // Nesting:  2xupdate_U of size eps/2
     // Next level is eps/2/multiplier
 
     int multiplier = this->as[level].multiplier;
-	for(int e=0; e<multiplier; ++e){       // steps per step
+    for (int e = 0; e < multiplier; ++e) {  // steps per step
 
-	  int first_step = _first && (e==0);
+      int first_step = _first && (e == 0);
-	  int last_step  = _last  && (e==multiplier-1);
+      int last_step = _last && (e == multiplier - 1);
 
-	  if(first_step){    // initial half step 
+      if (first_step) {  // initial half step
-	    this->update_P(U,level,lambda*eps);
+        this->update_P(U, level, lambda * eps);
       }
 
-	  if(level == fl){          // lowest level 
+      if (level == fl) {  // lowest level
-	    this->update_U(U,0.5*eps);
+        this->update_U(U, 0.5 * eps);
-	  }else{                 // recursive function call 
+      } else {  // recursive function call
-	    this->step(U,level+1,first_step,0);
+        this->step(U, level + 1, first_step, 0);
       }
 
-	  this->update_P(U,level,(1.0-2.0*lambda)*eps);
+      this->update_P(U, level, (1.0 - 2.0 * lambda) * eps);
 
-	  if(level == fl){          // lowest level 
+      if (level == fl) {  // lowest level
-	    this->update_U(U,0.5*eps);
+        this->update_U(U, 0.5 * eps);
-	  }else{                 // recursive function call 
+      } else {  // recursive function call
-	    this->step(U,level+1,0,last_step);
+        this->step(U, level + 1, 0, last_step);
       }
 
       int mm = (last_step) ? 1 : 2;
-	  this->update_P(U,level,lambda*eps*mm);
+      this->update_P(U, level, lambda * eps * mm);
-
     }
   }
-    };
+};
 
-
+template <class FieldImplementation, class SmearingPolicy,
-    template<class GaugeField,
+          class RepresentationPolicy =
-	     class SmearingPolicy,
+              Representations<FundamentalRepresentation> >
-	     class RepresentationPolicy = Representations< FundamentalRepresentation > > class ForceGradient :
+class ForceGradient : public Integrator<FieldImplementation, SmearingPolicy,
-      public Integrator<GaugeField, SmearingPolicy, RepresentationPolicy> {
+                                        RepresentationPolicy> {
  private:
-      const RealD lambda = 1.0/6.0;;
+  const RealD lambda = 1.0 / 6.0;
-      const RealD chi    = 1.0/72.0;
+  ;
+  const RealD chi = 1.0 / 72.0;
   const RealD xi = 0.0;
   const RealD theta = 0.0;
+
  public:
+  INHERIT_FIELD_TYPES(FieldImplementation);
 
   // Looks like dH scales as dt^4. tested wilson/wilson 2 level.
-    ForceGradient(GridBase* grid, 
+  ForceGradient(GridBase* grid, IntegratorParameters Par,
-		  IntegratorParameters Par,
+                ActionSet<Field, RepresentationPolicy>& Aset,
-		  ActionSet<GaugeField, RepresentationPolicy> & Aset,
+                SmearingPolicy& Sm)
-		  SmearingPolicy &Sm):
+      : Integrator<FieldImplementation, SmearingPolicy, RepresentationPolicy>(
-      Integrator<GaugeField, SmearingPolicy, RepresentationPolicy>(grid,Par,Aset, Sm) {};
+            grid, Par, Aset, Sm){};
 
+  std::string integrator_name(){return "ForceGradient";}
   
-      void FG_update_P(GaugeField&U, int level,double fg_dt,double ep){
+  void FG_update_P(Field& U, int level, double fg_dt, double ep) {
-	GaugeField Ufg(U._grid);
+    Field Ufg(U._grid);
-	GaugeField Pfg(U._grid);
+    Field Pfg(U._grid);
     Ufg = U;
     Pfg = zero;
-	std::cout << GridLogMessage << "FG update "<<fg_dt<<" "<<ep<<std::endl;
+    std::cout << GridLogMessage << "FG update " << fg_dt << " " << ep
+              << std::endl;
     // prepare_fg; no prediction/result cache for now
     // could relax CG stopping conditions for the
     // derivatives in the small step since the force gets multiplied by
@@ -234,54 +241,55 @@ namespace Grid{
     // Presently 4 force evals, and should have 3, so 1.33x too expensive.
     // could reduce this with sloppy CG to perhaps 1.15x too expensive
     // even without prediction.
-	this->update_P(Pfg,Ufg,level,1.0); 
+    this->update_P(Pfg, Ufg, level, 1.0);
-	this->update_U(Pfg,Ufg,fg_dt);
+    this->update_U(Pfg, Ufg, fg_dt);
-	this->update_P(Ufg,level,ep);
+    this->update_P(Ufg, level, ep);
   }
 
-      void step (GaugeField& U, int level, int _first,int _last){
+  void step(Field& U, int level, int _first, int _last) {
+    RealD eps = this->Params.trajL/this->Params.MDsteps * 2.0;
+    for (int l = 0; l <= level; ++l) eps /= 2.0 * this->as[l].multiplier;
 
-	RealD eps = this->Params.stepsize*2.0;                              
+    RealD Chi = chi * eps * eps * eps;
-	for(int l=0; l<=level; ++l) eps/= 2.0*this->as[l].multiplier;
 
-	RealD Chi   = chi*eps*eps*eps;
+    int fl = this->as.size() - 1;
-
-	int fl = this->as.size() -1;
 
     int multiplier = this->as[level].multiplier;
 
-	for(int e=0; e<multiplier; ++e){       // steps per step
+    for (int e = 0; e < multiplier; ++e) {  // steps per step
 
+      int first_step = _first && (e == 0);
+      int last_step = _last && (e == multiplier - 1);
 
-	  int first_step = _first && (e==0);
+      if (first_step) {  // initial half step
-	  int last_step  = _last  && (e==multiplier-1);
+        this->update_P(U, level, lambda * eps);
-
-	  if(first_step){    // initial half step 
-	    this->update_P(U,level,lambda*eps);
       }
 
-	  if(level == fl){          // lowest level 
+      if (level == fl) {  // lowest level
-	    this->update_U(U,0.5*eps);
+        this->update_U(U, 0.5 * eps);
-	  }else{                 // recursive function call 
+      } else {  // recursive function call
-	    this->step(U,level+1,first_step,0);
+        this->step(U, level + 1, first_step, 0);
       }
 
-	  this->FG_update_P(U,level,2*Chi/((1.0-2.0*lambda)*eps),(1.0-2.0*lambda)*eps);
+      this->FG_update_P(U, level, 2 * Chi / ((1.0 - 2.0 * lambda) * eps),
+                        (1.0 - 2.0 * lambda) * eps);
 
-	  if(level == fl){          // lowest level 
+      if (level == fl) {  // lowest level
-	    this->update_U(U,0.5*eps);
+        this->update_U(U, 0.5 * eps);
-	  }else{                 // recursive function call 
+      } else {  // recursive function call
-	    this->step(U,level+1,0,last_step);
+        this->step(U, level + 1, 0, last_step);
       }
 
       int mm = (last_step) ? 1 : 2;
-	  this->update_P(U,level,lambda*eps*mm); 
+      this->update_P(U, level, lambda * eps * mm);
+    }
+  }
+};
 
-	}
-      }
-    };
 
-  }
+
+
+}
 }
 
-#endif//INTEGRATOR_INCLUDED
+#endif  // INTEGRATOR_INCLUDED