Working on the 5d

lib/qcd/LatticeTheories.h

@@ -1,10 +1,10 @@
-    /*************************************************************************************
+/*************************************************************************************
 
-    Grid physics library, www.github.com/paboyle/Grid 
+Grid physics library, www.github.com/paboyle/Grid
 
-    Source file: ./lib/qcd/QCD.h
+Source file: ./lib/qcd/QCD.h
 
-    Copyright (C) 2015
+Copyright (C) 2015
 
 Author: Azusa Yamaguchi <ayamaguc@staffmail.ed.ac.uk>
 Author: Peter Boyle <paboyle@ph.ed.ac.uk>
@@ -12,28 +12,30 @@ 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
+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 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>
@@ -82,6 +84,13 @@ struct FermionicLatticeGaugeTheory
   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.
@@ -97,10 +106,6 @@ struct QCD : public FermionicLatticeGaugeTheory<4, 3, 4> {
 
     typedef FermionicLatticeGaugeTheory FLGT;
 
-    typedef FLGT::iColourMatrix<Complex  >        ColourMatrix;
-    typedef FLGT::iColourMatrix<ComplexF >        ColourMatrixF;
-    typedef FLGT::iColourMatrix<ComplexD >        ColourMatrixD;
-
     typedef FLGT::iSpinMatrix<Complex  >          SpinMatrix;
     typedef FLGT::iSpinMatrix<ComplexF >          SpinMatrixF;
     typedef FLGT::iSpinMatrix<ComplexD >          SpinMatrixD;

lib/qcd/QCD.h

@@ -46,7 +46,7 @@ namespace QCD {
 
     static const int Nc=3;
     static const int Ns=4;
-    static const int Nd=4;
+    static const int Nd=5;
     static const int Nhs=2; // half spinor
     static const int Nds=8; // double stored gauge field
     static const int Ngp=2; // gparity index range

lib/qcd/action/gauge/WilsonGaugeAction.h

@@ -88,26 +88,31 @@ class VariableWilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
   INHERIT_GIMPL_TYPES(Gimpl);
 
  private:
-  std::vector<RealD> b_bulk;// bulk couplings
+  std::vector<RealD> b_bulk;  // bulk couplings
-  std::vector<RealD> b_xdim;//extra dimension couplings
+  std::vector<RealD> b_xdim;  // extra dimension couplings
   GridBase *grid;
   LatticeComplex beta_xdim;
   LatticeComplex beta_xdim_shifted;
   LatticeComplex beta_bulk;
 
+  int bulk_volume;
+
  public:
   VariableWilsonGaugeAction(std::vector<RealD> bulk, std::vector<RealD> xdim,
-                            GridBase *_grid)
+                            GridBase *_grid, bool openBC = false)
       : b_bulk(bulk),
         b_xdim(xdim),
         grid(_grid),
         beta_xdim(grid),
         beta_xdim_shifted(grid),
-        beta_bulk(grid)
+        beta_bulk(grid) {
-        {
+    // check that the grid is ok
-          //check that the grid is ok
+    // todo
-          //todo
+    int Ndim = Nd;  // change later
-          int Ndim = Nd;//change later
+
+    std::vector<int> FullDim = grid->GlobalDimensions();
+    bulk_volume = 1;
+    for (int s = 0; s < Ndim - 1; s++) bulk_volume *= FullDim[s];
 
     LatticeComplex temp(grid);
 
@@ -115,16 +120,21 @@ class VariableWilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
 
     LatticeCoordinate(coor, Ndim - 1);
 
-          int Nex = grid->_fdimensions[Ndim - 1];
+    int Nex = FullDim[Ndim - 1];
     assert(b_bulk.size() == Nex);
     assert(b_xdim.size() == Nex);
 
     beta_xdim = zero;
-          for (int tau = 0; tau < Nex; tau++) {
+    for (int tau = 0; tau < Nex - 1; tau++) {
       temp = b_xdim[tau];
       beta_xdim = where(coor == tau, temp, beta_xdim);
     }
 
+    if (!openBC) {
+      temp = b_xdim[Nex - 1];
+      beta_xdim = where(coor == Nex - 1, temp, beta_xdim);
+    }
+
     beta_xdim_shifted = Cshift(beta_xdim, Ndim - 1, -1);
 
     beta_bulk = zero;
@@ -132,6 +142,9 @@ class VariableWilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
       temp = b_bulk[tau];
       beta_bulk = where(coor == tau, temp, beta_bulk);
     }
+
+    std::cout << beta_xdim << std::endl;
+    std::cout << beta_xdim_shifted << std::endl;
   };
 
   virtual void refresh(const GaugeField &U,
@@ -150,19 +163,34 @@ class VariableWilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
     LatticeComplex dirPlaq(grid);
     LatticeComplex Plaq(grid);
 
+    LatticeComplex SumdirPlaq(grid);
+
     RealD OneOnNc = 1.0 / Real(Nc);
 
     /////////////
     // Lower dim plaquettes
     /////////////
     Plaq = zero;
+    SumdirPlaq = zero;
     for (int mu = 1; mu < Ndim - 1; mu++) {
       for (int nu = 0; nu < mu; nu++) {
         WilsonLoops<Gimpl>::traceDirPlaquette(dirPlaq, U, mu, nu);
+        SumdirPlaq += dirPlaq;
         Plaq = Plaq + (1.0 - dirPlaq * OneOnNc) * beta_bulk;
       }
     }
 
+    double faces = (1.0 * (Nd - 1) * (Nd - 2)) / 2.0;
+    SumdirPlaq *= OneOnNc / (RealD(bulk_volume) * faces);
+
+    // print slices in the extra dimension
+    int Nex = grid->_fdimensions[Ndim - 1];
+    std::vector<TComplex> plaq_ex(Nex);
+    sliceSum(SumdirPlaq, plaq_ex, Ndim - 1);
+    for (int ex = 0; ex < Nex; ex++)
+      std::cout << GridLogMessage << "Bulk plaq[" << ex
+                << "] = " << TensorRemove(plaq_ex[ex]).real() << std::endl;
+
     /////////////
     // Extra dimension
     /////////////
@@ -186,23 +214,21 @@ class VariableWilsonGaugeAction : public Action<typename Gimpl::GaugeField> {
 
     // for the higher dimension plaquettes take the upper plaq of the
     // 4d slice and multiply by beta[s] and the lower and multiply by beta[s-1]
-    // todo
     // derivative of links mu = 0, ... Nd-1 inside plaq (mu,5)
     // for these I need upper and lower staples separated
     // each multiplied with their own beta
     // derivative of links mu = 5
     // living on the same slice, share the same beta
 
+    conformable(grid, U._grid);
+    int Ndim = Nd;  // change later
+    RealD factor = 0.5 / RealD(Nc);
 
-conformable(grid,U._grid);
+    GaugeLinkField Umu(grid);
-int Ndim = Nd;  // change later
+    GaugeLinkField dSdU_mu(grid);
-RealD factor = 0.5 / RealD(Nc);
+    GaugeLinkField staple(grid);
 
-GaugeLinkField Umu(grid);
+    for (int mu = 0; mu < Ndim; mu++) {
-GaugeLinkField dSdU_mu(grid);
-GaugeLinkField staple(grid);
-
-for (int mu = 0; mu < Ndim; mu++) {
       Umu = PeekIndex<LorentzIndex>(U, mu);
       dSdU_mu = zero;
 
@@ -246,14 +272,8 @@ for (int mu = 0; mu < Ndim; mu++) {
       dSdU_mu = Ta(Umu * dSdU_mu) * factor;
       PokeIndex<LorentzIndex>(dSdU, dSdU_mu, mu);
     }
-
-
-
   };
 };
-
-
-
 }
 }
 

lib/qcd/hmc/GenericHMCrunner.h

@@ -23,9 +23,9 @@ 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
+  See the full license in the file "LICENSE" in the top level distribution
-directory
+  directory
-*************************************************************************************/
+  *************************************************************************************/
 /*  END LEGAL */
 #ifndef GENERIC_HMC_RUNNER
 #define GENERIC_HMC_RUNNER
@@ -33,34 +33,37 @@ directory
 namespace Grid {
 namespace QCD {
 
-// Virtual Class for HMC specific for gauge theories
+  // Virtual Class for HMC specific for gauge theories
-// implement a specific theory by defining the BuildTheAction
+  // implement a specific theory by defining the BuildTheAction
-template <class Implementation,
+  template <class Implementation, class RepresentationsPolicy = NoHirep>
-          class RepresentationsPolicy = NoHirep>
+  class BinaryHmcRunnerTemplate {
-class BinaryHmcRunnerTemplate {
   public:
     INHERIT_FIELD_TYPES(Implementation);
     typedef Implementation ImplPolicy;
 
-  enum StartType_t { ColdStart, HotStart, TepidStart, CheckpointStart };
+    enum StartType_t { ColdStart,
+                       HotStart,
+                       TepidStart,
+                       CheckpointStart };
 
     ActionSet<Field, RepresentationsPolicy> TheAction;
 
     // A vector of HmcObservable
     // that can be injected from outside
-  std::vector< HmcObservable<typename Implementation::Field>* > ObservablesList;
+    std::vector<HmcObservable<typename Implementation::Field> *>
+        ObservablesList;
 
     IntegratorParameters MDparameters;
 
-  GridCartesian *UGrid;
+    GridCartesian *        UGrid;
-  GridCartesian *FGrid;
+    GridCartesian *        FGrid;
     GridRedBlackCartesian *UrbGrid;
     GridRedBlackCartesian *FrbGrid;
 
     std::vector<int> SerialSeed;
     std::vector<int> ParallelSeed;
 
-  void RNGSeeds(std::vector<int> S, std::vector<int> P){
+    void RNGSeeds(std::vector<int> S, std::vector<int> P) {
       SerialSeed   = S;
       ParallelSeed = P;
     }
@@ -80,8 +83,10 @@ class BinaryHmcRunnerTemplate {
     }
     //////////////////////////////
 
-  template <class SmearingPolicy, class IOCheckpointer >
+    template <class SmearingPolicy, class IOCheckpointer>
-  void Runner(int argc, char **argv, IOCheckpointer &Checkpoint,
+    void Runner(int             argc,
+                char **         argv,
+                IOCheckpointer &Checkpoint,
                 SmearingPolicy &Smearing) {
       StartType_t StartType = HotStart;
 
@@ -134,7 +139,8 @@ class BinaryHmcRunnerTemplate {
       GridParallelRNG pRNG(UGrid);
       Field           U(UGrid);
 
-    typedef MinimumNorm2<Implementation, SmearingPolicy,
+      typedef MinimumNorm2<Implementation,
+                           SmearingPolicy,
                            RepresentationsPolicy>
           IntegratorType; // change here to change the algorithm
       IntegratorType MDynamics(UGrid, MDparameters, TheAction, Smearing);
@@ -178,20 +184,18 @@ class BinaryHmcRunnerTemplate {
       // Run it
       HMC.evolve();
     }
-};
+  };
 
-// These are for gauge fields
+  // These are for gauge fields
-typedef BinaryHmcRunnerTemplate<PeriodicGimplR> BinaryHmcRunner;
+  typedef BinaryHmcRunnerTemplate<PeriodicGimplR> BinaryHmcRunner;
-typedef BinaryHmcRunnerTemplate<PeriodicGimplF> BinaryHmcRunnerF;
+  typedef BinaryHmcRunnerTemplate<PeriodicGimplF> BinaryHmcRunnerF;
-typedef BinaryHmcRunnerTemplate<PeriodicGimplD> BinaryHmcRunnerD;
+  typedef BinaryHmcRunnerTemplate<PeriodicGimplD> BinaryHmcRunnerD;
 
-template <class RepresentationsPolicy>
+  template <class RepresentationsPolicy>
-using BinaryHmcRunnerTemplateHirep =
+  using BinaryHmcRunnerTemplateHirep = BinaryHmcRunnerTemplate<PeriodicGimplR, RepresentationsPolicy>;
-    BinaryHmcRunnerTemplate<PeriodicGimplR, RepresentationsPolicy>;
 
-
+  typedef BinaryHmcRunnerTemplate<ScalarImplR, ScalarFields>
-
+      ScalarBinaryHmcRunner;
-    typedef BinaryHmcRunnerTemplate<ScalarImplR, ScalarFields> ScalarBinaryHmcRunner;
 }
 }
 #endif

lib/qcd/hmc/HMC.h

@@ -34,7 +34,6 @@ directory
  * @brief Classes for Hybrid Monte Carlo update
  *
  * @author Guido Cossu
- * Time-stamp: <2015-07-30 16:58:26 neo>
  */
 //--------------------------------------------------------------------
 #ifndef HMC_INCLUDED

lib/qcd/hmc/integrators/Integrator.h

@@ -29,14 +29,6 @@ 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
 

lib/qcd/utils/WilsonLoops.h

@@ -235,7 +235,7 @@ public:
 
       std::vector<GaugeMat> U(Nd, grid);
       for (int d = 0; d < Nd; d++) {
-        U[d] = PeekIndex<LorentzIndex>(Umu, d);
+        U[d] = PeekIndex<LorentzIndex>(Umu, d);// some redundant copies
       }
 
       // mu
@@ -268,7 +268,7 @@ public:
 
       std::vector<GaugeMat> U(Nd, grid);
       for (int d = 0; d < Nd; d++) {
-        U[d] = PeekIndex<LorentzIndex>(Umu, d);
+        U[d] = PeekIndex<LorentzIndex>(Umu, d);// some redundant copies
       }
 
       // mu

tests/hmc/Test_hmc_WilsonGauge_Binary.cc

@@ -79,12 +79,16 @@ class HmcRunner : public BinaryHmcRunner {
 
     // Gauge action
     int Ls = UGrid->_gdimensions[Nd - 1];
-    std::vector<RealD> betat(Ls,5);
+    std::vector<RealD> betat(Ls);
     std::vector<RealD> betas(Ls);
-    betas={5,6,6,5};
+    //betat={5,6,6,6,6,6,6,5};
-    //std:cout << "Betas:" << betas << std::endl;
+    betat={1,1,1,0,1,1,1,1};
-    //VariableWilsonGaugeActionR Waction(betas, betat, UGrid);
+    //betas={5.2,5.5,5.8,6,6,5.8,5.5,5.2};
-    WilsonGaugeActionR Waction(5.6);
+    betas={0,0,0,0,0,0,0,0};
+    bool openBC = false;
+    std:cout << GridLogMessage << "Betas: " << betas << std::endl;
+    VariableWilsonGaugeActionR Waction(betas, betat, UGrid, openBC);
+    //WilsonGaugeActionR Waction(5.6);
 
     // Collect actions
     ActionLevel<Field> Level1(1);