portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-09 21:50:45 +01:00
Code Releases Activity

Merge remote-tracking branch 'upstream/develop' into feature/kl2QED

Browse Source
This commit is contained in:
Vera Guelpers 2019-05-19 14:35:46 +01:00
commit ae5ad986e2
11 changed files with 190 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Grid/qcd/utils/A2Autils.h
View File

@ -1194,17 +1194,18 @@ void A2Autils<FImpl>::ContractWWVV(std::vector<PropagatorField> &WWVV,
for(int t=0;t<N_t;t++){ for(int t=0;t<N_t;t++){
for(int s=0;s<N_s;s++){ for(int s=0;s<N_s;s++){
auto tmp1 = vs[s]._odata[ss]; auto tmp1 = vs[s]._odata[ss];
vobj tmp2 = zero; vobj tmp2 = zero;
vobj tmp3 = zero;
for(int d=d_o;d<MIN(d_o+d_unroll,N_d);d++){ for(int d=d_o;d<MIN(d_o+d_unroll,N_d);d++){
Scalar_v coeff = WW_sd(t,s,d); Scalar_v coeff = WW_sd(t,s,d);
mac(&tmp2 ,& coeff, & vd[d]._odata[ss]); tmp3 = conjugate(vd[d]._odata[ss]);
} mac(&tmp2, &coeff, &tmp3);
}
////////////////////////// //////////////////////////
// Fast outer product of tmp1 with a sum of terms suppressed by d_unroll // Fast outer product of tmp1 with a sum of terms suppressed by d_unroll
////////////////////////// //////////////////////////
tmp2 = conjugate(tmp2);
for(int s1=0;s1<Ns;s1++){ for(int s1=0;s1<Ns;s1++){
for(int s2=0;s2<Ns;s2++){ for(int s2=0;s2<Ns;s2++){
WWVV[t]._odata[ss]()(s1,s2)(0,0) += tmp1()(s1)(0)*tmp2()(s2)(0); WWVV[t]._odata[ss]()(s1,s2)(0,0) += tmp1()(s1)(0)*tmp2()(s2)(0);

72
Grid/qcd/utils/GaugeFix.h
View File

@ -31,6 +31,7 @@ Author: Peter Boyle <paboyle@ph.ed.ac.uk>
namespace Grid { namespace Grid {
namespace QCD { namespace QCD {
template <class Gimpl> template <class Gimpl>
class FourierAcceleratedGaugeFixer : public Gimpl { class FourierAcceleratedGaugeFixer : public Gimpl {
public: public:
@ -45,18 +46,21 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
A[mu] = Ta(U[mu]) * cmi; A[mu] = Ta(U[mu]) * cmi;
} }
} }
static void DmuAmu(const std::vector<GaugeMat> &A,GaugeMat &dmuAmu) { static void DmuAmu(const std::vector<GaugeMat> &A,GaugeMat &dmuAmu,int orthog) {
dmuAmu=zero; dmuAmu=zero;
for(int mu=0;mu<Nd;mu++){ for(int mu=0;mu<Nd;mu++){
dmuAmu = dmuAmu + A[mu] - Cshift(A[mu],mu,-1); if ( mu != orthog ) {
dmuAmu = dmuAmu + A[mu] - Cshift(A[mu],mu,-1);
}
} }
} }
static void SteepestDescentGaugeFix(GaugeLorentz &Umu,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false) {
static void SteepestDescentGaugeFix(GaugeLorentz &Umu,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1) {
GridBase *grid = Umu._grid; GridBase *grid = Umu._grid;
GaugeMat xform(grid); GaugeMat xform(grid);
SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier); SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier,orthog);
} }
static void SteepestDescentGaugeFix(GaugeLorentz &Umu,GaugeMat &xform,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false) { static void SteepestDescentGaugeFix(GaugeLorentz &Umu,GaugeMat &xform,Real & alpha,int maxiter,Real Omega_tol, Real Phi_tol,bool Fourier=false,int orthog=-1) {
GridBase *grid = Umu._grid; GridBase *grid = Umu._grid;
@ -71,15 +75,29 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
GaugeMat dmuAmu(grid); GaugeMat dmuAmu(grid);
{
Real plaq =WilsonLoops<Gimpl>::avgPlaquette(Umu);
Real link_trace=WilsonLoops<Gimpl>::linkTrace(Umu);
if( (orthog>=0) && (orthog<Nd) ){
std::cout << GridLogMessage << " Gauge fixing to Coulomb gauge time="<<orthog<< " plaq= "<<plaq<<" link trace = "<<link_trace<< std::endl;
} else {
std::cout << GridLogMessage << " Gauge fixing to Landau gauge plaq= "<<plaq<<" link trace = "<<link_trace<< std::endl;
}
}
for(int i=0;i<maxiter;i++){ for(int i=0;i<maxiter;i++){
for(int mu=0;mu<Nd;mu++) U[mu]= PeekIndex<LorentzIndex>(Umu,mu); for(int mu=0;mu<Nd;mu++) U[mu]= PeekIndex<LorentzIndex>(Umu,mu);
if ( Fourier==false ) { if ( Fourier==false ) {
trG = SteepestDescentStep(U,xform,alpha,dmuAmu); trG = SteepestDescentStep(U,xform,alpha,dmuAmu,orthog);
} else { } else {
trG = FourierAccelSteepestDescentStep(U,xform,alpha,dmuAmu); trG = FourierAccelSteepestDescentStep(U,xform,alpha,dmuAmu,orthog);
} }
// std::cout << GridLogMessage << "trG "<< trG<< std::endl;
// std::cout << GridLogMessage << "xform "<< norm2(xform)<< std::endl;
// std::cout << GridLogMessage << "dmuAmu "<< norm2(dmuAmu)<< std::endl;
for(int mu=0;mu<Nd;mu++) PokeIndex<LorentzIndex>(Umu,U[mu],mu); for(int mu=0;mu<Nd;mu++) PokeIndex<LorentzIndex>(Umu,U[mu],mu);
// Monitor progress and convergence test // Monitor progress and convergence test
// infrequently to minimise cost overhead // infrequently to minimise cost overhead
@ -106,14 +124,14 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
} }
} }
}; };
static Real SteepestDescentStep(std::vector<GaugeMat> &U,GaugeMat &xform,Real & alpha, GaugeMat & dmuAmu) { static Real SteepestDescentStep(std::vector<GaugeMat> &U,GaugeMat &xform,Real & alpha, GaugeMat & dmuAmu,int orthog) {
GridBase *grid = U[0]._grid; GridBase *grid = U[0]._grid;
std::vector<GaugeMat> A(Nd,grid); std::vector<GaugeMat> A(Nd,grid);
GaugeMat g(grid); GaugeMat g(grid);
GaugeLinkToLieAlgebraField(U,A); GaugeLinkToLieAlgebraField(U,A);
ExpiAlphaDmuAmu(A,g,alpha,dmuAmu); ExpiAlphaDmuAmu(A,g,alpha,dmuAmu,orthog);
Real vol = grid->gSites(); Real vol = grid->gSites();
@ -125,7 +143,7 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
return trG; return trG;
} }
static Real FourierAccelSteepestDescentStep(std::vector<GaugeMat> &U,GaugeMat &xform,Real & alpha, GaugeMat & dmuAmu) { static Real FourierAccelSteepestDescentStep(std::vector<GaugeMat> &U,GaugeMat &xform,Real & alpha, GaugeMat & dmuAmu,int orthog) {
GridBase *grid = U[0]._grid; GridBase *grid = U[0]._grid;
@ -144,31 +162,41 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
GaugeLinkToLieAlgebraField(U,A); GaugeLinkToLieAlgebraField(U,A);
DmuAmu(A,dmuAmu); DmuAmu(A,dmuAmu,orthog);
theFFT.FFT_all_dim(dmuAmu_p,dmuAmu,FFT::forward); std::vector<int> mask(Nd,1);
for(int mu=0;mu<Nd;mu++) if (mu==orthog) mask[mu]=0;
theFFT.FFT_dim_mask(dmuAmu_p,dmuAmu,mask,FFT::forward);
////////////////////////////////// //////////////////////////////////
// Work out Fp = psq_max/ psq... // Work out Fp = psq_max/ psq...
// Avoid singularities in Fp
////////////////////////////////// //////////////////////////////////
std::vector<int> latt_size = grid->GlobalDimensions(); std::vector<int> latt_size = grid->GlobalDimensions();
std::vector<int> coor(grid->_ndimension,0); std::vector<int> coor(grid->_ndimension,0);
for(int mu=0;mu<Nd;mu++) { for(int mu=0;mu<Nd;mu++) {
if ( mu != orthog ) {
Real TwoPiL = M_PI * 2.0/ latt_size[mu]; Real TwoPiL = M_PI * 2.0/ latt_size[mu];
LatticeCoordinate(pmu,mu); LatticeCoordinate(pmu,mu);
pmu = TwoPiL * pmu ; pmu = TwoPiL * pmu ;
psq = psq + 4.0*sin(pmu*0.5)*sin(pmu*0.5); psq = psq + 4.0*sin(pmu*0.5)*sin(pmu*0.5);
}
} }
Complex psqMax(16.0); Complex psqMax(16.0);
Fp = psqMax*one/psq; Fp = psqMax*one/psq;
pokeSite(TComplex(1.0),Fp,coor); pokeSite(TComplex(16.0),Fp,coor);
if( (orthog>=0) && (orthog<Nd) ){
for(int t=0;t<grid->GlobalDimensions()[orthog];t++){
coor[orthog]=t;
pokeSite(TComplex(16.0),Fp,coor);
}
}
dmuAmu_p = dmuAmu_p * Fp; dmuAmu_p = dmuAmu_p * Fp;
theFFT.FFT_all_dim(dmuAmu,dmuAmu_p,FFT::backward); theFFT.FFT_dim_mask(dmuAmu,dmuAmu_p,mask,FFT::backward);
GaugeMat ciadmam(grid); GaugeMat ciadmam(grid);
Complex cialpha(0.0,-alpha); Complex cialpha(0.0,-alpha);
@ -183,11 +211,11 @@ class FourierAcceleratedGaugeFixer : public Gimpl {
return trG; return trG;
} }
static void ExpiAlphaDmuAmu(const std::vector<GaugeMat> &A,GaugeMat &g,Real & alpha, GaugeMat &dmuAmu) { static void ExpiAlphaDmuAmu(const std::vector<GaugeMat> &A,GaugeMat &g,Real & alpha, GaugeMat &dmuAmu,int orthog) {
GridBase *grid = g._grid; GridBase *grid = g._grid;
Complex cialpha(0.0,-alpha); Complex cialpha(0.0,-alpha);
GaugeMat ciadmam(grid); GaugeMat ciadmam(grid);
DmuAmu(A,dmuAmu); DmuAmu(A,dmuAmu,orthog);
ciadmam = dmuAmu*cialpha; ciadmam = dmuAmu*cialpha;
SU<Nc>::taExp(ciadmam,g); SU<Nc>::taExp(ciadmam,g);
} }

26
Hadrons/DiskVector.hpp
View File

@ -395,12 +395,26 @@ void DiskVectorBase<T>::cacheInsert(const unsigned int i, const T &obj) const
auto &freeInd = *freePtr_; auto &freeInd = *freePtr_;
auto &loads = *loadsPtr_; auto &loads = *loadsPtr_;
evict(); // cache miss, evict and store
index[i] = freeInd.top(); if (index.find(i) == index.end())
freeInd.pop(); {
cache[index.at(i)] = obj; evict();
loads.push_back(i); index[i] = freeInd.top();
modified[index.at(i)] = false; freeInd.pop();
cache[index.at(i)] = obj;
loads.push_back(i);
modified[index.at(i)] = false;
}
// cache hit, modify current value
else
{
auto pos = std::find(loads.begin(), loads.end(), i);
cache[index.at(i)] = obj;
modified[index.at(i)] = true;
loads.erase(pos);
loads.push_back(i);
}
#ifdef DV_DEBUG #ifdef DV_DEBUG
std::string msg; std::string msg;

2
Hadrons/Modules/MContraction/A2ALoop.hpp
View File

@ -89,7 +89,7 @@ std::vector<std::string> TA2ALoop<FImpl>::getInput(void)
template <typename FImpl> template <typename FImpl>
std::vector<std::string> TA2ALoop<FImpl>::getOutput(void) std::vector<std::string> TA2ALoop<FImpl>::getOutput(void)
{ {
std::vector<std::string> out = {}; std::vector<std::string> out = {getName()};
return out; return out;
} }

6
Hadrons/Modules/MContraction/WeakEye3pt.hpp
View File

@ -52,7 +52,7 @@ BEGIN_HADRONS_NAMESPACE
* | * |
* one trace | two traces * one trace | two traces
* *
* one trace : tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G*loop*G*qbr*gOut) * one trace : tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G*loop*G)
* two traces: tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G)*tr(loop*G) * two traces: tr(qbr*gOut*qs*adj(gIn)*g5*adj(qbl)*g5*G)*tr(loop*G)
* *
*/ */
@ -118,7 +118,7 @@ template <typename FImpl>
std::vector<std::string> TWeakEye3pt<FImpl>::getInput(void) std::vector<std::string> TWeakEye3pt<FImpl>::getInput(void)
{ {
std::vector<std::string> in = {par().qBarLeft, par().qBarRight, std::vector<std::string> in = {par().qBarLeft, par().qBarRight,
par().qSpectator}; par().qSpectator, par().loop};
return in; return in;
} }
@ -170,7 +170,7 @@ void TWeakEye3pt<FImpl>::execute(void)
r.info.op = G.g; r.info.op = G.g;
// one trace // one trace
corr = trace(qbr*gOut*qst*adj(gIn)*g5*adj(qbl)*g5*G*loop*G*qbr*gOut); corr = trace(qbr*gOut*qst*adj(gIn)*g5*adj(qbl)*g5*G*loop*G);
sliceSum(corr, buf, Tp); sliceSum(corr, buf, Tp);
r.corr.clear(); r.corr.clear();
for (unsigned int t = 0; t < buf.size(); ++t) for (unsigned int t = 0; t < buf.size(); ++t)

9
Hadrons/Modules/MFermion/GaugeProp.hpp
View File

@ -111,13 +111,18 @@ void TGaugeProp<FImpl>::setup(void)
{ {
Ls_ = env().getObjectLs(par().solver); Ls_ = env().getObjectLs(par().solver);
envCreateLat(PropagatorField, getName()); envCreateLat(PropagatorField, getName());
envTmpLat(FermionField, "source", Ls_);
envTmpLat(FermionField, "sol", Ls_);
envTmpLat(FermionField, "tmp"); envTmpLat(FermionField, "tmp");
if (Ls_ > 1) if (Ls_ > 1)
{ {
envTmpLat(FermionField, "source", Ls_);
envTmpLat(FermionField, "sol", Ls_);
envCreateLat(PropagatorField, getName() + "_5d", Ls_); envCreateLat(PropagatorField, getName() + "_5d", Ls_);
} }
else
{
envTmpLat(FermionField, "source");
envTmpLat(FermionField, "sol");
}
} }
// execution /////////////////////////////////////////////////////////////////// // execution ///////////////////////////////////////////////////////////////////

10
Hadrons/Modules/MGauge/GaugeFix.hpp
View File

@ -42,6 +42,8 @@ BEGIN_HADRONS_NAMESPACE
******************************************************************************/ ******************************************************************************/
BEGIN_MODULE_NAMESPACE(MGauge) BEGIN_MODULE_NAMESPACE(MGauge)
GRID_SERIALIZABLE_ENUM(Fix, undef, coulomb, Nd - 1, landau, -1);
class GaugeFixPar: Serializable class GaugeFixPar: Serializable
{ {
public: public:
@ -51,6 +53,7 @@ public:
int, maxiter, int, maxiter,
Real, Omega_tol, Real, Omega_tol,
Real, Phi_tol, Real, Phi_tol,
Fix, gaugeFix,
bool, Fourier); bool, Fourier);
}; };
@ -115,8 +118,8 @@ void TGaugeFix<GImpl>::execute(void)
//Loads the gauge and fixes it //Loads the gauge and fixes it
{ {
std::cout << "executing" << std::endl; std::cout << "executing" << std::endl;
LOG(Message) << "Fixing the Gauge" << std::endl; LOG(Message) << "Fixing the Gauge " << par().gauge << " using "
LOG(Message) << par().gauge << std::endl; << par().gaugeFix << " guage fixing. " << Nd - 1 << std::endl;
auto &U = envGet(GaugeField, par().gauge); auto &U = envGet(GaugeField, par().gauge);
auto &Umu = envGet(GaugeField, getName()); auto &Umu = envGet(GaugeField, getName());
auto &xform = envGet(GaugeMat, getName()+"_xform"); auto &xform = envGet(GaugeMat, getName()+"_xform");
@ -126,9 +129,10 @@ void TGaugeFix<GImpl>::execute(void)
int maxiter = par().maxiter; int maxiter = par().maxiter;
Real Omega_tol = par().Omega_tol; Real Omega_tol = par().Omega_tol;
Real Phi_tol = par().Phi_tol; Real Phi_tol = par().Phi_tol;
int gaugeFix = par().gaugeFix;
bool Fourier = par().Fourier; bool Fourier = par().Fourier;
Umu = U; Umu = U;
FourierAcceleratedGaugeFixer<PeriodicGimplR>::SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier); FourierAcceleratedGaugeFixer<PeriodicGimplR>::SteepestDescentGaugeFix(Umu,xform,alpha,maxiter,Omega_tol,Phi_tol,Fourier,gaugeFix);
LOG(Message) << "Gauge Fixed" << std::endl; LOG(Message) << "Gauge Fixed" << std::endl;
} }

4
Hadrons/Modules/MIO/LoadEigenPack.cc
View File

@ -31,7 +31,7 @@ using namespace Grid;
using namespace Hadrons; using namespace Hadrons;
using namespace MIO; using namespace MIO;
template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL>>; template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL>, GIMPL>;
#ifdef GRID_DEFAULT_PRECISION_DOUBLE #ifdef GRID_DEFAULT_PRECISION_DOUBLE
template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>>; template class Grid::Hadrons::MIO::TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>, GIMPL>;
#endif #endif

86
Hadrons/Modules/MIO/LoadEigenPack.hpp
View File

@ -47,16 +47,21 @@ public:
std::string, filestem, std::string, filestem,
bool, multiFile, bool, multiFile,
unsigned int, size, unsigned int, size,
unsigned int, Ls); unsigned int, Ls,
std::string, gaugeXform);
}; };
template <typename Pack> template <typename Pack, typename GImpl>
class TLoadEigenPack: public Module<LoadEigenPackPar> class TLoadEigenPack: public Module<LoadEigenPackPar>
{ {
public: public:
typedef typename Pack::Field Field; typedef typename Pack::Field Field;
typedef typename Pack::FieldIo FieldIo; typedef typename Pack::FieldIo FieldIo;
typedef BaseEigenPack<Field> BasePack; typedef BaseEigenPack<Field> BasePack;
public:
GAUGE_TYPE_ALIASES(GImpl, );
typedef typename GImpl::GaugeLinkField GaugeMat;
public: public:
// constructor // constructor
TLoadEigenPack(const std::string name); TLoadEigenPack(const std::string name);
@ -71,31 +76,36 @@ public:
virtual void execute(void); virtual void execute(void);
}; };
MODULE_REGISTER_TMP(LoadFermionEigenPack, TLoadEigenPack<FermionEigenPack<FIMPL>>, MIO); MODULE_REGISTER_TMP(LoadFermionEigenPack, ARG(TLoadEigenPack<FermionEigenPack<FIMPL>, GIMPL>), MIO);
#ifdef GRID_DEFAULT_PRECISION_DOUBLE #ifdef GRID_DEFAULT_PRECISION_DOUBLE
MODULE_REGISTER_TMP(LoadFermionEigenPackIo32, ARG(TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>>), MIO); MODULE_REGISTER_TMP(LoadFermionEigenPackIo32, ARG(TLoadEigenPack<FermionEigenPack<FIMPL, FIMPLF>, GIMPL>), MIO);
#endif #endif
/****************************************************************************** /******************************************************************************
* TLoadEigenPack implementation * * TLoadEigenPack implementation *
******************************************************************************/ ******************************************************************************/
// constructor ///////////////////////////////////////////////////////////////// // constructor /////////////////////////////////////////////////////////////////
template <typename Pack> template <typename Pack, typename GImpl>
TLoadEigenPack<Pack>::TLoadEigenPack(const std::string name) TLoadEigenPack<Pack, GImpl>::TLoadEigenPack(const std::string name)
: Module<LoadEigenPackPar>(name) : Module<LoadEigenPackPar>(name)
{} {}
// dependencies/products /////////////////////////////////////////////////////// // dependencies/products ///////////////////////////////////////////////////////
template <typename Pack> template <typename Pack, typename GImpl>
std::vector<std::string> TLoadEigenPack<Pack>::getInput(void) std::vector<std::string> TLoadEigenPack<Pack, GImpl>::getInput(void)
{ {
std::vector<std::string> in; std::vector<std::string> in;
if (!par().gaugeXform.empty())
{
in = {par().gaugeXform};
}
return in; return in;
} }
template <typename Pack> template <typename Pack, typename GImpl>
std::vector<std::string> TLoadEigenPack<Pack>::getOutput(void) std::vector<std::string> TLoadEigenPack<Pack, GImpl>::getOutput(void)
{ {
std::vector<std::string> out = {getName()}; std::vector<std::string> out = {getName()};
@ -103,8 +113,8 @@ std::vector<std::string> TLoadEigenPack<Pack>::getOutput(void)
} }
// setup /////////////////////////////////////////////////////////////////////// // setup ///////////////////////////////////////////////////////////////////////
template <typename Pack> template <typename Pack, typename GImpl>
void TLoadEigenPack<Pack>::setup(void) void TLoadEigenPack<Pack, GImpl>::setup(void)
{ {
GridBase *gridIo = nullptr; GridBase *gridIo = nullptr;
@ -114,16 +124,64 @@ void TLoadEigenPack<Pack>::setup(void)
} }
envCreateDerived(BasePack, Pack, getName(), par().Ls, par().size, envCreateDerived(BasePack, Pack, getName(), par().Ls, par().size,
envGetRbGrid(Field, par().Ls), gridIo); envGetRbGrid(Field, par().Ls), gridIo);
if (!par().gaugeXform.empty())
{
if (par().Ls > 1)
{
LOG(Message) << "Setup 5d GaugeMat for Ls = " << par().Ls << std::endl;
envTmp(GaugeMat, "tmpXform", par().Ls, envGetGrid5(Field, par().Ls));
envTmp(GaugeMat, "tmpXformOdd", par().Ls, envGetRbGrid5(Field, par().Ls));
}
else
{
LOG(Message) << "Setup 4d GaugeMat for Ls = " << par().Ls << std::endl;
envTmp(GaugeMat, "tmpXform", par().Ls, envGetGrid(Field));
envTmp(GaugeMat, "tmpXformOdd", par().Ls, envGetRbGrid(Field));
}
}
} }
// execution /////////////////////////////////////////////////////////////////// // execution ///////////////////////////////////////////////////////////////////
template <typename Pack> template <typename Pack, typename GImpl>
void TLoadEigenPack<Pack>::execute(void) void TLoadEigenPack<Pack, GImpl>::execute(void)
{ {
auto &epack = envGetDerived(BasePack, Pack, getName()); auto &epack = envGetDerived(BasePack, Pack, getName());
epack.read(par().filestem, par().multiFile, vm().getTrajectory()); epack.read(par().filestem, par().multiFile, vm().getTrajectory());
epack.eval.resize(par().size); epack.eval.resize(par().size);
if (!par().gaugeXform.empty())
{
LOG(Message) << "Applying gauge transformation to eigenvectors " << getName()
<< " using " << par().gaugeXform << std::endl;
auto &xform = envGet(GaugeMat, par().gaugeXform);
envGetTmp(GaugeMat, tmpXform);
envGetTmp(GaugeMat, tmpXformOdd);
if (par().Ls > 1)
{
LOG(Message) << "Creating 5d GaugeMat from " << par().gaugeXform << std::endl;
startTimer("5-d gauge transform creation");
for (unsigned int j = 0; j < par().Ls; j++)
{
InsertSlice(xform, tmpXform, j, 0);
}
stopTimer("5-d gauge transform creation");
}
pickCheckerboard(Odd, tmpXformOdd, tmpXform);
startTimer("Transform application");
for (unsigned int i = 0; i < par().size; i++)
{
LOG(Message) << "Applying gauge transformation to eigenvector i = " << i << "/" << par().size << std::endl;
epack.evec[i].checkerboard = Odd;
epack.evec[i] = tmpXformOdd * epack.evec[i];
}
stopTimer("Transform application");
}
} }
END_MODULE_NAMESPACE END_MODULE_NAMESPACE

3
Hadrons/Modules/MSource/Wall.hpp
View File

@ -119,6 +119,9 @@ template <typename FImpl>
void TWall<FImpl>::setup(void) void TWall<FImpl>::setup(void)
{ {
envCreateLat(PropagatorField, getName()); envCreateLat(PropagatorField, getName());
envCache(Lattice<iScalar<vInteger>>, tName_, 1, envGetGrid(LatticeComplex));
envCacheLat(LatticeComplex, momphName_);
envTmpLat(LatticeComplex, "coor");
} }
// execution /////////////////////////////////////////////////////////////////// // execution ///////////////////////////////////////////////////////////////////

20
tests/core/Test_fft_gfix.cc
View File

@ -60,6 +60,9 @@ int main (int argc, char ** argv)
std::cout<< "* Testing we can gauge fix steep descent a RGT of Unit gauge *" <<std::endl; std::cout<< "* Testing we can gauge fix steep descent a RGT of Unit gauge *" <<std::endl;
std::cout<< "*****************************************************************" <<std::endl; std::cout<< "*****************************************************************" <<std::endl;
// int coulomb_dir = -1;
int coulomb_dir = Nd-1;
LatticeGaugeField Umu(&GRID); LatticeGaugeField Umu(&GRID);
LatticeGaugeField Urnd(&GRID); LatticeGaugeField Urnd(&GRID);
LatticeGaugeField Uorg(&GRID); LatticeGaugeField Uorg(&GRID);
@ -68,6 +71,7 @@ int main (int argc, char ** argv)
LatticeColourMatrix xform1(&GRID); // Gauge xform LatticeColourMatrix xform1(&GRID); // Gauge xform
LatticeColourMatrix xform2(&GRID); // Gauge xform LatticeColourMatrix xform2(&GRID); // Gauge xform
LatticeColourMatrix xform3(&GRID); // Gauge xform
SU3::ColdConfiguration(pRNG,Umu); // Unit gauge SU3::ColdConfiguration(pRNG,Umu); // Unit gauge
Uorg=Umu; Uorg=Umu;
@ -127,6 +131,22 @@ int main (int argc, char ** argv)
plaq=WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu); plaq=WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu);
std::cout << " Final plaquette "<<plaq << std::endl; std::cout << " Final plaquette "<<plaq << std::endl;
std::cout<< "*****************************************************************" <<std::endl;
std::cout<< "* Testing Fourier accelerated fixing to coulomb gauge *" <<std::endl;
std::cout<< "*****************************************************************" <<std::endl;
Umu=Urnd;
SU3::HotConfiguration(pRNG,Umu); // Unit gauge
plaq=WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu);
std::cout << " Initial plaquette "<<plaq << std::endl;
FourierAcceleratedGaugeFixer<PeriodicGimplR>::SteepestDescentGaugeFix(Umu,xform3,alpha,10000,1.0e-12, 1.0e-12,true,coulomb_dir);
std::cout << Umu<<std::endl;
plaq=WilsonLoops<PeriodicGimplR>::avgPlaquette(Umu);
std::cout << " Final plaquette "<<plaq << std::endl;
Grid_finalize(); Grid_finalize();
} }