portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2024-11-10 15:55:37 +00:00
Code Releases Activity
a7251f28c7
Grid/lib/qcd/utils/WilsonLoops.h

495 lines
14 KiB
C
Raw Normal View History

Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
/*************************************************************************************
Global edit adding copyright and license info to every source file.
2016-01-02 14:51:32 +00:00
Grid physics library, www.github.com/paboyle/Grid
Source file: ./lib/qcd/utils/WilsonLoops.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
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
*************************************************************************************/
/* END LEGAL */
Adding some wilson loop support
2015-06-05 10:02:36 +01:00
#ifndef QCD_UTILS_WILSON_LOOPS_H
#define QCD_UTILS_WILSON_LOOPS_H
namespace Grid {
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
namespace QCD {
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// Common wilson loop observables
template<class Gimpl>
class WilsonLoops : public Gimpl {
public:
INHERIT_GIMPL_TYPES(Gimpl);
typedef typename Gimpl::GaugeLinkField GaugeMat;
typedef typename Gimpl::GaugeField GaugeLorentz;
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
//////////////////////////////////////////////////
// directed plaquette oriented in mu,nu plane
//////////////////////////////////////////////////
static void dirPlaquette(GaugeMat &plaq,const std::vector<GaugeMat> &U, const int mu, const int nu)
{
// Annoyingly, must use either scope resolution to find dependent base class,
// or this-> ; there is no "this" in a static method. This forces explicit Gimpl scope
// resolution throughout the usage in this file, and rather defeats the purpose of deriving
// from Gimpl.
plaq= Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftForward (U[mu],mu,U[nu])));
}
//////////////////////////////////////////////////
// trace of directed plaquette oriented in mu,nu plane
//////////////////////////////////////////////////
static void traceDirPlaquette(LatticeComplex &plaq, const std::vector<GaugeMat> &U, const int mu, const int nu)
{
GaugeMat sp(U[0]._grid);
dirPlaquette(sp,U,mu,nu);
plaq=trace(sp);
}
//////////////////////////////////////////////////
// sum over all planes of plaquette
//////////////////////////////////////////////////
static void sitePlaquette(LatticeComplex &Plaq,const std::vector<GaugeMat> &U)
{
LatticeComplex sitePlaq(U[0]._grid);
Plaq=zero;
for(int mu=1;mu<Nd;mu++){
for(int nu=0;nu<mu;nu++){
traceDirPlaquette(sitePlaq,U,mu,nu);
Plaq = Plaq + sitePlaq;
}
}
}
//////////////////////////////////////////////////
// sum over all x,y,z,t and over all planes of plaquette
//////////////////////////////////////////////////
static RealD sumPlaquette(const GaugeLorentz &Umu){
std::vector<GaugeMat> U(4,Umu._grid);
for(int mu=0;mu<Nd;mu++){
U[mu] = PeekIndex<LorentzIndex>(Umu,mu);
}
LatticeComplex Plaq(Umu._grid);
sitePlaquette(Plaq,U);
TComplex Tp = sum(Plaq);
Complex p = TensorRemove(Tp);
return p.real();
}
//////////////////////////////////////////////////
// average over all x,y,z,t and over all planes of plaquette
//////////////////////////////////////////////////
static RealD avgPlaquette(const GaugeLorentz &Umu){
RealD sumplaq = sumPlaquette(Umu);
double vol = Umu._grid->gSites();
double faces = (1.0*Nd*(Nd-1))/2.0;
return sumplaq/vol/faces/Nc; // Nd , Nc dependent... FIXME
}
static RealD linkTrace(const GaugeLorentz &Umu){
std::vector<GaugeMat> U(4,Umu._grid);
LatticeComplex Tr(Umu._grid); Tr=zero;
for(int mu=0;mu<Nd;mu++){
U[mu] = PeekIndex<LorentzIndex>(Umu,mu);
Tr = Tr+trace(U[mu]);
}
TComplex Tp = sum(Tr);
Complex p = TensorRemove(Tp);
double vol = Umu._grid->gSites();
return p.real()/vol/4.0/3.0;
};
//////////////////////////////////////////////////
// the sum over all staples on each site
//////////////////////////////////////////////////
static void Staple(GaugeMat &staple,const GaugeLorentz &Umu,int mu){
GridBase *grid = Umu._grid;
std::vector<GaugeMat> U(4,grid);
for(int d=0;d<Nd;d++){
U[d] = PeekIndex<LorentzIndex>(Umu,d);
}
staple = zero;
for(int nu=0;nu<Nd;nu++){
if(nu != mu) {
// mu
// ^
// |__> nu
// __
// |
// __|
//
staple+=Gimpl::ShiftStaple(Gimpl::CovShiftForward (U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftIdentityBackward(U[nu],nu))),mu);
// __
// |
// |__
//
//
staple+=Gimpl::ShiftStaple(Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,U[nu])),mu);
}
}
}
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
//////////////////////////////////////////////////
// the sum over all staples on each site in direction mu,nu
//////////////////////////////////////////////////
static void Staple(GaugeMat &staple,const GaugeLorentz &Umu,int mu, int nu){
GridBase *grid = Umu._grid;
std::vector<GaugeMat> U(4,grid);
for(int d=0;d<Nd;d++){
U[d] = PeekIndex<LorentzIndex>(Umu,d);
}
staple = zero;
if(nu != mu) {
// mu
// ^
// |__> nu
// __
// |
// __|
//
staple+=Gimpl::ShiftStaple(
Gimpl::CovShiftForward (U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftIdentityBackward(U[nu],nu))),mu);
// __
// |
// |__
//
//
staple+=Gimpl::ShiftStaple(
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,U[nu])),mu);
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
}
}
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
//////////////////////////////////////////////////
// the sum over all staples on each site in direction mu,nu, upper part
//////////////////////////////////////////////////
static void StapleUpper(GaugeMat &staple,const GaugeLorentz &Umu,int mu, int nu){
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
GridBase *grid = Umu._grid;
std::vector<GaugeMat> U(4,grid);
for(int d=0;d<Nd;d++){
U[d] = PeekIndex<LorentzIndex>(Umu,d);
}
staple = zero;
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
if(nu != mu) {
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// mu
// ^
// |__> nu
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// __
// |
// __|
//
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
staple+=Gimpl::ShiftStaple(
Gimpl::CovShiftForward (U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftIdentityBackward(U[nu],nu))),mu);
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
}
}
More on smearing routines, writing APEsmear (dev)
2016-02-19 08:15:27 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
//////////////////////////////////////////////////////
// Similar to above for rectangle is required
//////////////////////////////////////////////////////
static void dirRectangle(GaugeMat &rect,const std::vector<GaugeMat> &U, const int mu, const int nu)
{
rect = Gimpl::CovShiftForward(U[mu],mu,Gimpl::CovShiftForward(U[mu],mu,U[nu]))* // ->->|
adj(Gimpl::CovShiftForward(U[nu],nu,Gimpl::CovShiftForward(U[mu],mu,U[mu]))) ;
rect = rect +
Charge conjugation boundary conditions for gauge fields implemented as a policy class, changing the nature of covariant Cshifts used in plaquettes, rectangles and staples. As a result same code is used for the plaq and rect action independent of the BC type. Should probably isolate the BC in a separate class that Gimpl takes as a template param. Do the same with smearing policies. This would then allow composition of BC with smearing etc....
2016-01-02 13:37:25 +00:00
Gimpl::CovShiftForward(U[mu],mu,Gimpl::CovShiftForward(U[nu],nu,U[nu]))* // ->||
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
adj(Gimpl::CovShiftForward(U[nu],nu,Gimpl::CovShiftForward(U[nu],nu,U[mu]))) ;
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
}
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
static void traceDirRectangle(LatticeComplex &rect, const std::vector<GaugeMat> &U, const int mu, const int nu)
{
GaugeMat sp(U[0]._grid);
dirRectangle(sp,U,mu,nu);
rect=trace(sp);
}
static void siteRectangle(LatticeComplex &Rect,const std::vector<GaugeMat> &U)
{
LatticeComplex siteRect(U[0]._grid);
Rect=zero;
for(int mu=1;mu<Nd;mu++){
for(int nu=0;nu<mu;nu++){
traceDirRectangle(siteRect,U,mu,nu);
Rect = Rect + siteRect;
}
}
}
//////////////////////////////////////////////////
// sum over all x,y,z,t and over all planes of plaquette
//////////////////////////////////////////////////
static RealD sumRectangle(const GaugeLorentz &Umu){
std::vector<GaugeMat> U(4,Umu._grid);
for(int mu=0;mu<Nd;mu++){
U[mu] = PeekIndex<LorentzIndex>(Umu,mu);
}
LatticeComplex Rect(Umu._grid);
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
siteRectangle(Rect,U);
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
TComplex Tp = sum(Rect);
Complex p = TensorRemove(Tp);
return p.real();
}
//////////////////////////////////////////////////
// average over all x,y,z,t and over all planes of plaquette
//////////////////////////////////////////////////
static RealD avgRectangle(const GaugeLorentz &Umu){
RealD sumrect = sumRectangle(Umu);
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
double vol = Umu._grid->gSites();
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
double faces = (1.0*Nd*(Nd-1)); // 2 distinct orientations summed
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
return sumrect/vol/faces/Nc; // Nd , Nc dependent... FIXME
}
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
//////////////////////////////////////////////////
// the sum over all staples on each site
//////////////////////////////////////////////////
static void RectStapleDouble(GaugeMat &U2,const GaugeMat & U,int mu){
U2 = U * Cshift(U,mu,1);
}
Charge conjugation boundary conditions for gauge fields implemented as a policy class, changing the nature of covariant Cshifts used in plaquettes, rectangles and staples. As a result same code is used for the plaq and rect action independent of the BC type. Should probably isolate the BC in a separate class that Gimpl takes as a template param. Do the same with smearing policies. This would then allow composition of BC with smearing etc....
2016-01-02 13:37:25 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
////////////////////////////////////////////////////////////////////////////
// Hop by two optimisation strategy does not work nicely with Gparity. (could do,
// but need to track two deep where cross boundary and apply a conjugation).
// Must differentiate this in Gimpl, and use Gimpl::isPeriodicGaugeField to do so .
////////////////////////////////////////////////////////////////////////////
static void RectStapleOptimised(GaugeMat &Stap,std::vector<GaugeMat> &U2,std::vector<GaugeMat> &U,int mu){
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
Stap = zero;
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
GridBase *grid = U[0]._grid;
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
GaugeMat Staple2x1 (grid);
GaugeMat tmp (grid);
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
for(int nu=0;nu<Nd;nu++){
if ( nu!=mu) {
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// Up staple ___ ___
// | |
tmp = Cshift(adj(U[nu]),nu,-1);
tmp = adj(U2[mu])*tmp;
tmp = Cshift(tmp,mu,-2);
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
Staple2x1 = Gimpl::CovShiftForward (U[nu],nu,tmp);
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// Down staple
// |___ ___|
//
tmp = adj(U2[mu])*U[nu];
Staple2x1+= Gimpl::CovShiftBackward(U[nu],nu,Cshift(tmp,mu,-2));
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// ___ ___
// | ___|
// |___ ___|
//
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
Stap+= Cshift(Gimpl::CovShiftForward (U[mu],mu,Staple2x1),mu,1);
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// ___ ___
// |___ |
// |___ ___|
//
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// tmp= Staple2x1* Cshift(U[mu],mu,-2);
// Stap+= Cshift(tmp,mu,1) ;
Stap+= Cshift(Staple2x1,mu,1)*Cshift(U[mu],mu,-1); ;
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
// --
// | |
//
// | |
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
tmp = Cshift(adj(U2[nu]),nu,-2);
tmp = Gimpl::CovShiftBackward(U[mu],mu,tmp);
tmp = U2[nu]*Cshift(tmp,nu,2);
Stap+= Cshift(tmp, mu, 1);
// | |
//
// | |
// --
Optimised version of rectangle term staples. ~3.4x faster than the naive.
2015-12-29 19:22:59 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
tmp = Gimpl::CovShiftBackward(U[mu],mu,U2[nu]);
tmp = adj(U2[nu])*tmp;
tmp = Cshift(tmp,nu,-2);
Stap+=Cshift(tmp, mu, 1);
}}
}
static void RectStaple(GaugeMat &Stap,const GaugeLorentz & Umu,int mu)
{
RectStapleUnoptimised(Stap,Umu,mu);
}
static void RectStaple(const GaugeLorentz & Umu,GaugeMat &Stap,
std::vector<GaugeMat> &U2,
std::vector<GaugeMat> &U, int mu)
{
if ( Gimpl::isPeriodicGaugeField() ){
RectStapleOptimised(Stap,U2,U,mu);
} else {
RectStapleUnoptimised(Stap,Umu,mu);
}
}
static void RectStapleUnoptimised(GaugeMat &Stap,const GaugeLorentz &Umu,int mu){
GridBase *grid = Umu._grid;
std::vector<GaugeMat> U(4,grid);
for(int d=0;d<Nd;d++){
U[d] = PeekIndex<LorentzIndex>(Umu,d);
}
Stap=zero;
for(int nu=0;nu<Nd;nu++){
if ( nu!=mu) {
// __ ___
// | __ |
//
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftForward (U[mu],mu,
Gimpl::CovShiftForward (U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftIdentityBackward(U[nu],nu))))) , mu);
// __
// |__ __ |
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftForward (U[mu],mu,
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[mu],mu, U[nu])))) , mu);
// __
// |__ __ |
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftForward(U[nu],nu,U[mu])))) , mu);
// __ ___
// |__ |
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftForward (U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[nu],nu,U[mu])))) , mu);
// --
// | |
//
// | |
Charge conjugation boundary conditions for gauge fields implemented as a policy class, changing the nature of covariant Cshifts used in plaquettes, rectangles and staples. As a result same code is used for the plaq and rect action independent of the BC type. Should probably isolate the BC in a separate class that Gimpl takes as a template param. Do the same with smearing policies. This would then allow composition of BC with smearing etc....
2016-01-02 13:37:25 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftForward(U[nu],nu,
Gimpl::CovShiftForward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftIdentityBackward(U[nu],nu))))) , mu);
// | |
//
// | |
// --
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
Stap+= Gimpl::ShiftStaple(
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[nu],nu,
Gimpl::CovShiftBackward(U[mu],mu,
Gimpl::CovShiftForward (U[nu],nu,U[nu])))) , mu);
}}
}
Plaq, Rectangle, Iwasaki, Symanzik and DBW2 workign and HMC regresses to http://arxiv.org/pdf/hep-lat/0610075.pdf
2015-12-28 16:38:31 +00:00
Adding some wilson loop support
2015-06-05 10:02:36 +01:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
};
Compile fix
2015-06-05 10:29:42 +01:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
typedef WilsonLoops<PeriodicGimplR> ColourWilsonLoops;
typedef WilsonLoops<PeriodicGimplR> U1WilsonLoops;
typedef WilsonLoops<PeriodicGimplR> SU2WilsonLoops;
typedef WilsonLoops<PeriodicGimplR> SU3WilsonLoops;
Compile fix
2015-06-05 10:29:42 +01:00
Stout smearing compiles (untested)
2016-02-23 18:16:50 +00:00
}}
Adding some wilson loop support
2015-06-05 10:02:36 +01:00
#endif
Copy Permalink